From c48536dc42dfc2ccd7c13b23177c1344e9dc2ec3 Mon Sep 17 00:00:00 2001 From: Gharbi Dali Date: Fri, 24 Mar 2017 18:55:43 +0100 Subject: [PATCH] Add files via upload PredicateBuilder and generci method : (WhereAllPropertiesOfSimilarTypeAreEqual WhereAllPropertiesOfSimilarTypeContains) CustomerRepository sample without using the generic dependency resolver --- .../Abstract/IEntityBaseRepository.cs | 34 + HomeCinema.Data/Abstract/IRepositories.cs | 15 + .../ActivityLogConfiguration.cs | 18 + .../Extensions/CustomerExtensions.cs | 1 + HomeCinema.Data/Extensions/StockExtensions.cs | 62 +- HomeCinema.Data/Extensions/UserExtensions.cs | 37 +- HomeCinema.Data/Helper/EntityHelperMethods.cs | 82 + HomeCinema.Data/Helper/PredicateBuilder.cs | 96 + HomeCinema.Data/HomeCinema.Data.csproj | 232 +- HomeCinema.Data/HomeCinema.Data.csproj.user | 6 + HomeCinema.Data/HomeCinema.Data.csproj.vspscc | 10 + HomeCinema.Data/HomeCinemaContext.cs | 114 +- .../201703231700563_initial.Designer.cs | 29 + .../Migrations/201703231700563_initial.cs | 156 + .../Migrations/201703231700563_initial.resx | 126 + ...201703241203435_logAuthSetting.Designer.cs | 29 + .../201703241203435_logAuthSetting.cs | 116 + .../201703241203435_logAuthSetting.resx | 126 + HomeCinema.Data/Migrations/Configuration.cs | 7 + .../Repositories/CustomerRepository.cs | 19 + .../Repositories/EntityBaseRepository.cs | 404 +- .../bin/Debug/EntityFramework.SqlServer.dll | Bin 0 -> 621264 bytes .../bin/Debug/EntityFramework.SqlServer.xml | 2048 + HomeCinema.Data/bin/Debug/EntityFramework.dll | Bin 0 -> 5196496 bytes HomeCinema.Data/bin/Debug/EntityFramework.xml | 52816 ++++++++++++++++ .../bin/Debug/FluentValidation.dll | Bin 0 -> 138752 bytes .../bin/Debug/FluentValidation.pdb | Bin 0 -> 378368 bytes .../bin/Debug/FluentValidation.xml | 2043 + HomeCinema.Data/bin/Debug/HomeCinema.Data.dll | Bin 0 -> 94208 bytes .../bin/Debug/HomeCinema.Data.dll.config | 20 + HomeCinema.Data/bin/Debug/HomeCinema.Data.pdb | Bin 0 -> 101888 bytes .../bin/Debug/HomeCinema.Entities.dll | Bin 0 -> 20480 bytes .../bin/Debug/HomeCinema.Entities.pdb | Bin 0 -> 79360 bytes HomeCinema.Data/bin/Debug/MockData.dll | Bin 0 -> 66048 bytes .../Debug/da/FluentValidation.resources.dll | Bin 0 -> 5632 bytes .../Debug/de/FluentValidation.resources.dll | Bin 0 -> 5120 bytes .../Debug/es/FluentValidation.resources.dll | Bin 0 -> 5120 bytes .../Debug/fi/FluentValidation.resources.dll | Bin 0 -> 5120 bytes .../Debug/fr/FluentValidation.resources.dll | Bin 0 -> 5120 bytes .../Debug/it/FluentValidation.resources.dll | Bin 0 -> 5120 bytes .../Debug/ko/FluentValidation.resources.dll | Bin 0 -> 5632 bytes .../Debug/mk/FluentValidation.resources.dll | Bin 0 -> 6144 bytes .../Debug/nl/FluentValidation.resources.dll | Bin 0 -> 4608 bytes .../Debug/pl/FluentValidation.resources.dll | Bin 0 -> 5120 bytes .../Debug/pt/FluentValidation.resources.dll | Bin 0 -> 5120 bytes .../Debug/ru/FluentValidation.resources.dll | Bin 0 -> 5632 bytes .../Debug/sv/FluentValidation.resources.dll | Bin 0 -> 5120 bytes .../Debug/tr/FluentValidation.resources.dll | Bin 0 -> 5120 bytes ...gnTimeResolveAssemblyReferencesInput.cache | Bin 0 -> 8012 bytes ...meCinema.Data.Migrations.initial.resources | Bin 0 -> 4524 bytes ...a.Data.Migrations.logAuthSetting.resources | Bin 0 -> 6508 bytes ...omeCinema.Data.csproj.FileListAbsolute.txt | 33 + ...eCinema.Data.csproj.GenerateResource.Cache | Bin 0 -> 1062 bytes ....Data.csprojResolveAssemblyReference.cache | Bin 0 -> 26306 bytes HomeCinema.Data/obj/Debug/HomeCinema.Data.dll | Bin 0 -> 94208 bytes HomeCinema.Data/obj/Debug/HomeCinema.Data.pdb | Bin 0 -> 101888 bytes 56 files changed, 58394 insertions(+), 285 deletions(-) create mode 100644 HomeCinema.Data/Abstract/IEntityBaseRepository.cs create mode 100644 HomeCinema.Data/Abstract/IRepositories.cs create mode 100644 HomeCinema.Data/Configurations/ActivityLogConfiguration.cs create mode 100644 HomeCinema.Data/Helper/EntityHelperMethods.cs create mode 100644 HomeCinema.Data/Helper/PredicateBuilder.cs create mode 100644 HomeCinema.Data/HomeCinema.Data.csproj.user create mode 100644 HomeCinema.Data/HomeCinema.Data.csproj.vspscc create mode 100644 HomeCinema.Data/Migrations/201703231700563_initial.Designer.cs create mode 100644 HomeCinema.Data/Migrations/201703231700563_initial.cs create mode 100644 HomeCinema.Data/Migrations/201703231700563_initial.resx create mode 100644 HomeCinema.Data/Migrations/201703241203435_logAuthSetting.Designer.cs create mode 100644 HomeCinema.Data/Migrations/201703241203435_logAuthSetting.cs create mode 100644 HomeCinema.Data/Migrations/201703241203435_logAuthSetting.resx create mode 100644 HomeCinema.Data/Repositories/CustomerRepository.cs create mode 100644 HomeCinema.Data/bin/Debug/EntityFramework.SqlServer.dll create mode 100644 HomeCinema.Data/bin/Debug/EntityFramework.SqlServer.xml create mode 100644 HomeCinema.Data/bin/Debug/EntityFramework.dll create mode 100644 HomeCinema.Data/bin/Debug/EntityFramework.xml create mode 100644 HomeCinema.Data/bin/Debug/FluentValidation.dll create mode 100644 HomeCinema.Data/bin/Debug/FluentValidation.pdb create mode 100644 HomeCinema.Data/bin/Debug/FluentValidation.xml create mode 100644 HomeCinema.Data/bin/Debug/HomeCinema.Data.dll create mode 100644 HomeCinema.Data/bin/Debug/HomeCinema.Data.dll.config create mode 100644 HomeCinema.Data/bin/Debug/HomeCinema.Data.pdb create mode 100644 HomeCinema.Data/bin/Debug/HomeCinema.Entities.dll create mode 100644 HomeCinema.Data/bin/Debug/HomeCinema.Entities.pdb create mode 100644 HomeCinema.Data/bin/Debug/MockData.dll create mode 100644 HomeCinema.Data/bin/Debug/da/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/de/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/es/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/fi/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/fr/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/it/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/ko/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/mk/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/nl/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/pl/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/pt/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/ru/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/sv/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/bin/Debug/tr/FluentValidation.resources.dll create mode 100644 HomeCinema.Data/obj/Debug/DesignTimeResolveAssemblyReferencesInput.cache create mode 100644 HomeCinema.Data/obj/Debug/HomeCinema.Data.Migrations.initial.resources create mode 100644 HomeCinema.Data/obj/Debug/HomeCinema.Data.Migrations.logAuthSetting.resources create mode 100644 HomeCinema.Data/obj/Debug/HomeCinema.Data.csproj.FileListAbsolute.txt create mode 100644 HomeCinema.Data/obj/Debug/HomeCinema.Data.csproj.GenerateResource.Cache create mode 100644 HomeCinema.Data/obj/Debug/HomeCinema.Data.csprojResolveAssemblyReference.cache create mode 100644 HomeCinema.Data/obj/Debug/HomeCinema.Data.dll create mode 100644 HomeCinema.Data/obj/Debug/HomeCinema.Data.pdb diff --git a/HomeCinema.Data/Abstract/IEntityBaseRepository.cs b/HomeCinema.Data/Abstract/IEntityBaseRepository.cs new file mode 100644 index 00000000..c423b8e6 --- /dev/null +++ b/HomeCinema.Data/Abstract/IEntityBaseRepository.cs @@ -0,0 +1,34 @@ +using HomeCinema.Entities; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; +using System.Threading.Tasks; + +namespace HomeCinema.Data.Abstract +{ + //public interface IEntityBaseRepository { } + + public interface IEntityBaseRepository where T : class, IEntityBase, new() + { + IQueryable AllIncluding(params Expression>[] includeProperties); + IQueryable All { get; } + IQueryable GetAll(); + int Count(); + T GetSingle(int id); + IQueryable FindBy(Expression> predicate); + T GetSingle(Expression> predicate, params Expression>[] includeProperties); + T GetSingle(Expression> predicate); + T GetById(object id); + + bool Any(Expression> predicate); + void Add(T entity); + void Delete(T entity); + void Delete(IEnumerable entities); + + void Edit(T entity); + void DeleteWhere(Expression> predicate); + void Commit(); + } +} diff --git a/HomeCinema.Data/Abstract/IRepositories.cs b/HomeCinema.Data/Abstract/IRepositories.cs new file mode 100644 index 00000000..224c3ff9 --- /dev/null +++ b/HomeCinema.Data/Abstract/IRepositories.cs @@ -0,0 +1,15 @@ +using HomeCinema.Entities; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace HomeCinema.Data.Abstract +{ + public interface ICustomerRepository : IEntityBaseRepository { } + + //public interface IUserRepository : IEntityBaseRepository { } + + //public interface IAttendeeRepository : IEntityBaseRepository { } +} diff --git a/HomeCinema.Data/Configurations/ActivityLogConfiguration.cs b/HomeCinema.Data/Configurations/ActivityLogConfiguration.cs new file mode 100644 index 00000000..75d16df8 --- /dev/null +++ b/HomeCinema.Data/Configurations/ActivityLogConfiguration.cs @@ -0,0 +1,18 @@ +using HomeCinema.Entities; +using System; +using System.Collections.Generic; +using System.Data.Entity.ModelConfiguration; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace HomeCinema.Data.Configurations +{ + public class ActivityLogConfiguration : EntityBaseConfiguration + { + public ActivityLogConfiguration() + { + //Property(g => g.).IsRequired().HasMaxLength(50); + } + } +} diff --git a/HomeCinema.Data/Extensions/CustomerExtensions.cs b/HomeCinema.Data/Extensions/CustomerExtensions.cs index 454e1962..0720d056 100644 --- a/HomeCinema.Data/Extensions/CustomerExtensions.cs +++ b/HomeCinema.Data/Extensions/CustomerExtensions.cs @@ -1,4 +1,5 @@ using HomeCinema.Data.Repositories; +using HomeCinema.Data.Abstract; using HomeCinema.Entities; using System; using System.Collections.Generic; diff --git a/HomeCinema.Data/Extensions/StockExtensions.cs b/HomeCinema.Data/Extensions/StockExtensions.cs index e3c4d630..a7bbdf3c 100644 --- a/HomeCinema.Data/Extensions/StockExtensions.cs +++ b/HomeCinema.Data/Extensions/StockExtensions.cs @@ -1,31 +1,31 @@ -using HomeCinema.Data.Repositories; -using HomeCinema.Entities; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace HomeCinema.Data.Extensions -{ - public static class StockExtensions - { - public static IEnumerable GetAvailableItems(this IEntityBaseRepository stocksRepository, int movieId) - { - IEnumerable _availableItems; - - _availableItems = stocksRepository.GetAll().Where(s => s.MovieId == movieId && s.IsAvailable); - - return _availableItems; - } - - //public static IEnumerable GetAllItems(this IEntityBaseRepository stocksRepository, int movieId) - //{ - // IEnumerable _allItems; - - // _allItems = stocksRepository.GetAll().Where(s => s.MovieId == movieId); - - // return _allItems; - //} - } -} +using HomeCinema.Data.Abstract; +using HomeCinema.Entities; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace HomeCinema.Data.Extensions +{ + public static class StockExtensions + { + public static IEnumerable GetAvailableItems(this IEntityBaseRepository stocksRepository, int movieId) + { + IEnumerable _availableItems; + + _availableItems = stocksRepository.GetAll().Where(s => s.MovieId == movieId && s.IsAvailable); + + return _availableItems; + } + + //public static IEnumerable GetAllItems(this IEntityBaseRepository stocksRepository, int movieId) + //{ + // IEnumerable _allItems; + + // _allItems = stocksRepository.GetAll().Where(s => s.MovieId == movieId); + + // return _allItems; + //} + } +} diff --git a/HomeCinema.Data/Extensions/UserExtensions.cs b/HomeCinema.Data/Extensions/UserExtensions.cs index bdf1d875..0493c090 100644 --- a/HomeCinema.Data/Extensions/UserExtensions.cs +++ b/HomeCinema.Data/Extensions/UserExtensions.cs @@ -1,18 +1,19 @@ -using HomeCinema.Data.Repositories; -using HomeCinema.Entities; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace HomeCinema.Data.Extensions -{ - public static class UserExtensions - { - public static User GetSingleByUsername(this IEntityBaseRepository userRepository, string username) - { - return userRepository.GetAll().FirstOrDefault(x => x.Username == username); - } - } -} +using HomeCinema.Data.Abstract; +using HomeCinema.Data.Repositories; +using HomeCinema.Entities; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace HomeCinema.Data.Extensions +{ + public static class UserExtensions + { + public static User GetSingleByUsername(this IEntityBaseRepository userRepository, string username) + { + return userRepository.GetAll().FirstOrDefault(x => x.Username == username); + } + } +} diff --git a/HomeCinema.Data/Helper/EntityHelperMethods.cs b/HomeCinema.Data/Helper/EntityHelperMethods.cs new file mode 100644 index 00000000..fe6c56a8 --- /dev/null +++ b/HomeCinema.Data/Helper/EntityHelperMethods.cs @@ -0,0 +1,82 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; + +namespace HomeCinema.Data.Helper +{ + public static class EntityHelperMethods + { + public static IQueryable WhereAllPropertiesOfSimilarTypeAreEqual(this IQueryable query, TProperty value) + { + var param = Expression.Parameter(typeof(TEntity)); + + var predicate = PredicateBuilder.False(); + + foreach (var fieldName in GetEntityFieldsToCompareTo()) + { + var predicateToAdd = Expression.Lambda>( + Expression.Equal( + Expression.PropertyOrField(param, fieldName.Key), + Expression.Constant(value)), param); + + predicate = predicate.Or(predicateToAdd); + } + + return query.Where(predicate); + } + + public static IQueryable WhereAllPropertiesOfSimilarTypeContains(this IQueryable query, TProperty value) + { + var param = Expression.Parameter(typeof(TEntity)); + var predicate = PredicateBuilder.False(); + MethodInfo contains = typeof(string).GetMethod("Contains"); + foreach (var fieldName in GetEntityFieldsToCompareTo()) + { + if (fieldName.Value.Equals(typeof(string).Name)) + { + var predicateToAdd = Expression.Lambda>( + Expression.Call(Expression.PropertyOrField(param, fieldName.Key), + contains, + Expression.Constant(value)), param); + predicate = predicate.Or(predicateToAdd); + } + else + { + var predicateToAdd = Expression.Lambda>( + Expression.Equal( + Expression.PropertyOrField(param, fieldName.Key), + Expression.Constant(value)), param); + predicate = predicate.Or(predicateToAdd); + } + + } + + return query.Where(predicate); + } + + + // TODO: You'll need to find out what fields are actually ones you would want to compare on. + // This might involve stripping out properties marked with [NotMapped] attributes, for + // for example. + private static IDictionary GetEntityFieldsToCompareTo() + { + Type entityType = typeof(TEntity); + Type propertyType = typeof(TProperty); + + var fields = entityType.GetFields() + .Where(f => f.FieldType == propertyType) + .ToDictionary(f => f.Name, f => f.FieldType.Name); + + var properties = entityType.GetProperties() + .Where(p => p.PropertyType == propertyType) + .ToDictionary(p => p.Name, p => p.PropertyType.Name); + //return null; + Dictionary d3 = fields.Concat(properties).ToDictionary(e => e.Key, e => e.Value); + return d3; + } + } +} diff --git a/HomeCinema.Data/Helper/PredicateBuilder.cs b/HomeCinema.Data/Helper/PredicateBuilder.cs new file mode 100644 index 00000000..c32f8831 --- /dev/null +++ b/HomeCinema.Data/Helper/PredicateBuilder.cs @@ -0,0 +1,96 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Linq.Expressions; +using System.Text; +using System.Threading.Tasks; + +namespace HomeCinema.Data.Helper +{ + public static class PredicateBuilder + { + /// + /// Creates a predicate that evaluates to true. + /// + public static Expression> True() { return param => true; } + + /// + /// Creates a predicate that evaluates to false. + /// + public static Expression> False() { return param => false; } + + /// + /// Creates a predicate expression from the specified lambda expression. + /// + public static Expression> Create(Expression> predicate) { return predicate; } + + /// + /// Combines the first predicate with the second using the logical "and". + /// + public static Expression> And(this Expression> first, Expression> second) + { + return first.Compose(second, Expression.AndAlso); + } + + /// + /// Combines the first predicate with the second using the logical "or". + /// + public static Expression> Or(this Expression> first, Expression> second) + { + return first.Compose(second, Expression.OrElse); + } + + /// + /// Negates the predicate. + /// + public static Expression> Not(this Expression> expression) + { + var negated = Expression.Not(expression.Body); + return Expression.Lambda>(negated, expression.Parameters); + } + + /// + /// Combines the first expression with the second using the specified merge function. + /// + static Expression Compose(this Expression first, Expression second, Func merge) + { + // zip parameters (map from parameters of second to parameters of first) + var map = first.Parameters + .Select((f, i) => new { f, s = second.Parameters[i] }) + .ToDictionary(p => p.s, p => p.f); + + // replace parameters in the second lambda expression with the parameters in the first + var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body); + + // create a merged lambda expression with parameters from the first expression + return Expression.Lambda(merge(first.Body, secondBody), first.Parameters); + } + + class ParameterRebinder : ExpressionVisitor + { + readonly Dictionary map; + + ParameterRebinder(Dictionary map) + { + this.map = map ?? new Dictionary(); + } + + public static Expression ReplaceParameters(Dictionary map, Expression exp) + { + return new ParameterRebinder(map).Visit(exp); + } + + protected override Expression VisitParameter(ParameterExpression p) + { + ParameterExpression replacement; + + if (map.TryGetValue(p, out replacement)) + { + p = replacement; + } + + return base.VisitParameter(p); + } + } + } +} diff --git a/HomeCinema.Data/HomeCinema.Data.csproj b/HomeCinema.Data/HomeCinema.Data.csproj index ed07a013..479f69a2 100644 --- a/HomeCinema.Data/HomeCinema.Data.csproj +++ b/HomeCinema.Data/HomeCinema.Data.csproj @@ -1,110 +1,136 @@ - - - - - Debug - AnyCPU - {FDB8609C-3FA4-425C-BA71-4A71A7C43EC6} - Library - Properties - HomeCinema.Data - HomeCinema.Data - v4.5 - 512 - ..\ - true - - - true - full - false - bin\Debug\ - DEBUG;TRACE - prompt - 4 - - - pdbonly - true - bin\Release\ - TRACE - prompt - 4 - - - - ..\packages\EntityFramework.6.1.3\lib\net45\EntityFramework.dll - - - ..\packages\EntityFramework.6.1.3\lib\net45\EntityFramework.SqlServer.dll - - - ..\packages\FluentValidation.5.6.2.0\lib\Net45\FluentValidation.dll - - - ..\packages\MockData.0.0.6\lib\net40\MockData.dll - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {3e8bb046-05bd-4d27-94a7-c13ad4f3e192} - HomeCinema.Entities - - - - - - - - - - - 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}. - - - + + + + + Debug + AnyCPU + {FDB8609C-3FA4-425C-BA71-4A71A7C43EC6} + Library + Properties + HomeCinema.Data + HomeCinema.Data + v4.5 + 512 + ..\ + true + SAK + SAK + SAK + SAK + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + ..\packages\EntityFramework.6.1.3\lib\net45\EntityFramework.dll + + + ..\packages\EntityFramework.6.1.3\lib\net45\EntityFramework.SqlServer.dll + + + ..\packages\FluentValidation.5.6.2.0\lib\Net45\FluentValidation.dll + + + ..\packages\MockData.0.0.6\lib\net40\MockData.dll + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 201703231700563_initial.cs + + + + 201703241203435_logAuthSetting.cs + + + + + + + + + + + + + + + {3e8bb046-05bd-4d27-94a7-c13ad4f3e192} + HomeCinema.Entities + + + + + + + + + 201703231700563_initial.cs + + + 201703241203435_logAuthSetting.cs + + + + + + + + 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/HomeCinema.Data/HomeCinema.Data.csproj.user b/HomeCinema.Data/HomeCinema.Data.csproj.user new file mode 100644 index 00000000..e4826574 --- /dev/null +++ b/HomeCinema.Data/HomeCinema.Data.csproj.user @@ -0,0 +1,6 @@ + + + + ShowAllFiles + + \ No newline at end of file diff --git a/HomeCinema.Data/HomeCinema.Data.csproj.vspscc b/HomeCinema.Data/HomeCinema.Data.csproj.vspscc new file mode 100644 index 00000000..feffdeca --- /dev/null +++ b/HomeCinema.Data/HomeCinema.Data.csproj.vspscc @@ -0,0 +1,10 @@ +"" +{ +"FILE_VERSION" = "9237" +"ENLISTMENT_CHOICE" = "NEVER" +"PROJECT_FILE_RELATIVE_PATH" = "" +"NUMBER_OF_EXCLUDED_FILES" = "0" +"ORIGINAL_PROJECT_FILE_PATH" = "" +"NUMBER_OF_NESTED_PROJECTS" = "0" +"SOURCE_CONTROL_SETTINGS_PROVIDER" = "PROVIDER" +} diff --git a/HomeCinema.Data/HomeCinemaContext.cs b/HomeCinema.Data/HomeCinemaContext.cs index 71344006..310a6e59 100644 --- a/HomeCinema.Data/HomeCinemaContext.cs +++ b/HomeCinema.Data/HomeCinemaContext.cs @@ -1,52 +1,62 @@ -using HomeCinema.Data.Configurations; -using HomeCinema.Entities; -using System; -using System.Collections.Generic; -using System.Data.Entity; -using System.Data.Entity.ModelConfiguration.Conventions; -using System.Data.Entity.Validation; -using System.Linq; -using System.Text; -using System.Threading.Tasks; - -namespace HomeCinema.Data -{ - public class HomeCinemaContext : DbContext - { - public HomeCinemaContext() - : base("HomeCinema") - { - Database.SetInitializer(null); - } - - #region Entity Sets - public IDbSet UserSet { get; set; } - public IDbSet RoleSet { get; set; } - public IDbSet UserRoleSet { get; set; } - public IDbSet CustomerSet { get; set; } - public IDbSet MovieSet { get; set; } - public IDbSet GenreSet { get; set; } - public IDbSet StockSet { get; set; } - public IDbSet RentalSet { get; set; } - public IDbSet ErrorSet { get; set; } - #endregion - - public virtual void Commit() - { - base.SaveChanges(); - } - protected override void OnModelCreating(DbModelBuilder modelBuilder) - { - modelBuilder.Conventions.Remove(); - - modelBuilder.Configurations.Add(new UserConfiguration()); - modelBuilder.Configurations.Add(new UserRoleConfiguration()); - modelBuilder.Configurations.Add(new RoleConfiguration()); - modelBuilder.Configurations.Add(new CustomerConfiguration()); - modelBuilder.Configurations.Add(new MovieConfiguration()); - modelBuilder.Configurations.Add(new GenreConfiguration()); - modelBuilder.Configurations.Add(new StockConfiguration()); - modelBuilder.Configurations.Add(new RentalConfiguration()); - } - } -} +using HomeCinema.Data.Configurations; +using HomeCinema.Entities; +using System; +using System.Collections.Generic; +using System.Data.Entity; +using System.Data.Entity.ModelConfiguration.Conventions; +using System.Data.Entity.Validation; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace HomeCinema.Data +{ + public class HomeCinemaContext : DbContext + { + public HomeCinemaContext() + : base("HomeCinema") + { + Database.SetInitializer(null); + } + + #region Entity Sets + public IDbSet UserSet { get; set; } + public IDbSet RoleSet { get; set; } + public IDbSet UserRoleSet { get; set; } + public IDbSet CustomerSet { get; set; } + public IDbSet MovieSet { get; set; } + public IDbSet GenreSet { get; set; } + public IDbSet StockSet { get; set; } + public IDbSet RentalSet { get; set; } + public IDbSet ErrorSet { get; set; } + //24-03-2017 + public IDbSet ActivityLogSet { get; set; } + public IDbSet ActivityLogTypeSet { get; set; } + public IDbSet RolePermissionSet { get; set; } + public IDbSet SettingSet { get; set; } + public IDbSet UserPermissionSet { get; set; } + public IDbSet UserPreferenceSet { get; set; } + + + + #endregion + + public virtual void Commit() + { + base.SaveChanges(); + } + protected override void OnModelCreating(DbModelBuilder modelBuilder) + { + modelBuilder.Conventions.Remove(); + + modelBuilder.Configurations.Add(new UserConfiguration()); + modelBuilder.Configurations.Add(new UserRoleConfiguration()); + modelBuilder.Configurations.Add(new RoleConfiguration()); + modelBuilder.Configurations.Add(new CustomerConfiguration()); + modelBuilder.Configurations.Add(new MovieConfiguration()); + modelBuilder.Configurations.Add(new GenreConfiguration()); + modelBuilder.Configurations.Add(new StockConfiguration()); + modelBuilder.Configurations.Add(new RentalConfiguration()); + } + } +} diff --git a/HomeCinema.Data/Migrations/201703231700563_initial.Designer.cs b/HomeCinema.Data/Migrations/201703231700563_initial.Designer.cs new file mode 100644 index 00000000..385bd80f --- /dev/null +++ b/HomeCinema.Data/Migrations/201703231700563_initial.Designer.cs @@ -0,0 +1,29 @@ +// +namespace HomeCinema.Data.Migrations +{ + using System.CodeDom.Compiler; + using System.Data.Entity.Migrations; + using System.Data.Entity.Migrations.Infrastructure; + using System.Resources; + + [GeneratedCode("EntityFramework.Migrations", "6.1.3-40302")] + public sealed partial class initial : IMigrationMetadata + { + private readonly ResourceManager Resources = new ResourceManager(typeof(initial)); + + string IMigrationMetadata.Id + { + get { return "201703231700563_initial"; } + } + + string IMigrationMetadata.Source + { + get { return null; } + } + + string IMigrationMetadata.Target + { + get { return Resources.GetString("Target"); } + } + } +} diff --git a/HomeCinema.Data/Migrations/201703231700563_initial.cs b/HomeCinema.Data/Migrations/201703231700563_initial.cs new file mode 100644 index 00000000..7e630fb0 --- /dev/null +++ b/HomeCinema.Data/Migrations/201703231700563_initial.cs @@ -0,0 +1,156 @@ +namespace HomeCinema.Data.Migrations +{ + using System; + using System.Data.Entity.Migrations; + + public partial class initial : DbMigration + { + public override void Up() + { + CreateTable( + "dbo.Customer", + c => new + { + ID = c.Int(nullable: false, identity: true), + FirstName = c.String(nullable: false, maxLength: 100), + LastName = c.String(nullable: false, maxLength: 100), + Email = c.String(nullable: false, maxLength: 200), + IdentityCard = c.String(nullable: false, maxLength: 50), + UniqueKey = c.Guid(nullable: false), + DateOfBirth = c.DateTime(nullable: false), + Mobile = c.String(maxLength: 10), + RegistrationDate = c.DateTime(nullable: false), + }) + .PrimaryKey(t => t.ID); + + CreateTable( + "dbo.Error", + c => new + { + ID = c.Int(nullable: false, identity: true), + Message = c.String(), + StackTrace = c.String(), + DateCreated = c.DateTime(nullable: false), + }) + .PrimaryKey(t => t.ID); + + CreateTable( + "dbo.Genre", + c => new + { + ID = c.Int(nullable: false, identity: true), + Name = c.String(nullable: false, maxLength: 50), + }) + .PrimaryKey(t => t.ID); + + CreateTable( + "dbo.Movie", + c => new + { + ID = c.Int(nullable: false, identity: true), + Title = c.String(nullable: false, maxLength: 100), + Description = c.String(nullable: false, maxLength: 2000), + Image = c.String(), + GenreId = c.Int(nullable: false), + Director = c.String(nullable: false, maxLength: 100), + Writer = c.String(nullable: false, maxLength: 50), + Producer = c.String(nullable: false, maxLength: 50), + ReleaseDate = c.DateTime(nullable: false), + Rating = c.Byte(nullable: false), + TrailerURI = c.String(maxLength: 200), + }) + .PrimaryKey(t => t.ID) + .ForeignKey("dbo.Genre", t => t.GenreId, cascadeDelete: true) + .Index(t => t.GenreId); + + CreateTable( + "dbo.Stock", + c => new + { + ID = c.Int(nullable: false, identity: true), + MovieId = c.Int(nullable: false), + UniqueKey = c.Guid(nullable: false), + IsAvailable = c.Boolean(nullable: false), + }) + .PrimaryKey(t => t.ID) + .ForeignKey("dbo.Movie", t => t.MovieId, cascadeDelete: true) + .Index(t => t.MovieId); + + CreateTable( + "dbo.Rental", + c => new + { + ID = c.Int(nullable: false, identity: true), + CustomerId = c.Int(nullable: false), + StockId = c.Int(nullable: false), + RentalDate = c.DateTime(nullable: false), + ReturnedDate = c.DateTime(), + Status = c.String(nullable: false, maxLength: 10), + }) + .PrimaryKey(t => t.ID) + .ForeignKey("dbo.Stock", t => t.StockId, cascadeDelete: true) + .Index(t => t.StockId); + + CreateTable( + "dbo.Role", + c => new + { + ID = c.Int(nullable: false, identity: true), + Name = c.String(nullable: false, maxLength: 50), + }) + .PrimaryKey(t => t.ID); + + CreateTable( + "dbo.UserRole", + c => new + { + ID = c.Int(nullable: false, identity: true), + UserId = c.Int(nullable: false), + RoleId = c.Int(nullable: false), + }) + .PrimaryKey(t => t.ID) + .ForeignKey("dbo.Role", t => t.RoleId, cascadeDelete: true) + .ForeignKey("dbo.User", t => t.UserId, cascadeDelete: true) + .Index(t => t.UserId) + .Index(t => t.RoleId); + + CreateTable( + "dbo.User", + c => new + { + ID = c.Int(nullable: false, identity: true), + Username = c.String(nullable: false, maxLength: 100), + Email = c.String(nullable: false, maxLength: 200), + HashedPassword = c.String(nullable: false, maxLength: 200), + Salt = c.String(nullable: false, maxLength: 200), + IsLocked = c.Boolean(nullable: false), + DateCreated = c.DateTime(nullable: false), + }) + .PrimaryKey(t => t.ID); + + } + + public override void Down() + { + DropForeignKey("dbo.UserRole", "UserId", "dbo.User"); + DropForeignKey("dbo.UserRole", "RoleId", "dbo.Role"); + DropForeignKey("dbo.Rental", "StockId", "dbo.Stock"); + DropForeignKey("dbo.Stock", "MovieId", "dbo.Movie"); + DropForeignKey("dbo.Movie", "GenreId", "dbo.Genre"); + DropIndex("dbo.UserRole", new[] { "RoleId" }); + DropIndex("dbo.UserRole", new[] { "UserId" }); + DropIndex("dbo.Rental", new[] { "StockId" }); + DropIndex("dbo.Stock", new[] { "MovieId" }); + DropIndex("dbo.Movie", new[] { "GenreId" }); + DropTable("dbo.User"); + DropTable("dbo.UserRole"); + DropTable("dbo.Role"); + DropTable("dbo.Rental"); + DropTable("dbo.Stock"); + DropTable("dbo.Movie"); + DropTable("dbo.Genre"); + DropTable("dbo.Error"); + DropTable("dbo.Customer"); + } + } +} diff --git a/HomeCinema.Data/Migrations/201703231700563_initial.resx b/HomeCinema.Data/Migrations/201703231700563_initial.resx new file mode 100644 index 00000000..a6ff86a3 --- /dev/null +++ b/HomeCinema.Data/Migrations/201703231700563_initial.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file diff --git a/HomeCinema.Data/Migrations/201703241203435_logAuthSetting.Designer.cs b/HomeCinema.Data/Migrations/201703241203435_logAuthSetting.Designer.cs new file mode 100644 index 00000000..8a54ee3a --- /dev/null +++ b/HomeCinema.Data/Migrations/201703241203435_logAuthSetting.Designer.cs @@ -0,0 +1,29 @@ +// +namespace HomeCinema.Data.Migrations +{ + using System.CodeDom.Compiler; + using System.Data.Entity.Migrations; + using System.Data.Entity.Migrations.Infrastructure; + using System.Resources; + + [GeneratedCode("EntityFramework.Migrations", "6.1.3-40302")] + public sealed partial class logAuthSetting : IMigrationMetadata + { + private readonly ResourceManager Resources = new ResourceManager(typeof(logAuthSetting)); + + string IMigrationMetadata.Id + { + get { return "201703241203435_logAuthSetting"; } + } + + string IMigrationMetadata.Source + { + get { return null; } + } + + string IMigrationMetadata.Target + { + get { return Resources.GetString("Target"); } + } + } +} diff --git a/HomeCinema.Data/Migrations/201703241203435_logAuthSetting.cs b/HomeCinema.Data/Migrations/201703241203435_logAuthSetting.cs new file mode 100644 index 00000000..ccf771c7 --- /dev/null +++ b/HomeCinema.Data/Migrations/201703241203435_logAuthSetting.cs @@ -0,0 +1,116 @@ +namespace HomeCinema.Data.Migrations +{ + using System; + using System.Data.Entity.Migrations; + + public partial class logAuthSetting : DbMigration + { + public override void Up() + { + CreateTable( + "dbo.ActivityLog", + c => new + { + ID = c.Int(nullable: false, identity: true), + ActivityLogTypeID = c.Int(nullable: false), + UserName = c.String(), + UserId = c.Int(nullable: false), + Comment = c.String(), + DateUTC = c.DateTime(nullable: false), + IpAddress = c.String(), + }) + .PrimaryKey(t => t.ID) + .ForeignKey("dbo.ActivityLogType", t => t.ActivityLogTypeID, cascadeDelete: true) + .ForeignKey("dbo.User", t => t.UserId, cascadeDelete: true) + .Index(t => t.ActivityLogTypeID) + .Index(t => t.UserId); + + CreateTable( + "dbo.ActivityLogType", + c => new + { + ID = c.Int(nullable: false, identity: true), + SystemKeyword = c.String(), + Name = c.String(), + Enabled = c.Boolean(nullable: false), + }) + .PrimaryKey(t => t.ID); + + CreateTable( + "dbo.RolePermission", + c => new + { + ID = c.Int(nullable: false, identity: true), + RoleId = c.Int(nullable: false), + PermissionKey = c.String(), + }) + .PrimaryKey(t => t.ID) + .ForeignKey("dbo.Role", t => t.RoleId, cascadeDelete: true) + .Index(t => t.RoleId); + + CreateTable( + "dbo.Setting", + c => new + { + ID = c.Int(nullable: false, identity: true), + Name = c.String(), + Value = c.String(), + AppScope = c.Int(nullable: false), + CreatedAt = c.DateTime(nullable: false), + UpdatedAt = c.DateTime(), + CreatedBy = c.String(), + UpdatedBy = c.String(), + Description = c.String(), + }) + .PrimaryKey(t => t.ID); + + CreateTable( + "dbo.UserPermission", + c => new + { + ID = c.Int(nullable: false, identity: true), + UserId = c.Int(nullable: false), + PermissionKey = c.String(), + Granted = c.Boolean(nullable: false), + }) + .PrimaryKey(t => t.ID) + .ForeignKey("dbo.User", t => t.UserId, cascadeDelete: true) + .Index(t => t.UserId); + + CreateTable( + "dbo.UserPreference", + c => new + { + ID = c.Int(nullable: false, identity: true), + UserId = c.Int(nullable: false), + PreferenceType = c.String(), + Name = c.String(), + Value = c.String(), + }) + .PrimaryKey(t => t.ID) + .ForeignKey("dbo.User", t => t.UserId, cascadeDelete: true) + .Index(t => t.UserId); + + } + + public override void Down() + { + DropForeignKey("dbo.UserPreference", "UserId", "dbo.User"); + DropForeignKey("dbo.UserPermission", "UserId", "dbo.User"); + DropForeignKey("dbo.RolePermission", "RoleId", "dbo.Role"); + DropForeignKey("dbo.ActivityLog", "UserId", "dbo.User"); + DropForeignKey("dbo.ActivityLog", "ActivityLogTypeID", "dbo.ActivityLogType"); + DropIndex("dbo.UserPreference", new[] { "UserId" }); + DropIndex("dbo.UserPermission", new[] { "UserId" }); + DropIndex("dbo.RolePermission", new[] { "RoleId" }); + DropIndex("dbo.ActivityLog", new[] { "UserId" }); + DropIndex("dbo.ActivityLog", new[] { "ActivityLogTypeID" }); + DropTable("dbo.UserPreference"); + DropTable("dbo.UserPermission"); + DropTable("dbo.Setting"); + DropTable("dbo.RolePermission"); + DropTable("dbo.ActivityLogType"); + DropTable("dbo.ActivityLog"); + } + } +} diff --git a/HomeCinema.Data/Migrations/201703241203435_logAuthSetting.resx b/HomeCinema.Data/Migrations/201703241203435_logAuthSetting.resx new file mode 100644 index 00000000..25b42fa7 --- /dev/null +++ b/HomeCinema.Data/Migrations/201703241203435_logAuthSetting.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + dbo + + \ No newline at end of file diff --git a/HomeCinema.Data/Migrations/Configuration.cs b/HomeCinema.Data/Migrations/Configuration.cs index ed681ee4..8ed752a9 100644 --- a/HomeCinema.Data/Migrations/Configuration.cs +++ b/HomeCinema.Data/Migrations/Configuration.cs @@ -50,6 +50,13 @@ protected override void Seed(HomeCinemaContext context) RoleId = 1, // admin UserId = 1 // chsakell } + }); + // add permission App to Role 1 + context.RolePermissionSet.AddOrUpdate(new RolePermission[] { + new RolePermission() { + RoleId = 1, // admin + PermissionKey ="app" + } }); } diff --git a/HomeCinema.Data/Repositories/CustomerRepository.cs b/HomeCinema.Data/Repositories/CustomerRepository.cs new file mode 100644 index 00000000..c39af547 --- /dev/null +++ b/HomeCinema.Data/Repositories/CustomerRepository.cs @@ -0,0 +1,19 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using HomeCinema.Data.Repositories; +using HomeCinema.Entities; +using HomeCinema.Data.Abstract; +using HomeCinema.Data; +using HomeCinema.Data.Infrastructure; + +namespace HomeCinema.Data.Repositories +{ + public class CustomerRepository : EntityBaseRepository, ICustomerRepository + { + public CustomerRepository(IDbFactory context) + : base(context) + { } + } +} diff --git a/HomeCinema.Data/Repositories/EntityBaseRepository.cs b/HomeCinema.Data/Repositories/EntityBaseRepository.cs index 342afa24..325d6d60 100644 --- a/HomeCinema.Data/Repositories/EntityBaseRepository.cs +++ b/HomeCinema.Data/Repositories/EntityBaseRepository.cs @@ -1,81 +1,323 @@ -using HomeCinema.Data.Infrastructure; -using HomeCinema.Entities; -using System; -using System.Collections.Generic; -using System.Data.Entity; -using System.Data.Entity.Infrastructure; -using System.Linq; -using System.Linq.Expressions; -using System.Text; -using System.Threading.Tasks; - -namespace HomeCinema.Data.Repositories -{ - public class EntityBaseRepository : IEntityBaseRepository - where T : class, IEntityBase, new() - { - - private HomeCinemaContext dataContext; - - #region Properties - protected IDbFactory DbFactory - { - get; - private set; - } - - protected HomeCinemaContext DbContext - { - get { return dataContext ?? (dataContext = DbFactory.Init()); } - } - public EntityBaseRepository(IDbFactory dbFactory) - { - DbFactory = dbFactory; - } - #endregion - public virtual IQueryable GetAll() - { - return DbContext.Set(); - } - public virtual IQueryable All - { - get - { - return GetAll(); - } - } - public virtual IQueryable AllIncluding(params Expression>[] includeProperties) - { - IQueryable query = DbContext.Set(); - foreach (var includeProperty in includeProperties) - { - query = query.Include(includeProperty); - } - return query; - } - public T GetSingle(int id) - { - return GetAll().FirstOrDefault(x => x.ID == id); - } - public virtual IQueryable FindBy(Expression> predicate) - { - return DbContext.Set().Where(predicate); - } - - public virtual void Add(T entity) - { - DbEntityEntry dbEntityEntry = DbContext.Entry(entity); - DbContext.Set().Add(entity); - } - public virtual void Edit(T entity) - { - DbEntityEntry dbEntityEntry = DbContext.Entry(entity); - dbEntityEntry.State = EntityState.Modified; - } - public virtual void Delete(T entity) - { - DbEntityEntry dbEntityEntry = DbContext.Entry(entity); - dbEntityEntry.State = EntityState.Deleted; - } - } -} +using HomeCinema.Data.Abstract; +using HomeCinema.Data.Infrastructure; +using HomeCinema.Entities; +using System; +using System.Collections.Generic; +using System.Data.Entity; +using System.Data.Entity.Infrastructure; +using System.Data.Entity.Validation; +using System.Linq; +using System.Linq.Expressions; + +namespace HomeCinema.Data.Repositories +{ + public class EntityBaseRepository : IEntityBaseRepository + where T : class, IEntityBase, new() + { + private HomeCinemaContext dataContext; + + #region Properties + + protected IDbFactory DbFactory + { + get; + private set; + } + + private IDbSet _entities; + + protected HomeCinemaContext DbContext + { + get { return dataContext ?? (dataContext = DbFactory.Init()); } + } + + public EntityBaseRepository(IDbFactory dbFactory) + { + DbFactory = dbFactory; + } + + #endregion Properties + + #region Utilities + + /// + /// Get full error + /// + /// Exception + /// Error + protected string GetFullErrorText(DbEntityValidationException exc) + { + var msg = string.Empty; + foreach (var validationErrors in exc.EntityValidationErrors) + foreach (var error in validationErrors.ValidationErrors) + msg += string.Format("Property: {0} Error: {1}", error.PropertyName, error.ErrorMessage) + Environment.NewLine; + return msg; + } + + #endregion Utilities + + public virtual IQueryable GetAll() + { + try + { + return DbContext.Set(); + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + public virtual IQueryable All + { + get + { + try + { + return GetAll(); + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + } + + public virtual int Count() + { + try + { + return DbContext.Set().Count(); + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + public virtual IQueryable AllIncluding(params Expression>[] includeProperties) + { + try + { + IQueryable query = DbContext.Set(); + foreach (var includeProperty in includeProperties) + { + query = query.Include(includeProperty); + } + return query; + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + /// + /// Get entity by identifier + /// + /// Identifier + /// Entity + public virtual T GetById(object id) + { + //see some suggested performance optimization (not tested) + //http://stackoverflow.com/questions/11686225/dbset-find-method-ridiculously-slow-compared-to-singleordefault-on-id/11688189#comment34876113_11688189 + return this.Entities.Find(id); + } + + public T GetSingle(int id) + { + try + { + return GetAll().FirstOrDefault(x => x.ID == id); + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + public virtual IQueryable FindBy(Expression> predicate) + { + try + { + return DbContext.Set().Where(predicate); + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + public T GetSingle(Expression> predicate) + { + try + { + return DbContext.Set().FirstOrDefault(predicate); + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + public bool Any(Expression> predicate) + { + try + { + return DbContext.Set().Any(predicate); + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + public T GetSingle(Expression> predicate, params Expression>[] includeProperties) + { + try + { + IQueryable query = DbContext.Set(); + foreach (var includeProperty in includeProperties) + { + query = query.Include(includeProperty); + } + + return query.Where(predicate).FirstOrDefault(); + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + public virtual void Add(T entity) + { + try + { + DbEntityEntry dbEntityEntry = DbContext.Entry(entity); + DbContext.Set().Add(entity); + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + public virtual void Edit(T entity) + { + try + { + DbEntityEntry dbEntityEntry = DbContext.Entry(entity); + dbEntityEntry.State = EntityState.Modified; + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + public virtual void Delete(T entity) + { + try + { + DbEntityEntry dbEntityEntry = DbContext.Entry(entity); + dbEntityEntry.State = EntityState.Deleted; + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + /// + /// Delete entities + /// + /// Entities + public virtual void Delete(IEnumerable entities) + { + try + { + if (entities == null) + throw new ArgumentNullException("entities"); + + foreach (var entity in entities) + { + DbEntityEntry dbEntityEntry = DbContext.Entry(entity); + dbEntityEntry.State = EntityState.Deleted; + } + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + public virtual void DeleteWhere(Expression> predicate) + { + try + { + IEnumerable entities = DbContext.Set().Where(predicate); + + foreach (var entity in entities) + { + DbContext.Entry(entity).State = EntityState.Deleted; + } + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + public virtual void Commit() + { + try + { + dataContext.SaveChanges(); + } + catch (DbEntityValidationException dbEx) + { + throw new Exception(GetFullErrorText(dbEx), dbEx); + } + } + + #region Properties + + /// + /// Gets a table + /// + public virtual IQueryable Table + { + get + { + return this.Entities; + } + } + + /// + /// Gets a table with "no tracking" enabled (EF feature) Use it only when you load record(s) only for read-only operations + /// + public virtual IQueryable TableNoTracking + { + get + { + return this.Entities.AsNoTracking(); + } + } + + /// + /// Entities + /// + protected virtual IDbSet Entities + { + get + { + if (_entities == null) + _entities = DbContext.Set(); + return _entities; + } + } + + #endregion Properties + } +} \ No newline at end of file diff --git a/HomeCinema.Data/bin/Debug/EntityFramework.SqlServer.dll b/HomeCinema.Data/bin/Debug/EntityFramework.SqlServer.dll new file mode 100644 index 0000000000000000000000000000000000000000..481c1c7c1840333a5d13039c9090ec1ae2e48ed6 GIT binary patch literal 621264 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�bCIn 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�eE6F5~0qFw_l5pN{l2Z>)5jU+m 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 literal 0 HcmV?d00001 diff --git a/HomeCinema.Data/bin/Debug/EntityFramework.SqlServer.xml b/HomeCinema.Data/bin/Debug/EntityFramework.SqlServer.xml new file mode 100644 index 00000000..1851514e --- /dev/null +++ b/HomeCinema.Data/bin/Debug/EntityFramework.SqlServer.xml @@ -0,0 +1,2048 @@ + + + + EntityFramework.SqlServer + + + +

+ Contains extension methods for the class. + + + + + Configures an awaiter used to await this to avoid + marshalling the continuation + back to the original context, but preserve the current culture and UI culture. + + + The type of the result produced by the associated . + + The task to be awaited on. + An object used to await this task. + + + + Configures an awaiter used to await this to avoid + marshalling the continuation + back to the original context, but preserve the current culture and UI culture. + + The task to be awaited on. + An object used to await this task. + + + + Provides an awaitable object that allows for awaits on that + preserve the culture. + + + The type of the result produced by the associated . + + This type is intended for compiler use only. + + + + Constructs a new instance of the class. + + The task to be awaited on. + + + Gets an awaiter used to await this . + An awaiter instance. + 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 canceled. + The task completed in a Faulted state. + + + This method is not implemented and should not be called. + The action to invoke when the await operation completes. + + + + 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. + + + + Gets whether this Task has completed. + + + will return true when the Task is in one of the three + final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Provides an awaitable object that allows for awaits on that + preserve the culture. + + This type is intended for compiler use only. + + + + Constructs a new instance of the class. + + The task to be awaited on. + + + Gets an awaiter used to await this . + An awaiter instance. + 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 canceled. + The task completed in a Faulted state. + + + This method is not implemented and should not be called. + The action to invoke when the await operation completes. + + + + 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. + + + + Gets whether this Task has completed. + + + will return true when the Task is in one of the three + final states: RanToCompletion, + Faulted, or + Canceled. + + + + + An that retries actions that throw exceptions caused by SQL Azure transient failures. + + + This execution strategy will retry the operation on and + if the contains any of the following error numbers: + 40613, 40501, 40197, 10929, 10928, 10060, 10054, 10053, 233, 64 and 20 + + + + + Creates a new instance of . + + + The default retry limit is 5, which means that the total amount of time spent between retries is 26 seconds plus the random factor. + + + + + Creates a new instance of with the specified limits for + number of retries and the delay between retries. + + The maximum number of retry attempts. + The maximum delay in milliseconds between retries. + + + + + + + Contains function stubs that expose SqlServer methods in Linq to Entities. + + + + Returns the checksum of the values in a collection. Null values are ignored. + The checksum computed from the input collection. + The collection of values over which the checksum is computed. + + + Returns the checksum of the values in a collection. Null values are ignored. + The checksum computed from the input collection. + The collection of values over which the checksum is computed. + + + Returns the ASCII code value of the left-most character of a character expression. + The ASCII code of the first character in the input string. + A valid string. + + + Returns the character that corresponds to the specified integer ASCII value. + The character that corresponds to the specified ASCII value. + An ASCII code. + + + Returns the starting position of one expression found within another expression. + The starting position of target if it is found in toSearch . + The string expression to be searched. + The string expression to be found. + + + Returns the starting position of one expression found within another expression. + The starting position of target if it is found in toSearch . + The string expression to be searched. + The string expression to be found. + + + Returns the starting position of one expression found within another expression. + The starting position of target if it is found in toSearch . + The string expression to be searched. + The string expression to be found. + The character position in toSearch where searching begins. + + + Returns the starting position of one expression found within another expression. + The starting position of target if it is found in toSearch . + The string expression to be searched. + The string expression to be found. + The character position in toSearch where searching begins. + + + Returns the starting position of one expression found within another expression. + + A of value that is the starting position of target if it is found in toSearch . + + The string expression to be searched. + The string expression to be found. + The character position in toSearch where searching begins. + + + Returns the starting position of one expression found within another expression. + The starting position of target if it is found in toSearch . + The string expression to be searched. + The string expression to be found. + The character position in toSearch at which searching begins. + + + Returns an integer value that indicates the difference between the SOUNDEX values of two character expressions. + The SOUNDEX difference between the two strings. + The first string. + The second string. + + + Returns the Unicode character with the specified integer code, as defined by the Unicode standard. + The character that corresponds to the input character code. + A character code. + + + Returns the starting position of the first occurrence of a pattern in a specified expression, or zeros if the pattern is not found, on all valid text and character data types. + The starting character position where the string pattern was found. + A string pattern to search for. + The string to search. + + + Returns a Unicode string with the delimiters added to make the input string a valid Microsoft SQL Server delimited identifier. + The original string with brackets added. + The expression that quote characters will be added to. + + + Returns a Unicode string with the delimiters added to make the input string a valid Microsoft SQL Server delimited identifier. + The original string with the specified quote characters added. + The expression that quote characters will be added to. + The one-character string to use as the delimiter. It can be a single quotation mark ( ' ), a left or right bracket ( [ ] ), or a double quotation mark ( " ). If quote_character is not specified, brackets are used. + + + Repeats a string value a specified number of times. + The target string, repeated the number of times specified by count . + A valid string. + The value that specifies how many time to repeat target . + + + Converts an alphanumeric string to a four-character (SOUNDEX) code to find similar-sounding words or names. + The SOUNDEX code of the input string. + A valid string. + + + Returns a string of repeated spaces. + A string that consists of the specified number of spaces. + The number of spaces. If negative, a null string is returned. + + + Returns character data converted from numeric data. + The numeric input expression converted to a string. + A numeric expression. + + + Returns character data converted from numeric data. + The input expression converted to a string. + A numeric expression. + + + Returns character data converted from numeric data. + The numeric input expression converted to a string. + A numeric expression. + The total length of the string. This includes decimal point, sign, digits, and spaces. The default is 10. + + + Returns character data converted from numeric data. + The input expression converted to a string. + A numeric expression. + The total length of the string. This includes decimal point, sign, digits, and spaces. The default is 10. + + + Returns character data converted from numeric data. + The numeric input expression converted to a string. + A numeric expression. + The total length of the string. This includes decimal point, sign, digits, and spaces. The default is 10. + The number of places to the right of the decimal point. decimal must be less than or equal to 16. If decimal is more than 16 then the result is truncated to sixteen places to the right of the decimal point. + + + Returns character data converted from numeric data. + The input expression converted to a string. + A numeric expression. + The total length of the string. This includes decimal point, sign, digits, and spaces. The default is 10. + The number of places to the right of the decimal point. decimal must be less than or equal to 16. If decimal is more than 16 then the result is truncated to sixteen places to the right of the decimal point. + + + Inserts a string into another string. It deletes a specified length of characters in the target string at the start position and then inserts the second string into the target string at the start position. + A string consisting of the two strings. + The target string. + The character position in stringinput where the replacement string is to be inserted. + The number of characters to delete from stringInput . If length is longer than stringInput , deletion occurs up to the last character in stringReplacement . + The substring to be inserted into stringInput . + + + Returns the integer value, as defined by the Unicode standard, for the first character of the input expression. + The character code for the first character in the input string. + A valid string. + + + A mathematical function that returns the angle, in radians, whose cosine is the specified numerical value. This angle is called the arccosine. + The angle, in radians, defined by the input cosine value. + The cosine of an angle. + + + A mathematical function that returns the angle, in radians, whose cosine is the specified numerical value. This angle is called the arccosine. + An angle, measured in radians. + The cosine of an angle. + + + A mathematical function that returns the angle, in radians, whose sine is the specified numerical value. This angle is called the arcsine. + An angle, measured in radians. + The sine of an angle. + + + A mathematical function that returns the angle, in radians, whose sine is the specified numerical value. This angle is called the arcsine. + An angle, measured in radians. + The sine of an angle. + + + A mathematical function that returns the angle, in radians, whose tangent is the specified numerical value. This angle is called the arctangent. + An angle, measured in radians. + The tangent of an angle. + + + A mathematical function that returns the angle, in radians, whose tangent is the specified numerical value. This angle is called the arctangent. + An angle, measured in radians. + The tangent of an angle. + + + Returns the positive angle, in radians, between the positive x-axis and the ray from the origin through the point (x, y), where x and y are the two specified numerical values. The first parameter passed to the function is the y-value and the second parameter is the x-value. + An angle, measured in radians. + The y-coordinate of a point. + The x-coordinate of a point. + + + Returns the positive angle, in radians, between the positive x-axis and the ray from the origin through the point (x, y), where x and y are the two specified numerical values. The first parameter passed to the function is the y-value and the second parameter is the x-value. + An angle, measured in radians. + The y-coordinate of a point. + The x-coordinate of a point. + + + Returns the trigonometric cosine of the specified angle, in radians, in the specified expression. + The trigonometric cosine of the specified angle. + An angle, measured in radians. + + + Returns the trigonometric cosine of the specified angle, in radians, in the specified expression. + The trigonometric cosine of the specified angle. + An angle, measured in radians. + + + A mathematical function that returns the trigonometric cotangent of the specified angle, in radians. + The trigonometric cotangent of the specified angle. + An angle, measured in radians. + + + A mathematical function that returns the trigonometric cotangent of the specified angle, in radians. + The trigonometric cotangent of the specified angle. + An angle, measured in radians. + + + Returns the corresponding angle in degrees for an angle specified in radians. + The specified angle converted to degrees. + An angle, measured in radians. + + + Returns the corresponding angle in degrees for an angle specified in radians. + The specified angle converted to degrees. + An angle, measured in radians. + + + Returns the corresponding angle in degrees for an angle specified in radians. + The specified angle converted to degrees. + An angle, measured in radians. + + + Returns the corresponding angle in degrees for an angle specified in radians. + The specified angle converted to degrees. + An angle, measured in radians. + + + Returns the exponential value of the specified float expression. + The constant e raised to the power of the input value. + The input value. + + + Returns the exponential value of the specified float expression. + The constant e raised to the power of the input value. + The input value. + + + Returns the natural logarithm of the specified input value. + The natural logarithm of the input value. + A numeric expression. + + + Returns the natural logarithm of the specified input value. + The natural logarithm of the input value. + A numeric expression. + + + Returns the base-10 logarithm of the specified input value. + The base-10 logarithm of the input value. + A numeric expression. + + + Returns the base-10 logarithm of the specified input value. + The base-10 logarithm of the input value. + A numeric expression. + + + Returns the constant value of pi. + The numeric value of pi. + + + Returns the radian measure corresponding to the specified angle in degrees. + The radian measure of the specified angle. + The angle, measured in degrees + + + Returns the radian measure corresponding to the specified angle in degrees. + The radian measure of the specified angle. + The angle, measured in degrees + + + Returns the radian measure corresponding to the specified angle in degrees. + The radian measure of the specified angle. + The angle, measured in degrees. + + + Returns the radian measure corresponding to the specified angle in degrees. + The radian measure of the specified angle. + The angle, measured in degrees. + + + Returns a pseudo-random float value from 0 through 1, exclusive. + The pseudo-random value. + + + Returns a pseudo-random float value from 0 through 1, exclusive. + The pseudo-random value. + The seed value. If seed is not specified, the SQL Server Database Engine assigns a seed value at random. For a specified seed value, the result returned is always the same. + + + Returns the positive (+1), zero (0), or negative (-1) sign of the specified expression. + The sign of the input expression. + A numeric expression. + + + Returns the positive (+1), zero (0), or negative (-1) sign of the specified expression. + The sign of the input expression. + A numeric expression. + + + Returns the positive (+1), zero (0), or negative (-1) sign of the specified expression. + The sign of the input expression. + A numeric expression. + + + Returns the positive (+1), zero (0), or negative (-1) sign of the specified expression. + The sign of the input expression. + A numeric expression. + + + Returns the trigonometric sine of the specified angle. + The trigonometric sine of the input expression. + An angle, measured in radians. + + + Returns the trigonometric sine of the specified angle. + The trigonometric sine of the input expression. + An angle, measured in radians. + + + Returns the square root of the specified number. + The square root of the input value. + A numeric expression. + + + Returns the square root of the specified number. + The square root of the input value. + A numeric expression. + + + Returns the square of the specified number. + The square of the input value. + A numeric expression. + + + Returns the square of the specified number. + The square of the input value. + A numeric expression. + + + Returns the trigonometric tangent of the input expression. + The tangent of the input angle. + An angle, measured in radians. + + + Returns the trigonometric tangent of the input expression. + The tangent of the input angle. + An angle, measured in radians. + + + Returns a new datetime value based on adding an interval to the specified date. + The new date. + The part of the date to increment. + The value used to increment a date by a specified amount. + The date to increment. + + + Returns a new time span value based on adding an interval to the specified time span. + The new time span. + The part of the date to increment. + The value used to increment a date by a specified amount. + The time span to increment. + + + Returns a new date value based on adding an interval to the specified date. + The new point in time, expressed as a date and time of day, relative to Coordinated Universal Time (UTC). + The part of the date to increment. + The value used to increment a date by a specified amount. + The date to increment. + + + Returns a new datetime value based on adding an interval to the specified date. + + A of value that is the new date. + + The part of the date to increment. + The value used to increment a date by a specified amount. + The date to increment. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The value specifying the number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two Dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns the count of the specified datepart boundaries crossed between the specified start date and end date. + The number of time intervals between the two dates. + The part of the date to calculate the differing number of time intervals. + The first date. + The second date. + + + Returns a character string that represents the specified datepart of the specified date. + The specified part of the specified date. + The part of the date to calculate the differing number of time intervals. + The date. + + + Returns a character string that represents the specified datepart of the specified date. + The specified part of the specified date. + The part of the date to calculate the differing number of time intervals. + The date. + + + Returns a character string that represents the specified datepart of the specified date. + The specified part of the specified date. + The part of the date to calculate the differing number of time intervals. + The date. + + + Returns a character string that represents the specified datepart of the specified date. + The specified part of the specified date. + The part of the date to calculate the differing number of time intervals. + The date. + + + Returns an integer that represents the specified datepart of the specified date. + The the specified datepart of the specified date. + The part of the date to return the value. + The date. + + + Returns an integer that represents the specified datepart of the specified date. + The specified datepart of the specified date. + The part of the date to return the value. + The date. + + + Returns an integer that represents the specified datepart of the specified date. + The specified datepart of the specified date. + The part of the date to return the value. + The date. + + + Returns an integer that represents the specified datepart of the specified date. + The specified datepart of the specified date. + The part of the date to return the value. + The date. + + + Returns the current database system timestamp as a datetime value without the database time zone offset. This value is derived from the operating system of the computer on which the instance of SQL Server is running. + The current database timestamp. + + + Returns the current database system timestamp as a datetime value. The database time zone offset is not included. This value represents the current UTC time (Coordinated Universal Time). This value is derived from the operating system of the computer on which the instance of SQL Server is running. + The current database UTC timestamp. + + + Returns the number of bytes used to represent any expression. + The number of bytes in the input value. + The value to be examined for data length. + + + Returns the number of bytes used to represent any expression. + The number of bytes in the input value. + The value to be examined for data length. + + + Returns the number of bytes used to represent any expression. + The number of bytes in the input value. + The value to be examined for data length. + + + Returns the number of bytes used to represent any expression. + The number of bytes in the input value. + The value to be examined for data length. + + + Returns the number of bytes used to represent any expression. + The number of bytes in the input value. + The value to be examined for data length. + + + Returns the number of bytes used to represent any expression. + The number of bytes in the input value. + The value to be examined for data length. + + + Returns the number of bytes used to represent any expression. + The number of bytes in the input value. + The value to be examined for data length. + + + Returns the number of bytes used to represent any expression. + The number of bytes in the input value. + The value to be examined for length. + + + Returns the number of bytes used to represent any expression. + The number of bytes in the input value. + The value to be examined for data length. + + + Returns the checksum value computed over the input argument. + The checksum computed over the input value. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input argument. + The checksum computed over the input value. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input argument. + The checksum computed over the input value. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input argument. + The checksum computed over the input value. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input argument. + The checksum computed over the input values. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input argument. + The checksum computed over the input value. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input argument. + The checksum computed over the input value. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input argument. + The checksum computed over the input value. + The character array for which the checksum is calculated. + + + Returns the checksum value computed over the input argument. + The checksum computed over the input value. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The character array for which the checksum is calculated. + The character array for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The character array for which the checksum is calculated. + The character array for which the checksum is calculated. + The character array for which the checksum is calculated. + + + Returns the checksum value computed over the input arguments. + The checksum computed over the input values. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + The value for which the checksum is calculated. + + + Returns the current date and time. + The current date and time. + + + Returns the name of the current user. + The name of the current user. + + + Returns the workstation name. + The name of the workstation. + + + Returns a database user name corresponding to a specified identification number. + The user name. + A user ID. + + + Returns a database user name corresponding to a specified identification number. + The user name. + + + Indicates whether the input value is a valid numeric type. + 1 if the input expression is a valid numeric data type; otherwise, 0. + A string expression. + + + Indicates whether the input value is a valid date or time. + 1 if the input expression is a valid date or time value of datetime or smalldatetime data types; otherwise, 0. + The tested value. + + + + Provider to convert provider agnostic migration operations into SQL commands + that can be run against a Microsoft SQL Server database. + + + + + Converts a set of migration operations into Microsoft SQL Server specific SQL. + + The operations to be converted. + Token representing the version of SQL Server being targeted (i.e. "2005", "2008"). + A list of SQL statements to be executed to perform the migration operations. + + + + Generates the SQL body for a stored procedure. + + The command trees representing the commands for an insert, update or delete operation. + The rows affected parameter name. + The provider manifest token. + The SQL body for the stored procedure. + + + + Generates the specified update database operation which represents applying a series of migrations. + The generated script is idempotent, meaning it contains conditional logic to check if individual migrations + have already been applied and only apply the pending ones. + + The update database operation. + + + + Generates SQL for a . + Allows derived providers to handle additional operation types. + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Creates an empty connection for the current provider. + Allows derived providers to use connection other than . + + An empty connection for the current provider. + + + + Generates the specified create procedure operation. + + The create procedure operation. + + + + Generates the specified alter procedure operation. + + The alter procedure operation. + + + + Generates the specified drop procedure operation. + + The drop procedure operation. + + + + Generates SQL for a . This method differs from + in that it will + create the target database schema if it does not already exist. + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Writes CREATE TABLE SQL to the target writer. + + The operation to produce SQL for. + The target writer. + + + + Override this method to generate SQL when the definition of a table or its attributes are changed. + The default implementation of this method does nothing. + + The operation describing changes to the table. + + + + Generates SQL to mark a table as a system table. + Generated SQL should be added using the Statement method. + + The table to mark as a system table. + The to write the generated SQL to. + + + + Generates SQL to create a database schema. + Generated SQL should be added using the Statement method. + + The name of the schema to create. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Call this method to generate SQL that will attempt to drop the default constraint created + when a column is created. This method is usually called by code that overrides the creation or + altering of columns. + + The table to which the constraint applies. + The column to which the constraint applies. + The writer to which generated SQL should be written. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement or StatementBatch methods. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates the specified rename procedure operation. + + The rename procedure operation. + + + + Generates the specified move procedure operation. + + The move procedure operation. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL for the given column model. This method is called by other methods that + process columns and can be overridden to change the SQL generated. + + The column for which SQL is being generated. + The writer to which generated SQL should be written. + + + + Generates SQL for a . + Generated SQL should be added using the Statement method. + + The operation to produce SQL for. + + + + Generates SQL to specify a constant byte[] default value being set on a column. + This method just generates the actual value, not the SQL to set the default value. + + The value to be set. + SQL representing the default value. + + + + Generates SQL to specify a constant bool default value being set on a column. + This method just generates the actual value, not the SQL to set the default value. + + The value to be set. + SQL representing the default value. + + + + Generates SQL to specify a constant DateTime default value being set on a column. + This method just generates the actual value, not the SQL to set the default value. + + The value to be set. + SQL representing the default value. + + + + Generates SQL to specify a constant DateTimeOffset default value being set on a column. + This method just generates the actual value, not the SQL to set the default value. + + The value to be set. + SQL representing the default value. + + + + Generates SQL to specify a constant Guid default value being set on a column. + This method just generates the actual value, not the SQL to set the default value. + + The value to be set. + SQL representing the default value. + + + + Generates SQL to specify a constant string default value being set on a column. + This method just generates the actual value, not the SQL to set the default value. + + The value to be set. + SQL representing the default value. + + + + Generates SQL to specify a constant TimeSpan default value being set on a column. + This method just generates the actual value, not the SQL to set the default value. + + The value to be set. + SQL representing the default value. + + + + Generates SQL to specify a constant geogrpahy default value being set on a column. + This method just generates the actual value, not the SQL to set the default value. + + The value to be set. + SQL representing the default value. + + + + Generates SQL to specify a constant geometry default value being set on a column. + This method just generates the actual value, not the SQL to set the default value. + + The value to be set. + SQL representing the default value. + + + + Generates SQL to specify a constant default value being set on a column. + This method just generates the actual value, not the SQL to set the default value. + + The value to be set. + SQL representing the default value. + + + + Generates SQL to specify the data type of a column. + This method just generates the actual type, not the SQL to create the column. + + The definition of the column. + SQL representing the data type. + + + + Generates a quoted name. The supplied name may or may not contain the schema. + + The name to be quoted. + The quoted name. + + + + Quotes an identifier for SQL Server. + + The identifier to be quoted. + The quoted identifier. + + + + Adds a new Statement to be executed against the database. + + The statement to be executed. + Gets or sets a value indicating whether this statement should be performed outside of the transaction scope that is used to make the migration process transactional. If set to true, this operation will not be rolled back if the migration process fails. + The batch terminator for the database provider. + + + + Gets a new that can be used to build SQL. + This is just a helper method to create a writer. Writing to the writer will + not cause SQL to be registered for execution. You must pass the generated + SQL to the Statement method. + + An empty text writer to use for SQL generation. + + + + Adds a new Statement to be executed against the database. + + The writer containing the SQL to be executed. + The batch terminator for the database provider. + + + + Breaks sql string into one or more statements, handling T-SQL utility statements as necessary. + + The SQL to split into one ore more statements to be executed. + Gets or sets a value indicating whether this statement should be performed outside of the transaction scope that is used to make the migration process transactional. If set to true, this operation will not be rolled back if the migration process fails. + + + + Returns the column default value to use for store-generated GUID columns when + no default value is explicitly specified in the migration. + Returns newsequentialid() for on-premises SQL Server 2005 and later. + Returns newid() for SQL Azure. + + Either newsequentialid() or newid() as described above. + + + + Contains function stubs that expose SqlServer methods in Linq to Entities. + + + + Constructs a geography instance representing a Point instance from its x and y values and a spatial reference ID (SRID). + The constructed geography instance. + The x-coordinate of the Point being generated. + The y-coordinate of the Point being generated + The SRID of the geography instance. + + + Returns the Open Geospatial Consortium (OGC) Well-Known Text (WKT) representation of a geography instance augmented with any Z (elevation) and M (measure) values carried by the instance. + The Open Geospatial Consortium (OGC) Well-Known Text (WKT) representation of a geography instance. + The geography value. + + + Returns a geometric object representing the union of all point values whose distance from a geography instance is less than or equal to a specified value, allowing for a specified tolerance. + The union of all point values whose distance from a geography instance is less than or equal to a specified value + The geography value. + The distance. + The specified tolerance. + Specifying whether the tolerance value is relative or absolute. + + + Returns the maximum angle between the point returned by EnvelopeCenter() and a point in the geography instance in degrees. + the maximum angle between the point returned by EnvelopeCenter(). + The geography value. + + + Returns a point that can be used as the center of a bounding circle for the geography instance. + A SqlGeography value that specifies the location of the center of a bounding circle. + The geography value. + + + Offers a fast, index-only intersection method to determine if a geography instance intersects another SqlGeography instance, assuming an index is available. + True if a geography instance potentially intersects another SqlGeography instance; otherwise, false. + The geography value. + Another geography instance to compare against the instance on which Filter is invoked. + + + Tests if the SqlGeography instance is the same as the specified type. + A string that specifies one of the 12 types exposed in the geography type hierarchy. + The geography value. + A string that specifies one of the 12 types exposed in the geography type hierarchy. + + + Returns the total number of rings in a Polygon instance. + The total number of rings. + The geography value. + + + Returns an approximation of the given geography instance produced by running the Douglas-Peucker algorithm on the instance with the given tolerance. + + Returns . + + The geography value. + The tolerance to input to the Douglas-Peucker algorithm. tolerance must be a positive number. + + + Returns the specified ring of the SqlGeography instance: 1 ≤ n ≤ NumRings(). + A SqlGeography object that represents the ring specified by n. + The geography value. + An int expression between 1 and the number of rings in a polygon instance. + + + Constructs a geometry instance representing a Point instance from its x and y values and a spatial reference ID (SRID). + The constructed geometry instance. + The x-coordinate of the Point being generated. + The y-coordinate of the Point being generated + The SRID of the geography instance. + + + Returns the Open Geospatial Consortium (OGC) Well-Known Text (WKT) representation of a geography instance augmented with any Z (elevation) and M (measure) values carried by the instance. + The Open Geospatial Consortium (OGC) Well-Known Text (WKT) representation of a geometry instance. + The geometry value. + + + Returns a geometric object representing the union of all point values whose distance from a geometry instance is less than or equal to a specified value, allowing for a specified tolerance. + The union of all point values whose distance from a geometry instance is less than or equal to a specified value + The geometry value. + The distance. + The specified tolerance. + Specifying whether the tolerance value is relative or absolute. + + + Tests if the SqlGeometry instance is the same as the specified type. + A string that specifies one of the 12 types exposed in the geography type hierarchy. + The geometry value. + A string that specifies one of the 12 types exposed in the geography type hierarchy. + + + Offers a fast, index-only intersection method to determine if a geography instance intersects another SqlGeometry instance, assuming an index is available. + True if a geography instance potentially intersects another SqlGeography instance; otherwise, false. + The geometry value. + Another geography instance to compare against the instance on which Filter is invoked. + + + Converts an invalid geometry instance into a geometry instance with a valid Open Geospatial Consortium (OGC) type. + The converted geometry instance. + The geometry value. + + + Returns an approximation of the given geography instance produced by running the Douglas-Peucker algorithm on the instance with the given tolerance. + + Returns . + + The geometry value. + The tolerance to input to the Douglas-Peucker algorithm. tolerance must be a positive number. + + + + The DbProviderServices implementation for the SqlClient provider for SQL Server. + + + Note that instance of this type also resolve additional provider services for Microsoft SQL Server + when this type is registered as an EF provider either using an entry in the application's config file + or through code-based registration in . + The services resolved are: + Requests for are resolved to a Singleton instance of + to create connections to SQL Express by default. + Requests for for the invariant name "System.Data.SqlClient" + for any server name are resolved to a delegate that returns a + to provide a non-retrying policy for SQL Server. + Requests for for the invariant name "System.Data.SqlClient" are + resolved to instances to provide default Migrations SQL + generation for SQL Server. + Requests for for the invariant name "System.Data.SqlClient" are + resolved to a Singleton instance of to provide default spatial + services for SQL Server. + + + + + This is the well-known string using in configuration files and code-based configuration as + the "provider invariant name" used to specify Microsoft SQL Server for ADO.NET and + Entity Framework provider services. + + + + + Registers a handler to process non-error messages coming from the database provider. + + The connection to receive information for. + The handler to process messages. + + + + Create a Command Definition object, given the connection and command tree + + provider manifest that was determined from metadata + command tree for the statement + an executable command definition object + + + + See issue 2390 - cloning the DesignTimeVisible property on the + can cause deadlocks. + So here overriding to provide a method that does not clone DesignTimeVisible. + + the object to clone + a clone of the + + + + Sets the parameter value and appropriate facets for the given . + + The parameter. + The type of the parameter. + The value of the parameter. + + + + Returns provider manifest token for a given connection. + + Connection to find manifest token from. + The provider manifest token for the specified connection. + + + + Returns the provider manifest by using the specified version information. + + The token information associated with the provider manifest. + The provider manifest by using the specified version information. + + + + Gets a spatial data reader for SQL Server. + + The reader where the spatial data came from. + The manifest token associated with the provider manifest. + The spatial data reader. + + + + Gets a spatial data reader for SQL Server. + + The manifest token associated with the provider manifest. + The spatial data reader. + + + + Generates a data definition language (DDL) script that creates schema objects + (tables, primary keys, foreign keys) based on the contents of the StoreItemCollection + parameter and targeted for the version of the database corresponding to the provider manifest token. + + The provider manifest token identifying the target version. + The structure of the database. + + A DDL script that creates schema objects based on the contents of the StoreItemCollection parameter + and targeted for the version of the database corresponding to the provider manifest token. + + + + + Create the database and the database objects. + If initial catalog is not specified, but AttachDBFilename is specified, we generate a random database name based on the AttachDBFilename. + Note: this causes pollution of the db, as when the connection string is later used, the mdf will get attached under a different name. + However if we try to replicate the name under which it would be attached, the following scenario would fail: + The file does not exist, but registered with database. + The user calls: If (DatabaseExists) DeleteDatabase + CreateDatabase + For further details on the behavior when AttachDBFilename is specified see Dev10# 188936 + + Connection to a non-existent database that needs to be created and populated with the store objects indicated with the storeItemCollection parameter. + Execution timeout for any commands needed to create the database. + The collection of all store items based on which the script should be created. + + + + Determines whether the database for the given connection exists. + There are three cases: + 1. Initial Catalog = X, AttachDBFilename = null: (SELECT Count(*) FROM sys.databases WHERE [name]= X) > 0 + 2. Initial Catalog = X, AttachDBFilename = F: if (SELECT Count(*) FROM sys.databases WHERE [name]= X) > true, + if not, try to open the connection and then return (SELECT Count(*) FROM sys.databases WHERE [name]= X) > 0 + 3. Initial Catalog = null, AttachDBFilename = F: Try to open the connection. If that succeeds the result is true, otherwise + if the there are no databases corresponding to the given file return false, otherwise throw. + Note: We open the connection to cover the scenario when the mdf exists, but is not attached. + Given that opening the connection would auto-attach it, it would not be appropriate to return false in this case. + Also note that checking for the existence of the file does not work for a remote server. (Dev11 #290487) + For further details on the behavior when AttachDBFilename is specified see Dev10# 188936 + + Connection to a database whose existence is checked by this method. + Execution timeout for any commands needed to determine the existence of the database. + The collection of all store items from the model. This parameter is no longer used for determining database existence. + True if the provider can deduce the database only based on the connection. + + + + Determines whether the database for the given connection exists. + There are three cases: + 1. Initial Catalog = X, AttachDBFilename = null: (SELECT Count(*) FROM sys.databases WHERE [name]= X) > 0 + 2. Initial Catalog = X, AttachDBFilename = F: if (SELECT Count(*) FROM sys.databases WHERE [name]= X) > true, + if not, try to open the connection and then return (SELECT Count(*) FROM sys.databases WHERE [name]= X) > 0 + 3. Initial Catalog = null, AttachDBFilename = F: Try to open the connection. If that succeeds the result is true, otherwise + if the there are no databases corresponding to the given file return false, otherwise throw. + Note: We open the connection to cover the scenario when the mdf exists, but is not attached. + Given that opening the connection would auto-attach it, it would not be appropriate to return false in this case. + Also note that checking for the existence of the file does not work for a remote server. (Dev11 #290487) + For further details on the behavior when AttachDBFilename is specified see Dev10# 188936 + + Connection to a database whose existence is checked by this method. + Execution timeout for any commands needed to determine the existence of the database. + The collection of all store items from the model. This parameter is no longer used for determining database existence. + True if the provider can deduce the database only based on the connection. + + + + Delete the database for the given connection. + There are three cases: + 1. If Initial Catalog is specified (X) drop database X + 2. Else if AttachDBFilename is specified (F) drop all the databases corresponding to F + if none throw + 3. If niether the catalog not the file name is specified - throw + Note that directly deleting the files does not work for a remote server. However, even for not attached + databases the current logic would work assuming the user does: if (DatabaseExists) DeleteDatabase + + Connection + Timeout for internal commands. + Item Collection. + + + + The Singleton instance of the SqlProviderServices type. + + + + + Set to the full name of the Microsoft.SqlServer.Types assembly to override the default selection + + + + + Set this flag to false to prevent values from being truncated to + the scale (number of decimal places) defined for the column. The default value is true, + indicating that decimal values will be truncated, in order to prevent breaking existing + applications that depend on this behavior. + + + With this flag set to true objects are created with their Scale + properties set. When this flag is set to false then the Scale properties are not set, meaning + that the truncation behavior of SqlParameter is avoided. + + + + + An implementation of to provide support for geospatial types when using + Entity Framework with Microsoft SQL Server. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/HomeCinema.Data/bin/Debug/EntityFramework.dll b/HomeCinema.Data/bin/Debug/EntityFramework.dll new file mode 100644 index 0000000000000000000000000000000000000000..774321afbf3b0d9bced40040269d1e38c0f0e20f GIT binary patch literal 5196496 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⁡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%0AKO~)@qy8bLc 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

Y< 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 ZqQu*h;lPXDa% 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

K_E4V$lhz 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�{d$UJ+cBH*xrL=YJ_-d|Xm%j20 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

Gy&%J;9eew3iKIZC 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

)yvs&H!L&U=EUQu*%Ck*ZUXWSz-on)K!OtS_%4 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 z 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 *oQIXo)R+i1(krB$TS=M#)|h> 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

lBDs+|=>8UZ+wsCbM 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≤;GVYXUX# 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

` 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Ξ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

KA*MUW(khUi}rggxoRI$RYc51 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%0A`gsdk^n9ZkV(#|#vgGoYOX+)h1H8j5 z`FPI?E8Gw>z-w|F<&&=lLqW?>!M?dJ9t+J@}$>Aq^8IeZ?1?Z@|1T}q#MLUsvNIfSDg<@E67xDAxp4FP4gCM zDd~TwbegwRh-uFx}{-JSBu!yRp`G~iToMW~;rK%VnLcj_3D*^uYGI7>ldeR!USm)?+1 zFmAl$RbdJC-j}>9EP1$dhwuL&pM0-^Y|}!F8^!NPS2MjAxQ2P^7$o{uaW&g(EcH1L zc?2Uj-kbK0v?B$E(K;D7O^D6e{RwS;QUh(Fz@r#ak-! zIBK{LGT&P(@*?C1$ZOt!K9mo>3;J5BYL7d!3%%(gI}r01V&3r9iyVWb;C;q7y^43~ zRJ5kO$v!+m@mh$`79@Gc8zAyKQk6%l|9bJhI#mfTO;v>~^@>F5LvDn;>y7BIV~(6q zstIJ7H(lfw#I%CE=j|5h2BEvw%f0g=o$wrgZ)aQ`dnp5SK7%A?rB_zuBV2<@ z$eEAv%_qnzubxQi?f7LVwqvB)xs+3u|t`4ln+F<*K`BKshz*n4+)S4B=r zs-0e$dv%?!NX#y;x=8t3bgHktrYu-BE%J@mQlyQ@Zm*l9qB?J_fNNndBS|KpK6|}Q zBK>ggej2jht1?h}3^E;Zz#A-bkL3KV_k_qS$O6P1^cIOMgS-v-&ihDYoyhmz7Ljj7 ze()*|(q*k^i8r2*>adrSB;P=ecnt^Zn9Yd!0rI2QMPx4|jQ>39^-7Yfi22zYB61ut zp>cQ%$;(NSijd>pDi-{{UMsx2jeJgcpYjNhr`mN6sX5)!@vCzCM23l+@=Edukf)}L zoc3-ISuXOscU0$`80(6>%m;NV>Z7bWD80xlKU7OQk#pY8;Usx#I3$Lc3*Ph*I%Wo> z2jp*WgGd2n7$hZ*B={>Vdu?ky8%&G09!aV6`8@+MY4PqXdRFi>q(uDdq?nf>W#Zq8 zR7XBXmM5@KNiyRQC9={@TLZn8#$rx%WzV8R2x4CP^hp^;h{ie>jR{TAd znW`$}I+R{JzFT6NLnze^@$Vm@e3HIO5nsg;To2wDKgOcxhmDZWjq$52g&}_{*Nvx- zrF;rQejnD2m(im9p067pmL$}Nb>o{vsGmvd#p{gYe3akw_2ZL7{9dge-!J0#>P>Mo zgHjz!p;cfOYS<``k;CvNW=)O(l^fCWMeZ^n0Ik zKIh)2-*^6e&HH@Lv+vJyZy?jsdy^y&av##lTRK%%J`X7}3}=yEuaHc3AHugtFMAhJ zrmTgdFJ#(#PmolHJoFd7Ywd0G4zCkiqB?me35iYBF5c-v3gT|B#+R;F;!d&mE16;H z{Isig7l}HD?dHuVQPa7bx5T@=ue|7b(cRmCL`~=J-V_owoqKqf2?;X?!(0Jl(bKz6 zh+GmX3wdmes2p9F`*`aKi4AifZ%3Jl4)g2Y*Gbec_w^1XQN!HVyV@mu>FwvuCsD)P z&s$)?V(Gd3c>O%6E8jJqkk(3#N%u^WV0p7VJ??UPe*(5~Hi?+D8p5pyM)`^bS zK<{NCvGE${tsIt9Rn3bxymd*`cn$J4AyMNs$lKQ?e7pvG(@E5L4fbv!QDZU0dqGGB z`v=3^6T|$bcTQpCo4wUD9STjOJyFl3mw&IBoc{ev@6Y+FWn zI|<2P<E*YMdkT)UIyi5S6%jPhWEk;a(GHPc-Qq4d}YpCK2u6<2+w4C zJz26zW&VJC<_B-=aIm8l2WPytgRBzkM_x@{_mR zY}pqd(^Zh4z4e6TB=Bz^ZG;^5wk8Smj%PWLBi^wjFG2WsRgQa?xrD#hcgnll)#?J| zwD)fzd2t6ZzwSW(@OnO!bC54%g-7E4jyF$8UfgM99)SGmJxFpBQXX=_`->}66>`aY z%9Tli{N=qM1i$!zR*fN7yjAA#zVJ;Rh#zv*n;|4Gu4GX5b+rt*@phUk$Fv@#Ipm%v zl|oqZyqieWH>MJ_qa?46iD$uoao<7n&XbiNN2@>4s)*K?q#63+_c)4ZCrDaBI-;+l z+AWg7kRA|^R&hSBGm}k+Jdwy)qSi@Brnn39G45U`YW+y&BE#?571M?b$%|VD>4!SS zwJ^zdkkOEmT9y#Z3w+=Bb^@NB)q)G;FkeJwGBRbg4niUR5dH>DC9UuxUI$-A zhVbVK9@k1r!S~=3*w?7@xb~!wG^Vz_RkWvEvJ06fv`#MJt*U8bs1Dy6^GppborG_D ze}>f7&XQb3Und}SwQh^~@Pt{B<_YW%NRoDT374FNijZ57dfMToT;#Xc3Xj6myxJL( zA3I~Y5OR^EE?Sj`Jg41oWuAmI(C)i3bs!Bj&oW*)gYi0lZ)dEr)_{c9X@E=?_%E1fTJR%Y8CPzxJsg|Cm`|%O#x#R@u_RRLPy~`d zk_?&QE5!U-7tsp8tcp6#QCZgplU#+oBxJfv20{Ybh2?TAcxEQ#MQz2$QvQW3hP2j7 zuZYP8$Sc}lDbcGLZ8Z!q{&F5D-U4@2k%>uV$RQzDgW1riIwpR{bR6#Z+Tp93E+nUz>ML0bk*L0swbrgye3?(ydb)%!^T}GOY?ZJCy;niy z4%$MQ@q7W{UySUm?G}>8c0!&(rnBZ*#fLB=o(}avx@uKO_&X!bAw9HYDPpbc3F)N` zlj8XUbp}BCXzvI~^W1>&HLi~~fu#Hka*gYwO(kgx;hER9nIy@Sd0ks5g$;)cLFK+$ zwh%eR?sj6Vzji=KPQvn3d>eZrV*|7cB+Xmmo2Y0tQ1g7k$1BW+LdxL_=7Y3kk|_}0 zYOpp{h^(B2R&Q#b2`Pw6sV|R&hiZqY)jG7|Q+}v+N48@8Njd(Vz@b{=YB>%06yx6s z9IlloQAgAxwOT^(jK_-!>ACX!Uh z3wyQOnpE?V6C-c6E&Q;AgzDTza2D zqKaiZ)wFm|ei|@csJ~t=k4(C(Q1VOw;BG$z^I@ zWN6vhGE?RyIps67&=*o_LNYLf8Couh2H9AJu^C$R%`)Ras?Wnwj@E$W8%(hUXf;dg zM$#Uc<&fFh>@Q`j2xJZ9L#^*uQkFvald*HP(AQid>`TZ-Waeo{x5-RCWCvt{Hfg(* zKPa+pza&ew(ZY|fZ<=T1@{w@q(qCVEHi6P8jo0C1P zD4zITsqGaRIS2ERS*0BoBIn={A-@ZW&5JeKSrRp!*J!eZ;5fWQ|)@l2sB&cy;r;W{%t@gYt*VFad zdLfzY71X(k;aRV3Cs9*lgLX}b+ydN3=5sA!mlzAr6in4l*k*pAm6pQPw)YDyiR5$I z8gJ54NYwCrsg0&OdyyH0I$vq&B)>u45wd_Y6!PzmnicyTJgQr7VQQ} z+$(aAwnh7wTGfRNN9C_I&u%`&A|3;hD&!hTSIAT$cS$0Ug+j{ik*z+4@MF=fS{*6T z>m*yXwk}zRR$H~cdqpd@39WWQa?ZPhYt`PY|M}5d%t?m9;@2w#Rwe3RW zQpdlg{GHbF0MAI_-%|cwvk%6Ee@poXt^6S_VfF^jiF%+;zIIti#51g|JSRG)-4c?Q zI2qFTD1L=XW8d*sd5P*7&SRQ~WFa#AS)*fGX_AIN$Y%nNY2}5ac{U@%zrcJS%>|BI)`vgPhUwgve=l9&%2*BSriQ zOj!)`MJ@hE-YU(r1a%m;6c@E(Bx?Fx)E*>J)9|A9D2bY47qurz)D*j@)gk#5mHE1J zQS%DH)dQTZ^Z9;JnZ_A+x- ztNXLeG=NmRh^H~NmO?Vvi;&0A>bkZ@^U7OV*~7d}PQ3cHf`7Dn zLNeI~)H#Odf9`A7T;fCJf3*_7@K*S4Au{|PH1ka&`H3XXH=X1>NxW}1342wxO7Pi7 zWSxge3i zQp$ITWG3WINEu&+qq5a1NGhb9&rh3CU6(_x()5pEu@r?W_2TACtX5fXpnkdeT>xq#EQ|{IjaB3W*Q02$^cWB$s4E zs{67?S|YO-Qq#AXq$}h&q?YeflD8mdA+>#5NYWu!Aa#7nzscd558=Jn_4Oy&LXzYg zM{9t{=Cf{)Op&s!X+Mjf#?}u<>RvQ4YYa~QqPy0ebY$z?=m!mJm;I| z5(`q_caEfH2RVcdeAQ0K%FQ4zBh%2AO41U-myJfg6(oHjuOZXKcbtSj1KbQK6Yw1+*@{*HJgE}&6+O*c#m;U*zNds_vNOok#6Ls6#v~U>TKEi-xYuN+ zrLUb!`14V%e0@o(Ql_E(NvggUa+Z#T)$Bm;eCN&X^v!&l;*9E+kIWt~C3r%5W24EE_H1GmZX8sckC z!k-`Gy}#*8cF8(S`L}$-R4W?OVZL!B&rs#zzG)=t$)XXyStNeSjPz|H;m^GBzDD_W zlU%{{;m??j_EkGC$6`GV&)dE>F5#I}UpJCARQVm>K$6~&nkewDZxYEU%8d2RAel^= zux~BNLI~eRMSS~6) zI5yvBU*fGYS-DQKuSLEoLNZuw2%kPnee+28G~~grqTARjGm} zBz@_ZWyXf^EB32=`V}d!U&1px=zWzhi=;C$^&qQ#AD@w#pK#8|=liF=?IdR*d<*cI zZzIVa$TMAwu(iH*qK-Ts3!u(A-*zdU$*9~Cvfj5_$V^tR2c9&*HS_g8{VMNkCNoGj z__Bn^I{c_9+c(c8{Ee_|-$yRtzoqrL?=vCtIGq2M)<)kJmvqU+^N_x4LT0kh@CH(i zDR}G9SM+b$JC}DLU-=$&$sx!V-%~EBJQZg^KHVk#AzOWIT(Sia9+jS2ez-@EYNCCSCIS_ATmzwJGq$zT~p;@Pv1w*JLJ zuNn2!^A=A@;m*g5UImq<#AO4ruIT?2jP&@<_CFFQ$Gsth&z-mZHHD4jBR&?;l9g4l)Xo=1(Q*1_?tZ`6rX~hfIXL@1H~R7Gw$}-M^CLZO9DBRR1QD z@sJ{O@wd9;__vc(AX)0aMe-u#ATrDR^%D3n7bNx|`N-c}NN(I{2;UPe z_lHT+Nj~<^7m~#mLViM>75-(E$)?N-|7McCBrE*~giK&3AxF__6^&_5(Z3*nKt7F1 z$=*`dDS4m{WPT~^8U25VIy2Z3?9uq$lWc!NAwCu}MCHq<^M(H*5+7RKglzQJa|z4D zp3&dbB_7BYzvhxskga~*C1oMo{FY0e!TPhq@3^EYGT-={yQDTG*Wc15PeXS4Uvh~L zvdjO9OJ0QR_P29M8_2i*WS1mE_WC=zq%UN@zl%#oKo0o3yCe)b{tTD+A!q$rF0mo! z{Igur7V@Wmj!Sw%F8JrWq#xvxf00Yxfc)iO>XLUMSNzLeG6izgztSbMAlLk>U9t#r z-T#?OvLQG9>s_)7a?Ag@OZG$V_&2%ad&ocjuUv8pa?iijC08K#{X1N86TAPG~Vg{b)*S~eiV~|4newRD}DWV^8NexI*{Rfvcf+Xrcxg-E7rvKuS7a%3{qb_L; zDXAZKNjJy?`YD$Tf|StMnlT#f4by-$V2)imwX6$SijFn~6-JnYgZ{A0hb&!p~fu)6WYz z&D56vIo(r)kHu-Gw*2+=8bW^esBL%yU6aDpmcN1i8j0HSH`Yf8i49LveT)#fALP9^ z)h7yxok=y-r~OZ6mdr%I3fNR%NTR+U)l^?WqQ0omOkYc)er>0jzFA82ZjM*q@jtTX zf8;xtl)yCf>X)Q={>C)qcPsq*4U#f_l-wt&5fx8SK2_zImPH-Ep6rt9kf6R+O0;ro zeG`eQ+*;pGvXd&e)_0Tq0O7xM)>=PAat^}3chOouOmZ{Y>I6yQ*Hx>tB#%L4tIH(n zS58{%w@9wwyFGkw-dblKFs&jIwm0g@=E?hmD}h7Aiq=Pn5Ze%Hk!GN44+>yQFA9I34Ie-6U>XK6jt}+ zVp15-T~zPosv|P5R>m)DsJ;sGj1P6%M}JSzFt=E^4dF?;K-*)d9 zl}9jyyiTY82(QyQDvu+Rj7*oP@Hc4qS5mv^0Wno$>tGi>*(G7os-K+lo|JyLW(Dc4 zPa=ts^w2*Rl2d#>Nl$$x$qtfU`X@pn9<}`R*1sk>i_ABu+*{u%1YfMBC9}7FSV&%? znqR&3KS|X5>aE`waxyNVzZ}!vdWl579Oe{%5wcrUE=SU?Ii4Kpfh(?hMUpPa91xkt zLh=&TeDAFXC^G^X{>`G^`ims$3q`&4c0wYabY%Dv-dpcXvIuhUeJ=f}mHK8;Z~aXn z1&M0u?X8a`QA=-ceY&i}_#Di~5cbhK731R-W*bqNFTH*BLnWo`ft*IBub%RNl%tT# zkbZi$kPLPMaud>DZ&I3P@Vw{%oHxzF^Va%VA$YP8QVud$A6kZI3h+XSd}84(eH@8e z=HJp0z+YZ;nIEbPfT(4Dn4TqCMObZA=G*xZ`l1JUWqjiW!l&2>eVLSmKEGjYLhmE= zZe>MANJGeI{W~Ei<658mX@*fHI|0aDNAN zChD)bgs-`i^oi7puic%{`+L#eUqmZjXL3|JLwX^Tu7Ba`YXD@5ewJh~GW@p%r|GHX z<#WGZBi zepX1BJv>m>nX6|%$}8heI%Ebi^YpV7rGy|0APe=um8A5B@G)JgFA@@Ad}{C^T&CBn z%rg-dL1qPHmA;Q;C4>**CwjLkJd?=|Le?PjiGEs0gk6Jt1zDrBCuN=ZH{?>cR!0;3 zDwQF8s>Y-N)%iJ^u^@b1J{*+}kYX5%n4~}+`j4cS#dRAjV@IN`vXJ4u$7K2c z$YuyXk~yMhi7A$oa1HV_D*vi)AxRt}r~EPf8co%jkWSdA9M>Dv=5r^^UW7D4tK)jM zkPJ2iVn9ymo;o~(Z!tkyK+fnRg=Da8ke49^`Z6J5b{4|t@_GF*WlFx8z`7%IK`&RA z*THXdL;6E5>VrvoLU^4kdOk@yBo%U9x07V66_EEJxAe9`B5WIEI^?!K&n0sp|LBFD z;jMBK_9Mfm;eFjBB*OlHe2mO}eXNj7A)6ubM!kBxRfPRRt%@2uND|+|o*J2=#u*_w z2~{Dyvd6eXndcz?ijbUQ>Nx5_V*-gfjw)*`5EAyB8j3eoKE!h%##SK((O*3%XY3Oa z@!Ug(U$HM|{7xD5TL9&Z0wE_87ax|(d^zKskeqn6^p-P{8u0Nt8Fw3*X&Z0{&iGtN z9xlw|NqHRQK5XnHQG5JHj1xlA#9sIue!HQ9(XAn`BZYta`cY$TW-5%$0^ z`TGUcjNQ~qZEdO>Lz~LVYHL%|*xpQv+S=4KlD$&Y7NCwXmPBpq>KL<0)RryDSV5w; zeoq<4NYqyJX`_TDE32*Ov&J(dY8&;O@hpkjMl~>AAW_?&2F8mdYOB@ING553EfU{8 zH#E|P$UO-E^@K*oN+GfL=o=Y%)Jknd8yP>4sI6!t;{?@FPt-Ru_WAf&#D4Lik#U|x z{hC8#qmW;WX~N@}7aHdB^Tui^@oK-^)L5a*siF4E&5YGT(pVB&@%7Ye6f$@wjWs3F zjM*goXgP?=K4Y_xoOpFy=QDPYsJ))gI6|WKdb)wK_{%HV3U^Z%e889ym67O+AOA$9 za2liw`ZA-LS&-fk%lJoB4tq{Q#tM1Z)&fA&I(@^MdiRkl2-+Rz^Tb?D?NoYHAcVM#%dPF=C@imCHguUx0vd*H~Ns=Bze{7OVVIL}-@;Xh`oCk(N z_}Otx#{ZAZg7CfP>qa-KvkI~nb^01-N%lbaQTG6&Qw!c#PBC?6_lA)oB*F@i`5LX> zFp~I>T4CI|9E7}Sq_&cB5AsD@+zBRe`|v4BLK%ZxO(lc-~o(MGk_vXwf!8Ew2pqK=>6HfEEkWA#*{)624zI#z$z*ewL# zVZbo|g7F$_RC`5^*J}`doDep8iK&6#Tkq%*@5_XZ*=>0yw$zO?J`p09I=+mJGj_;K z^oxHJj9*C9Z%IrrZVAaLrsipy!Pk$-h7gg z)PYNw{f4nPh4FgdI3y$|UhN&yjS{bkzT(y1A>Gi0#P;~<#w5z9eeM+FmXI*}8*nsHfE8iefNh(K8f0Q&oge3sD1Z*gLRifsP^3pjnX7)-@VZA zk*Iz5A|ptm_T7t&6d`HiiV)w&EjFf5M(yJk8?%K(*h83N{2YI=ae^{x54*%D-$M?M z+QTk2MhHn`wb6?2VV4x_<+dGsB*C0S?mB&h@8OWisng+yH~TyIPjl2cq=8(eS979yYLuZh0a z8{34)FI?4wY%q4qI*gxjG!oLXw-^i76n*(1pBt_FaLHgVL6RX~8ns@RnI4bzh{sd{=p0S^e8!58RZOHG)95%`i|j~V(PE}5)3TK$VwzZoZn$i6y5 z66fMhv2ksv?2F5zkW)taVN%|J)P($Qv~|fdkTXWUkPOB%O(ACueK>E0V@Qle2y(#~ zPr~O#JIEztw~&aK@;xAzjawvP)OiDP)wnxa*7*PuhTJeJzAZ(qJ2#B&LL#06SXTKS z|E6(B3R{L&d^x;ntVrdpGVxrzJjcIfc;4X>VK*UsdA@CQB6(H6SUfcR)x%?LL%%N$PbXB=Fsu7&P5162PtOGBe@RY*9wZ86(`6{>9JBunVU%J zK=`k{OV~@*tjhJd;eBBM^Qcq_TNfNM7_?OqI=NC-EW7i+%&Sim8)y*dc#Ypo)nA z&lIi|#xG-{a!isTk3ya_$B0&PyV?*^&0H@e%(fxJr*jQ+myit4_mGrUxCd<>7IHG~ z0)#&eRm1H29v_~Qan;62scB|ONo)_{V_M5xLy{SlE!66JNOKgZWd`0CbrKUIs?{qb zPE^{Fd>oZzk{eO!NMejvb-Iwe3o$UJwanfmKSF{+QiK#FR-AxeP!ckMB#ET9xj?px z^F!JqQ^)*>WGJK~q^`M|8rqO5^gXtJD!>KC0FnN>-~Bg5xKBeRy2xHS;| zjj~4O3X*Rje7-j}%cskEdJe+xRx~zSk`$jPTQxD?AxVPp-k&$qNm@eqosnkdV^d_E z6bN5hyk;FCu`5)X>6H@4uMEsW9nEYfTP03KE52;_&18}(r^nfIZ%mtD$kdmVEb&`1yKJH!3dn6kme81e)^km90eG*^K z<=^7&W+q8t-y%~1b-K~EH>c5fb@vU%G=mNKzc@npA$8M^diYETx=@7 z6@$L|m?6| zAvy7C`V2LDk*Mi2%p4@8_!q_Tl;t;g+Swc_BscB@)H#GY!_7rP@GJHZz7`BOuL+T3 z@vF$_AIjlTLzrqN&*Kssi+9Yhkep(wuXoHvlu>=XV_p>^&q{8i@;hd^`EtCzsEFUb zSb+QD=4>H3@g2|OTWEM|BW%VA!Ee@M9bEbrzMf|mBiRet0g0IVsm>XU#e=9b-aJn7 zz;vu%kO}5BA+q<4RWL8r((=G-_|9ZaWG0#o7s%nU(CR56JxMx4nn2z&hmeebSdhu) z7?-qyOfjdBWFo_5nmLyw8`1%iVXhLAlkgMdbx4-^wUF3R$_#U_kb<~=I3{@mnVDvx zg?tEO$1StWGD33W&Y=#^%u?f3G(IDN4TH>%N>Ru-$cJV{(JG5Q1W6ZCPDlp(1ygm= zP<-#*Y$GN5)u6d%KOyq!$`Skq@mzC^kb=Y)>)`%-GB!%)M49nCgUZ>+%s2BF@nJq0 z$A4dV4f>jIUM5jrnw@Xn5+av6K6mDuaf^AYoMLM3EHDd6iC5#bz+AmVWa8C$Ej0HC zp*rYmq4}H4MC&XvPYcOqYKko~7cP}`ROQ9yJ`z=ViFubq&95b9u8<5iyt{{09ae-b zHM5rSIfc6d|(J4h-{hbBWAEhxuc3g^<`Ve{42c{@-C< zVP>uPZ{?L{Hi;VMm1dKbu_4@xzE+tbA+hPa+H5H#*4JutsLVviVvSj46|XasO~YKy zN1ad2k)Qmx_x0us64m>9^N^6Rcwc5c;v39bt9h%~R&;}D36WFdJ}Pf8$4g;%&{wI2 zxchImUc*~OScwntbPZ&qnJ&ds74igRlbIzXPyBuy?`xAekEAIwHAQBTkPH@tJSAl8 zr($^6tB^*JFU?drge=sE=_K_@4w(B$+Ct(N;R_gM$_Cyl!UjS3x!!l?-(q+&ST{`741DwRJM&8# zo*|G=FrB|Q*UMJr&uzz7oKYv=ESD|ow48yvT^OF9O%>_bY*UYb*5h1a)^19lCh<)YPXm#COCo-}7R@cqVLgbp;9^-Z0 zJSaqNTX?IR=J&45Xe`e+&66(q0hwFo4cRJzAAKEx+&0VQ@nOyp@(1LOSzAb$HOE+7 zf!sA;5OOlEGvq$xUvm=4cu4WZxB_FXb!Eyz;;cfuc;%CEJo6YN-tv-s40-Yk#uBU) zmz0APwpI$sWEYTm0)m>A*7f!Pe=x<0_g}TX>Fud z<$HOUuWlh$%GyTqEXf1bE|L}`rLBV`JxR(~BdKyKq~T|bJ!pkV=8%-L-Y3~a^01Xj z@)JpUtKJ?y%(40YsI~hSF%}*R!<>O(e$+Zh@-k$hke{TmZjd!XZn#gReO6_b(}L+x7w2g zA(2rXD$iVkdv;536~f9AlF71fGj>48Ws=3n@V@F= z?3f&jwUB&dlC0d{q-=+1@8C@V>jcSO$SGv%StpLmvG^6j&vWZr6;H}m{Jl{w4J?b~ zPs%j3I+5ImTtb~jR)bTrRn4Ud>>tSU)*d0T`PIxiEkv$^{CK{Zb-^WxOL1OgCH~Iq zqlbcP@q+_rixE z{M(qOl9JJ97?cz~j|`uNR#a|4_|+aeDv8Ua1S}s-jY^O+7%#_iNRlCZ|L$0=q(txI zJJzct>OOwZ>PDjOjY|eMO~c26}%IQ$8mAt=`&@ zmsG2w3z2ya@^VzxK$=3@L}e$0&x>|Z`Tl=IJ^2vJs3#xVM_Z{UA6|`$dh+45sGLM) z6TNq~-W6k-ld!I~ToSrkGlWFg-_(0o>k}#B2!sz|SL;ic3`U)<)=rm^^(HWS~=JnDkRLVpw1VlGuS#yQv72%eTG;~F3LJ; z%^hOBCxxl?bcmHjqSoah)}l*tywrL+#47xktfSVrA(ka1r*kxH+t%Gk_FAIsVBnl7+Dv2MG3mImuC3%%H!>#dGc%29v2;onUjIe$q z84uZuR->!}Avwj=`ZdbBAthcdtD~$YS9zVBc(ts)ZDo+CHSTR|4vAXh-m#XFs5Nek zwVFh&abYW;M6JtV>!^@0n~fpl%ltU2?BB9?wN{R^91^uwj`**AG6 z%=qx|R+-i&ArW=~8UFo*nbw~!`4z2ZS+`yC2V|~Q{+8^Ex4H&dWOX7*Sb=XKLzY`9 zF5#_KS>0~SRuzybv<&ywt?eZBASEE{tO64L%`^MTQg>8cH`Sp#Z-;;HIh43q`-&m(f&Qd1F>UCdM zj$euGAu8usr%5V8T0nMM`oA*M5W@FOyDbkxIb3~G`?x(;l8`WKhs?`p^{tg2$1_;w zA-wnf))paQHW8AH%mFJYfoE|31$iBkZ*>zAVP8Q8LVmLJLbA@!5I$Z_kdQFj4B_K` z)ml-GXCmx8L__APwU6WuWv*HCACj4(t7WTe)+Ul#5Z>1{tM$V&K zutmu5qb3NyWrFcqPrWDD-;nHryoSCC*#}4pNQ&4;g@jrB8vLRGG9LR@MOo(o$QzIn zc5)>t)gk;jy$9?|BszqTX=$51E;Ah{Q^sCIG7Q4U;z4_MWto`<8G*_V+N-NbSq&Kj zDQ6#gLdt$f8ss5+UR5sm6)MOFkP3FUYBIC6XFQt+dCblyxrYqztCC%@I?v#%$dHeb zsbu%6C8ffr@>uk7o7IlV24pJRCxk@UGsx_OJYkopEBkr{@++jOokh|M!uzUfXD5k_ zXAFcdnN{sAB#WbxOY%)ru8U(NoVE4wuwO?PL92Z-BaW>2`#aU_ABChbelN1va=f=@ zpAvF1F7g?EPfEyNB)>x*6LObCT}iHPmv~B!#UGw{RzqY`g~ZO1s@w0$Otkmv_J=|W z5)Tf+y(F}%VJ{YPGVz7A3GDo%Tvn1yo{aCtW7Al}UME{czouTp&L;T+89se#*d?Ck z!&4Ba_T4q?QbOd>U`X^;l`{M~|I3hC_Ddv#Asr!g>`6jmV^P;$;i|*WLF(G;UD5-s zlI+Vu!feh>+!x);*fVxwJvj$!ti$gYU@Yp{WrXB;8bQ_zsX(IMZm4HJK@y5)YD-}q zApGujJv)hne>sOgclxY7gXDE&_`36)J&%NcD`qk>_3gh&-lRGW?Hf`&6Cr#WHnMLE zkyDHxoi?&P&&shVjCGX1ktqOz4L$3z`<$K(hyDVT;a z`3u6A)uR0Ddh5rGO7t1~sPN+iK3-N-_#T#vt)yg2ROZV@KuO_M z_3>v-v{F)X2ZS#PZK84t!uP^a zDa^OeGtsJTG?TDFwrU@hI#H=0mKJ&Sat&Iww{@3ngmkdi3MoibXA|A*O(bf5b+fmV zsQJ~+-b141S9klc5WKm7ImqAf>2BYpj2f>Vc8TZ2Rw7Z2R}cFcDRF8p_q1D+sJYz7 zP9;%uxu5+P)lo}tKl>($T6+80tiJ3^&C~vNT@p2Y`l~4xUBaUheUD>+%9K<~cuds# zm7+4yWj-cqIgE)~4hKeCspasEsHi1sP*l_sH8?72iFz|CYFQl`6}7AmR}#I7H8Ltc zU}@p^G^0{jEtxSc61HFjNnjNL(sXGAu>4TWWFjNP4NVpRG`VY477 zMP>xa8j`X01d;;CS!BX?wvaG;^m8fW?6VE{Tn@9RNg{UZMqFZhkn#3 z&XvMGdm;g!NW*<|`<9R}3!_eP$RvA1V^N1qgFFJ6Y;PBWD;|&z$MCDe_Af4}h|E;` z0!cP9)gaUDNlkbi*?WCRhF$UbnAngk`xTemdl2Vw_E;%Qjr%P7kdWAT&9*Bxl|xu* zBaUQHXSThAgA7}NyUF$nl0J|`$YR^$ zm95@_JOo*4dr4+Oo`5X3`;vSOc?R;aoi8MVeFyPDR@!4VS?4r_Uv2)xUQ2Qr(gK;) z_E;a!GLr-u2w8705|Y6*NGc@T&L?RHnE=^j=jyyw z2I~qLf%{fp*`*CBBOzJHY_Z=X`2eyAvdzvSSp!)G*+^U*UVXke}@oAv4)a zkj6qz%S`kckHdDm=Dd|$D{W*B+XJL{9vK$T%Hj>{BlcS)>8QhxzK+<3T&)hE)e-w{ zOI|0Ft=odT$&eFvlNaUi?1S8coU&7dMA&f%KcYTukCNiK0^!FSr|mGwzmOuU@LK@( zdqUDYmA}UH5t1Q=Jq_X4-cQ>rNeq%R_6};*7V-#M71(_DOsC;#5ExH#milTGm@Pyu^Ec6|X<(B} zJZo@wDNy89UOD3V5q%~`i5*w)KOEbXht2Syc896l+reEK~$Do$Z8m`_JMzd z6vV0Hu~!3$ukqds;#B42KqV4YxkDg{L{;t*?W_29d3Mt+D*Qc7{(fal)EQ9sK#Hg% zho>Hfr+eUSs;uht2uvbTb$SG5lBha81IvWS<9P>ldImfl`B+F90O=P93&~?@Oos-h zk*F~p7ML$3de3EeU=@iv${ilqM6FcsBLX`~)N$sBz)=!)oH;6Ri$t9>z8z@Xi4S2O zQ^&NaftN_sG3`5nz9j0Hc1&QA6puP%4F}ecsN>ae;B#uF=2tkdheXYiu(S!FDJGz(~s30;KEb$EwD>11E zde=$nlgtbBAn6P#i_HAMRFd~e76h_MzJNT6%)-D4l2as$0v^$O>?mb%V5|_i)#`v@ zUL08IlJ_8=1iluM=TT>5YXjS*Fm-OVHn5vA>da+bV4tfFue>gB&n3L_SAhyW`P7J2 z-X5qZC0coV;Bm^R$~yv22${+1W47{dhU^HuLK1{Le*$+a0x2XtxO|3Zmjme}qah|_ zXJETaT0wRNmh}4X+}Rsg?Gk?Ous4v@n`iKAuvPGe7Gz&wb|2A7oK1{Jo&5p!x)9HU zdH9~yZpID@Y1KZC{Sfey*pNkNl^@6z5@s(! zHb8y}v>qsjryFDk0nk&y_%-5mN3z&O!bT3>A{W zO6|hYJLGyGS4eE#xf8fBObj!tIoKnfUb_?6=gRQ8b2sp-6wmK<@9wdp=u6?LY# zr0`li)8*_I65E56cFvQiJxCen0*P9`9&|2CiSAR%I_2Kxz2`;0X;9W_M55Nya*kID zQ+t_mPG=G|zsfmXN!0v$*y%x{=5l$b7m3<~JnHlzQG23_PG1tWv{Z5iNQv%c9(P8P zsJ+bN&RA-t_A-w<=_G0|Q`MPEt<)Bvy0bt??A_$*&T=7{9v$=IQB3FR&Ke=HD{s}E zwIpi#RChLzsQqAd=L-^b?W?-8nM7Uts_uLxB~DGl8qU`wY8uvZwo@y0Ew_%7L!yoW z>Nq>8m6|(so!yjC*9Pl4dr8!_!Me_V5_N4b$vH%I)K$JD=X(-$mG2oRpX8r6VG^|*)_0DmR&*`5fpb(!qPp(a&^b;SwInojPLil4p^QoskTfGb! zQypJGb=s2jhct$~=A@H^Aq&u|qce7#Y?Th-y?1uzN2Dx(@Oyt z-IVF->?ZjcvJRQ9PQ~%E&LzkeNO$LgkPKF2PXhZM(!*&nfoJ62q0~A&ALWdd;u%s3 zNA9>z($|?p@&xXz@wwC2nXWRZbG{Lm*+Mc|CZs&-^mXnFkz1R(b@96uPRTSmJU`$~ zQa+|BPI)1@?AxpOS|ntkGgwF-<4=|Ui7EDmv(F{vYv6Y)oLUok9hrFoGT7PYl2;)^ zoLZA&nO2ZDopd2`Ic$s}e9Ni#o*bUB5{lyg`}2D=350ZDakkre$_ z{;t_OPPg}Eo$`;Q)642EZ> zQ*Q>(WU%9qi;!8)cp(MReZhxLgPAgO8=33K%yl-BJhT_*DeG}f*x43MgBx-;0 zsWXK{?F%+IONGR?^PfAP35j@mV=UUB_s^Y;Lc*RgkUm1TQ|3d+Xvi1NZpy5MqzU>mxLJQ@* z7z~s!MrqCgo$#V`<<`D?b-^uIhd!1$^k3;xYbgyHRG=cD`vCnBKBUf zztfpA!yx=Aru|MI%6vd|4mfX6W+l}*;Ea?RwjIKcB@Q}2lYAGIa*M^(U?-xIPI4_O zCrFBXFNgV{(`$)rRRJO^ZzQP`mF*naCA^eUqhnz=A&P1gu$*rg)ktF^g$Lo;eC3!R|ElFxer5#C=sB|F-MCEmo zu2C5*B(~2zWmj&fJw zE|t^GC4)c5wH;@uOZYQge>hWw$m`gTLC!j>T{04_&O7^r$YX%9kPA+eWVr|qZoy*uQ z=NGEe48rI8E$1Z3%hcB`=RC>lkdM*VZRe_xyu^`^HA3!CW-?@hkoXm1`gj&WHVY{( zB=(K6J5E_4ClhzJkWXjbaUK?u=J_10wxiV@ry9vXZr^B5!#ecf~Bk~~Lp-^msdVJ#titNyQZNQ$RB zgikRRyeuRyZVZI41^86YNo6-9vttI%aD@6Y?s`Iln!2YNy#s8e=wM|M)tlAm8(G>3Jw*5?{q>;YY|OWEuuH2??`5A$%@34tD!W)+u!yH&Bpi9DHnxl%|l{IJ0dUY#<~jp*4iJ z@&>01$&2If-sYo~H+WY_2J3;$X^1aa>1$bM6ohXR{6U|Pyg0ru;LD*u7!rc-=|TQP zD?PZ4GJNmAGiGofWw`K+6>PbcSI%XNX?Oy`R3Qb?Cu{@3beR#tr$!)HY#VPC@hoeO z?K75nCsc356QpZ!t@54W{gu zqCwIj1A=FTl?&Dj2wzjOf~h1yF34mB+aBYYG}Zw!5i&D4KuBI3msyb6 z!P39UI$Tyk<^~I$h{@NG1;MdG@C5^8@*s?+b5|=cV3pt9+sbH>A!d@nRyIyJ~%;$tkVE;DLC7ec>!`YSnY4w`>&|n8*(#P>!y@D5T3agoGm0TuJ&~% zjx*y!M_n=wnS@Z%E!nEV@3@))DH5u8TS{HX8c2yyDoJC=0Z6%!{twUO#f^SXz9IW? zXgtZ6QQ1v02g0|#4~J6j%E~QJ=kEmk0$^yiki587$ndX!JRBN&k7pvRJ2Dw~UhCn| z0@~{x!<8;x=aJAVu}8~bufOSG7giR6L}*?9VJN# z$YAG3$uB}z2n{AFG+N4|q3=ZRu`5fDg^tPL5l71jU*YH?bd82^{%Jgs*d9k0p&s|e zFpCV|0#pu-6q4rIgbW|%%Av6&1&|LBuN-=hq}&;qsS?T{sSDwmDxo1gZErW^5XcfhnK`OtQD2Zc+=}4NS&zM<#G{UO9)*T zl`~o4v-rwf3A~>YV*m2#EGrMp!Fwg4UM}HBgU^NXg~+RpRZ+P?s4Bx_qj)|ufG4K- zGS)Cum!t_Q^Ct-#hU$~>cSiWrh7Ci_NccM={FtO+$QBau)NdodP1h*Yl4Ne_1a`GC z-aQGmBWXdE8;3eeVN04|kB{ML9O_Hb5t({Irb`i1tTCiXXqAxIR~(-YZ4`1caRFNK zCF=Rmb|LbcmLaryK6FdA62IcX$GvH2W*i^)f;e@?+AOq|WEsAz_7XD9Lf;BWV_f(X zlHSl6%J45nwns(_T_fS=xxAG>R5zYi&Wq#kWOaq;p(a9Nzipw1LP8>}@Hu%FsfRiw z@KzC4FAu--jG3v2dI`y7WsvEQIz}j0NSK{HFMo;K3?&uft?&dpGJO5ALWU5z9P+OM zTA|i1;Tb!WEX6Y!t;V3T9qJ||r}!Mm1R<%EQQuLtL+_EO?JD!pw2wsH&kclrAyMyo1VUFyuHfwtK2M#{za;B1gnarqp$7}|aZmH8 zFEj>2l}Xx{lwVy4hLT89AiPyD5F3fwTzS6>>8AJ2fpsg^KVYJel}^WZik3PUZhU@G}c;jF7PuY1C9m*(Q-CNjdjf z?sK2}K1vKxlrq_}eM-#T*vd9zkUeV3nq5g`G-C)cBFVmtea|lRd%dsgI`_H0{ruqiDf&AZ6S0L18FQ)j}IQF-70@2JhAk_DOTA$UP zrF4hnLoD?rCj4l#6%tejNwNzPQVW^zad-&QR!u2ETO&*9hdk#X?bQD<@y6;K>R3r= zthQHYGx3g5?bUfg+`qNjUfsh*q5btYGIvnV3Zeb=FCd7F-WbDs zijX(eXN1tRyYyxI&Z;AXp53jFn9k~Kw^Rju)fLi3JtBmj-KChWYMqiiGd;UY-@WXn zUKB#l?uHT5O-(ArW9Zr4w;=DTju3iwm#!k;Q`ZZjXLtJ|riXf82tB(?d3vhJrFkBD zc9&}Jt@ai|&+d}+Q6~zaXLqSoU$uw{|GFUk{hfYltpv(*G-fpRj&B8t%_J|@9Z~(% zH-xw&s-N0bh&z7zsl$c1u7pfweHA zoPy|cNEWbC-rOc#J;Y>qbl#G#o@8<~#{CVZs~3g1zteQ}2AAkxvr1QQix~HBSEY;J zS3#LM;+T-G#w1dky{mOMCcju(L;lu$x>}CK6vWWF=n3>I68)XJ`@$1bO@)fu56V&gRNFuMA@mLHuhcbCsW(w7 zNB!+TrRJ&E{!?ncdbtW~k8&UF>59w?)%b@ zd+{BFw)1ASoRIG!??HZ5s|$Hgw0Vn~BBT#wE@HN-U4^ViDeBiYwXYC*1D&?~Z|X`R zPova0$aeLrkmn$@<#(uYk5GF~mfRGZjX#>Vez zx+F9<{!mvk@y6;N^{Nnetp2G!U7c#@dFW{Km)epEpOesAnSZJCndFuJ>H@!?yH8yv zWEF(2T=uDJglvY;uW7&fi;$xbx|_3K-74gch&iC{5>nS!hzzUD%Xt2sg}Aw}vsCV6pPA@ny%PpJEtV0BK&DfO0!$%O1j3(u(alGt8W zW(YZ_I!q$UcS0_xqlDx`=uX5X^%@hb{GW?eP9e`_b@O9v8^+OhMQ%Z^tLo!i_MnvV zGuDXIOd)q5^cMdewOTTddHgazqy3}K7NSF_)IaK0A@4)zZJqmSk&t1KGKl$Ct@{Me z^BsgTD}GzZZx9*@G5(%HEJ2>nvZ`qOGsOt$hrNE^hI^%vG6$x^04IzlS@>(u6X7D9SJs`?Y^ z@ECgPbvWd4e^(}XaqAH?0rI53-!nY(F34Aq+Ww?^T>ggSK~nq%6RbY{jc<8D8u=GV z@;l^te|&vjdkSKXK$`k{Gl?iIA(tR6{6+&F^BUwHq?Ny)kZwX+`?oQPD19JwYS*3rU1Lk5Z0*n2^EvQq4<{w*CoBj>bHLn7Wr0f%>hQcOV%eY0p12}36NYYLeJX%Cs~pUosMj=ll-He`x_nm4Dy}-lqf}49Q6BI;=jzLw0m!KiT{>}aqna; z@%J-$o70hb9r7&kpAYidGa__f2I)nHdGO0mH#}Gi1LHT^S%GB zkX=H4@FzRGE|SYAwc3AP$RQE4)_02hpVpqY`ArD5@K=AXkPIPP{B=4|OkNz_>wg4!w)$^zDg7N{Xx{RhUrA*#r8h%p z-twD&#N#~kUmyFF^qk_#c7M5KE~N)^+2P+OqzUB3Z;LC1{@Lv4ht(&@WAlnDJN+eD zW^eBIyFXEq7HH4!{s%fz<_zC~JNz%0?Dkg@;?7rh`>Qj_EA3u`?Dp5>F^W4^-|cV2 zW8(f<9IL3v{D=QFk%!){vLJi>okXegsEcOQd;Doa?m=kQ{ilDTkgET1+3R1+g{?4r zh&+G!8+W2MpDgJ<_qEU8Qi%K9*FJwxi2K~vK7TtQ?sH%J{N07P&wcIl_YmSf_qEU8 zQ;7TA*FJwAE-~(NU;F$Y3UQzN+UH*+#C`7TfM0o&wK=+qe$YQii2K~vLH|-A?sH#< z{i$83RJPLXF3xD^`!WC8x3~;~Oop8DpMIMpOPLIr3pwK-)RjxqHh3Nha>1V~^6= z-l04Z=AkWii*{+jPnsSKr(h`Hf+m_(RR%uWAhA?{yHyXn6r z#QlqDxBWG{vpj6H>_waZ@$Y7mr8Glk`tr%Y{_^kf7Pb+!E825Ryb+~n&4sulO3~U1 zaYvM*brj-`C`Icg#2rzJ)?J7@q7OB3Rbs5ot<5O+is(^~eRQU%KY(D!rLK0Ym7$bxqGt~DeErRdvY<+WrX+oDpRiT5qs@>&XyVf!NSml%`^G4Z}joT#O8QQYtDCTayj+;8(H zYJ)%EZFavfoTyC|;(nVqQCr9*`bJ@*wo-`uo?W80j*0hu<3w$}$m4#gxT3aGi2D`d zO4@ND?pH}GYuC9%ze`+2tK5^f(EToP742~@KKGl$RkT-xxZnG#qB)|J`>o(AT8&;j zkNd6QhqNX_+;0Uxtl3PwFZx#194@i$S9Ysv?+9_f@mo#%REYbP-RjyzA?`PRt824` zxZn6q(sG5k-}rq@yC`HM*5YVvBx|L5Q=9W*-LLf~Yn6n!U+aBBdrXM?wcaPSXN9<5 z>#e0VW0Il#fe}>$qot1aB@;ZM1bG%xS1V+KH{$Q(3CTWK$JdUEQWQgLG7YqITzros zCIzJ$YFC9cg}lJzE)(yI$0=GuAL>Ph5=P8Rh)L1<3F!)d;_U2{&%U?p_HwqGVx|IA*~k|-!jy-3o#*WAd_t6XUHKY=|cX5oPdP2i9(J- zE~CnBWOX zWRA_lb)}XsO9h=~{#F`c!+Lf(YfkS^LpA?~}JZ)t0VypNc6i0P`GWa1s?yJ;7hc<)`)dH?T`iG`cUP#pmc+!{U){Bul6-q`xhg$x<{ldj}=RmBo1Cpt2VUkxmIVPU1F}1}LL0Q@{A+zmR_C!#Yc1D!?pd{Y>K&c7ZRY^`l zCTjPX@Sfg+pO~+-jUvX~r(bKE{}c1I zwo}Boqa{b%Eyd85&(RL?m}r~7)lN%7ZJwuHW0D`!G!Cl*brofSrl!;W%8&62S*Q(V zk{8!W$Rcf=i0LlmJM9Z0^>J>hfGxjRnt<>E0TfUMSb3Au(C3$jK#$fO{K-ei9RvR1n$VydCk+mN5Nds55?kX)@q zgnG(L4TSunm6s#}$=9k%G8$5#Jt4^?$Y!msBws?dXiX%U580-@EXfMUcFmMz9i&iu zU6M_Z-?c81?1b#rdPuS#vPbJL$qC3_ZKx!dAp5k>B)JVapk+%Ew-JB$O`9o68ORZB zt|XNq$FyaV)PNLeKS}a560WWQGmCQ^e-hT4@uPLOHvh5Nnat!6ObzUI!Wq69@aNW(gadX-zmwoBCZ9AkC~2rF&EN6Zz07jgQV!Hh*^%9pCFC&kQB2K(pXQGWC!F0{T(LWGda!l zo=o_WpPr{}rvHzLcP47CXE4c&9-o`*VK1Fp_Tpub=^iUUe&K~VSjIw{?fFn-xlJYmsLG> z812D~=u^smy_6952|&MIK}ZL2&ee1j!N0r`bcQ{St@?lE3dGQB@KS6(=G%lTJN-40 zXB_fWg@pA^Lf%ZkT~H?P2&r%yV~|NtAq!CIIVJ;ytcCEHAwsr5nzEP?LMZb~OvVX0 zj+iz~CJVU?p>_4JK8p)$bBM+4l7z;_8~Pz8-X3hPpJtL5-GlA*b6lc(u)Tg=654~Q z`oB!PJ=jSvJ)G?eR(t;$_`Z!^Ly~d0C)HVR#wEJHy6CNixU;V=x*_BWo*}0>QWyPg zCI!kHxc;Jfco)3~k70E!L{GcuqeQ7MP5v%bS3Oh6>bQ92d&G3rrwDQD>Z;FXg69Dc zLw^;$t3Hp3S64TEA1}q~+J-#c^jjiN!gF|c8PZ)>M(}ZX1bGfJ@iEDZbu)L@tMC|> zhh|Oh>5nnt`-0}HJ@lt}sp!5))1T#~e3c&LPdlgSjf5n`$FnCx()1U3sp$UtK=(^R z`>U58X5#IyK6)3PhqdPp+T2I)%S)9GBXjZ1xQ^5N^BCWkcNHapNjej6`}EV5k=}l% zJpJ_2l01P@1NG`m@=CdxKh~e*!rDx~!H@NNlF)DP6TKM|udbnb4<`I5k%G)a^#PL5 zR*mTCOuVg{p?}82JNgaNvn8SJGeV!q#M?fj^!-fuk@h9jHA+7(3GJ`Z`gNYCwEG6c z82uiX=pG!SE2C)pct%0V&e7UYrO*#uRUMu-K0_n zQ0i;Fmn4+u8~uO($un0U&xG$C+8T59DZEs4w9M0|Gx6%0r+@SR#mwUp?ZrHOxg=Ek z0(~tLuNRB--0Gc#Kgh(Z>pT4v&l7FWcluc_(Yn6VuSr66Ez$2Y@#9P$Q^+{PTt=P(eF_)Wi_*W6EN0^Eoh|xmQEC%PJ%N}l zdM*?1SGh&sA_?uCZTfB|-rm`+A7SEU-mafz!pBB^WZtgd=6RwcVTXQ~$FQwRbCMl; z{1|>@bB|Fw^amuN+IQ+zn0U4C(vz8Z<8YT=mxe{QPGU0W#LBICuy}0-;U>m*$IiL@e^3bR|phqO3QFllm!^9g2NA#a~9=5-_ zBhL~2EE8`e6zNxao@g&l=r?#NUzy_Z${>_Fq2Cu$1wvc(gkF3sZB=h;oY2cL;k_8a zNI@_2yC@Is%;6RVH3t7xWO%6K(Say)BpMmcO9CDGAke zNq>)tSJxH2KNH^O+6@)uivAfd73aQH_qRTi$M{Uq_rLXTguK=_maRzX+)rjoBjP<*58Fq#NXCR%)M+K9GDS$Ax?%Vs7i_gnTAqZtK^$D3c&t zQRKDg-aM+faZ-qT{3&5vmV|0AY20Dr^`f*UzLvz{IPooY8^_?MC!9d7kJmuDtOYmuOw(jn0x# zT@{S?nRsl z)-dsU@raSn^RTV@0P1?g_>+t8mD2ngHpw{5^F(`^WE|rX?P-#6UJ|P7G2;dkucygI z>;&3_UhT<70u$cTB-Ea4RAJ)n!6%KXT%vV7X*?kb)m77|%fzdzw$YS{S66N06{!@B z`Pzmh3FWC{yz!qr&l0|Ods-UFOuY8AGV1X>Y>d%4rIn#`QTiZr z04;pkcwdsXkk&>&NxDE@F~&&J6Vk>wAju$z-)J|HA8Fk)h-Rd5@qL84=uE8{{e+AV z{nCuVLb4$A)`n&bXX0%!-5Afr>$`4Dm4y0k8ecQ<`feFNGU5A_jwF_m&&10dG`90R z(R~p#c5;c1`Jl015~?d?oM7VB`kMNkT!^k-AXYjTv+BZOu|gOZTPm)QHp7Xn755ICf@#f*BBrP zZNvABbSB<5>|u263X1uSjEK4+}qf|#2X2{jcrW4 z%zcbKQXb0O$2cMhW&Y4O%f!pv-?+iV%iQ0n{DrqKI$>)JFlsUJ>KbIE@EBzZwsT*^ z3^ICgVXHvYR_O}G!w5qLyRdrk1`*b>5kzL;} z5iwb)E8RFOWG7@ABw}0^azey>Y9vgdenphOMNEcKlS#fp_ZcbAFk=dnETu%Lc;#!z zaN`ye{)OuAAR~=Or&6ALh3>ih2>HyYDTMAtZiI|B@|o~bJ0W9@qG?nrTX__j4?@Np zY12t~%tc71ku%eiJCF&+uvxq=x))h|8}5J`{bqYH4?-pzo#*fvy6;&XGR3(36&Jei zSsOCVD3`;9?t3dYnK?Fm3;8+RpX5BbVSo9D&61IaO_NYWSb zt+9GO&rJ6?hCt>Sg$qc$F}A?i&%_&13ymTs-e_59T$F@H%Xh{tCf;aSV#F`>GSeA$ ziBXn`mwA~{g^8DWnemt;lzD|whl!VYm4OETpKr6c!oSTj5&il>#1zEPw^?REevFFy zZI*RLtmm28Z}}EvuW^70o~}V%vA^MNvhnUB+NXK3ZVL|> z1DIs^=w<$urX;jg4;#~XDOP)B7CVE~jGOkHNEj(%5XX4d<+9>s% zH^S?q&8LlOOuROqHJ)VR)qd8f#Y_2)*1+>)cyIlzQJ=>|Yd>o=m4s?PZ>U1t=VUG# zA2adVbIBOVgpWg7=f7l3yL>}4~GzYk9ERuxg0N0K0r93UsubajuF40w* zJH`&F6y>>N{3QwHxoaGk^61EO-?+}i+dhiln7l5eUsO6XDNx*} zLra)Th0ybd^yZz<%opO`5%ZZPmryUfp8CuRO!(eOLwkJY6HL6ZQOc~zWCR-Uz{HCkf49YnTr) z$?&;%3?DOVaABimHA+2Z)?wo9!N<);OuYT|xY>kDbniTFzAOptohM9_iMMy2GT&gr zw;0v+l-ZSuS65B5C(jf8UDP!DaEaDc)BIQxs;jm+oQYRg9W#pwuZ!-`)iGyCLU+=i zH5W>GXgfDFS4l$K`8jjFRO(l>`FV2(m+0@biMf}Fw=bHQk!9Wy@-Rv@F=ue`g|V0E zo@NU(M+jZH+(b+Za}g77zqc^ImxS8W(#&Pz)z!)zv)rqT&Zn)+$xOVnRcmu06K^}e zVy@yb(e3<-xmuKR&sMLPzeqycxsADviMO5o=CS|e@tY@@WUxCd^rV5`yddOb^qsDf z{N{Bbw4O=VuzvF%&lBCtezU|1>KES{RJ(4LXTtYs;&xo0nvEo(tDCU-5)-edj;ZrJ z(VjYHfJ?M4$80AF)%BYB789?h?aZD`cd9CofS5FMq7Vg7EQ~`;nmI!VjRY<^LRy#MTP)37#Kar(Y33##!?q9I zUrsasV&ZMXp5}2T-WKa=p5&!`-9+Y|=0zS8-G)8QTawT=>}|$=PrdNAVPEqBCSF~A z%_>az)|iie^);X2;`;)1(byPZKF7p6n-4Hwl!WRUWcrzSb$w*E<#||7e@5ny%pOd< z+6SBcc}#R14mLj#;vVM*o5PuSTVt>}ic7TbgUtz&PSl^BOOu{EBUO95TYJ@&g-D%BidP ziUwqq*_lbcGV26pUXaht8It&R;O`Td`AqU+=~>xC$T%}$HRa)w1j#h}Nm2(g!CWdy zW5`6a`;T6!){x2OAW4FdDQ2!DsgP;r1xdO?W|#?UygdCNv&?pqq(f$#!x z(%E9B=2Pul=zh~yvlo-R((d0l*lG?GQnehORl}TZt2tCiGK6M>Tg_2i;+}y}o^9qt z5%Vg9=4{){GT6EO`TWtn_0L`8{8kb`DElZf&H zVyK0O%-tg9Wym9lIbebLLV>K7w2{izFEX`P(e_ zE3ch0&xBkvpA&KzvKVs1Y$xP0WHscL*+odn2XRb*+%fwJsSer9WU!E@Av+=enB#=J z0@(|>Yfcstipne@ogs%<%(p`NKu$sKnM;HW6>{HPEhGza88QEwn}o~~q6GE`SpvC@ zn3%vJA!{MA_=aX|;Ixq6AoQKhxIn2beES@MRD=`@R2FgpQkBUQLSib!E6I@JfoFs~ z0C@&dBG5=k66ASE$v_JsDUg3o;y% z80am@I7r37Cz5;tsT3F?o53as#p-@@Sxzh$)sBuN-AkUr0sBSx8c#iICcmtB@LjmxMHf+=Vig92DZ-73v%~Da5@i)Fp69h z?c^~ebs--HIt%$7@*-qFV5N{_khYM)fzwPflv|MQko3T)-+3NiWjs*^85YQ85>YBb zhCxOI&hePi&p<{)Mh32lQhvx}CcW92I!l>=nckEiiYuc6J=r-oOPK?ykG_8vm?31n zkk12UcTw&9s^l45X^svgNsmaFv=aj7neaP(H1o_3 z)cb?#%2(Vs_$CI{3US{boE(_3hhq30F?xq?N?_%mp3u8p(*l>74=k00-q%|hSS!gg z^y~Y;<|AHR^w!wwK=-4b(3^>C0=bgVn~7@!X~(=6dPD8!z)DHz4Yl0BT_*X8`<~`6 zfv!bfDSG=XKae9yc}PJ(IYBY`iu*3-=0Fh>z6a?|w=IEoC%ruMR^7J1YDws=!|eg% z6vaf8O4zEjvQ!u-5>g#<0$YA(AmucVc?v@7tG@?wnRr)`y8_#I3|mj2k-00dTa>Dg zQa6xiS762&%9Evh|0&-2+k^RhU^5eby<7&eC*Yi=7%r6|djqE>sR7v+NIU1nJPkPz zn0MZj=OBjyMHf7I5ppEZ`=Td)$gx0?BwOlc-!Y4>=+m~q{USp>Nem@COj$gRMyOuV}O2^^7Pwjt)9fO>=F@%6+0+6B2A2ntDu(4Dor zfp$XZeVOAdrZX318e%Rm*~2ntDfD-N13wj4?gjFB3>zC2a0I*`D7wk(x`$HLAu-l@ zA+&-=cR6FMYeLFC#IIOmth+*OuSXT7%RvmTNzyz zYy7PCG$#C*Nq1plt<6ll6^1ygkO|)xEm11Yx*$mqQrx=7#kb@`tkFVzRh1qD& zJ50(5nFdK?Qc1`h2(2EJw33A^g3vL%q}5Q!4-i`KEoHqdWTPlm%CdzNic+Pl&O-K! zQl+ilLe7X%rL7@Cu8C5mt+7J>6)_3cbRnf4=CvnS3x!mP%33Z8-BG2x?Fp83hxh$S z5mUzM$b~)4@*(kZ|t zlU$;!j^(Y(lF({l1?!HKXFBStXqEVfTIj7hRZ)d~7IFu27-#%Pt%SR5`>=lPK}?dBbf1axKvf)jA&*(P3LYTF zJmF~}k6T4dycQ-~rcPk)GAkSE{m}Ib+mmzhngx)0mHTF1m|Pl~mPiPz>7YYQ*s8;;C$ zXEw$9U5I-(ImJ3G#J!uGVx1S_-c3%iZZq*#zf-KZIBK(Zf2WaEhKaW|8e0!B;lE`% z>ovA&GV$8n#A?9vMDOo3v7Y0lqU+&JtmZr>IyRbEZ6u+w(bTe;c(pgTI`TZxebLQ#5-!Wu#|YV2cxyOuzXxtp03yzEv$zmp?m`ElF$~@ ztcy&%EoNAEc^+jFMoT~R)UbLNqpjh!*|4e^17AH#rLw0zXjROnl0qdM#zkFZaeF=D774!$Dlp!ETbf=i;Xcl8oyz6 zXA)6XBZhj~-r6Mz{Y~T!)-@*H-bu9vmtuQ|eQ}G{pHr=wO!#k*@}ydexF|g*#j?yD zt>2iOEV-i(Z(%3vK9i#*M~}wc-LiNK+wzsB%qL^MhtQd^la(rDSuK8*)XC~5#Qn}~ zCksXX&oghX@Ta_HqVJtW41eZr9^|d4xKDY#W2Ljq{C7dyr@NKOBwHDX5%n`ly=N`u zF-&M~{Js@Tpf*R8OW1}R5%a!vpbSZt5?2jtAdoc6d4R_}2{{h=z&ax270ADkK34g% z6qBulA!Yu;{Xwe{lf1a@kjjvL){9Is6p|!Jf6J7l7G!|cfr+=j23l`1;ZJ=~n+IC& zGx3f91FgPH@?zb(23r09lV^}Mn2GmW9%PN;qO3%FnxXbVR=sk(@AV(y^0C$OK`w)Y z46$;BEEN*5jEX#_San`%n3YtC%UeQ5T1sUu5r~GmKDU|)$rmwWtub7pUrEihhCM>1 zvXy@kL-WH-Yc`V%g}&`W^TRCbE)#FYIKe7bol5cRxQ?hR+j@`*zao1VGRb;Wl0J|x ztY;+o7&6s*L6YH+=~f#_#zSUWZ%8r~@}-r^gkKMS4Vh!T&%`?(er@$-!hdlzR=>8= zC0T<~Io4z@O2VV@N&@a6d~1EfBrmQqgyy32thGXF2$^rydzAW~p*#y|hEfZxmQ1pl zY(wUSRw|Q-(iAaqh*@k^t3jnA%7;B;l_ba#tECW%p<}{QtGgt}k!P8eDal#La?5y( z=b=*cRKp6Z_2YbBxL;LTX{k*3zMw1LRn~A3wt)HS2KRH?n^QB zjhA&+VlvgmGt(N#daJf1v{taeYAFd_o99^>OuVc9jn;f2?iKweYdsVGi@SoJ{%RF6 z$yR8~{{z`-ooA94>+Xx~mh*(y9=ht^VJ(t`Rv~s;EuZAu$6a&SWo>2>QB-91?ZdUX zb(0AnEl)%Kw0uudDJ~5me_0c`_}s5j9I$2xc^`S`TIPV2BV_FI%(AuQULiDF(<8hLUu)^F&CDZ`gPL! zNW{2LHJr9S74l>fzluCtT{qDKsF%r8Ed|f-jGd9mJ1mU zp|kl}YmJaEAe8y6l_z9AgfgGA_6Vu+H-E0_oOMV@9SHqW&RM6K@bk`Y)OFq}R*SX| zA3tXym#suD>`Zh8a>be=q*4vs3Ehu7eb!nbPeaN;u3Lj^vpmtKAFs3XAm-R*+b@b$ zl3C1WEGDmXTa>EJWDFDU407F?$b^p{nv-0&R&eosh*C5IxnXVKc}lsNZ&>+4+{`zu zZM>B7D@xH9W^P!6p7uuOc+`Hw`in_Kxg|2+wv;-o7s`q1vC1mM+_tI-iF+(wSr7Tg z8ukp2sSY^^QG)I01x_5JQXqFB#e*&DbFm=t2XKuabcDPQDFZ1PY~6sz42M*Pln$O2 zG96L_QYM($kjE^BJPj!uTr4CXLYd14^M&k#P@5kNswuqGHOO;_NerTS|7RvsSqPuW zRK2Yz4@HHZSAPYi9*zplWI~Wff|Ge>_Pd}ne)ZsNCRyw`na+r*9?WBst6CugLDUH0Cd5|ZAo0;J6&|Sq}mx9y``ktp4zJ|6HQac!yA@s?lkXD)2Z&wGKS zke5>GJkIAfF9&^1sdg{VtHIVxG87vzol)1T!E_-#AoL^l2d6ZnQv4T3`&0|AW|F0R zhnNW{r3I6kQ%tr}w|j{f@dZ90@5dVUy`pO9|nuHrWW$r zmq7Xl6D0WwGB9{rl1-5R1;@PNmD&aQIN14BPYy#q3HEE_$vMc-V74STA(7w$N#YLU zYqY^-l9YuE53ZJ^Dr97Ey(CXTJ_{B|(hxE__?sjzLdFJnOQJ)@2lq?zIwUK2Mv}K7 z*}=<_^ny$Z7E`@`eGK^`SXPpekg36zl4L`s2YXBMC1hrBjwA~qUk2w%@&jZ}aET;& zkgtQQnPe&FF~)X4z6nUpya;IwSruHxgpVjcjiTn(;}WEJFka19guO$zbc`_14lLe}D#ar`X) zVn}cc7j~|sIpob?5f^0xwjtdCzZJYH#n3VQcJLobHlVKC!T1i;!i;FCJHd8Bb|TMj zi1~-jkuaAiaR9Oxaxb`=#dvete}lQa6l)J<{x`Uri|-~%orWm(0Va8|ZXU%()%cfR zrsPw2(y5W6#M(|OYY)qF4W(l3p^V&G zeQxGr_F^8xGRGgooWuTE*rtb~2+KY2>naUH!DCLvD=JCTXk zFQ45^im8j3Qg$jAZ0|Za<ND_(2JpOM89aCXW~8a@{*m} zkF|%ja58FdW%pw;S$Y2Hcx5)Ewf%B`FHiU;K0<6elH_4M%Cu)Qi70QN)TsuT_u44~ zsTBU=Lmm7bXXFXmX-p!@JBV2iv2EWVis9{{Qek_n5PFZ^hrT;@CKKM%e^J+KcD5v! z(4KboWJ$I{+S^l^@cH~f)Rk&4;o>Wx7D77NTZ9~gu=Q~Jl#rM@d`+g4eMv}V2wit~ zvTq7G3u$tkT>9Fphj1Auq`$4EbJ-+hkbRy@^tbb|-SSh4;bV0nYX8`7$0S?%z8cp2AfMR% znD9MF<0svo!Nl9|pV~i5d3K{zhJ8TfsaY3KGDC*jN(R-%^U%uVD7!V2e74$5S0$g@ z?U-aK1t`_H2(w)KIFk(arL|X?oMSSXUB@|0t})?Pb{!#O>~h1re!T}7XLlaKw?>E4 z_}hZG`J8Ew6mk}IeTbMWdj^vT4w%?GxN|+hJ~oo&Q4%175tD6S7E(#bL_2X5kEsb6 zj+jZdDx?J@3-X0MM#vi?W~x2rGhS->I$Xb^uIYBU&$$c|nP=D&nPjorXClu`dz*-% z+E+lnw2uh6f)$1W$ZY$LkkZ%iZUN+LJ83k}JQk(sclxcpatxQLLgv~jW4X)|GS40= zWIdz^dFI>MLiRu|Ko;2Zg!~P;0a<8o7E-xBo>o19FFe?l$MMX?#^A5zLYCMmLh2x< zB4nA}RY)rc9aopx6NPkyRAn*7c%G*Zq#@VopGQx2sL_{Ao{=q$*^uT_{O1iZ0AbyHspw%Jlo5Y203aElcYc7n4K@l5XfUMW%f2g0%|xl{klS|VVz2fF zkh^x*C7v{e+_N_?)b)n3eANX5`{HWKiyp@>h}-3EUpDAe>vit*I@F5dSkSf{NY8YxL3q(NvQ6F#@0cbprB^0}~Uw86;pTpU3` zX&kEaGnXFd#S}=Bkimp!Ud-e?k6~A2bVuyP&@~}+MaJc>kPPJ6j#4j%;@7jxzSR?O zOl6WFWFurBlZryzJAExfj|g$^^tB869KDZ~yH|Ak__nP(_eO$a^V zuc5ARD9D75jZu)cp}Sm^V$Wd@Lf!~9%j0!bhS2+-9YQmhWGN(z5tAB9$mcOnKz@OA z3au5A0yzwMD-a9FNbW-33#q^I zQUf6IXR-Pn+P0O;SjYpA4?^v>@ltakG)L+cO5V<6wnFM7rdMc?kRnJ^NT1MdCK2Tx zM1y=7s=0&bdAt$cFM#w9wG+}B@-}2($SLG8y&zQApish2Ue`#-`-mA7sv~4EgxdU3 zsGpFNkbaQCp&}vwh*CpCEq~{E9(g`q8H$)lD3b~9JVHi8GD6pO@!B;AJ)1Ey)MYo9 zR7ehDJ`0Tz(jT%IGCI_I56?UrLhTt7s`4k7WkSY<7D+R5K8}x zmm;C>#bt+zm_(E!2;JSD6gsevm-RiJm!ngC`o7=P6?eCl7yHwsB21S z(Lr9Sp^&Me&>>!X8^{L4Obc~q5>YxpsD;x*bq@1V10b6rGeT>b;H@9X?~qxc;87kk zSHyf3$`z6a`5Q4gp=!r?%svRUXKtwXaV}RO)YEyPLP@9>^Fxh`cubil{2F$CDCq>3 zs*rz>XMU*WNiIzw7Ory_hEySbNQrZ}E(l#d#beq-9)v6jEjrC*Afzf}Y3RTiPo9M= z57j&C$@7pEq1i%4qLc<%6&iGo$IOKEf&3JjEMy6U+LIevDr5s>6k>h}6$zn{+4v>Q z%tOu2Q=Tkk2Vyc2QxICal}q&upYq!kyjdS=zU!%1entOVDDx7p>mMP7p|3A<`KT$6*%d0} z61}3|6Ux6yG5qL9t517EySXS+P>SA$`!nRbMKRuW_ukMTA@1Lt`YSY+37@mkvo!ld zt0keQeGZ12-KIP|hW--M;n2i;UhQ9EiyaN+a`7!i?eihWLz{*C5|u(G-j}kDhsxaN znccO@qR^8<-oWZ5tr8c7S}@^fVLI;=h59k^o=7|q%H%Q8^Ulf8B`(o3+R4yeCRxf8 z&G6O_R+dhNn*B?)N0bH-db|8oXt$78A@oewnb2J!?IEksud|_a{B=|sEqx)sLe7U) z$8t%B9D!U69S}m#kKKn{4&7oBQ9eh^gXb~F4pobzQhck%;i-mep#hT63e1hr7)kb{ zJ-0%`;=NMq5pySWg$e(rC9TEX4f%>uOhlQCx~O0GLw9{#av=29p%QLglFN@mV#BML z$$tTgm`0#oryoHBv;hWy!ZIV0<@r9o*MR|CP1t}G7EJ+7QLbzFJipf{pbN2&b zl?gBPC}PTmn{m?WRwlUjoIJQ{YG@D`qf)ClKD@;v16@GVJR zhCC5=s`AY5B6Ani^;Eb@H7=h)`a)`jt2{!&Ggm;Vr^CCe^O%{UJJW7(U(6fAF zQR>-nYLZtf8Kb3MxO)v=>PM8S2Wb#qD&!ByRFp~yS9zSroP^AUJQqIw6c?pMypjiL z67E-vOC`u*Nb~R_Aw zaYYXYS)1|I4*acEdPh|c_hzLczF$#_zB^}x)48x&Wnbhm!n>L9U-vAC9ZsstYo{lW z>D=UmPjKMh!eghV#>W3ucRcC46DaWRfViXp0?r3LTU+lJzS+ek7)_XMa&yv zRfxN8(;>W62z_sdMoY)=&q5rO+J;h{!h41EfY5sHn_;B^&pZP12V&j~rwW-aq;ojE zF^~BfatJY9!V85I33)r*wJDEz^B%4l5z{T4DdZYrl#7^WhO0H>F~wWPD@l+K!iJE_ zkN}PVy~ApA9`hvRImGk{mwSlaB?di z^DcyrT7$z56P|}g=8*6d5kt?j^+u`maO+ojso^L^PsT>V-GyX9XlDLtc#M!QA@s~` zMtB|*o|%q6!@>t7p`*=+aJ@E^na9x4W>k2FBy?=~JbYS`e{jqk6Q1IyQrXI4)b&5K za9mi?y*wpQYJ50X68gPog%!h#p>%`E@Vm zV{F53!Zq7@LT8Y<;R8$}O4XNeeTq`^!+YPLn21sbvJbK-T&IIqitgPk2|JRULY`&e z{8TUIO~kASAL!@_9S>K9AMNDHam4%(t|iHzkRQV-Oz;&N)SlQ-QGN=izDcDbiUv7@ z_N)uJI$qOr8yqGq~yfIwsZ4x|pfjqa7XH(c=!nZ1&VYh^rcJ)eC zhHMM3k)$+adpKW`$03E`LM9RA17s%oJzVb{FHcj*?r<|E5oH`=%3Z=rX?Ti|IS}gU z-f+(QUa67j#lCR&9-gc~o&({Pk_?0#3TLKKOhj3UJk^l-NI3BWE?XhBAjiX}gLL^c%b$-pIt8AKnZXGV$hzx58(6Omu#DJM8Q0<)L}h?Qk-a zh%yUx(Q*EtaCad;3b`9D6tWTW1NPUwaO#JYC!!n_@^3h|pO=|pVw@`dNxb<_oYRsC zZ!?|Iia9EiY+u3yxH87pDCSs9ye9;TIj=GC))5m+cpmn3xbetS+?glx z&{y4>;rLw2DLsI-ne9`0J~P32m`S#>`DI)oqEs2Dj*ulE;BE$_tdq*b`(|vS(^be0 zl%mzAL?=zi1ql5;g+!;n5O*D^qLV4a{n}VXXC@b=bZg8&P*+7~xsZn-Cn1%bO+ua) zF_oPIOd<-k@B(70I4cIRekqL+Q}Qz2QFRK1n2-k{)t!X@u^3+m2(|f9=XoX>zK^5w zqL42j)Qd+Qm6uXhh?pcNQ%JoSJ|{_X4lwcdPLgwtNw%``m3ZYL)Sl#w{fKJMR(3(2 zfIRMO5OM`l7xIL&TL@jlHiA6qQXvG(jm_~Rfcfs3(17M;1miO3Yi9J=A;az7#txXRC^02O$gQX6=Gg=GSew0OPK}v z3DU~BCdn4aD^4)NV<EoZVca$1&SU%b*y3lxTegPXIXiOfuL} zA{Els88wXOS=$EhGCYW<8l1I4euvPPR9|MhNp(_2aj6T*fpm8AKj-oiWF_Qnr}1bmAxJ*t9jE&kk}RbQWH;nJ zr`%W`(;spK(!<#;WGv(wq?c1=9FJKFiNhNgeVvvIR3$$z zHQ1S##pMM^UBnD^c1|GS-)2c{hT@axOB7D0>l;+E`I?oP=od*vljGzF`5Q4EAm2LbbY9oL z5W4E0=PaGUB}v0~)ey75X*QcnQ%FC^cg`Rtd|%M~XPJ}p6~%C&xy=e^OpYgYA*-Cd zb4f6>LY^te^MliRo)<$i#??+LlZes>F*%4?<17*~60#8Tlan~#D@8N&pPhP=&^$cX z`GJXd_WZ@UB*a~*$aj1TC{IM0g3NSOFK}8j;k}^Qdx6uHNtUtzF+ZX9&CYo#hE_AS zIL1P+J#_7`%^9@F6S}_G?u?U!X2ONeY9{=NpaNw6-KqB-FXgUl{oyng@*dW;>S0~$ z4`&*a5lR8tLvw&V&I%@3%1(TZWEb-6aW*sI$8dT&^iSs!m*^Wtd!2hs@}h4T?RAvJ zRC``2_YI@Hj*p3V-M!bT$R&C_-0M8Y#G5t!Lqcu{IpUlbQcTAaq`7Q#9LiC<7|^+Xf5TOb4(JN zHC=Gdi&E~WyX4%GV(9wxiqn0WR~H@Gt~$#lp)q#dS<56}p?5G(W2@eDYOdfteFQzd z2D$CjTcGNoZDvR=HA)aS(eL;#~0HUQY|#Y7h^%54y~1vA*Lg% z3#58zKg)8K8ljfksjm1lr8PslrKl^VE&f(M8%p_>VwBK3(`tuS`-I+^_FQO-Pj(@u zUa0SP@vMG`X%HIXli`q*&_SQjJJTA4f;&{-X^-CrZEhS|AVt+qZyS3lw9zN@MzUt1 zY@fV(}pcVDL$d6a9<0J@X5E3*F*10QTMuQqU2Vg1-=;i)^nRsaA&;a z`^ah=svt#Oxvh{D3QcBl-#e#=zV~I(rzern37^m>EN1AIPw1U#cBpR_)upb}hA24} zYPw5_`|auWp@UM?_|TKX9Ye=_Lf`N19BR2c-sXLfuA#O**$L?$GNh=#DfD-zN2sF| zb@tMJr$=bC68!Ft`rFhqv`l5mXJx10c=ZhJXIX{6Xfq+bLbboA+S7vVhO0Mn^bVyc zk#EVEhnU`>#VquM$s#G+IE&uFwH(qXlr1H`^X(IAyoXAT@2&cTT1%NO$``})cQWgs ziV;`P=Dm=9A$_lGkNg`)Z&vId>Y^lgFiXg{^b82~l@k9{MY7dsJoCC*lMD+z!SXyLFJgv;o@8kYc~r_XEbSqW zOKHsVR9p4N>|vqiEGu)WcZLiLwPxv!tT818N{&d`k!L7mv5q^pp)M?wAau`sc&Ima=+o0vz=oehp2LX=9pR#I?BUC$5ag7 zPl|hJ=;`p#Z59nu4KgBBe4iXcyrWZPjSgMkuVlC<^A0GP?n(25N|r$WNf%;ts2j^> z2#x&c&{!#{f~205V=6|TEkhtLk}j53vFX@kKp)FCX4$E zMXU-&x#aF+Oxsi5P>rK0ph{hngNzW9S}>384i_g6>hC99kwN z1K$x+e{&~?j_Ps1$g;H3quxt-aWhvWE)wLru z^iP#VcQcwD!r$Z2WF_8uV^?VW2^BM*vv!60o|NLn>XrrMkx3Z7E!xy`aK)KrPro&%x0r&Ua? zkjgp`YN^DF`6ZMtMg1kBJ5;}fmPt|TsLME}heN?LR8D*sa3nNGiu%h)pF124h0m&f z(VCxjf4_y&rKpmt{D*x?Xr&ZYaxKW8q1`G*uF&3soC-bhFO`GuwxiA8?Z%z$(332Q zT9TNJnDe0;N<@`%_^T%+%u*aNOCT3QX)JU{=)XU4KRh&tr4nLRA?9M}jFePS3$h7v zDU@=KYEKofLAFD#gpRS;kb{tGp&92@%pk}K$n{W#3rZ$HE&kb4kff2(29Mg=Sn&7vyAT=O~+IW`kEIG8_S>AzA?MYhGtE%MpAvA_b z+613a?K!nMEFU7KE+m)M{F=(z2%(sOHvYPjUs!_Lvj3Ev;;dw?_Dv=3=gYaZc`PD~ zJ4+}hk2dTU#bk(rkXIr3v>8&=?j{P!udU>m=Md8aQc$aRo3f^hHY|m;u$1^WjEZV4 zrNq}iMKwo?y1L&*IYqS%QsVakiffx$-1`8q~KFU2pydg+T=TOG=fzPJST&4N@(G`O4@jG zgk`iR&F`t0rJfYMFGYL}IVj6H$Z{C+FQlZ_^MQ&Chpj48(5}5Xne|O+gMh4lBqeTx}RA^OUa?ip_1#N_NTONEL{-O98yhdm!x9)Lg-VxXS5S6=@8nn z*3ho9d<3Bu*3?8!Rr?l52bA-y)=7#wGwFG)+S)cLI}+XB7ObNkVR3(3@Hwq-E-Gh7 zqWepNb+t?u_tysNX~hF7rZ09J^wzQlT0JTF^bP%b8?`soHpub8d*>#r{d*%Vi={Hl z3)(G}C0BZMt~S<0kV=m4I2vmKDe)_=u~tM%e2?E)D=Fnv0^QSFvy{qtj)hwI1*D1A zT*`F$>yY&R`Ij_PO1$J|T33#lZzsv`tTodzSejQ*-(q`N`+#Mwq2v{9AxnX94*9%>wpnk3F4 zM$`H$kz@E2&V;Zwhhttw44o|z?L5nykc3+NvifLa3Q$(6s1Ml(d0RWf(wxf~q%|+7VhW|=lS$mm9i$DFf?w$1n8DiQ!W5Gx z-hxnFgSB6!;ByC#8KPwtQRR%|m?2uxq9oJB49Hp3K2-ZyN>=cPE_iwibq&+LVtMj` zkTbwA?GVdS#L%2DOuNo<*vqP1j7rWDZ`V+tR}Rx=u-r$?ff1Cog5_(-=Tf$?%=1c~ zQ9_mTCi=ee8Ol1zGUB0X&v0$T<0>Wx+6{Hhny4IUz6Qnz2hV~B2 zHxN2HGqqVPb7sUtm;cYnd$9Av+-Rv_GX}ir;W_KAME%s@;-uDtQ;q zv8j+nTBAzTuTu%XLS{*MljRJAvOdw;OTjx{-V4f+U##_zqUMCVxSAGgsY*oHQFFo) zZ39a;2wkU3v@2aC)fBvqeWlioWhBa>_qeXmIz2^Msp11J zd4;xKN}AXTDUPhqv~wIoGYS1ATBRjdRaq50DZ{b{S@b@=RoWb%ltDSGHK&?vVel@# zA4b>LI&C*2vbfjjMs17|@2cFSP4Ed_m7BFWoaJ6|TQu>E8nFWH zv2SXJzq{HzDOtk3;D;xe_aEbbMzQya+QUU6C4SQht++okPh zaj&@DTHYF}7w#4JgVst){E9oE*;3-y*UwrH7Weu(s11-ZODrCZyD#JM38uE+Cu<;w zv}!e}E)}yAa#$PhlY@{W+DV_BfgIHuKO4`w3Heo<=aW1Wuz%NX`J@EocdcD5m9>f6 z^M|(9C)A!lwY;_CG1Q*Fv~E73_8ikPeM0T|TPss1o<;3Bu8r^swdaI(#3$6AlUnWP zRMwI)cv=%#|7cTvLhU)Fo%ac~=d{+mZajET2$&&S_hG zLhU)P6|JwbKE|DPYR?6&uTQ8w7qx7kPpT+xpCgxYgeOKBL- zqV`EFsW&vweUVQn<|TbK%SMiArf>BL#k`_tv3$)jE%XCEp_te7KYh|0^1A*n%WlqU zrQh%gWwp^08>x|}7|Lp^=Vv*{Ss}fIPbf>*pY#c3Mf7J`j&YW$H}VN(+4`$Kp{$s$ zv0UM-_Id}OP*z91w@)amvp$R^@d-8ZUG;RIP*!(+nolUJhd!U>DP)a<^wL-OWFDlC zzKP{Ko&oylU$A7eysdAOk|BEHFMcJgfBNf5FVGmOJ7%;a8>pA|NlC~cy|t7y@zG28 z+!$Fy^qErPyZ)j2M=b7BIz#m(EVQGS`!9X9lytE?i0>(4r8i99BxRP!Jc{=xq2yuu zJ}J{hks^4q4>DXotg_^OxesK7eoD%z1j?cv&`ABd68Y-@Rv5b*Jy&Du*Wbw#@vdB2 zRgTh&NQwXQ(I_1O_?MNlWQjyE2qllw%gC7cXpGih_6d!~7=3_}V3`i;ZEWx8Be-O@ zoOkp*FH-ICcM+uNMWv{c$Dyt?eW#SHJ@9D>shzH1`BRECR+m!m1Dc(cO8MJwdUYlh;#e2Wcdjwc z(V79otdkON&s2R2i`$;5`c5hF_GIY0RgBl341GUm{dpA6ZfwH7QorYu7LaLrm1flU zczb5(HKk-Fk3*ZOUo-TVSU!Z%7|zh!u&ja5&Sj?Fk>wzSo>-Wv4`R6uX?O>_M14F< zp-%YTpOjfr;JMhw+HTVKoa4uoo-t$)qpo?~iacSmuK zeo9JKa$;wE_aC*-(QmPoh9ur4$@Q{2!&4ws`v-b)77aqRf1p3f(if79thstUmQj!b zQeI`bk8`7#6pLjNVoFNs%`z8KR>}w|@zMBDAN&7FhEKl5UA_gnr%UvnzN|TTgUS+pkSaO3D()vNMafI`Q7rW!>!pm7k}3MX ziYpFT%k&viW{Gxa&)0}quCJA%X1`w{EA;b91kI2%v#rwWyh^;+xi1`PyPPbl@BPP$57Mc+2^+`Udc@KBr^x0D4cbhlp16op+x|>lCF&p$2 zud6Y1y5b%_WQ(pzNtb`)-jLEs%BgoVyJ(ODqtUluy+2C8yoFVt`6ExwThG5@H3iNC`EE~lXESE{IB z1!OO_>fdrqaY(gV0c72jCC88ZmwJvjV8X{&3 zV!qQiNXZb*Aheg+p_gh+F?eSPWIR3#$kba(iI2L0CNS6LS%OAhxkaJ6xK9A)FgyxnkeT5RQ@4NIZEVoDI5I>@vUHVCu zUu=9!OY7d+6mH;@8STe6JT_p)ov)a`xzzS;j(W4X{_w`=%TX@6)$z zy_}TzXk_bEeM0kmwqD;S7f|vKy5ke-*FJr*l&plluj9-#@r1U1M#bRW>-dBmSwHEO z+fwc6VpkGAKfI4;oAnVa7ZS14gdEfNvsk#p8HSwJOSMy3{UD4Fjc(E(g`bg`j?gS z1bRVtcRPpAsoE1xdD7NWy*LNS_XfqB^vO2#t6R9ctzz+e|V;pcg1s%9}zP!yv-;7K!$`1#whDu(F8F$M4}iG-XbMKgdvYZ#)O5VVxBFY zLsWyj6Q1gmx{wLs*6meHM`TeiriN$uWMWr*f)M`QCryzxJKVTKJnMDHyzoAjw^0uD zVnO({Pc+0V3P1EocgUyVM?0!=C~FX8S-1|%2yV~Ha2u9%mNnsCEOS}bhi9@ZVc8h| zie(#wda)&Zo#lJTRMfRC{7NTP`_G)UJ>0`5ix9ITJcs2^&e|0|&+;#1En@bDn|4;^ zkbD8zAKuS$i%b3`T(padA))a(5^l=!+BMXJtY51wH}09%Ig$!Ca(88 zm=hj^JIJdtL)>C{7@jO!m?17s4GO1j0JmwrUNr)^{wR){l^Chr zgZh;oY}7;TfO14qSZoOWWy}$2#xepzyNRU8>nxKX^p`Oy(t%|zmyEOj9(qNOWs|BvMjJ{JMBFQl7=VE*_0kV{xyG;*r`?;@3s- zNQ#vBbx}OhREa!$ccT}@BV$!L34_s|?zlVkSR_M9a%rqi_aWx7$b2d3IKt|4&&MK5 zIg5mj`(u%fQg-B+jB;9ImsBFMgJVAAl1oPRv#j>y56;Sj{DQhlMlP}Jhx`pG9eKd= z7o_4m+%u2l?ITAl$92d##FUGaVoBpO%EYCq6 zfmDvPWoZp5E2T4w38?|878%IW5i(uFnk|yX(hHJ;m>Q7`C3)z~q${OnWIo4?Kn&d# zsTo-*Ma>(FkX18sPl`HQ)<9}UD)yzGs+diXI*}nh*$$~28Qz~_QpKNrv2uVkj7()Y z4>>BO;XoC04?;&dB{Ez}R?t1lDUmcOJ94{iPKiubS;74M@HYkJq(r_`S;9T0DUp3F z?lDb?{LSK?Q7MsoQqn|elygd!b8L|8m#71|0C_&LV2EmABM2Sk#*wB&NwVZwN9Wj! zk>D^Dqa%i-Nu=p;68yd}kNiuK@ht9n*fesT#XW+}BBe&EEca|_9+{yeM;DZQ1MO)Z z$(E8T217)SMDc2*%qW%R9`}}!Y!>%Cd_6K`w2E=h-qw*ZV@NW@Sd^0+<-8d=FC|sX zgwU1JHu8L`%5u+*b`gigy)N2CrjDhURIvhCg-}j75=&QE?%5lS^ki|*@MvTVi+dF~ zk(E-?1W8qt(>~&iQzdUh$@L)}BYnrmr8%T?B-jIlRg8kr zntycUH97Jb;uK_Q{Q#sb%Wal1k(cDL$Pj7MgCb{xfJlwBWSIx42}z4|XE^|A3mF^f z$8rurCBGXP!ICrs-&I6RdSsg%=L}IFvZ`S~jE@|UBbFhG&kTyPDFHDdQh-OS0py2V ziDF_TQ;xQU&sHr1lIY>mdyw3nI&; zWF_x{G=(gTtd$bKbFwg!#wCA?+7~qnAZ8=W5lALvQRFbodB`EiCy`?;VpdS(eIXzg zN6tz~6-6PHA)iJ9vV|Foz%EwBoKvqDuMy9eff~<#ZiyT{^V%~u4fP5FJy)a(# zUPxwSn@@g$WJLxnipTr~*&Pv|knBvbP|jJ%o`_f+mz$96i1n$GzKD6J9ljAC$&`|r zK>Z5jOcXyw&iSMebB;-is@@H|W3HdD&TospwkUt^| z){yL!bv1+h6{)vQ#iXG>gyvVUVdW-R1VWbLN7P+eCd&SsKSF%2ywxfa~h%i!p zLVr^djEO$khnPfTnNJQuav0Zr@&_czX#91&JtrYKjlMoP3&~|P-5!s*1_>IOKDiIc zZ8ZHh9uvSEmDgD7lR}XEMyc=OF(n}djm18x2q|n-+Yyhc4k>C(W?71(Lp^=OD43~Y z)+r{nJo0+SdqKYqh;fYr;xVHr%U_riK8KVvYO>^+9TdMn zN*QffN<#9y7!Z#e21`{)T}WwTFiRK`fs`@&d_XP4@25bFmja@!F_`5LWDKO7@sQ;d zWC^6a5s>o_-p2@`zZVsZf-Je_D5+?aWO;<;N#mZJB{IaT5Sr^M8TaHYks&&>R5sG( z)r7lY9|YwXRxx_Xqm1u}K`84fW3X?;Xf0aRn5`t(uxg@Q(^fOKu;go*DA!}vj6bAg zCD6K#R(ekx4}8)LN9P%%^iCR$tOQyOz7DBjJS!zVn1wqGv|6rVG+-$^K&|v@7_C@p zLgb3t&{-OBOiiOF%WE9-tTBMa;+SWR2`s%hrk0VxGK^zt8B18kaZGJvHOownscr0F z`2=zc>y0|bUY2zbTH)6*erEX&Lc9Jt#_vkJy9du1mpJD0fq3hbjpvDtn=HE^_bd{T zMI)9T{EcJk8bOw;98=dQ#F9Knl~d1njHL{O%Bg2mP$Fv&W8~`_XQZh8h5T-Xaal^H zSol{Cxgu(8l-VU~7j;n%?Hw8$VU|}QbPYB(=19p(aCZSO8v9w?UBHV*aJMRl_Ke+; z^`eo&qM@A5XwOT=WGU+W=?Qt+ILR?|whV&2YCQEll@os&p`}q@3ii~s@Ee#I=axnf zDXF3(N*;x**Nx>Y{aM~HPze5I<$PqYI>%ah@^gOmnM-R=s^nDC#@HdtiLYDUH1;p}EC04oOKB7a)s~Wf|vL z9zf_Wgl%YhX~f2gfIgbUS(YXc+OayuQ!E;U zW{LL3vn&pT&ffM$Ln-n0bTHnKk}2E~>tJ+ISzhfOjow_&7OuUcF^DCbYwu``W^r5C z$r#7twy={imBnpgXJZbF+rrMqVkz+!b}^1giMOzeaZ6=+E$nKDALNJy3k_4_)71#F zl!wsxbTtaGxbt&2<1rR@e(q+JW2wXCbT^)2d4 zrWwV5j|=URW*Cd5#CJ)vj5&W$j1t-<%`q>@t5O5JE<>?dp@DM zzA{!`p_uqC=^G>IYCMZ}N#7b9d_udV9mXd&;xV*K$}+b5gmy{0j50UlF|xBOrn@(Jydel)K8gmy{$jK;U(?V(-L zeq*vvXqWVpvCSv6OFCeTy%W!(UD81#>26$TmvqP&>l4}~9WgHZgmy{48rHpd7VVOL zH%|J5c1eF4J@3b3XqR-%$YybONym-W4^)i1OFChE#NzIfP8w^Z#AmjDjA?S-$Pm>r z1JEw%ALB!oMiAO1oi?_xbcfI`>5OrNWeDUh{=%L${$?2msq|_>c1iykU&y1JA+GRF>V~mdj@T@* zU^srY86$tw_>pBT%Pr#{mQ0r0#yyto_BmwM9izxY>enn`v)nbFVmZuN_ly@=&avD# z!Yub$9vFRC@{LgKd1$1wq;A9cjur~@BbL$}lVEOOsl$?J?qzwEC5L&O#b!w|Z?p7a z$!Qi8#bht0u;el;u`Ff@n2lIIX9=1imIExwW>1zAEV<1zmMbiI%(*NHBUMlHn(J6@ za!>P_yIG#*QO$4u#qt7EGXC#6QI=WDZdxb|B_YjA0>j?f;1>Y&K1l zSzb(GbA%G_iK!xH!5se^Q^ahp#EU6v=1roQtb`v%;oS(RtEkzNAJv*>OvYr0)yQh}dO*}Pd&-zu;y$waBdfMKz$foQ>X;*Z z<;;dWXTGaMJTfLpEP~WE-%}DS3!&9%U2`7C)P&Ht3F?~Lq?}4<2%%5J>Y7dSPzz5b zyuwn?Tp~rac^yiwZ>~`y>)HZoU~X38)z!ev^lTzY!H86YT{olG8n){_p z7oCyyHA+q~FSGQAWJ8`e3*?KB;jcJe&zqJKF%~h05!1-b%ug}1#2iTJV4`Sdo?}@C zsS0_;e8`fH|B&peHHS!1?b(NNLT27aC@Vc!^Bw%s2mTU8&7v$VJSoM}0YY~MqGkn_0T9|Z zMa{*JQaM=(^m*lNlpHfpmQX^^+ax6?iVo(jQXGTN&HJ~*cg4*SPbf)8Ir$LN*(_65 ziTn9!7js)V5_~fnF^?jqt2w5;idhMvv$wn1t%8z`p0ul|WMB#Pdz#(N8B$Wk4#d2I zr!3wwD^yl7`yg~4_AqNdqvSUTJ!{m%Y{zmL@+4~SVK%O=VsfS76M0B4GrP7D_mj}x z=6RMuAqlbDtFTUaW+Q_;o+?yiZKXQ1gyY-h>P@AFnI><=s0SZdPP*@0|`epJ8#IH5y?) z$KpO~G{Ss=#H-9D(^`eTI z0=W&DYnExMVirNZID|KxoAX{(F&iOybK{9kbAKx(KSHWQJ~Bl}$!W-&kojhkrX=ZI zJQE06Xg1VIGQ^V*S}lKK&M;L>6Ub`BEH*1xDy9wOZ^#n!piiztmYQSjcuXJY7gh2Al+zrt%DnuRikS{+D`k7nxO9T7F@t?o*5`;B2w7*29iZd@WD?|a zv)vGtbqz90%H?5kSqj-`79FmnPfxHI!&ulzP$?uRZkQ-*f*-9=#QXx0Z zOexbv;qgi0J;-fy?1w6*EMzX^jwu!@sR!8!xo?hO2}6E^JTQkWQZc|Y&C3z+&DQFGYtfVw#K4J=6&X-D_g?tMsYBk@cq$%WgNHMGBS0ouigPd0KwUVxo z!UgaIpcVc`$uP+CkjJgyP9@_YtsrHrBT`buT*xp;1#8PLib)kqAY&m@?^Vn%kadu!tulL6%o)h|d*2Bd+tQpzkr(hTyvwc%G46B>^ms2#e=1IvA zA42kJ0r9f+Da$5EeMocbJC=(O6Vk%^g(Z1;5bp;Hh*zyYSSql*W?f);0YW9Wv~I8% z5Gwf%D_QrCHiQ?m!||WtM)Bm(74M ztp+R^kaUP;y~MH(aupJ_rnCG6sf~48%$mh=1+oCr-kQ%+Xq}P{)@qiTkSxS>w6?Rf zfn0@jwzkT@rx{`jq^KPbU98OeaCVVB0Aw|I%}^K z{6gz?9CyeV>kp0zLz+NRty3&ZAX6Y|)-{&vkRKsqt$Qp@z72{7o$*|p^|V|SWQbLe z5s-1#t1NdR*^u$p>ntt43yR`h0%D?NN=X&7Ax}XjS-m*sD@Z-aWNQ#ho*hBa2{Ogn z#4-qy4td}DnI#jl2{P4sq_-N4(!11XOtYR~=>?(Dm~Qoyk}AH0tbQvXW?I$zsI0#s zUqNPB&$3kCt=c@t8Y3lDjD(EZo>P2aCCRl-hWG?>7FlzxN?g|!2px-gR&|yazQ+@Z zJp$q*s}sw6keZN>twCJZZ;+#q1y+~-sy&1Ds&W=uy;*ics27W@!BX&^u55Ko7h4lJ z<|W91o_M~_n#M8{@{G{dz14wbB4im#{@fbP@;l@R zWP@dlRHL!=XEhp|tPU)B5314FZ1s?mDxwfN!@saba?Ci$r~UBlS1X<6DC7!cn>C%K z>MuAJZwJIz);yMxkdGkWSoc`=LH>elw;r;TJ*4{not2N*qWvM%_Z?PgDH&oOg!-Oo zRc5&eq4PP*n$6Pqa8Ok39}v5&2V+%FJ0Hd0i-7_0z18?#CF>wNA$zU2S?+Vp57r)* z7Qd>jeO9@2l{FJ`8(BYDXXUCgL;MY)+3#m-%KIv&=$~p-f3aqHP4`|RB;$W*Ulf-S}7Sq z91Dt8$okVtkSos&@g}4XI{Ab0Ks! z{bSXguG)Mal7C1*oU(M5>c@kk2IRE0hvjX^aL5_!fRt46Ib8<(#()@=CZXq|8u!dSYGRm{bVeskms}XUT-n3gnWNQ)Xp| zz)Ae3B(g4BiE{mn=f@ya`xUDiuc+UH3`5LSYv^p%!fF2m#mq)Y;+nOXf&)`dVV=W}n9>ekl;rA_E45ykhSjwL^1mvmi3ULX#w%5{V~f;$eWPj_LnRvH-ln6`#ReFH4cXB{fv755I1sMW)%D%_ttb$NhHT%V{R92^lL9q`pPunkk zt)#d}7RBESh-d85-zjO6BUuEd1VnYaGRsUzEl5p!U#5yV3K=e0c!=4dBE6=+2@ja^KBapYI21I@P z4okUQ$zmm>f&Dn|>?T6aKpNWLWUH)Afn@O@BOso)53-10vUqA*K)hh@W_cAt=W1iy z_(^4z%#$qi=>gHi?#0p_@)6`E`(2jJkQ_4tqN%-7b(Gk+jE_gtd(-u--Wnx)YGXOhQ&A!hvauDum-NReU?3}+-d(wlm z5wofUNq&~GBXOsP-m_po!m=JQRq(qfVY@WT9kizi+7q!Wu{={d2Yw8iqz210+*|JV zE*@aF>#^)bIm6K&!+ueTcjwl`)3Nj~D<9nxru)xvDLd)^%CW+(w2 zKI8*r#q7(nWUPq7cst76fN<>lEc6LNV@P}ZFvk z)G?Liev7TY-HOHirrSWf2aEe1x*>KNi~C)?A$C4la;j*KHq-s^q4qo(quNa0KOJVD zS0d;c;KKNYq~Ug{`W84;| z*~eMj@7bl<|48BXAS=x-dV*?C59Y<2E9e|cw@a~<*d@eIh)K6oq+|te;Ef!KT`6V- zOJW=KM&ERMm6X4e$9qyi3VzWNyH%Q3)9t5Own4tfnJ~`&Mv6KQ>6f9#+doT55B@q# zwP%9;8_NXuM}$YWP2rN6?iX6*7csf!7T?ub-ibA zV|fljPh-AkACr=mPy!?WHm~}qj&kU;i7EC)De*CU z-%dRBzsGc{ottG8FnQWcYHGJhAi&*WZ18>xZ{&yYf`d;ZVRW` z5h?Kzn`U=WS>A|EvuALYdqz#S|5Y);7cufQV$|k*zJ^f=krIl#p0gNAK9Ix#K-v~yC;j=i;wI9QsU?HNA@OFj;w2FH@r>W-tLoP zkoop?DXHQvjt;#~W`Ui0Mjq4T-C^~ffd%#imi$xPm<*OHkK$8(ne_pSD30%lqwfps zMJ(lzMdP#3UcpimLgTa0{+y*T$1JkHWNFPYi|kA(>A^Dijk&J4mOrtxSscXVDU=BL zQ%YK}FXVglYq5QbWh~_HC3qj2eOYCRMUe8y`qa)oOFhkyQVA_wYLEGsWJh9?cKDq` zl(XFaT}u3O;pKMg^Aw}b=W_T3vgP&%QsU?H3VW55_#E|_y^+N|pFgwru(;>*O8Wqd zdp@tUPqDb?^Gf>`i+et=v=c5+d*WyBDm%XvHD}WGzRG@7NpLuytE=tOEaUlHU2Qj& z5Q{QOQsU#2ZO2qO-h7yCck{_xXwMJ! z0#!~z9UQ?S`0KFG{!fW_EcV&=S=_qz+2V@qg;(-EJJ~0LQSyGfqLg@>57sR}vPgX$wuxnqHXPtM3AGcFj++%UvZYl*&7EQ%(@FDBC-BQJPBX-GS; zI_jeRP{nvXy<|UjU5s#DwU}H%ZhuQ&wX14WH2ah!UfYl&l1LcCHzEnj^ZFg?>Mm zo}o&L-eakNl1Xw#o8O|6XNjX|VM}D?iVl$ye;zUr9pjUZhzUezsjOgN8r~lTNsfLb zB|TUXLTk3<=%-S$lJB0vuakX8vWjEsBBqbb+Q#xKWT2EAQf7$(c(>sQNbYEX+p2{m zVRak6fk>rcM#L|y&&sa9IJR04}GVV!L`(x3+ zSbjvzd#Jr+^p;O%KuSdm-%)Ko#4%4qtNMguN=KWq{Dl~jve6jJd6x3gp)7Y;Dn_TX z@hLDQ2*S-L~$ ze6Aj?$np}N6{Q)ndbF05tc2uBYBsJOeNjr980lrTQd!~-#*m&8tRA&la(G!iSXx8o zVKk~o(^(dv9FiK*g)GZiYDTxQY=C@%m}jGZu$)0TYaq3v_gTI~%$Jbb(c<@HPsK%C zDI|5GwOHtBR+8tUZ?NpfM^F)KYD|u1!Abp^`lAmRo`z` z#yvE&xqh^Wl3Y!DsIk_Dl&rD1d&%Ml38 zq79={S^kC4nUE5l!}0(^&x@u+7b@{)$mgTWrNn2X=cDUKtvuve1i(vADBV=V&h$ch>409nLZe@0F!_taEe%%W9OPWVV#}%+@*jsg(H4);apQ z%JOEm&e3mK+?lO&bRP@NY!ziM{$-(=jigI7X9A4|-onSyHCl#cE80Ub-J%UyzGLYg z)mZkhycO-ovbdD0t4DM)%Ze#VdPbMB{DiD(D7ja39}CT*wIO|?msw~QZ4BufEtn`< z7(9Y3Iu`w+Pbd*IueOv@pM~aClDDJnSZH1)=^yRGLh~xgfapXe-n=?6I)`IuULArt zYG8CJ$DBs(G_MYdZe+RX$qp8GUL6$uiN&2)2Sxv4ap%=R(F-gzuTsATMenlEys9KQ zhw8gKuMUbn$`Y7`w~=6`9Tcs|;?A^#qP3I=nrW#QgQ871#+_*gM_aQLMmbd1;AoVk zv?o1Tp7mrH%S#ZN)dxq%D-jK=sJaG6=SYdq;X|UwIm?~HheZEnap&+M(Q7R396mI9 zm&KjKhenf<)M&VK_^@bR7IzLG7A>a4o5P1kaeCulR?b0aGyUBe9xWqdvJ%oD?a}uU zUd&7gjo7GYH;!2d>5G`rUd(z3{r+I8Cz&koMAyo!_zFKQx<$&Y;He)H!~~R+7R^*8 zC!azVUGHhpT~cOSWD8`1 zC$|wpGRc!;Ebnp%pBZGux9KsOwwE2md3xA#**c zh8U80o)lx5?@1Gu1)dCMS>%byve=VpEK5A0)hX4r%#%;iW@_Pz{}GD$%#*el`TdYp zo^)qf?a3ereJ^{BClesFs$A;{tzao;UG$7PHxg(COS0aJp%v_5)b+V1G|yAa22W_7 z{|hl2J)wD?WV0tU&y#%N3C+D{AzykzbMH0CSDw&Jdmr+RCp6QNeCr9#v?Mz`p_!Is zrzbPe_vE6uU*`$Uw8bF1Jz0zxT0igcWG%~HPrhQw_GAys51#zO@}nnzL1>M=&yx!* z`#rf0DUJ60Nt5a#J8j zJ$VXQ%^<&eQVy$>mXP26N7_Mt_vCfNko@UM9hPIBbYeN~$%iZ_JsHJv%9G73XFQ>` zAJz4*C+*AQIdjPQ|B+6R3!aQe49O)=-e$St$ww^LJlW6kpC=nxZhG=B%WY3+T}O4@ z_2e3aT6q6|gkm0eLf3Lnh={p!Z&Mr#S|=oULRUA%Bzn@CV{&*x*SmZ-ohNj?(>f}r zCl<0ua(U8?CEy9o2~<~{p3s~? zlHU`W6G#erLTf*g!k*CDkEEz4wDu!;#1mTkkrelY)_x=UcskQWo0toF^Znc9OcD z&>Tg*sOJgIQPhk2p3odcwKw!+IfUv;@nj>*^PcQtY2?Xa2-Wq1C$#pXx*Eq`mFH@F z{nI2?MoRo1W0P0`CGuOwv?6K}ds9mM*NB?L430_o09O-AZW8OpQVMcH%2bx>kbfaB z#kTw88l-9LvXm_0uA`d89?d1MCgHB5UXC?pao16=#3r-2>!{|jZ9buuOpDkl7Iz)> zTI>RgyN-H2cAdptN41LGWpUS0ZDNT5)gE^p)i##Q;;y4Yv4Sk_I!ccfXK~k2kyvw| z&??1JXd4;;y4Q#b&a&>!>cVc`WWas#|O^ zi@T0`D|XN))WRMy5mbG5*HOJtFEbgjlRP1*a zchxi|c7nxSHN6x2m&IK*jg4JlaaT?0v0E(es%c#8A&a|enh?vCtVY#cHBF4=V{una zlVU|#+*Q-$SV;ozTJ+ zu^(C7HPXu1FD&jFX?5&(7I%%bHgGao0#+$0o42You>tQ(4?K()QSF7I%&GZEQY^yGHsh z_9=_IM%ocu$>Oe&GGiN9+%?k9*zYXviYP0Vlvnl3T@meyJ;ma#h<3+nvbZavJ+XQ$ z?usZo_5zE$BKk4*GK;$++8=wJ#a$5{h_z#JS40P6cyR`;;)J^*Iuz@`;;x8}#JaP% zE27_GeOcTU(I2tFEbfZvuh=LScSUq8_AZONB03(M%;K(yPR6FQxGSPlvAHbnis(#i zA&a{rIvZQY;;x9!#n!O6E28tUO)Tz;=tAr(7I#H-F_y{Vu81zh_OiI^pUbfWEbbcV zO6(|$yCS+8JI3O!h_1y>v$!jw>#>V0?uzKY*nceUis)wS9*esox)sZjPaQ9JMRYrs zo5fub-H8=qaaTllW5rqA716y|X({pb&x2T1De5zYd$_(H#2h8wCt`_CHzlGq);9EM zMWQp7V~*g>1oRn4qBEJrLX46bQl^V;kev86%0y>s0qVtcF$7W=lFPZpa_JI&2@aCS zdA=aUs84tsLGn2*rJPEjUvD`zUx@sU$wI&0a$_pKf8j)>%o43H;{CPAD&+KG8HQga z?glC1OknAXm`RXg&K#BqOL1o@3tcIz5mVCH#FA@X4v__U!s#g`Llh{IEEe>|v!2dQ zDXPu%X>vK|Hz`@cW9aF5WR-W$uw3BrDewHpavMUQ3YB+q6q0=p=A5fOi>%<}VJQfq zPnRkpCS2JN|qS-qIx!?igVN_^sLBJ&IO+Y9>Mq4orEG( zj>^glspb^(Nnyy-PF0`8&f>k+&I>*%ftZ?3Tc6PQJnMAzNomB?a)$eao<6GWyzdv> zH?HF>_DKa~)pfS|*vXf&ERn|wl}@v`%iPiQn=anAdMMx(hC zC>C$w7>q^>r@T*SG+uKW`-Dd04af3H<7^>XJA)$Y$Ku0-z0RMuK4SqaN>CkO}aY2)aRQdVZdFDU0NNLy!1aaoS|2U4|t^3F^UQKuD4zM{z@3o$XL zf-E^cK8`b2%B5YygS&2kJf3DUvY#!~V_ zJV62J;Fw%wcsEZbSSJDDs;S>AHauv}v4;p8brZJr*?HBYstr&C;sC<|GMHurQIvov7o z?R4cVowNEn12|?dgxb^BnZq)LrJu8nWiezuN`Bip$K`D2at1j!Sq^%V<8jr(i=Grz zB9cB*bq#WAvpfQ!HV<|zmMR=G)EUE)!ZOTR%o1T4?(Ami$1=h>rzAKYLdR>QbCYGM zCrMAp7K-m7RQpJ$8p~Cd(M~&-a`RQ2Q=K6!FR{Gi%wy>Rp>ookOqLlO^R9D-Wi3m( zlee_0eGkhxrv}SemhnzImZXnW?Gv0KEEQNLI`deXL8$ggP9{r)ba)4#IBg(0guR~}wRyvhg@-I|%t#-mJ zwICF;-WkKv3_>m3;H+fnz_Qsn!ZMm=tCLh-)%5}7TV#FZ)MMEKp)vfCSS% zS-_IUa?sh$vX14DbD8B7gxY+>DOyq0Rqzwlo}*3*OI-*Z!QY&oEDnTP_?I(>We$YO zIqqy@$>gjP&Uuzw5bFDBr^u7Cu3+`W>dHOqlu;s@La5}kPD_>ugtE>%16T&ITy*BK zjE7L|m!0h_%UG^BCs{H%>#CEtlIrR29CO{N!SWx+{O5#Of}g6AZ#pAbs<7O07O*s8 zx$R`Kv|_pAoMGw6a@WaQS=BzD<(^Z6^u7~j$+bkuLuU+20|<>zLi?30-C2^_ zA7Pot5@?@PMb-5smy^4FHI{!MG-7$%w`RGst6=+YlmwrJ z(A-<7eKyCm<*Y*Oue0>#tRn4;Kc(7}#!|F>3d>TKV(lH4U64KK=_BnIu$t1 zQiLp-EFo)g-)BG8vKECf6fz=)CX^}Lgpef)jm8v35y~Ffm$9$$yRLJ+?)S{+`|H1+ zkL$YL>pAy*pZhlNcMwxIGzc;sG4(F1w`maC4cUsU7ecoommp0;6`ql{$}W}G zn}u3KnnGHH20=oQmZ4_er?26PkjU&yeMW)nGZUiE9K(?1j|q8TJSivFQ^ z$VZTYp+1oHkT*k^lS8YKHI9V)GbOYIF>6S;@|4gS$Qj5-q1d|8!?LTT zPEx3jh~AWh>r4+dfmlk~LS`xH3fZQ_6w$IsxQEk26A@E(0a&Q zBzzy65xM~Rl7vT*94hvl^!X?WU)^&-G{VLv1Sx3S>{3_HBat^XMG!s&8oy05+ZGvjk^L@JAD^fR`g^_8In$O;m!yec#Zat^XOG!s%| zgJi72{F@1c-_-OS&-jIcvdq*r5Z@(G=uC2^?|$v*%=xS`3CZ9Xffm> z30M9tv>WpD_fmOx=sLuQ{2nURP+I>K@<*sKWH)3_sJDn7{ez5aZ>TS%yOI&eN+jXc z*&9lMd91fkhL$g1JZP}RNfcb51Fat1SCtzWk{1Pk*s@=sY>!Rl09}nNl{4o zt&yzqkiJT)LB3T|AM#L13lXisk225uLVXd_m4x^6fzWWsSS90;m4>VXp=F5Kg_yrX z>k)GcF@J}SBBo5bR6Z2CfS6_^JkN(hg&NC9`yu9Vs4V0&B~>9umDCl{DsGcHheO>U zFOu+{KN1=b@gc`UDZgd5644$f;Zd9k zH9|}i#GDPaf>=sAL8dF|gF0(a=WJ*kVtzr)xzIGo86_#m%9SCbI2TGsOlcDC^M%lE z#Iz&f9$pAthYWyR43&IA#x)yRmqL|Av~`HN6l#T-1BkgC>IAu^q&K9-c4_@`s2}Qd zB;nRCho&KB7-F(QpF-v-Sp>;YvKn$l$rcf=*^LuH%FjKz`gjNJ&uiD(HV ze5Kq7wMWb_#M}z?Ld;y$xfL1%*$TNGN`;(2ojakOkX$>Z^1aYC5xp)6xBg$~A*8pG z{4Yumrz$B4*`TBnVp^qF%LrHAu~yM><>d}kWGk* z3h#!ThvW)h6VVI(CY7VZTC)`^;Wn9f6dBe3J zJ|thblZZZS5xfasr>5#(V7LasE(QrS=Wk~VxOi0l`r1g^FO_0VU+*axEF^CB%6OMTa zZ9&S0;~+Ab0vSB-FE$Qcr@Tr+G!^8G0>wZoGj zwMaPT+3-q8ZxWuvy5U2R50O$SQR}`twrw z0%BT|aLh~L*q3GI2a#}FEyMAU6iDlEAIPtem&21Fmry4moCYcQm(+PByhlWTnuKS* zefSt+ULxVv+lOP?O6z?f9l~*tcOf0a36M`nxQDNXhd`E+{7KR|{I!UFh=kkf5#EHD zsJ~^`^$4GVJWj${uZJrqNb4<0__LJ}?k1x5CE+@5*o4ebG6-2KNw`05I2m$)gvaHF zH$ko;rf>KpJ& z1F}}hAY|<#;ZckY&xD+VydPeNtj7*Z>*K=dkXlN1L0(jH5YkP_X-I!1*C1n*XzgVb zGfB8Vd-F4jT%GaWKD+!(SHGA(REwxiDUa1!J!WM+61B>z#VJUe_65(k+RF3?fhdKL0% zxGtnG3D3r7;ck#wBz#@W3(thCCE?eL)bKXQX%ZgS;&2w^v18KuvT&(arL9&ZT>0y8 zV~B;A--Od3+aasMyCJtBtHakJC67y6Yr>^EN$YhW--a7QT0qu@ z`#@eJ;k8&7o&*^~!eieM-UeAg!dJoO@NGys36FhSxN>J{>jGqZxC5m4KhmFH!b2b} zAv?m!khe&VQk|XQlaLe=uKZ^>wu@BW0yz+F47otUeLfgAA^A^;91c$w(Vr#ZYx!t6 z88NSt@LC)VZ-NYh919#(j)Uwa;nq)tJ3zFPQu*KT5Xdu-Q{iMt z4-y{N>2SJ;K9PibcrLsfF{?O($N(j2l~ zNqfjuB|RY(Pem#_kOU=zA;Xl6hNLN(3^|}=HYC^SNacl)T1r+xdMeo@q75bC*|-!w zftarmlNG)U`B}+*WMz@?Drbeucas^*b4FUf60QcRqNF~gos#B|!Ajag<}2w5$xz}z zE+`ocDRDN^`e;Z?C6gfomCS}rRyVq_){qY%cfvy;Ye;xj?}w8i=MeK>cpIerd1*^CEIQaz-t@g!U) zx6v4~3R#aBCgdbybYl{v+y$wV*H{DT1u0-0gM2{3yQPq!_msBMAcc)ukiQ{Cjjkek zp^LIQ#SIfNFOzT&iyIRW^A=)C7&9Palq^8j-TLy|j1tB+NL)Pqa)kO*(zpPr{&Q4N zxwH}6OM3Vz+A3qzg{*~?HM)xEJJ41+!+=~=G7ysYl8mC9F$#5_BH>Y#GZsJ^lJHtQ zX6%HtC*dAeFs`A_Ak=xncnC>UlK=If&-!vDr9`yfNw}>ijK+|ENw{()!-PCUOci4y z>QucfeSXrIiI}D&ob{x!5ixxb6K8CPyscy}vZj-8>v6_y$o$4K^G_KS-jI1-f|zPX z3&;;7JR8-GL6F}eHH{R=S;(_SCZs@?wDp{EUPO;0;d^*J<2GVmMoc}UTyJUpO-OyC zDP%e%-Y_9)kOsyi$W};0BMp)TX=Ln%#9Wd7G&Zh@=w(Q_KhGNvA@NG`_mLHRO-V_} zFeQ~BDN1TW)+=cQ*{`Ivh<28Q*W!7jA4I<@Yx;sQ6H*=0)Yt^+0%>NPgnS5TVH60- z9BzcPH0nb3knjq&Hu^x$Af~M`2~yyi#Jpmxfix!JcX1tzlMn|nosHPAv^A52_hDBf z9+C#>ZuEitNx~!TX^e;DzAo>PdKv2>bx62Q$T$WuA%>C1khS=PgxAY5ibB>YDGxcM zq#ERglKPM$HzIXfh-fuQxQCYELSBK`#uP|jh-0jTBtl$cFJvCXGj56KD@nM|z7cK8 zD1K2AE23RQmT%OB6uT+?>1%X@G=uarMnMKb`Wp)%(;)+lZICsPfyNogImjTRfF&zf z{Fb!!rcn#hf`oU=TShO)Fvw725@Z>&Mi^<3Ovu~DZpa15JH~ZL(c9A2NTZZ3tv82^ zG8#jMLf$p{K$b(^GsZ*qK}H*kMD#l(JkMi{)sSj;BC-WpT}XJ9#~3Fe!y#i0-I4x$ z0(sx4CZexIopDAyVvZqZoY4zX;I332Z;VFP3nbj13C3i|a3!-LtCTE+oKvy_Qu$t_ z&L$D92MJ#(6O5CPPf2)O6Aj&!QTz^>WK@Ubx-T&w80|&$swCXQ4~<@k=|;lq{-H4m z@-Aemu?Dh`gg@^j8Cj6skXc4`Pg;KfNikf=Gyh4Szc7*@uajJ$I;qB9$P^O3+oTyW zzSP+WS!vXT94FzCt}(hnay=0F)))n;O~RvCYb+AcUnAj>ZZOs$=3QiMFb+WGlJK~` zGm7<<);Az#ixCew0@-Txg4}@oXpDhWdMN!#H&P*uAlr;gNEgUY#s$bbkPIWXpS1o3 zWV=xp@;xNe=mzXZ>nqL3%-U8KwG5>!XqN zyU`dj4>5ljCS*NiuQ3I(2U+`!6(ago5}x_}#wNs+jglVjH;zG`ha50s21x4`3HR_X zqdH^~gwL&VEE!0L9!h zYKrLBQTc(<7%^3HOMf01y%E!vgj;`T^o6{uWCXIlM%F_k1@bpUGq*tUJ|dN)%#)D% zB;21|X6#$i!vQ2biri*ABn4S{%wCYa5ZxRDiOnOG^O~uUS0VY#Ovne2{N@G7cO=|a z0ki1fpmqHW36Jzqvpl4f9+7I0_DbSKvvt@+S%3*-DwCAhG$R^5fdmWOXLt*Mgd+K1}*EfrQ(tW!8eML(H>gXGj)e>X@S-PZgA`=gd?{ZxXIt z-^_$8g2bB_AeTva#u}KVhD+-e9u;Y9wt#db;TdaU4uK?+a1WcCDUi*Om&|RD+sJBV zUWe2!Bw20EawDXzcSyMMD`o;@EeZFhqd5X{23eiW1&~6qGOpLmZIBKm+@G%I1;{MK zbT?z)mbU(Y^f2o}9xW_&dYauJO-Z=*Ugmg+N5YkRn`w|QAt7@wj` zB3X`E9r7&1Gdn|GC*jrUYmR^Q4Q^!Y6_c9g76ZOCA= zE+kCCt31T)1(^*QW{wllw~_E#j4-D`VoOFO1zD{~xXuW38)P^Muf;p&8OWC;yvIhG z#om?v96`)`W_=MocPXhn+H8TC=SaBDXwyMVZ^Vo-2SX+*8H239kTu3kg%m3-b;g>R zkk=vao99ty8VQedoOuhfT}kwNvVU|sS6O0WMYN|$cQ`BX`J$Ztw| zLQ0mE$`ecn(p|}5$Q&hOM6`V*-1-D_5n_szlR6X4)eu|B7G!-z!m~QjJb{?s5i`lW z42gP7>P#~4L8>XyN6QMfC*eAi%<7Q0As?6>AoCy}nnNHzLMEHZkmHak=0*{{@Z-|@ zRC7DzStWZQ1C$&?ouwq)pQ&cd80q2fkdMr&BKiYlO*88v=E?GsHO=gbn6@Om%1Ne) zm6s#b1W}53!rzr`q*G%&m#D~l>^|8|D1tdI*WV1Tt z0A!BYUPLcgQ7X?hdqP?%aUjE$3_+dwB;5L3GX=7pgxg9nw?J+{J~K~3sy`ty^UOT& z%T@3y3D3`bvzUnXE(uqjZ#IUclJNEZx#>doknlHasb&i5JVc!(=3>NDs3dJIF?T|` zL6(}Ak(ETktuHh0BW61Zx4z7*JWl5D0kXa}TSMwpmdeY`evs}YyrwJ66v#NpYIBE( z{xu1=wa(lR`9sMG$bU*ML#kJaWZf6hd=j3Gb!Oan>ESFAp84<01jzR!Jc^CxU=jU1 z>U?jGK}_){CF^@L719LqgP95G2ia_%N1fRuJc=#mEyy+{(Gz4%FDoeoiLDyRDhsKr zBu+%@N5Z4nVkST)LbjTNAZd^v%^9e(4|USb1&H|%G3n+uNL-w(&NlNpn{ zqRgQK`NeDjnMA_<*=f3vMX2+unGD&6nBUEfBKkQJo}WL=?U2$>MPx6s8j^73Kg`>Z z-Xy%Hd(27`Wez_?);_bAh_)J8`^?UeeIz`J{pLty#XK!-{bf!<%rhih`7d(~q!$Ti z9WoChD;Zfw%+rwHm0W}5t0t9?m=7VXmE@l!eST9(Nl1#4$|BkiBs}&bW-G*;LCjIJ z6Qq1~Y3r!j2U$HyxX(w;NsvUyadRbPB?(tPVeUblo2YZrJcgJC&q&NkGv)(X_dX>&n!Awo zH?l692O&{4rOsvZ46+)K@V(`-S@J`f=P+WfnUzJfBoc1xn%Nq%1#;c&i>xeU-7rTW zrfMz8x?!e3x8xZ1#85IHGEm7f$Y>?&ATyMtL*^^l1=*tHAmo^m(~vt#u0irW7a8e8 zNJ%C6r^^1RqNF6Gu98ZSW=d*8dMarI@szZJ3|G<#GF3@$NQ#oakkv|tLw-^+4suY* zG{_YtDI!{)da|E2YcpbslJFH5W$l1Gqhvp%sge_rZb~jg`YX8y8K)%AM>4Ckl@x_6 zQBoeVT1hp?HYN2Te=2DXIjN*QVAx|hd4QZg{8l=6Fhmamh@+Zk!3|3MSGEqq-$b2O=A6JyncTvgHt65U9~9%HqF6j#y-Qb|c4 z5$y#M9%+m<4l(T!liQjG@s*??YYeh-TU#J=AdgrlkhKX}d92HjeM;^l>ngJHSQS1F zMylm&Ed9}~<|6vjBzzCgYqf_oQ_>Uini2=nSIJ<=XeFZ|Un!Xk*`#DP_v{P~v(nra8$Z#dMARj4-o*{eVb0vi!tCW<5Y*SJdvQJ4J z$R#CBMYQ}c$XevJ48&9*;kC$T4MNQ9?NPyJqI^~gqzT3F?k#AgBdZs(3R$}m^FCq< zS+^lyLJC_IX39?Z6;jk{C8A$Ko#Iv}NP#BOpW;>@WK}2O{aoA{4|y3oRw8CDVk%e%AQ_M+tcS?DhOEj~{#mjUio7UoRklh(o>fu_@~VtPRL|+L{45s$>DO@-&m#c-ql$Q;l82BP zO7hQ^aebqtB;+q8l^}PO)DqFkHkbZXw>lxFAqltsjMW>`MM*zo4JF~#dB&Q7n6Zed zY0ZbsSCWRT>f`C}Z&6lF>mXuQBc_gZ1~I!xc%JK6#gb)5ohISETF;7y+=tY+dO=FJ zkp9G5;~|wvxK2ZBC8QqYdF!Bv-j;+%+SED?>96EEvgVNRNSj*a=170mk?<&*SqYHe z5!2EdETUgUoz~VE#1wojFY9L}_oAmbpPSgVn>7+JHdEr{8Hm|50I$W;>V&upu}=hB}72~v5ERSQyy zgk$Df-5{?bCdC>B83y^xS^!x}!ZS9{+99IvCE-zgZtaKMRB{qorC*V@KDP>dA^mAU z!XsU1)q-?HOsdsYM1O~bD}QB~h*^M`udK<4*@2kFRx)BPl5pk4)<(oU(oX6uu`&_! zBnihXvCbprCB!VXZbAAhiC!4=Sx;6{2(nH|IT7tB3D4?Mt2ts~+e_8NBlWPppI!qzhtpT3aA*LVmN( zK$0N4t=PqK?JPo_Kdd?;`eqWoBki%8BIYDw_E;t)?`zWfUTYHM1<0RP8pJ2zk?ynh zi0E@kxbgw(7-D`#%mFLU5}Azyi22(p3c0JKf{0eBtF->N)f_PiBwYER)gCfHNl(ah zB`)f0K%Ilu6vzR{A!`M)ZXoNhwGmRLo3wS<+74-=WH0KNB)mF@ty_qhiI^i+^imn= zw@P9~w7n!eV@Is|h&hXxV^(uWq3+W9F{=Zzs*`YA$E+ccS0Kl&WXJ##-iQBK>8LXg zb^f(>LAEM62sx;n?+;lEZb$TyHvRwohtD6&pl zy&=&(rLEIeUr0qIBT(mM60UsON`VZ7oUt||YaX)BT00<_N)90FJPFUwSt~kCRwuTX zw0^-V1gWc}oQT$*gxBkW)f_Pc5Oc|D5BXS0PsnB^4&<!65c=8ta!+iA<4RF^@6m7+_J_%!jRimDr6kw zjH)-*v$tO)((3+eM+s}5pDBj%pf z1hPm;TgX}^T_FdRm?ByML#~v2))YuR$bZ&qWZ5J<(udX-#C(F7ht?U$4ia9AC_Dd3 z8O3>I<+4kOX!%TOE0^6A@&qKtb|DQ&xXvT?6i6q;w!Xa)X3-OJREfq=+SbE@o#!YC%famqql}Bs@Q*?0b+ml;l|@ zvoS(RQOHy!t+ajgy(a5Sz!u=^@PlgyuW<#bcSqS+> z$x0C|wn@~dT}LrA#w$L(s6R3-5u+MmdJ-0q2(EX0(z z9Y|qU>Xf$!Lux1)gF4+wc(;_dQy~K&73@sNojUSwcq`gjkVJ~%QB<-^t&!dGbZz-J z*H!FBBKlmk^`zYzF>6ryNxL7U2W4@cs`d;;IqTuUlHWp9H#g0`Nv&p^sT zs@Vm;mHzyNtm<|x$W9V&>lwQnracC796hXUr$Qb;p0zU}k9#s>b?gg}W+c4l z>)NH(O6vm=Q{Qe3`4|#!_kkRsKJ%xx26hr;c2kk(?Jbb6k@cc|LPXz6!h55corRdA zBs{KWcBysJ`m|?d##-2oA(}5SFWDxfETok^SwxQ~;mU37WW=;XOdER(qy=_DTl);; z4T|CY^NL+yy|n&53C~75J03CzbvoL8AS)rA>`9PxNEdr0!_RBMsXVAp@1nfJ|31AF^6Wnuzv3W+QCxg;Z%I zGjH0rA(@oL^JCd%zYF@T-$5PQjuX+U_LJ4I?GBKaN%;3;u00+y5HbDjG)NL;puHEe z67r^fAF>@X*si=$X6#Y)aH!o%L_b6^JR8I8&WOp|U-~@E9s#Kh8E&UQT0lnFTOgfD zcptuPpBB*vl5pjb_I1QeMb=2W)F$cA^XShgyD{Vq$h&qQ$O-y;4qW*?dlIB&1DWSB zb{b?6RpwP5Yaf7o4;gRAd@pSsLF*IkILM)TQhAcy0TMkxM)9FN0#cKNS8$4*0_hH! zYHxu|fP7@1gzTUma-XN!1%8m$S0HA(T?_I=L;2TmAKSekrx5drJq9xBc^T;}I~CFf zGTY9CjCes}lI;tSX-!1t*o8I+t?MNR%392|%ZX@BNqENQ+N~k)P@h>ovxh(?QxAC` zF0dCvx=|L7>q~n#WF!gC&m#Le+^s)J}lRr7XVtEw@LC=ouuu zTUObV5c3LUaa*hGm5}RbYmL1Zl6R1d;#-?K$|opkkCAYH*4vdKbx63*20H=L1~D7$ zL68xM*<>d}zCg?m_9n5q0dNKv|Puw>Yi zAb+6sU+k5TEXYp#03`RDGOpk3`;bpDKfCP8>C$=$is6y|ZYMx$A#0C42-1Os*L1I) z3KM95XU1LQl%b$bNlBIKsM0P@&isdL-TgtUd+wX+~2AouN( z8A0p%S0ua-AJ~;ev{LotYI-;!a@Io*Q)M1$v~vMc zpJMom)16Y=W$cd(kvYuow16x}okyL1kWO@U^Zdj*Ga(1C>xww*MD)k04v(U!vkfsl zNcg%a>YPT*hlnZWT!Z|iQDWFTapl2IaBZ`_~DI}0E`K`J=u$hwcLiq0-b z!{IVN6`g~SZc0u=1}V8NqV=QqkUXx6PWfMCy*@@vWv9A`wuyvCTG?rjnA3=<;`D@+ z9wDt)aU94iN`|1$KoYJ~#hHzmDTsN}Nkz;m5?-$-ot=>V$cl5aAO+u+I!`&pcF0;h z3whd!hjfKhb9zB0LaIAsAnPH|I15Gevm|^K)NocJrqnyqRt;wlVw#e0Oikw~WU!L+ zkk6Fdg6vchy;J7-x{^YW!XqP<%R=fYsR}Wa)Pa1YqzPn$lD3dDO1eS{kBYQqKpH9; z2r-n5gv?Vi5pqDu3`mi8BbDbvx+qx&8LDI*WR8+_$oEQiL9Qq{2#I|!($;Cn^GdEk zdMeR=mEDp|!h5WyQ&mJ?jhNa_9mpXiO_7y%v}DzGTu2iV-p_TMDUbn>y3PvJnMK08 zRJJ-mXLc&9q#(J|6i1E&L|Hl(351kwr8$VrBbA>qo6 zoh^_BhS(`9>&cK#PG!hb_S7)|}{=_($)$UFzVj7U}xVk&r z5z`JaJ)Av|K}wE7-dA!SvPj7-$Z91qf5<2@Nw}>ZP8{SO36G+u(*cryyu`fj41v^! zyx}B6+Cq9en;?TAeVk*E`H+wkvqxHA`2zjTRBAo!#6fl=#&8lKH%YiZrZWUmWrFm_ zc9J14k#LOTY=QU?&p88`h^)R&fxXiDr-^2b#YzrBb}Km}qUD+{4eDnUD`jIBUMMSwvq*!mWSd z>_p5q#C+l0hMXng{(R|_`%79cHAO0a<+OmbA>o+CjtdzJS>jBAdqo0o%4u!VtQ`vaIst@w;)rML?4kJ^6AgFX;u$Au@FA}`60;>=Wz(1{>(AQ zoN5q0{h8&s6A$6jpIQEKUV`xH&nzdLS0VG!`bp;v$ahM72%rAUt)Fy8K=|}$mQzk5 zgin9w%4eJz5I+5x<*c&+!lyrT);VW6gin9wmRA7s6*EbLFSpw;_DqF-tXfB81O7W_iZ_1j6SX zbLE=u7Z5)0n5CAx0>bAVb5?EldkCL*%rSM`Um$$mF~`((4?y_5V~(lk{tMx=j9Kct zS0Q|sF-yGr5W;5}vovrE9G6+;vy8cNL$?fs&oX9d?8ZU(EMuOr7u@;~KFgTpMYkn{ z&oX9d;dX)WS;kzam1{uwEMsoHjXMa!XBo4+?7j;*i+e&__X7x@Q_OYRy0amCPBCY_ z;-*6QoMM)C?l+J{koN8m5I&WdV>-AyAbct@SMKQk1>sYPSvt9=A$$fgOBeSBgwG&m z>FP%RBXh`S5cAl(yG0;;1~E%7w<3hkAZF?9)`IXE#9Sxrz5wAfh&je|UxDx$#2n+e zJt2GsF~@kW58*S2%aHVQM?v@uV$OQg{Sd-u5VH(+lOcQtG0RZ*D+r%K%re|v1K~4> zS>ASkgzy=}EF<0B5I%#L`}3}Q6vAf^^E{7nFF^PVV!oQjy7wV`1~JP7x4;RRLq3C; z4QZfly`0K(@BbIiwXD+r%2%ynkET_IgQme;{#*MRW(!km@t zz6s&;g<0mhqal30FiVO%6*3-m=DBkqe7-Qp%ySn(_ zy1zsCd|{rkuiPULK3|w+k$WDp39T=7Z$VBfi9RWF$R`DJ)?zmnqRo)8FLBF3swjzr zG*wa;(n(2E2%ihgm6y1$Kt>^EsoNdGXa4fImbwn)EMn5!!4N+4m+PdtV<3FyFU!~N zR0yB>%d*^^3&}TAMzO;E3c@G+a?A>MHKaRYR=S%Ze8MmHXQlfqWEf&rxqm_UgkRoK ztK2gXKH--uf9u|W@L9bqYu#M`$~+hRMEbMNeH7AANf`*A!^>Ig+^Uc%h*|H}f%Km% zb=JF0Ak&q!h46WrTxY%84e~8wHn=9_A0>kz6+V^98{AQlL?x3T3sNF6Ga-AFEP#~w zEE1CjX{cm9q``tn%r*%B{oX1xs~g-y5dKSIycS#CbCAC_NLIRg6T*Leh)0_4MxT;- z=D$9~vdxW!@LwNd`N@3@@(^`0+@~OM-$~^R_c_QEB`-qw@9l7%47VMm+D6IR?)HH2 zU)SN7?XCkEikM7yFl4Ec(U8)cq)w(g8Dc4!4dK6d!<94LRLD5Q{OqoTtW~lJ!hg+% zvwn7ehFn6-FYccZ{%bZI^Nafrg#VfizdG!2uS1^sUV6CO)lSPi^WSgbtle%w$n?J? z=6AO=gnxs_F~7S{LY5)s5BFKfE+sEO_MDVDf4DD0_z52Ggg@MF5PpKkmG`<9grDGX z%%ARHNdAAN&VF|^grDGX)_!*i9KP!q14ft$*EikhIe>W2f96k*xl?wK}vDPPt*os526C+VvnKzK9M! zGoE$_1v0kO*)5v(UOxIIvzrpgbnSb}in|d_k}0BZC#ez0jzDJV3x~vLbptsdqHTUa zf4BGm*XebZ$382ND)}|-tUDoxG^DI^ZW3e6f~0pUr9amy3&>49za$)N#Xb?k^&ca#uD{?B){Efxe!Qt{!=7-X%x5JycdHQ?FLDW zqFm?c95TI#rrmMd=8*qL?z;VQ$Z3*$?$jJoi{!q$9P%G3|L6XkL%8w-_hb&?$`9R# zIfN@~UYSeML$1S>qr8Mb(xYc*%5{;;OATbKrk~5L?Vy-k-nKwyXeCIF(nzDdGdbh} z$s=Bo%UpSeR+VDzljQTt=8)){(OQ1*^I%q|YtIzRs}-g2f?nkyMy>+BDj)T#2Qs}> zmG3pJVqTUOfn-DtdL@dE)nM5b$hN3{17ZRx2_%KR z7qVpRE2)R}D2>F0Olck!#1!$;a>(11Rm8g_qQ|~OS7jgCL*BhWW@%UJMQQI-Oi{1F z6{%b+DoUFZt7*l&K9H(zjJ9}olvdpH0~x2Wd_-9#ytffksd!XyM=IrwM-0m>iYeu_ zzABYBQ=dP3lumK=c0-1iiGmckCNY)sM&%!i^wH&t=7EsU(kiE~Grk(m>JznW6tqJ>;0jz3(7bNcy#lBH1mX6+fRl zSkuS7BY{lU>X3XBWZeuTQA;5Cj-wD~L~V&4rLCg-b3HFUkg-}mJ4U+}9Yr!zV)VIY6g`jOm{iEuBsBs#3)wh4Ml1a~ z{dI2dCM2EYelM2PV3nt93ybH~KCSYI7Vj+xR&ctuQc3CCJc{hADc*|_(S}vX6RcOf z*FKQ!YcSq>J%^m6nUD9T1|rwjd6EWRD(bAJdA>o?$U75=yzV?8Y3wzx;44AZy3 z-jqPnqnE`*Y58wOYfZhZK*nj?sZQZQoV&ryNB!F^N-IP1qBk0Hlwv9dl9VGRj-;7) z0TT6PwDufHb1&~bsgp%n>ndm@6#_|*=9s1w)52?pn3erBtu@I@-W!1=YMI?>?~uOa z_01tQ0~rBXeqYlX2C^oHGz~<%AGDtL;oKOlgU5ArNc4r=TBo3`QX)|$NV*5oB8Tv7 zwDkG~GEQIDAxaCAwDN`oGFIa(H<0oFaa+^1E|a3P*XdQSjki9Kv06Eb(dZujviHdY zjv1#{AsIqhZN1L|$==~@y)Pk=9p2Vk4vFmW1aEC1**iSJ+a0XnbnO`Jx}#s_(Gt7^ zkOw4x_06Nb;!O(XXS!CdL|$#!FELs>?+2+9+_8C&wf8QIsF8N?ZUr({?@N8=7@kM| zFQeel15w%(8bwEs-Z+xT&g55+j-DRK@w}f?4Bs<5dih17?vPAd%~Ax?^P?#34|*-= z=v9V1PBDAaSn36mk@xdcaxHiCT1!mcZ%DTN$T7Vj`$=NAv7|^=)H`8nJ?P2wW39%wACb?yg02Sk6qo7I(aPuNzWgdjZR)Gk?4su ziXVck0f8LPn?!TSGuGJ~hB}c|?(B_*L{_;>A0Z7X>vzg}&D)(r4v}>A?uq1WK{32K-MuHHf{{j*bfdMk zompB!N<0@8NDt43JU=B$J4bbTdWn!sdZp&9Ufx%bc2t>TUiUH}{0iHK?$2*{S8~Xc zud$TN#jVTC-=(`&Z}0O!j_2)xvG?|t1d^UVG8?_UG?D1}6myN*>h0|bBqNGnzwVOs z@$yH@3Pxr=>=lDVX5R411(H4UhF3Wd+2KWQM{9;xN3w!F_85uj^@8voizBhT5fI*E zA~OS#J@#x6^GzVxSBmYe5m8r)?QMkIrg1fyp=q}FDlE0B7Za%(!R zsqIC_@Ys*%eFs;Q?G=Yat|r@ygG8<-+jAk2-D`V;0vV_Co^L{)wB^{Hf(ml8NQdH<)*d)`<7r_OucrvFptJ+Fn%ea@~k+G`nztUG_Y8RNNu zBx(!k`Z`Y|9qY}>AvXhA2YGlcI(Qu%>-`OBa6CHr#4*-86G--zGSprBU^qYDMWP=y~5~EA$s0WJdjF(WREM+s|JaTE77Y9iHvKa z*BEso@7^b(Kk0=IQ(G0N@jODK!k<_tdjpUaOP>%sQxB(jBLm6MBlA4Pn;J-ZzQ}A$@sg3nv(Y2Ss*|6`C1ZC2 zq5q}-GSn(h{hw71(Y-EPc%;K9YpT~Ms3UiPQ6wMze`_&K)!`markH77>mVypi|mAH zUXMVscfvF;42kT7Xj#J;|FKNcJjE_vQwY zp;q~0ZxMu7c{yc$>}`PX*w+WLJ&^2Gp5g6Ote>D`A!R(YnE zuYg>+yvpg+)+b)MKxCeO4dkgnvR8SQS33~d2|UlUyyk((Ncp|rEU#@2DSVe>21%X# zZ(PnDeAb)ojeta+*Uk1ONS6NC*qGo`_G~XXkVI`LWtE~jv%NtDWk-ELQjsLta|4;K zwV`{=yyRIsDQ)EOml8 z%Q?=pnvkgxYIy#q zc_7mIR+44j#y}Fa$ULWchjPeniuu}mq^Qg@#~dM9?mZ2Oti=kiZ4S9ZF)O{HIV8`$ zXzd$sP9U-t{61low>XgOyWeVWB_wk9TkUOtMDBiTysd#`zrL^WeiqT!pOjaSHQqkR zDH7hjYrKy?3&pzj^{N?GSsg%pU1 z3F@r#o`Z~__2QWIUNguiB;3||uLEQiVm5fMLv|u&gV$FiSiyA_=zJM(Xdp6&FVU=S z^pbMKbRzlQ`!tb^Jd$6%l_gm+^5$tH&n5ow)qV<&d8p2vK*nlaV)JP4z80nJ_YMVprcVOB`m2k%!8dL<$EXy(sfroWWsRfcq=n7i~{z(Ma> z$QNPyT_M#uaYULi0&jO5io8V8c0Meb22yne`HdB)JRlinwYiQKjR z^}c{ap4k8EEk#!3UEIIksz9<=@LzAM!~`qIpSw?admxb&JmnpOL{{*WcL@?%!PA~r zUUouc1y6g$MAQnN_TnLt6+G>AsPMllc-or>iLBrmZy6-Af@i$%a|o~C8E*$9vVv#5 z^Et$%Sv}_!t0--8%v&Vqy#z>Pl`nYxa>!JQx#)e8Lp~+Bwx*T$aVs3iJ0+H9;ha|VW zi-?KrvD;q0O5C699d+Al7)WBU#|r!xt=;hq#6)(~U2hO1vZL;LBaju@QFpyDfyj<3 zM|JLcvvSCjB=^0YIiwcJ1MjZX(IfAKH9t?~V8-;w_tctSERa)q*VKyA{w+-1_bWm& zmDE7iU|Q3S^lgOZHw|Q*9(mWT`K=*I6w{De*ZdBWrLE{6r8Nzto5TdKRviOz5ObKa z_>*{)KLoPCpeGRYzBkJM2*Tgy@I5M*zaU3UH>#7%-z=gpx)>FFw;t{9g#5N$(|)CA z@6mot6&d?}k}>rCSBzg?L`$Qm>~Bn`zaQm46UaFI6!oV!RnFr-7fAMdn>_yWkjQ-_ zkKYm!SySC_7fAMd8{L0RBp7>Hdacy`@gn+jd*rte`TQx6`JL%|NQ%kl&kSU2uz&he zfAaa80?FQE`TawXNb3dsdx6M%$l;V#z}KJTvCIA$LsHN$8A$f~=STg@kjUqYNB!E6 z$mfek{U(8Ae`YM?CqN>f84LN{a|quz3i*zR`pg*X4}nBJGsgPwBP;S`ps+tJknAS| zh5gS1$$qz7*iS>@x%D97y)qi}*$$*<&y24}wHK7Zmm1heSRX z6!kv|Bzx?|{4XGpu^01KoJHTL5EFObOCi~9$V75The!ao;?+-(-pC`$OZ z0?8hGN&jIW*`Jq7`i0}NS9u*}mGpZBlBk!yE>G~v_^U*MeaN4w%lKPzND10?W&B+^ zWKma5E9+kkWUTgPi2f!GWj*FMhuo$2Eg4_uAvp>uP%^K!VKKc|@E>`K`;(|wq1O5R za|QoVNE;G<|6IW@709WmeN>sR_lo`tfyjFON~3tfZzEZ%&z1d-IfVOM+3%4%Ku(s zRDYiKGZ9nh20as|n5X@2PxIJkX)I?*s{8c6^k0U0_Flsu7sRATFU}XGm8S1=YxuJR z$^MqSrawOrnGNnwO@DbH8Bv^dl`7ZrGyhM_v;O`-(sTVr-!F6JI{t+~~(0FZjE1#BhI_`Ui3d z@46S&Dtq*cpsv)P<`F5l_GS8pfqtpdLdoHSa-YwZ$SZXV|3Z$+U(x4+7XF|b+~-qK zk;*UmsUmqJbz1sqkVsoC{WXwC<(B?GL1p>8Q!<~Xwe&XyF&V*kB|i1Jm7fXW-|ZAm zqF*ieb!&3#8BzS(o_FZeR$ISuAlZ90!Ecd6-lRGSemfEUTUwnDN!t0ZLH;C}8%Uo( zW@*K5=GL|Zk_o8{>EMTJaqF|RazE3rS!m{8^~XWtDTaS*)XAR-=|GY}bvpZ6ZOO6_ z^O`>d@*c^r6w}pT37JXq4@nPy@w1Y3ilpkpXswsOppM8blDZ_X`zg<{OxN<=%B{5| zdBZPIPhv`uyhdX9#p;VxBXLPgzZc|1h~=k3UL$#vVr+j%L&=&%@-B(%Cqw3wOegXE zv_{hU3X)`!zW((gRlt{{GEiex_?5(fyg{aDbm2jC8v8 zHA$X=nl{ky6O44a7E?-Okl!Ej7)eQrdDDM@vA=|vxBQ*xPwO&ygVqQ8aY5_ZPfCaQ z!ve|PEkpeGa>&_q`Zwu*Y9Mm2<0nf){rKm36yx;EG}84n(qVp|K(=Ye|BBXr3}na) z95Ys{aGQR!okHL1`F8@@rZpnrSF5-EB274Eo7R%#+BufEKr*6I%h4|}_R?Q$^Cv<0 zTSb;p{@y^2M|GqumUsQbkPjj6`KKUf6X{M&vpU*;07;lA?_kIH#hY^L)3vSK`eN#< zpM^fpq8a1L@B3AP7?~e_nla8_6UbOC>W*AH?o~|7v*}5u^_JO}%vea)T zKlG_H^j}87$gdW&#h}XkT97S6N%%cLwnU!)WXlwaIZA7qEptg;?w&JiF)B}1t#2UV zyK%Neo<2=cF~1;7N$%4mlWE4L_$PvK$;^LEzs;E9-wR~C{to?8?hMIPKl&w}v9bEj zL-ZsykOF~ZAS3b|5mVS4lqh%eM|%*CS*9#D79Wi?sfU z-zShn{g3;(wb5FP_KBYi`3Ew~-y4X$F3+Tx*?ylkTv>$sGsmAFNTPnEK~(UZZBAsQ z1-sDmOkQ^-xqJU7J7JE$D9Fl)no6>eD$ntEN@abiin)N8EhN%b{L3<{e<~R(lJ^n` zfAXED85<8`Eq=+R7-HMskegE469j~u|&m0zMIIF$nSfXs+h>{dzbocf^jA4k?${-`5hsV?=P15Js^?qFVg%l zB=Y@5n%^&wZQAEYK`n}#W?>Xn(e&^5U<2^I)na{q>37(HD z^&(_v@bPDK&f^gC3S?KXi<0aFde5BRD*rMVWTCgp>HYApf}>ehqf{nJ9SrVdS-cY8 z_(Hx3-i(tON{T(J+oG6-N<1am37?{#Es$@6->_6XjrV`i)}i3ZIH7kG4+Wcb)%6@i zsn1dByXZP*j(RaMN12$I{d`oC&Z3@dRZlxrb9SmZ>KzVtV=+g)!@+?pw@}K*cQ;3Z zL6(9E$?ChCBSD+R9QBR{T^4h!JQ^IXBvV~8Havm-+(hNfD>apObTT0TrkEI&EhGu) zqU|rZ|A960```hVO^BiO`FQYGRVrN^gltX|;zaPl=ct~DxC*%+=XE~>2P;Vzm%HJP zBI@}un5`sJb(AThOy@fa(ET)cV5s|x0s`!3=3S=A~RjCUPFI3E+%43<1edRrFO zJSDMfd||CrqOaf6Q8QxtQO#Mxj886Wm6B}rq=v>Pw}k-wvhye5xeSd)Oq%1nTe>G4 z6Z0NpVzku9IR4YVB_`E6>o*n>txc*eeGM`WZ6#XAm7GmAZ3V2KSxj5_41~qBm1^B! zF>R$Z$JgOth71l~fYzdwy%Ul33phSl=ko87@Yt0@iOzVi^{;{$ep1 z7PgAKNNt@>H5nGMs<4<0i&#MxlVOqQh?%ztVq%^_MPcFH zm>iP7X@LasR2RITVPf(>^-hAAGbv7zZlRu+y2i^d5IUwrOC=pe&26xUEN1FS+5w@M zd#n+vUwRwdj(mz+la*vgN28=EmESzciivrWRnnTrrF^W<^gci-YbncE$d{SXYzYN6hj6C-kOnDeIOhr8B&&Vsa0l<&~Xa-lr{Nm0_VLNA#Sij8$Jt zs(E|1tks^yJSQq^y~w4^GqQ5l8%jn8?joN*(N;NYla5huxY5>B&brPq`I3|Ip9~3* z8Urbx(SZ_>p-QM%*iMrwKm@%wqJsu}Ch83+IS`vb2o!yPJ}%B64evi z|5UR2D$yBMK};oUR-Dv@RJH;^)q1Mg3aVIzSj<*X#j3($-o&V46}NOL+6riIT-AD% zh2F%_VrxmDcWJa7vQ?=BdK04wTCZwV3X!CX+2}=ENHyz(qh$l6vywZmmR*n+AP-t; zp03Bdtx?Nr#bVyBsbyI#^xnk)l&Wn_WTE#iTu5DO3k$vHFa%QH>gVg4=?#i>NCRtx z68$FOI7nk_qLOs=Zs80_Gpm1CXLu4Bu7I?#3Q1j0LQ1mO2x(=FR+27CK(<0!TQ@o8 z@gliJ7Nm{!++ba*7Gm~7+FG`fh2BGz^y|q-AO3i@Kp8rYfG|RMF zn3D!;-ILa3mPv^D36E@_w3@w4ZDj_&Uz=N;M9oiHtys)4?n$eolI#R}qvNcKIiMx_ zj?hzCeK0Wyf-HD|H->i>8$$|Fnftk)+;P#FVV@GrF)uc z-cs&lon$d@DR;7}ysDOIbpO-Y+QMS?0G+L_LntO)EJy2feD7k7Vc8F%dqmGzguNV^s+LsqrfzrZBNp?fZg=Y>*OQ#8*PkBN6GPP!4A6eQ2x{(W zbyJcZ-6Qq12FD5Qk$PGabt!fBPRq2X^`4Fim}T0_n$2RCX)kLzi&>__}bw?EXiVW?qiK&F**0Krm&ct`&b_+ zi5+G7SSyvpjxznMqgoQyW0}(W)8Bgfb;>6qzJoMDPhYh9D~TP623j_YSq}$Vr?o_v z`ylILoX~O~Wc{urc9a=pl^98F@l^oY8f3QRq&#_&MSF;4B!5{*H%Q2;uS#VGYD4Hc zH)J(s8CwYNP-CwZvRblya8{qehNAU6f>JuBy^c}q;Y+IKUP`h9rY+yHSxhP48ly#+ z41MbZC3xzJYY=)WB(0B?#Ckf|%2uM6g+yC}tutI|Kk|7U@|q>mX*9BTrz7d8E}?$Eco8MO!1Swo1+>(6@o~)NGX1fh8$# zvY=;(=~hpcLM(4s7E5`^Jk*n6y~a|DWwiAc%dJ2z74xPwm8Av8WLgVYmg8$~s^=|h zEz56QYK*mwr31G<*7}O2AIsa;aV4h`LJ*p1WSn){)N@U@=c8$6J4~49S~I zyf`R9ykjN5K_h=Q_0@vmIL2H%OtOY?jJbB0WR2k% zbL}w6n#y9X9VS`xxspdC?G2Obvvb>c(mzZu{k1MqT%YC|amt)??5~Oz+W?D%Zv@9|M>mjs0&$RL@(bt1p zP->=CjboNg)c4tDS#@6FSyp@9y4t?JK!&rdkP`il&_T#NYYdk%tuM01vzXQw zSwFIv))!g1N9%opX?>AZMTs7b^Qd`|^|%t<)^*4-t3Q`AZLP8564MjQleOGy%Z<;AZx7&x}Jc!)3x53#bWMj zt+$r5nETJ`tt~9(De!tLo5kE8TW=j=G54s~Tc=sf^W62;Wft@7c!Tv}rtX({db`2e z%3_|vY_RgbMKKwH4WsxA8mp|5^yqW64OWdY6q7Eh=ffEhdb+_HuOuQ`L&`%oS^385 zn4XX-kS*3ImJBL|G5pBdphS=A2*iAB)p}cH7`=P>xz&utJPG~WdV<9~3H{u9P7BV0 z^&QU7t$|un%^l9qt=BllJTd&-8pmRu7=CUoXEFCGcUUL1M3>-BEB`p1p;;C?t`_ z`m>n3yI)!pSpY9OySvvaHc8iP?(XihnzNX@yZbDg#oXQf%9_Dq z?(TkN?Pf7|cfYnSvzWWPUt2{c>$c2SqWi64YMditN4Zq-=*KByztu(cJt9)dr;75Q zq=*AnI?Mem2d#TmJ+bqsZ>&d@=q=?_jMz6;H{Di3;|X|Ae;)SH)~Yxu`ay#D&f3G0 z_Z!S&1UYP7kCQTxBUZU7l=G>CCDZYq>?S?Uz+4^wWQ|vnC5B&25ZPHm{AAUbMy0aE2$b3eIcXhG z5)oq|H&M?iD=?j6B4RltS8}5G+3Lcw4U!k~iN1Ow4;1a*H=Vi7S<4 zj%d-CBy-$}3C+nvGlay1j%YNC$azz95*@#C3eCw=9(|9+P+K&s$%SYsYKzXJ zTR?t~mNIjg{23K9L&#rIF>`d>$|0RlPgJ6FnEY*Zi(5BnrkcO4fl7AfF*6k1wp=CI zcvDr+k96Cbz(UJ{=100?&10cup=F(}CzqKY>5laUi<#-@uJx6Yvk7Kd{9}F3VwTrG z);T45?d^+R{A2y8WSW|lA_V!@%0H9V`B=^g_B||Swx0yMoRU~C66~fdrWd*Fr&vrc za@oCgJ<(p|vL(lu8Iy9`nH*#Km1s|3F*6G#+2h}%46_9-FPcLs**>i$VCGN?*uQZM zEkU~98?Y1J*QH44ErNiZrX)6EsrG{`X2eqMCQ9^((VL&C_TzCf0wb2k?yn>}!EEpO z?2wjJv%TlDU*;II4d$~au+WIn7MI^%!9pXZWjBl22J_ozwWQL1gWiNMU|&&kDzyT( z0@{-lu>VvtTJ(j`8}$Y3e|4$o+*t+fe6!SOq?&z8LAw--*|!w5D=Rr0odK+%U026M z*Rg_jJ0+(Q!f1=m@C(|VIL3@&K|9DXYY;={`~~f>lGvygw1??Z!i-@ddy0~?(V2V- z*%fC~&Sw+Mc3RlJI)@}(bSQ-D9gJa7+ncMU4`d>i&OP>&d0GZTrbCL`#pY`n1(^#e zX%A+JKvqM_*i9Eu%-QISKxOTPN-%>K@7c=Q#THUbwz}%4eN;KyW-)uV^7a%Kvmd+H zzRY6wb!qmDMLM5(XniYMzt2uw9FyIU`|XuV&PHbqs%meI6WSwHweu}e`2@_mQOz!` zBs1XMr@w=)W>;ZZhPLQ#Pc^#%i@DOQX18Sd95Hlnr<&bGNp^zS_g1qfvY35uHG8*` zba4cwjv=3F_V}f`7j!f~38`-1Q4+h>t7+$1rgJu1N=>_@7PW_@qg7423X9oNYS~>` z%$8Ei9>QX_lv?&lC1(@Nv7oj+WjVEVHo+VV>f3jfWCzSv(8$iaLg!<)f<|^JEyCpY!nHL;s>J?31isXZ-D z=v=Fry+KLr9O+@Z$V$pk*RydVW|g$dD#;QL7fu%4@t%2e+hu7Fp)-&c_DC&(?hv{U z(87L;#fG#&sTTITEN?&_RWhArdbHFmCAxKLtA*X=Lp5S}Pbio82TQr7{iTv=n0ZmZ z|I^w&p(G*#EN$!}tEf~&+{@C|ZlpxlTree3JZ|?_k|ow6hW6p@?D0ynMd>&2ZWz9k zYG+^O81qK`6L#~}I-d?4^MpM|N$ef__I4Hv%>zvJJY}b?p;B35E83#>@H^OJl%$I+ zNNMErv^{<;#iWaq5V}9s**?JXH%k}0*gA^Qy{Og)&kO9@T12U$y417wyttU^sJW}X zm1F38PwP7&y4lUw$LeW;nCI+gwFDkVJslw3?H5?y#`_7hEqAvEDalTt*^Hl8Fz?&f^0-gf4iHK(W;*9 zN-z}oWhLE2%t6Qi`=l-<@)k=LKSN%!3vbNXR?se^C0dVdS5cBBOg)Z0KCaXssK>YG zYY9Aun*W7Jd%2SIz^jm?0LglenF^t2>x1o2;_9KE4z_n|QLUFisaNdFN@A_QYIoTb z%Q+1(Lv340cETOh`~YN_{kf8?gu?gW$q{6@eM1TEZ$SPBdEKt`G1Zfm@Gv9@dBZ;N ziI(n=cOY-tgSW=yJ;)gQ1WOn(3m{|dXFt_3Qz086Z`)ZcYau%zqSp zEk#VQx3C<5wB4Q}CfZ+qMD;|(kC=M8%I7I!lKlfqLWNZE6lAh}iKP<6gG{k+vb2HB zgG{wcseVO75ONtZ-CnP9j)={W6FV_ykzHS97!ju+^kv6PdkjljMIG~=J(;B`%lq~m zmToMw@Ldu8vXji(JKKJG8}&kOgFm6~bM4+rV%x<$TWpWTTtduzyQGp>%tCuhTugE* z-nF*Rb4=6XdMPipYkW@iWGB%2TnI7C?2byZ5;`EJEM$efh+_sqsz5%p4=K?ZwuY>> z=j~AW1R{u`{quTz6^pssyx!i#GA9@Q;|QhJ+aIfX^xKBFmL)-Uu+R)4UuLC<4fbA^ zl08z?H$I!}&vZTNxw(saHrxB+WHe-p{e7IwfqZ12kCXL~kL^F>WH;m!J8`G#g{t{D zWUE~yPJV-YYNy3XVxC0tnO!qZ%0sr*Or|H@5OcH3dk2mQt0XJS|x9&Qn9m?Z2N5%^JRUuJ(YQ@m!jF8zd-A|>~l)=9qAt-yX`-f?95|w-eXtDqH*4t%jCSr zepE>;=P&KYSxnAf+MQTT&U@|WmBeNP*lP9(Qp++P3DU^C+4&I2e%P5JB#sRw`i^=(bU4zBse9*41B$o3*yQvbLAuX?icKbLf zmKX26+eek?=LHYFgt><7?%9-2MxaV}%*W_r{vW#^OW&wiEc2owS*}K9m=Zl(IL-b1 zt-Vr7CjL+v??_i6DY;8;aWp<V!pHc@6j=fSPt96 zza)u>a=6!29Wh7jl`Q9RHq;Dq+z#y3rRZ9Q+WNr`?28Gt^`m`MNrqUBnrR-qAMN^I zQA`F_EG<9TvsezXoV1I5tz&LN=$qnG_FyHLt@k(?D0y{#Wu)OU!;iN?Ig9l(#3a>UXbhdGBv6ZaSgHu za>L%v@(;@&_7Rr6m2}LX_7#?rEPvS()u=|q{g9Uyq==jL5uKsh+jPY8x@G4(NPW)~ zC$I!*eZFHiQj)Hu((@#5DfvRQKZ;PyoqpGzt|UubIF2*!qWG^3dkM>4$YYRy?T=YD zK$=2C=u56=JcRzMB_Z@Z%P`bD50Wc%kxMOrR7G34Lw|G32}o;5VkplylyjEIeGGG2 zLy|(JSxQ4FCOK4%HCy|p;1b7Jy$a+W^SBN-wTC4)1{(&{=%VyO7P!0 zlX8m;v|c!rc!=7Ht%rp}-IVBAdd8}lWgKJH%p#$yEN0Ct8Y=T0)iW(Hpbnmpqg2sQ zC6+MDJ)zo4@T|Wi?wlZ|M5qOedD>ng)JfGG5iWWvF#}JD&{>w@kSBMgh*F_0s#NTm zLYYu+C9!>Gnb2+}dJp+M+A0&eahNjHd$v=MvY|UlG6R)L>GPkmp~NE;lNopfLSMC% z4drKf9&!$)%7yM>83ehkq&!O+-ZZ#50B?teDl5rOxYZMPk}{RWgL-O-O1!+>;57(xT37N+`LkM8ALd0Hk8*p`$wIWhhk>QYqA1i})1M zSjiTS*$-(Bxj(d>`C`kS3wt zEZLAFkVir%ST#7MA`U~w zL0$?Cx~Am@WER8zD^1A3?m(6utJUS@p(3&{84vB<5i<3aXL@_C}FHR~zCWpR{lZKEfp*(+4h8b#aLsunJLsgYz z3J)XpG-9TO8nGnc{HMDTJ5B~brib2PNkvQ;GBdP{rDQqW8-%iwAAZ3HdB7klA;lqELQ_OZRcaHYCS+@2$$uyC_e6nyM zS)oC>DQ23e2YCasCsZR*iw$`fvM+RqWj16MWPj*E2O`Sk}=Md|&R zy)$&2ZD*+nISu(G)Fp*VMMN{mHOTqUWtPs6(uEVnZ=tdQ9TS8!hFl8` zVi^p15^_B>F;%zzHl!cqM(7O72awkww?eh^=$MU=$q?ZzW%(Ae1d`~iQ5i-=%Q|`w znc^JHt6M*Vm<@;tIBEHHJ%Kd6w&Zha=hHC@>*~E|VaF?=V`?I12TB!jx+;l?1Bjt9 zEaCKGInPqk8OS2);h%jFQ_AUBkm}Ly-H%+X*uUx7PFm}b55|B?XALyOA!I^oYqMFl& z#q^@O(?Ln>nz6c5Mb#V;jj;aY$5FVt(^bc)oax%3hU04ql*WC2`X9^(o!3~pg%d<8 z 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

@4S}5Gk6X!;3d3**YM;N%!g<29A3ancm=QF z$qO(ap22f?0WaYdyoM()#C&)L&*25Ugjetyo}B9Q3%r0Uyo4LPf;+s1!;Ab_6F9Ub<4K8oqwex!lwf=76xnGmd?ceJ2^V{78u5g1pT;AbpE4+B;uJEaSR?uW*Comxn#P z|2*l7Z4dFQzBYZ$9nSE_OZt}QO>B>&cBbe3JMQpZ_N%HS{=(XK^M?!4#^R2xT<=>Uq>BAW=aD^M(;d<0?+|R_l zLW4UT?&_T?e?Mk>XmfXZpgY3_u5gg=aO?T%Yi@g(ukCP*bGBAnn%%lA-q=EbkM zS4hYD+6?#O{Mv@cdMCpD@t%h#xFh{!&l4P^jtwhFqWL?*H1DIepX56Yn$vn)#8doO3C{8z1=~Y` z(@Q+haDgivU+(=x%kSoOKl<-l_g8x-yvE(c+S&Zg>>EAraD20O>buy}93h#OHK4eAM#@Cpg1JtmmbBt8jyhd{&|z z-B0?$?r?y7S3$oI6TUL!zr3~lUmo&4MmxH<1h=mb`F^*R$Hf`Gx6{t_`$_4Zx3#;& z;VjQ1oZt+1vE5$r2ZJ})^M{_da|i$a4zmCA2J640Xx4M7=lgN%&)i*X*QEd49e?Yc z1ZTLw6>f0+oj+H^u$SLw;0zZyU)1|etouCZ?(!Tv`fGP{A18T7Zq__pY*?$`hY9jp zWw)`&k1)P&g;83klPf_aDnST z4E^gKEw88WT5Q*0au;_L>vhw9hU=E?y;hUl+|f~69*%NH@y>j>!X1uxMIWwkhvVJQ zhb!FScz5*S3U@f(1AVx{9ggxo!_HT2*CfGt%hoT*tJre2&1rB)M{S)T?>Wp-Y;)9> zCpe>{woZZLKl*cTf-_v;DE|+Ty$&XLAKU~5qcn#+V4ExuA5AbNYkJ{_P32=Lm zcRE}i?0JPd93JAG)iJ)eH9R@i^C|r(&u8!)UcgPPx5eh~5FhPpr*L?Toa6XCfA!9H zyv4e9&sWILJ7W9J_WC%V6CUg5G7;N#p29P@iS@JJcRX~jptjFE=a2KX3wZf>&sXsL ziJlj+?Ne?0S08lF@V#`ko#R4m`>e>-c8+SBqqg~rC;8eXoS*F1Veu4n;3n2N7k;=r zPr{R@dVdPf;5j@!-up9n4lm#(yn?4s#~gSLFW@D-g4gim89s9g&)_+{fS2$JUc;gI zV|*gE+c7TuzNFUsSbc>2ADv?BOrGhkC*bxK@7(TUyPs&sZucg(`;wZu^)}|UY+XuT*K*Q-VZN#7r4S54zKWjdaXOd z@%6(#Zzj)AO>D0uG~K96sco_{qTs z%5zov)ZoqM^J2SiiqBS@@YS>`k5iu+pd1r^9I*14xP8i^F;WPcOv~| z&l4QaKo0kB4KwxgxWWzYaM*?UaDp>j;0iam!(lh(!wD{Mg&W-Auoq^+ z3C{58VtWpW7utLC8liu4nnr)@h4S+wTt@3>-R8~X=pr~ST;K|aix0=ze2xJZv3~Y@ z$rs6EM{KWgYI|KP2kh;SDX~7LzVKrCjQzl2<^x_LuN|XxZ|QHnuh#xdUdQt2E6Hn= z+8(FrQhr>u9apV;J4^aqtaF|quW9O?wU-|9OT1E^SH+f>E$iB^OQ%V$ugib`DmmZF z4A#G`Fz^1FJdcg}jbAM@FFSPf`9ELI=c{$*PhKO>tCt@-`ur0|pD3@fX|!JR3>Ub< z4eoIGJ3p>kkNeHn$+1R%R$jN&cJ5iM=Xl>Y$oY=e^NLp(bA8?x+iQJ;I~<~SBAnn3 zhbj7Sf-_v;3OBgJ;fk0KC%9kL??2&ce%qDNn|}}g>O-!Ma5`kjH@6p@uI2ppXzyo>(h|K^?2V;gTvFkAK?O5I6uSt1&+n@ z1a~+ryc3?~j&O&=3Eru2gVTxL$#8kL=M_%R@jS!vdBgovpU2cE?=AlZ#kJ&lNo==Q zg|%RLggYFb@0|)aIG^I30;d;vp5gF9&m-L64yRMSpWzON7kQ_^6)rFKPKDD;J zndcGiaCo_Q(kt8;kn|m@)?O)zbkA0FUiaQ8#?;>Yu3*e z%-XLX_Va3Rhr>s_Q{W08{ZW72sh{zr`oynvdRG+aC`3qvZ3dI$HCi&+}{5e=>A5 zFF*D3t#J7na=82gYe%28l4Bt^ANp_dzWSF#|CaLEnE7nvx`#Y=Hv1Xh+BYBmpK{!>vxj^ZXx7`*{8n^ye)#>cw-cprW`2(3aqMVr zzU}8cf3rBDWBx1h`+Q!`3!O6ho06M#e*eR;pWA*x_B{HH@Mdp+96I~RXPja5W^WhZ z$4e)Uxz0(Wzbv^~*P69cFvomb`P|g}266xMu!jTWb5rwq;`o;#-|T1fHNWEdbHsVf ze*$mL>#xJw?|fCxYxFbW%|6HcF<+DYkJdcHW%T90E_)vRY3ZA_U&mbU59ZC|am+W* z1EXImbFA}ASg(oYo4rl;**v~x-;lkH-sF1>Ij!^anCl+Q+9~Lp&z6~Wm(MZlFeSP?OF#9^w`g&h7AKv9Yc8TFww62ZF&6?LSr}a6lkGVb< znKyeF^Rx6=2jKdQzSG)sU7N=IQD?aigmq@PB<76X^?kW-Add%nr~l31*Zn~DHu?o; zyEpqB^P8e`mUPmke2)3KKa~5-r9F?A8GQaZ@)#d|b6DqFey4N2^GfNYv47R`+@Fz- z<+?VH9s1YOxBS)OGIsR-V1Cb!-MY46PQL)_>t?v@a4rw{iTmU50q1+JGp(=pt30mV z>~pl9m*pRmwMBA!Uz#rO*U+rDbsqBv{?x5A``>v#U%}@TI7aWZsXJcr|N7fMlXE%9 z^A5Lzhg_e>%$xJNviA#|ui|-wJDjfSopLqbe}x;|;c#{DN3p(#`Q~rrzBGEXw`*Yj z=v)0xuK5MzZ_@k_^hfXidpY0H4}*1nyw=da?;qs2qnYm|dAjz{d4&AV&8(d^=KA_# zX8uR%_pzh7S@)B#-%xd`g|L2 zFyvpI?7d?>mgSr0+p%-l9(#vA`Umjle8>D$$-|+;%&+a~egeEXm$CDLU3-T*TJttq zUt7(a`RL>u4)fz)dk6E=VeMP~vE4HNMnnIJd%HJ#81pY8zsf#xj${5hSodl9W9tZ9icKA3k)xs%yp8$#5Mzdfaj=?^L*p?PtJpo53HEzo$2E){gm)4wP#(TK}ye zv%a5iW3GMk{r^Uu2X5>0+i1z1 zebRjNrDZ?pbU5D8*Y?qRzGgjEypwm#x}SpFtUsrmF1dZqe>NPB^f_kzd+L6dA-~7v zW#%dDS2#Cr^#tNxwbzN591N9+48 z^UI}U)=s+Du=ao}$o+QoX6@)>B+sMu`O~bOdY@tKU8CIAqcv}%^*x)JxxO~#fAVuL zaJb(vQ~T!gWPU^5#rF6L_jgA)!6o}l^Gl|(XXJ5?4%{!mdSA8to>!Fnz=M3P`H2U~ zwR*7Ub@X|Xn>W|wA>JtubGOm@crk0gKHNL?n8Dw^vdkQC{IJef?R?to`_CzqSd^$N3)Oopwd8*8J0w_tCe!`rwzy)AY$# z4xv4MpPlb`#3x{;Sl7<4A=h*CMGqNlYwMVQQF68A`H4QW!5xlI8sjNwRSWQ&vM5t+i?@}yk+YY z$-W$T9%hQ4;9*mAYb(LBL<%hoT*>z1w4Bv&7Gt~|y^?;5SgdL{C= zh&wuFU8~mqAJNf%IB}S-Gu7JJ?>x`76UWYFC0A?bG2%4lr;gVA3~?SiX5GJb%9x-0 zlfjz*Y|Pb%{@C-U!k>Wmz}nl0>$nG6*J`f&`2{*U-}*Y!ta~uO34J|Q8|Pf~{K2+o z&DA=`tn>SrA0&OX?%@%mwXfG9Jlk_MbG5FG$kjUMc;wniW5;YA%k@}!TzjhY)i&R} zxn0mH=$N%rk(-w?Q?186Pu#|i=4RcS+BzK_vv$-@vu6U7Z3wRSAGe#ct19!qChuKn=5AwO%h&C%TE#L?PU>m2P{ zu6s+!)wb5GYcq1S&iO5J?G$v(mRrAKt=jf%*8Q}xb0PV6t<<(3v(D^TtJeA2w_N9h zlYPG0I+klEqNCQ%m1U0Qo9i=nXx&3XKcl0zIhJp(13G2wBsrFP=Q?az=V+&5ZNpl% ztu^aD`~M-Z!bz+%H~%&T@+`K$(ne3Rcl6P)1!SGd6)4yR!zoZ$jjxQ+hH zq4Kk{SpSCN$QusUbJT0q(GPF-W5v;W4b9q5=;RCV<~BuM;Rbg&yamUF6P)1!SGd6) z4sXSLIKde%aE06GU+XnQ-jSR2T7|a_$JM@B^El?4zd?9A?vrqW^Oo)YS&%oe-9I}V z-r;$K3tZvwPW0jMF63~3x98sR>DVEuPK!~Yw+`MVgnjMjb=?_66reAx2{Cpg0eu5g1p96o~iaDp>j z#P(WWx2)GwADaz%_$cO!wR7YxJAO00<;RI*6z!mOdJFfY6hs)#T zW1gEe&ttCpF~9f-&vpL=Yum?%Iodbt?Os3WxmokL8gg~|x4}QTtvuevJNE%Ne9H3( zCpg0eu5g1p98Sl4IKde%aE1G)eNOlfcY-rq;0iam!{IZ-wOZazZi~_S9-zVv?w|EN zgwMGnoZt)>xWWzYaQM8>&tGsCvEKJ|&kYV=^iG5moZ$|KFJUd5;0zbIifupP%a{Wv zIKu_5aDzJ>{>zWm;P4e37fx`7i`e$ukaswI)n_KLJ>Jcm$Mu-g`dDsbzIptP*2lZ$ z+Ub}Xzdp?0JeEi6+VG7br?peQ>HT`fV12yDZ(+}Hh6`Nb26s4|=`$mo;0zbI!VT_l z_%`N??X@7mdCPiR=>G*-kXN|D9S+~|`4LWVhKqRTSja2f;0}lH;#hEkv)JaV?c57o z;Rbg&e9zZLIMIDL*5&cb{+!C7ptYXz=w z6YIHb-aCEY`%!G?o8ThWzCQn(KX9a62juDOp`*E3`}qexv%nQ@aEHSWhnf1`FTzD^ z=UCzJBhOD0+jkPed7ei&!5J=a`mwLgaDgk_;0}kM_?!qAxWWzYa5x`x;PTVqTIqY^ z@Uy}CelNo5=bqOK@YxTO+Z1{Fh4;_?rC-k@e&w!Wy>IARvmW;}bk2s4{K22s=!D3sRkY~8S6>jk9Vw=;Ehri;uaDp>j z;1k3)vm$SBhvi>}-+6pR_+YWkNysx?;0iam!(oDB!3oZAfh*kL4u?H3A5L(F3tZvT z#CGltd56QEI2N4X3>Ub<4eoH*h52xTGhE;bH@L%LH|E0$&TxS%+~5v}y)Yk6aE1$9 z;Rbg&?2Y+wf-_v;3OBgJVIRzg6P)1!SGd6)4*Oz0oZt)>xWWzYaM%y?;RI*6z!h$A zhr|Au4<|Uo1+H*|I~*>A`EY_We6-jevjusD8+%%aDp>@wAl7skXN|D9S#@8vET$}xWE-|aEHUiFdt5Eh6`Nb26s4I z9P{A>XSl!>Zg7X=C47E@GhE;bH@L&$0G}D*1ZTLw6>e}k&}U}2z!h$A_*-8aFSYOH zy}Eu5)5SaQ!!PZQVtqfaoqQR06^D8{FY=1@A{V zN1vak?jpARR5)DG^9U#L&UJvxLEf)$gF74!_I`wucxOIb;0l*3dB4K(%AO~myF>mJOTIoBKJXg`eB{g~O&{Y3Q5+DX^<{iGZEHP3K? zE8O4?*BcKrH`i^no{Qz1Yc=M&hc;UGZ{A$PG2dK6^gD91&WSg{xxnG3L%z8tqjf)) zZ?55(>z*U}X5E`v`)1u|Lf@>Newgp4B)_&5Zg7Xg%=-~8VtuSlUN4_7!Sz;tj^@oZ zA9LN0<$8_{xp{N_$9!}BF|(s@-rROa_;K54J+4`gYu?<4$BrJWW372}-Nsz^5N_@B z&Du$0u8*Tk-)87<@;mt2JX-f=);VU~TNyjLH?!`+tmkXiwH5QtnwL8c$KA{vy;(b2 z_h6mPoH5s9)zP{KGdr7WK6W&3qcsnA@^g=HJ<{`Xm%$Hxo%}BHD8G;8yAAp2a=$8f zclZ0a!#}y>1NYth?aAqHklzQ1cm7sIY|pVxtoK#@9ZE;8wmcmDzin%yKC{E&IM1Wlj-|Hmy(F<6H^T*PaEJ3_hnbsy{}Zloe%yYW?|s!H z<=+;5ydO8iMQnRh+ur&U-Qh{@D7L=Z`c`YFTOXTDV)r=wpZ z|F>in+p!wlw`_YW$79ZDofDq!b0VC?wpMM&s?Qj5eV-YM=MheD7TX-P%_(BLtt*@t z-Y;V7SGd6)ef3WNgkg?ew{W7*jAH8~IKu^fwe{n3d}e&^V13+W@y@xx?Ri7zDQ}nO z%;)>saEd#R){c4e-J~(6wG&=|{lE#%Ti&_;rw;eYo4rH!^P*u7`ka|xJb3eOxQXpt z!b{u{PH=_`T;T@Smk!6$=b0|H*Acb;ZR2m>DSLalce2>7e}OC9;4ZfFRomM33eUqU z{kUp9Zjpa$u!(i8Ui0`Wcew!TZPAgNHBYY|*6MvPkKX+LS8V&KaDzJ>UV}Z0ZEbt) zkRS4H+4Ji>?{Ij%=TU6eL~V288-1VYO@3QvxWE<8r+L4?6>e~N+i)zskD2v%=>6?J zC%$9oXrA7^-_C1g7TbNYz!h$Ahr@e(ZG0d6es_Yy2R)B)gF9S43hQZIqx*Me06vX zp7>#TjT75*LOf?!yZQbqTz=+rD%{}w8-M+6zjf!|`FyoL_Fwcdd0zdK=W5Nb_i=gr zj^6hZgKcjm?7wqcS2*q3e`o&%ZhLvZ!)+hraM;)L2q!qh1+H*|I~?}Id^lVPIh^1u z*4tG79>J{7nFYC7^E&3Vu5HN8ns?-8&BKNLxaQ4s^_bJzPw1PqlaZS>FPLN2ITg8C z^M>54c}H&6JX~bhzaGo1d6wLslM7toHm=>gKSv%f>NCwcvr29=8{FY=G4H5%UL(Zz zJeJVOaDl7X)~fBe<>KxNH@I)v=A;9LnZJ;qFEU)C!&4U&b9S>#lI4FF%~4exIj}*6%5mD|l|+eE&ZVxjKpMyfR$i3OBgJ zVd`@toZt)>xWWzYaJVAo!wGI;y}k6YW8OU0koVD>$J#;O52H1Y$jzE3zstXS^F7%v-S&ev*!6q!*MrjM{oLKdt6tz z!F|j2_zG9{+qa7~*ZZeg@7w9B-pO!*E8O66wf%SAE2gXaoCz8{FY=1I&jLoDUtYmA+q%H}-3r z;0%{7+x4%K+x2X4hr><0Q*Y|WYH)|cVSf9n?fw(RcB}+vxWE-|aHntPGsDf@5l(Oy z>$&US_m!FVE8O4?hr_)e;RI*6z!h$Ahr_KfA5L(F3tZs_cQ_n@`EY_WT;K{fxWnPr zm=7m7!v(HzgFBpWJKT2qoM7HOKTB@+t8hDagcF?M0#~?;^?stSDdx@V+U#OayXbZg7XgBQgINcY@2Yo>#a(%JcAOcZ3sM9^;(~_s4l29`BBDc;axK_4|HF zY}Y5l1+H*|JKUZ+%+%)`^X6x+r(r%^;0iam!{KZg7V~!F)Ku87^=>VYux!ubX1KKXf>p=y`+_oZ$jjxWOF`&>> ziS;>9?^kBsXF;dJ4eoGw4(7uNZg7XgbFmiga5%|3nSP$<1@2-!FFludvUd`k;SPuA zd%w}Ac;4w#Jr6H(M>xS5E^vCWug!3QE8Jf)oTL8TcX+8g!U@h|`|e7CtJv<74S9#d z%Y1Ew6P)1!SGbAwcF~{B)wZ7whnIUEx2$WAeT)2lR&ureE>dlCGF;#aH@L&$6+S1z z3C?hVt9a)c!W|B;^iG5moZ$jjxWOF`uflvd!C7qAs*3G;sx5C@woXSLUhVw|Cpg0e zuHv0*g}lSzHJA@4IKu_5aDzJ>UW@r~f-_v;3OBgJ;dPh~Cpg0eu5g1p9A1z4aDp>j z;0iaf-M(tO4|F)Z!Se_wIKu_5aDzJ>D(1rpE^vh#+~KgqOgOzYj+^ ziR~I@xWE-|aEHU2d`^TDoZ$jjxWOF`r(r&v;0zbI!VT_lcr)h1No@Bw_0F||3tZs_ zcR0Mo=R`Qc87^=W+jCKe!&^O%aDubg_Fv!%H@L&$ZN4_b3C?hVE8O4?hqq%soZt)> zxWXL{@4!sBz6;mtJ?;c&xWMtf!~J3Nnb_#f&!osR^6}Rxj-T>8!3C~xhr{Vu3um~(4Nm{=Yb)H~PJh<>;dAZ;XSl)*PM`O+ z8Ln`H!xy|C;S3kJ!5xlY^f?LcU-CSB*`44FSGd6)4*!KYaE2?~;0}kcU=Ez&3O6`@ z6>H%FSGdFBYrZzZ2`+GjI~=}_IdFmtT;UFf|Hd3R!3C~xhr>582TpK-E8OAmP0WE4 zT;K|KIGlkwaDoe5;SPsyVGf+&0#~@h;Y`ed6I|d5cQ||-bKnFQxWXL{-@zO>!3C~x zhr@R<2TpK-E8OAmJf0&A?CmtE^vh#9Dam3aE1$9&+&eT;0ni!dcVLGZg7Xw#e8js3tZuFaqmYs z!5MCFhr=a&PCmfh;0}jNdMCmKu5g1poDTFk87^>z!{2y6!U@iBgF77l7IWYNSGd9P z(!Msq1+H+1!)1JJgF75A>zxD_xWeV~7ux)7!Y{8b|4ymc{vM%;?Ps6xckmV532tzT z-f3`{dY<3{H#l4oeYn644hNwR7r4RUVD#YvH#l4geYn644p&AWE^vdxRnUhE+~9Ck z^x*f02j`t&6;0kv*T-VnoIKvI@ zaJ(MY!Ue8yx`FpIT;T?XL%kp20(Usv5Pi7b$ny@z8+)GN3U@f(#QO=(aD^KjZt80z z+~IJTcM_c83O6|33~S*GSGd99=Ds$<87^>xI~;G}a}u240yntB@s^kaSGd6;c|XD# zE^wQ9zr*ox&l6nW3Wr;HKf)OkMKDOE^viA9B%DvGhE;XcR1e0*Cx2Y4Gy>U zeu2a7ki!*jaJaqqBb?y^H#pn@YvBwRINT9^IKu^QaEHs0KBvMR4u9{R1ZTLz;m+v8 z8Ln`H(_MURhAZ6QaFq8WT<+?5g*zPX=A8s*xZT}59gg?#Ji!I7aKESb!@b-I&Txer zobTsr3*6ui$NPIf!5x-Ayxe)e7vT&SxWOH6bDz`U_yErnT;K|q2YSE44Gu?pC&C#n zaEHT#d~Jd=T;T?X2m9IxXSl!(?r?Yr=D-;)aDzJ>9*Q||h6~)_4#$W4oCIgM!VM0O z@U;;xaD_V@9_ecnoZ$v{I39zwaDgivj`ePrw|w!VL~5dOyM$E^vp# zvwdxXGhE>Yhv)d(2xqv!4eoG!uFpwufh*kMaFVYraD_V@p6C4pXSl!>?r=C6bKndY zxWXL{&&M1%!v(Hzhr=nD182Cw9gZ)+TDZU!4ySrQ!Wk}bgF75wPT;K|KIK0x=COE_O z|I>9B&`w+p*zfmvCOMoWNRc9e;%>zyxLa`#?(QDko#GOTyA;>p#frNHcXz-4_xtYq zX0N-}U8g_tWU^!p3A9FTHI%3&#s4bgplQVvQvB;|;d#m4Bqekli} z9F}rK%D%s)eWe_fa!AU7P0{i}DTk#Tk+N@dw7g%+VJSzX?As!hmvT_bAt{R;(egei z2c#U7a#+d{Df@Rtj}wq`NXlU;i`~)kJ}LY6Mz@Eg9F{U4ob%qNjV_ppp?T>j!4;e zDta8hl!IrZ+r#Ale9oIb#T5U^|NUO7I2SGBmvThP!Sm5F!3)tWE=IFo%Aw2A?V&5t z9FcP9YIJ+(S~Q2H9Fel`dbEsR%0VfIq#Tj5xFPK;<$#n!QVvTwa5K7ZP|9H`N2Kh# z6)o?Va!|@4DMzHthr#`Ct@BGcAmy->BU1L=miCo$P|6`GNA5(+i@VY6mvTVLAt{HY z9Jm+VHz?(>lp|91-H(>{OF1m%h?IQ~r1DY@N;xED|HEkcfRsa04og`)ikA0DIVk0j zlp|6WkE8qgr5uoQSjrJ8`<_VqN;xRykd%E-rSeh^N;xFuh?K=MXt+lyX?g z5h(}k=y8Hl4of*AWuG%z-Y;dJOWH2wpp-*Wj!0R=Nc&1TB;~M_BU1LqiS8Sca#+d{ zImbrJ3wJd8r5uoQNXlU;`#sTpLsAY)IU;4@jg}8cIVk0jl*3Z?#f|RkmvTVLzIaj@ zDF>w-l5#}KB7SsVksz9VQVvKtDCMw}BT^3i5$|7NOyHCmiDF>w-ma;EVbYH)e z15yr3IU;3|IJ&P-%6=(_q#TxVM9Lyb^f&=22c;a6a#+d{Df@nn9>*``pp-*W4of*A zWnWV1I8qKuIV9zyIk+Mh;E#s4NP|6`Ghou~m zvhYQZO4~zHUM!UfOWPw- z*3(MwMgHG=NjWIxVN&^!v^^~4h?ITlq+?1sDCLlp{TZU=LsAY)IU?o78Kd<-C}llU zbbFZm-}8z{*_S!GJvI5ipOfjAwg;sgl5*-S(eekStY?jGPc7vL`M-7WXN%^NJhUNZFqwT0S7<&c!aQjSR3 zUog6FK*~WWhYLl^_zFj}U&;X~2c;a5vM3VW*C*wWltodgjFkOS4oEpH<%pE|F!%qB zXP=aVQVvNuEahOa=)Msti{jDkJ}HaR(d_{#hou~mvM3WR?~}4$%0VfIq#Tj5C>uRa zSjwVYbbCB4yD(y4@$`h?M;U zqGbY74oW#BWic>X-X~?hln;{sd;Qf1MRW6DG>6Fly>{P|wu`~h?LH~{r5uoQSjrJ8 ziy_hD=;Z&_$0uzsDQyo*+lNWpL(=xJlmkPf#}7+6B4sfwTE-{kpp-*W4of*AW&iN# zaRO2fN;xEDF(O*tCuP5s15y?vrSektOF1Cru#_WG7Nex&NI59wkd(tx_Kl0~8t+lyX?g5h;fzMvo&VMYB)Jekq5fEGA3krR=|t`W_{ z&c}+W_5SZ?uq>9celfZ|wUiZM@zm*k=jsFhn6vk<~Tir4{H3F?ok=!9uFio<9x??TQ;~Jhpt)PovPy(Yd6|-;&Z;_>vF0SJvL}gw4iYzFC z4w#OW*pC}{j34k+(M1xZ#qTJFI_QDH_zQ=SsH!fipa;fd6As`SUcyn0e#KGT#TPjK zpuaE(N1#>bz2HMt)IxVm$7*cAHXOn^+=Qx0lig{Rso!EzKxDC5D?SfxW6s1rH%`qR#u@--07xv>HoX2PUMB+O1 zEz%$d3ZN7!q8&Ek9IoRbp5qgKAWmJ*1)VSoXK@X0@B{hlac&4;H16OXhOo4Csn2}J z1-wRzhO8eL(1`QKRIEi9XYduGG4({^0PTk|2q1{Dn1Y!Ip?nki8&jInr%2L_K0+Zh z$7sBO*_>mcGHRd$CSop5;|3m}Nek-VlCjc?F^ejQz}uR#IElJ#=y&97%W>drr;CC( ziZ2-1o<2Z>4xA&BbmSax7Fs9X7rRitGvf`eE{t^?$9X)4t1HiO2A6RMPw^VQZnR?$ z<`WY4B%=|s_tM1-?1#5E^BotErw`|iwonIgj#wDf#dny4brBaiP!P2-0t;~l5AhB^ zpbgPQa%4dvltpFK!!~3es*9TFfbLjW?qRu>sj9JSCF6R{2laSqS$3BGZ( z6TFk@H~fS6Q`jH55I}!S!A68}0eA5n-{71|c@#k<^u$u^#lLunl+$#P4YSaDI`b64 z8M+vQO$Z~)Ox_cf(H$dZ@xGXcRoH{fv*`;oMEp6lDZF#(CoIDSJjYvn#!qCQM_ZsQ zDx(JKA%K=>kHJ_rUl%9v5@{DO-jNR(L%PVli208Ji@7hra@@gp#9P9+L@E?SL)2T! zHG3Iz5+m^^9wK%*>mzEQIW{2g3f5nohrWt7!=%-$%ZRsz>m}ynJRTtXT8@G7*oHkg zfphqXqU*R{!bCj6Tl~77YcL9W+ymeRmhYhr@ylLaWJP5R3$uox^FCcnz+7y? z71Y_!`(YA(J-~UP0eWFL)*WO#<37Y8>WN(V1IZ6F*RT$oQS=DqQ0yQ28$&Q13vm{$ zk8&>9flGLg=Et~yLe}GqDU3P6dI;kr;{ylq1Ny(T2gYJ0j^Zq?K|95~f*)J44^>aI zR$(p*6+6WmAEbG(Kw=Q(E#!E9WCb%EpJcT`7L48;@_y~sAyMQ`lDLl~DB zqo{yZIF0XEaGA9O`L1veinLeh4@`x)MqTjYI>)}jn7+w+fd|Nbi}$_Fx_(C&!Mn^? zOvFsg$6{>6el)$uy)}koE_UN7O5UfBaR`_3%LB$8uH!E3hpb^(jB9v}53g7s-cTM# z-%=NpddJ%Ho_0k~OvgJoJ}`Dr0t2uO7x5F0kF3*3h)(zb^%K`3#6x1FMoaXC|1)C? zK_vac7{?f7`%2$n4z}PZKEV9Oy)X))0lHx({=#PL!b=SQ&h-@wu?E@?`T$wsM-}wM zGMvOMd`7&VJR+_zL}H{zb`(J^G(dB-K^OGEV2r?IEXIBuMHR&mGqD^O@fsf05NVJJ zOR)t9aTc!-SL67)A$A~xVTe(9faInja-bAWp^9aQI%tWW*oa>phG>j#=!;=khwa#l z6S#w?uxvwQ#5gR&XT&-UkrE}*12eD)uhGQC{ zG58jeA*Lb>CDstB&=7qv1N)%6IcF3{D|E(UoWVPs_i(;m%EdKAecXoK?{FvJ|7(ZL$c+Lhi3+HL#%PDm=#Pb1hL5m+ zVSgk*L9{_<48U#tge##T(jqg8qY~<)1%_ZZKA~|ULyX5=d_<4Lh8T;jIF0N0f%r-2 zJNPj)xgl=h3p^=!9~8nLXbn3x$H4@QOmB!ocnB>6eS}|;6>TvX8?g=d@Et}*+5zqH zCn9K^iFzYJX2umBz{tY!&=X_u1a-4g7W0uI8+F1n6v$2=AxjR%AM)m8J0|2Z#4%LM z&H2OkJM}^3Jcj56Z(jDr0X)OxeAGQZeUAt_7chhs#eT6<)23Kv)8D-H79Wek?upQ5kxvn9)Vg^>@0E*NzL=CjT5Y(*C z7{VY}4QNl~L_SnRPYl2sT*P(UN9l&Vj&|tWi1))Acp7sIq(c_uLLschUL3+{+{9}n z2~Y?0#B3bLRs2N!CbSirp$&RqEDqr{z9Vf@Lli?z^uiuo!dtkTF$a(mxlsVk(F;M0 zz*Nk|B0NRP=FC4dMSqOJI-ExQ7K{^g!2pcJN*uriG;e8$d02+SsL+aIAf`2A9s6+% zS{vp)ZlQl$#%eo56vb^cX;1&*DDEJ62j&5)qBG)mr2o(fC-D`YPP74nn2!}Wj2n1> zHyG5}5YuoJuMoEj=Zfqoi?-;Dp6HKZn2JS6*p zDD8o?D2w*!fsyDwjO!7CSb!DSj$3$*gu`hsR74}R#{kU0q7kgoID~V!hKG0#=SV{& zLNe6F+5bEr#eP_f{U|q@xquK3;3#h52@Z~7?&1Z$A?H}uKvY5i{cs1L5Pux?N8Sna z^+ehTsV4Cpew0LcR6}hvLMx2IWDK6deo&_xA|49i1RmlOejvj%>WFK&jZc{Hry=HG z6Aq*GblMYBu@HN31NZR(-)FFf%rr!5WJE3u!vsvjew@QC+{aVA#z$nF#rQ`altL{u z#~kcL^4ZK`G(%VP!!Z1bMc9p$b7%{cM;)|BR}8~!gs=@qa0{_>4UrUSkQuem6=Sgs zo3Rsza2#iF3D58bpAcsr>k!@|FrW6pDjdc&s0+B>AstGh2l`_uMq?uW#2hTdGOWSh zID&ui1gS%`KL%quw1uo2D22x8je!`CjW~&O(Eg(BkOc)%9xX8%voRlkVJUXuIIiP9 zz97LO)@@Wl7>O1$S1<{yaS{2JFrU#A!!Z_X=sDqyZ)eP4#17Vkovh8fI3H|=XE*B#>f#`7;vSwL z@gCX_J#ZY?aTmk)vL53A%7v*PCSnol?BlwO{rF=){e%-pe}H;mFh=4koCjG4aR}~1 z?1P7RkC?-}KPKTguHZdd9ARDkhvT6Y`ePDSVK3qzr9IF9y)X=8u>@NXLGEL$^;n4$ z$Z?!&8pdN8E+ggy>oN}ED^i?fT|!?>!6CduoPT*wRKQrw!%A$&alC}*6ze1^pbJJ~ zD~{qUF5@nqK|O7V-%toOF$4#39e3~uF=x0QAUP^y972d7^I6UhMNkW~VVvXs2QBdy zPtUWyTwvTHFWO=d{=^m>$5;G%k#UKVXo8WKxTm|!JqlLgERtN|+KpNmjAB>$`@=Pk zeVzA2><#)DP0$?+a2YR<H=1Gq!nlq*c#gQQS&vX33-J!E-!gXIF%BT!b03IA$c67%{(*ZLr2WV`hMgGs ziR=Am+6Y~-2l^NK26fRF*I|8S%ppFKASH66FzTQc{=qHW$9sH(^^N1>chpB)%)@Hz z#4((M{hhgtN~no07>A|!h+lqiPCt2$%i!!pa->EnR7P(M#3<~;BfLNn#S|MLR8u5| z4~5VJ=kO6O%@i%r9~Y5YH$`q##T%3~Oi>LDFaTi))8s!>bi`boz**eK7u2*&u@fip z7>dIbu}FoiD1sVji>)|`EBJy$Hg!O8R74$g#{_J}Zs<-^q(xbbMHqKsy4WANF$GI; z1NZO*u`wJQ8BrQlFa|qt7ccM*iQ;g4lt(wL#X%gyX+-b_U!cXBB0kc=kHxr%XV~TD zm{2^XD2Hwsk44yyy*P?@aC%J<59yEvwa@?~(JwCVk7GEEpD^OlcPNCa=!otZfSFi| zOLz!Jd{d-ARy0I!jKTzL!6P^mn4%uqVGQ0t`^6N$A_t0~5rSBS4cLogxQ8eB0wtj- zEO?O=g;55z&;Y}+18EX5b`zUoFh*hy7UClA<1LINrtlykDxf(=Vmj`k*sqKoyudeP zPs*4;OZ3E&WTv^`+h>X- zNQ*oug$ihkd02}*h@a9F>5(5b&kqGG#Kx>S{dYp%r#uN#V6}eFkRZtV-@BnY1rR6*^0?Tm;ukZmA)0tugzGG~9 z#uv^YQwENK<=BqB_y^~38()w#BYll2ScX&BmdO7W{)-sF#EG!$CYj#+=L@1kfHsF&V3H0Z(D% zV*DdB{AhrFIEh5L*$@3N3|sLAaeg<&?>L5+c#p5hna30zFbjKd7G_>kxRDu^&;~s) z5L0jtw~-(pYY|#t9Jb;g+<`AYeTqUTjt1z6Q^;9>@rW^4g3UOB&+rvwKa@aSOvPI4 zLV`l3D2SHmf;HHS3wVN8_<;n4nIkBJ23U%{IE3T4h8jgU4kq9)EXNl7R+QIJ4^1!v z7ZAZq7=Dh8;W&vm(2AL&GqM+_-|-bGOVBqcgX(C3E*Of5IEK4;g`fDNB$bj z0wQ<{M=4YE!W0xN&78-4e8P7WD?=Y)ASPi2j^Gl$;n%YCCw@m?Y{5xfg;kEV8bK_? z%JQbzkJGq~)El?08Q4axh#b8XpDttl4%B2f% z0IbCs+=pJ>6v>bd*^wW`Q5IFv6n!xcGcg|<@f=zWQ)EC1w80Q0uSGkcEkhRM z7W?oNKcKf`UB)jchVu9hXM651kPAi71f#GTJ8=e|k-7utiE{V@%`h5EaRoo%?8v

4?+{R1%z_@Po1yXfqOyUS$;Tz)i;97?IXpgQKgUvXIv$%|JaP_3`P!HWO6+3Yn zkMJ5F@D*Aw${~RM7>4=SfFrnr4={Su9w>~8sD-9zg?<>0$ykjKXx4{wM~=SC2Q)xS z^u<(c$6*xi$J&5DPzR0B0`1TTL$Mz3q4j4RAPF)cC%Rx6!uWv61GuNdYHY=Ee1vbH zDT<;u24goa;}PsZ+`}M0I$|51-~+56V-iW=Lk1K?E3CtPe1I5CA7Lyu;~~-y;oQ*) zeK86P;2%nxBY>9ZiP^Xc&oIV6QXmV)U=G${4<6w))ZzR+3CZvqGNC*MV-8kg9rmHn z2(FKqfVo(YgE)x`xQXXTHj-;S8e#|z;UQk*3v!O)o(qs(#ztiFruHh}(&SVT=1q#oipYRItXVWLxh2Q4TH)w?k zn2psqjY@M_)A0@&=FxU2HJ`D7ybE|8Utol|k3}}*Lvggg0Gz>1d_wVsyay8e#Wf#S z5O)#njCJ@2j>TO6kQ}AZ0X>$mMl7WqR$@I4;SGGtxKBb6G(mqX#$$YhSk4&1VyG)9 zj|2D@x8PjKy%F-DII5y9nxZv2p(lo5EM{XBcHuPc;T5v3;#^iUE-(&%!dSz4i7FV5 znK+2kc!=a{na3E8nfMFKu?hQe63>x!9mhd&)WQM$i}QGjc$Ye3wv=H?!TE!NQ>+!h6*UR zi8eq-tU?5K#In1Iu`g%?nFFiwyidC(TUFa@))0$XtaCvYA5PRb(>HsKDOyI50J2G=y;#B`>o+pc4k7!WFKQ=#LH1uX26FLR`jM z1pw+@O9KjHy_P)!2g*h`Gu7fR7Njn1}ck=`cG& zpW!5~p!99p0H^Qp96!+XE`5eR_!FCO7WeQ8);;Qo-%tZ>(Feov={{}wfVRM6d_~oV z+()4u)*{&>`U#63b3glpHRmbq^Ni~Ts-wem#wnH{l%BmX<@g_*p5o^x=F?}!ENPEHMv@uoHz9OSHoZ?7(4UR4tJkoi$5j*DX;T z_3;+@3`_LHdOR>KVOf@lgT!cxpu-YVP|3E$G@Ni+BH*&bY~+oxL_dtfYTU=bIF{HH z%lo(~i>e+=^uh-0L3XbtDxxMjz!BFHWl#qPa0ZX?0^bogo+TDyB{pFPevNO578rmK z{>Bm9#2YvhSRxa0qcF;$Cx&AI4#5A5C8}cw;v}?03N%DF497H_MEpd&51!#G^u(5k zMG_Q4O&r2!BdO04Sx^isa1i%UDJAEPx@e3R=!_?LjgR;aE0rY@ zA~W)%6t-hO{>2UWeq$`5Eb5^dE}>XzOH{xpY{9>{j{A6uOld4p9(B znRpM}Mw`r*7>w*$mRJHohtr+5ozZrTU4uohulz(c%4?%yrZ97C}N|Kd6x;5`=P;km$K|T~k71TsSbi`nUZ~(VaxFG8gdSL<1 z;t^iq6DAa5?BgsxAZ20ZK1vj^gyFaNd0$J^Mh84A&ap~TXWYRLBrnAngS#|q1-?L( zu|z5i#|HSza;$Rn8xkQU(jg1-peV|sF&1Ja{>BbO@C>dB)B_zc7I*LnFQ8PkL_t(V zb96>e498NuMfysX$ciaQS()}lcTB+&Y{vn7Lx(Ds7=+PSg^X2sZw$j5WU0n@z){5h z!8k%&48Rh+g{L}m7DW)kK3u?UJVdn`Tqp3lCiSmHU23y-<9Qv{;<}Vat$LPdk0D4F zpf0$JrA=6OnsSV0tZNvEDOip@IFHM1SclQHEpxRUpK;H4TmXQ6~&Rh5pPrd`HRwvY@|g4rF}`vJKe=v!)KQL>d&t@L`siG=lnL3lffE%wYd$#w{Kp>sU+tF^;tjamMo; z<R#w>DU$xO~?7RSOYq?yf{ ziOE=sjWFggCXf(5WJg`JLoa;BPdMf>u8<$q(Gnfe1An5|e9jx|uoKl5u(o3?;)ggk z;x44_n2JT{`xo~Bi|7-~$4Oj6{Kc&G$c19~0(5^u<;j!A-nDj*Z;+!2dU|V=zWy8kXQZUf~0bO`HSjp+9C|AI{-Atj%0o z<13;Kk0D$`hAph?Sd4%19OhQq3zbj@126__un(tk6+htH#(cmHJcYHL`x|6JeiTJn z)I&>jLLUsp82pJXI0j<};~JT;41eP|9wFXN)(K3;LTtcA+{YVyLh4<#H@e|AUL(P7 zuEPl72p*!*9@-m0Ou=HT#U32PY23g|D0?mb{>mIhHT1_6Y{CiLz#|+C)Atbjmwpd|{REkP#fWdE=Z zqBX|g5T+hwo*rXvV=DIH3?9QcZV4~4p&C|T@(Er;wv(1;t zdQ?OU3_=7iQ0xZJF%2hh6_4;4lWtmK8_wY|Qr_m;iZPgtfp?fUcNrH*c8~YC&s;|V zlzG5h$7hs&$T&rpM~vae%oRLCp(pe=dZ0f>VG17OGcG=*930Q+PsBXuTu>WTUNEQe z2}xfvZ%`CX&A?#qAL1gBxYb9HsdKiA^vObr%@79umqd26G!kG)*H?d zO|cy3@fOS8G6vqU?LFfSVI0P3B>zDBqdMxMDY|0)NA6E>A79bn3)kastlOA_)5!Fl z?dXry*pJJIs1A`tbBNzj0Zq^g%diiZ(AeP+V_Xg~FUG;|E;>X6B924kKwgwaRrJ6@ ztc`Vu3y9}-h{VW-(x`&5ScwfdfIIlp;}E614$%^|;yOeF%)n+m#AmqUQBRaYeRTfC z!Ou21#N&hx@e=Rx6?!7x6Dg1enNSXmFcE)YD|X`m&f+p|;yym$I}#;!h@43rq9=x9 zB4%J7R%0WM;uJ368gAnup5raP!SO3~K_=uz0aQQ@v_nq>F&fh_3n47SE*!@*yn&sR zc0gKGKwWgk0lY@aWDZdtH&7|LLv+LjT)|8HlENX6po1bEIseI2#Wo=zL0M1EQ#z?Oylw(}{GLtGTO#bsW-A_|GC z{Py!TQB+(P#l#I!LfqmfJtLxwxGlf)uSDPD`( z;=QORK8X6_qi7^P@eZFwGx0^V6yNy`>Yt*m5K23tC>?~VbP}4sq_(+ z(qA}~LBgpF7O~1u;Z{Zok1|HYQ^t$<$|R9MnI;k{(?ud>rbw*J7DtGNBOj^6QY*#uc)h>5&`9mXsTQk&6Ufdg>pr-R<4RR$~Dnexh~o(_eBTg zf#|3_6kU}^qMPzm^ibZ2Udm_DTlpgTC|^ZC#ZdYyrZPZ@Q3fh;ltD^-C8#7&1}ncP zLzRTeNF|XnN=dFvQhdr}C8aV|Nu~U$q*i7q>6MvE24$9#Rhg}1Q|2i-l=(_7Wr31M z2`TxN#Y#bCiBecus`!;(uUsGDo?o%vEktvj{c2P0j8o3zfUdU&=jdc%K?RpmqNUlo-cX$CO~s|&R$|n9N*wip z;#MCi9`&)}Ri7wv)n`h4^`(+feXS%?-ztgKcS;iVgYv8TQAw(PQj)2kl@#hX#i#yI zQmQ|d-&93Sqnc`3)l$=`4mG{%R5PeCY9`gAW>FKVS=FR!HZ{4LT}`Ftpj0ki&8=os zf9F|VHK&@7XZd+nK+U5TWJ@8o6j2MSMfobmR|&P8T2if`mR2i~s;K4Fs%mBR5B{vF z)==y6XFau++CZ(XHso1At*ubS#%e3IiP}bOs;VYHhS*T3hWD?{->i zuU*tSXjipPT14xt-P5{g_qDFtLu&AdMgKW9c%}8y-fMj{P4BB2dVkHK571otKrN0w zNb~AJErC8*OQH|alIlaXRQfP2wLU^iqmS0o>0`8v`dBTqK2FP`Pu8;QQ?xw#G%c_G zr&dItt`*g1X~p&VS{Z$TR#p#b74?N$Reh0GS6{Bx(^qNr_0?KKeT~*kU#m6O*J&;E z^;%1PgVsjhsI}Ao);j2$_>ieBS{Hr0)?MGF_0)H3z4frxU*D$<)c0$H^n+SZKco%T z4{O8pBid;FA8o9DRGXk5(*8-w&~Mo_d%ca`U_)%{?eGJzcME2uZY^8NZ0IT#sX})ML$6y4zf>d(8E^*W9MZGq>yU%^i9IbGM$*+^Z)y!+HvHpPtU# zuV*k1=$XuedT#TOp2s|_7dDURCCz{IO6F0$vUyCeW**o7Fi+@p&69e-Jf*iVPwQ>W zbNmq7dA);qLGNT<)VrFO^Ceq4`Zx2b{?mM>o7QXHVZG7a)_Xmn^-)h|ebQ4{ zU-eYhH$9{EL(gpe)U#WPk;5{KJeFnTvm8bNKF*}5AFZ~=XRDpzaC9&dIyxIk99@hQj;@B!(ap%@ z=wak_^fU51`WrG%7eo8{x6paV#-bI+hx19LtOyj^)Nq#|mS& zW2LdjvDOGX)*A;M8;moKzl{ryEyi`ncH^#Nhw;j>%XsYw8*d!@j8BdO#%ISt`k0_A$e0A2(d~DI>-{ZN#z97#{nq5zjtnB(~2RN$d+oGW(+8vo9H` z?8`=K`>K)FzG0-ZZy6cvh>_X8ZDg_U8rkf7Mt1wYk;8sqX* zU_Uhq+Ru!__H(0%{lX|}zcPy3uZ5u{)~IN|H!9g5jLP;$ql*2>sA_*U{;U3qu;ZJp>;z^T`xmpFozQG= zCo((OiOo)S60@tF)a-62H+$GA%wGIDMsGW%*~d<8_O;WP{p@t+06V=o(9U2Eu``-O z?M&tfJBvBe&T5Xevzg=V?B)bJw>jC)Z_c(0nDgvH<|4bWxz;XfuCt4o>+KTe2D_xW z#V&1bv&)#^6f=%2uCAGdLHT8J&yF z%+AGTPUjLck8_P#z`52e?%ZUScWyB&I=7mYoZHMQ&h2J3=MJ-mbEjF0A5*F0+-=r( z?lBuW_nFO{2hHZrLuOm&KW01U3A2Oqq}kDV%IxDjZT54XH3vG+n}eJe%%Jn4InsH> z9OJxhPITTdCp&MN)10@>na*eCEa!7`w)2fS$NAQr?|g4Abbc_GI6s<8onOu6&Tr;g z=XZ01Q&=0FinZ0LTDzT^wa=+rN1TRr)M;A(IxXvh(_vk8+SW~{)4K0;Sx=oY)^leZ z>!mZ+dhK*uADtfSv(wABbmCfuE1qS$;#)DU1XdhZV$0)7V*Td&)k^D1YL##$w@SNw zR#{gXtAZj#TK^m#}=~+#um4V#+I;3#+J0o#+I@w#g?|J#+J2e$5yZ!$5ymj#8$F8 z#8$St##XU<##Xfk#8$I{d~0V&Y;|j7Yz=E%Y)xx?Y;9{oY(r~OY$I!OY-4L$Y*TA` zY%^Y$xkpY-j6!Y!~ZsY**`f zY&YvgY zSZUltt#s~TR%Z8bE312imEAqc%HH`;xW6ec9USzGCfhU$yqSuUTRD4Qs#qrggv_ zv5vSuTNm8lt&48camj5tF1u4YuDXA7Tyv*!MBM2dcidSWciq_?58OE%58XK(kKDN( zPu+PO&)p>)FWn^_uid2`Z{2kr@7)a?AKeWdpWV$IU){|e-`y=7Ki#byil?>PYD6=1A=6?)cTy!;#F>(~-i{ z%aPL4*YTUDpCgT@zayPzk|TrXq9c>%sw0cXX=n4e?HnGDoy+63fA_?-^Lpaj`8^5j zf}UUO!k&b7QBNYfm?yDa!js%C>y4uw}LA$1B zh+W$=%&zMhZrAsWup4?t+KoM9?Ixaab~Dd-yM-O4k|ZsVC_xAV-iJ9rk^ojgnI zE}oTkH_tk|hi9|h%d_3?<2hyb^PI5q{ZEa!HQ!@1LAJ9m4W&b=O&bDziK zJmB#<4|(D`k9guck9ra~k9!h1PkItNPkE9!&v=qM&w0{0FL<&$FM0AfuXyq~uXzeM zZ+HqiZ+QwiZ+nV3?|Oi^coVq%-d|kBy@_2Vy~$jqy*^i2 zZ%S8rZz@+s?{BWk-qfzD-ZZX1ylGuEyy;xEyqR2eyqR6~yjffgyjfk1yxCj@9(a*-h!_7-eRtf-m=QRH$}`YuPb0Rv))26=ezF#vNX5;KG zvw3%Rc6Sy5kqnYVLKqp5 z=JC0n`{O$w{@3q1Rdp(Mb$4}lO~`K%l|s%(G!D5K(IVt>gb+QqVQnxN3yGq0WkcnD z7Ge{2;}D_-Xq%!{p!*tEBVygxH|y9%!2)+kGMSDvAajQj{5V zT2Y>l@gk(AM?$QBOM1!hScvPHBsBu*9+Wl*_SP3-+20WC#*Y`gUz+lLN3;>7JFXv-`iZi2ffrrAo}k*=b_cI( zsWy=H)pe8g)wB-rbm>okX1(T_YxKN}DM6!chB&l6^3Yx~hniY)s|_RDJka&mO0^$0 z-3Hv^k73jPta9XeH4GO8W%<=BdzvVJ2QlqRJqh zFXzz@wnHk#a0>k%r2FzmkS;y0-|#rV9f92^y@*yw2Am%43!j zVkMEB^{OhH-EG=54y0$U?4aMu$rMFEHx;$Oy!N-Eaak;)VR;!UXEHJm%FCIx!b8R3WxBG}Lg)iUvL$0amHA34rs%t37E!9Mv~2{HSM(96x*{$M zmzhiO=6tz)>_r}fx)(U~-};kfu3k@;H0(nQ{%=AOd*=4zHvR9kpUn4)%1wH9*O&SJ zg%W7u63E=Lt5Dfnnz)wI%SaX4wFLYrdVuSXn~Da)c2Ch5&|^jK=dpRQT-7w#<{8(co_1s+4*+Hc**W{m$vl(DqA&dEhI zsizPN8wvcHbZrfjk``Y7r-O^88?-YI7h zM-_EI9(9|@w2jM~dD2qBA|@!CFKDVFIsctj*OTpF)5ofu&Gx9!**G%=Hr32I;gjiR6{d&rwz1 zX(w^s1tbu*W3jZ8Ma=Fm=?Bnm zMZbV_E&0w`&W`$8DyWM^^v8A0tM}6}unkoG+<+H;$k&DaaumiEBeYKSb$Mo^fdeV}+nT)tDV z>7$XoJnU`3xBoJ2U?2RCo}yS#J4J5}9fo+?-z1_g7#Eknl>WN+HRE6)NFV#@N0S~y zJg#`u@krzm#^bb8ZXxClmw7O83iik2bnZv^IA?@R@%cb=m%ycGI`^eT%oro%y(Hq^ zlK%cyq3ws`#htM-9*^uTu<2Qk@7i*VM9s&^c)k^I_o-+kY#S9V1Km)x8gy638-+EB z@iIjy(L7wgBq^J`4?V4pcv+Ux%2sZ)Mf{?uE=c z_O1$*_tV;oTvO0gg;L0)Oxt$n#hj(ed<~(4RNCTWO=u&8u241}r}7HmoU+NgN{<($ z&^0q zE~JQ2#JO?*4no?GRVe4dJ-C@XUk2&^m8*z)M6{k_Y?qM7VC5wb@*Sb5BSO9PzOIq% z1s%GU;%y;Hm}~ki6{N>nCeZA!Wqpf*7AvYl)SE)55Ur)qO!F+_vP!|@fIZiI*UZ#% zl|;{u>kHsMeyYsv=|W>;%DM>mh|^?fyCoK}MbT)Y`Jf%j#_i1Ob-U@9;iISHQe0)s zkp9+y^vc9Oq9>qHDzwvb6MC2^*9sHL<+}l!E?@9UQ+lSntNt0<--~Uf7u#bmw#3!O zpS*w5cXv%-8#z#tc~F*F(n~`M<<{V}7P-#V z^&1)QKtUk}D&ijG672cOBED3iCqTO2Zh|H#+g~6()`E7J9`x4YhY+eu%5BeS+20^s zk&av-OXa`IBE~C<0nJd9N|c>QuB&WSq1=~c5vu!gH)fxi3#Gr{0~XIUVe%nU7N*(n zneqI~Vbl8;iFizwKVm|w6LBc}J9`{$wM6E79kg4KEa}^;r7i18w4b7aAl)wBZ1SwD z&$Zs}C3$_Q#wk-OK2Lk2-%cBU9Lnc&z9-o{`_;RSoZrhbd$Y-F{vj$<-Y+=T%XpId z61{HYw&G_`pZ{h`KNxg#v-C0n^i~AFeTt?$AH_$##e{@RFG46i?{cd$z$pr zGZPkuzXm_clJ>rjI|5vH3GpRpsG@@pOxvFY?N&B#V<`Oyd!gd-2;3d(KdPJO!-x&;QO~xNHOxD zwAFoS+LS}({iQAo`{PjQZ{p$f{^Zqb@KI^IZ?%djMSp`_ibh~G>0`#*iZx$nPj4VZ zuM^UXxBiFg zXCHpfxpAOH)ITfh;fo`ssUo?8)=H6FLDMA1vmOWB=Xv8yeM=J6A!<)Fm}nBw0#I9( z$Er={X(X?+u0*JAq0N-y7^ssN6 ziJpRVNdwXhC4x4qc<+GpSStY1JyQm>Lxt9*P=4;mJ$NOP84-UF@rae{L!~atvOGs< zc}4OHpsJ$a%%&{7Vv_;3S}N2F=CY5* zDCz^-R7GPz-zb^|TB(TBdh;ir@841J%4N5Thl*s4bXvCgR}rGbWtp#B=_sp6#;dHT zS`Jeq?jz2(EPAVpiuYDd6OUK?bC8Yi{kp(5MWx`gfgJaG9m$(bzEh-ISH4rEXMcm?i%&<+4FkMm}r-whbdPd?&B2Li=o_|rEv!S*=(!L~=)te7K?DRRSh zMp0SVE-K0fo9;nxxv`DcV>u65bA5F0tYj7Cu);5}54s^oWz$EGvsgTB`fo>*Z1Mj* zhB)8!$EwdwS%UFZts+R#bWpS+zOIv3jC!WwYjo}-?l(R@9>R-mA)ZgUFQ?IYMxI^t zHMJbs6;-|qs#!hH?qrR^Z^`ndFSDL=N>;au+A36*PkZ6=Nzc<%=zYY~WqAtHXM?~R z7zZkpM~)m34erR?xX;I6?6y+2F14&ez9WW}JR+V2c(ijZ^Vc@{$~6i-CO?2ppLMy_ z_}nAQtmE;_u&Iq{g9&x4Vv#Drzs-ZsZ?kZxsXdQvXpWvEw8A$Bw$tkVSH6F$>EFf+ zYm84o|B&s%PX^>T&~Nl4B2>41Rw8-T9H>&f3tO0?5}+tWRY3`gUg9pRyP}y*O!*w` z+B<2GX^h2-54`@_F6`XU8jPhBzzO&)h;JY2ZJ}B1JD$<_IGIy(u zYcWMtVAEq`UK#Utn|v?)Z58?{LUoN=fb>Z0Ml_s4xy9K_M&!|5d0~HB>Il(S*)Ddo zdfp+GS97{Q?!h)#h2q0=5Aic=2W%r$Xg$ypMY~Y*Rf<}`rl})nqq6y+1Xo{6Q5d~{ zOWFQLsP@Mxy!n%*_kST1h>T zDauhzh&nH29wBHUP29iStK64-celEa>7$Jx-Isen4VAwuM1K*5_BEktpk^vwZcuwg zAAx!*sskFLr~}0t3>v3w-bTbE9MgKdj72<6a*ow+3-j2h*&laa!h-tp*k}b?4P_e& zYN&|E-!AmlcxB_>=Oel20F&EjknVl%RXIEAvBCX21@T@VITOFaEbk*r#iMgRY`XM3 zPUBFPcolCMLUk>FB;r2zHX;sF9z8KTCMz%AT9W&6*d(mU_{maj!3wEz&y_ zomGm%tIaXky1pqD+q@B?y1A1Rk0M0Y|$|D5x&`@PNgHSyy z%Qad}a@9q*3wvSDoE!UNFPt0u<9O_uQ+V^t<>L}?e|)nMvr3|@o45AkH}Q+s71(D< z##@V){8-U?v`Ym=yc)%;R=f%p^0VpHPj*_x{uJqD6=tNGsggd}V?xV=io2!lQ&1U2 z%_x-TupVUlif9heDxy#JVH~7Me{yxYuOj(;|4T)+5vu3seFsblUhXw?9=5I-W!guu z^;UEnHl5-brFj3K>GL6nOlYseR_rM()AIH6Z(D>Ir)=^qE?oluBUTS_yk@Z7Rq>uT z$D5t+s1ls8iad&ZPns05pkm6F3M!@O9Z(fT=Rtby|Ibra(I%VpvSI+nWDZG1f3u1U ziYkDvDQZB}5v0exEc0y@D%XaG4(=+g%l}Z)YK@ z6_IHRqD|*3dh_V?HYRywb1ivvK58gDW1Q1&xntUtb6bKLY1sR+EGH29m7=R4-A9jz zeD0bywG;6Xka*7=TUm)XkHTczcHi7}93VOi(mj0@q{k_*UEd=cKf~awIqqq`*Wmez zM=bY(T!n3nCkwbnq+?ayTeVa+pNFOdcF&^E|deusc}i!pZdE8wlJXNB9tV8qS~<$}hqs!u7haRDj}*GaBXh`JJS zZnEaxRoe7x$a+oMn?Fv=Bb#miwp5%VOM)qBE+X!8UagSFdCjJ>T_iP8#9p{p<&(2# zDl{_1^gfR!`TWu!PpdJ{CHi>oSLHYTIz^((l!f1t|2E0T^TaL_`Rfat9#?X=08P8d zR*2$N0_k3mdkN@xO(~S0$?-AhyAJniEl@m>nC9bIx8+*$db@o4SbOHPZce1wpz8J> zXon)cOZ^x&U4mQaZ%y|$nNroF&?ZE@YQ-z`Z9m7mmdbN)#M7fB4fD%UW$RQGqgD~G z{ZAx+{3X(s3#J5%D3rfC+DbP5{^$_d_$#KXWaICdxUF~$@yzhfTRvhqzLLSY0yI&P z91*h>$>-Qh6tNdM|LHZx!kK*VO_xktiKr<^w`5~X?IFLfO z#zgAhB-rM)kgb-J3HKHHDySc&kR$usmNK3kC2JK`$mZj*RVR|Y|C0)peXfa*0Qu(p zAr;yPDYTbnlva&S6)H#UO+|8?K2y{V@q$~)5^!%xdc6lf%#Jg$iYKY5B5v{3U9fhe zY;QhC@!ZKr@|%y8e|rQRK&kX|7dh7S(}(n9a`NZ0mRx2YIXp^uY;Z{j;@ID#(hkaL zdRjge)aO;6U)b~8Na4An$nE3V?_oO8VvxSJSO?PA4BJ4XTFdgy$Yb*0=RMwLxJ8Jk z=eqAf8&uleAbmzW1^QXpxKw;r+k+>M`Ws4q&Mu!pMz@hA=%3fj!19dqfwJ+ng|z7} zzSzcJ6mV|bx{q+i(R*G*It}g2Z)$#o=qlprGrJA(G_gOvhFgF;(vNV2zuK34{^e^1 z*_ZlwV=sKiat^uez{;NxEerX0R$RHv9~LvSKq-(uy8o@s??WFk3}5wOe;Ohe(VM++ zC{xnMm`l1!e|bPl6;%M~FPcY|HszZM(odi(mGKdmyU7#{Kz9{+v;B(Ds@-M0TV-*t zq3AJ4*Eg!1A#Z6{R`3y>ddRe!Ks^+(7fJicc8y5e-u%s8`KmsiZ~Hz4?d>V^Xbn20 zs0ZkZqUm^Id{YtMWd-7Sy#7LPIO6Gg3`e|sD&9)i9xK`d3hX64-vsGa`?D0@VNte^ ztND1|>g402CT#l3gTFUu1Dk%9An)Y#bAy)Ev4eeY>6z2AKW|<-AcZdJ%ujtpmA*3V zM%=fYP64P{`SmwA`Mu2!O-))Rp3V3OE%=!!eO00+MBYNPG&3pkfb@M?36OrKUXem; zQD`d)#y!=CtpAfpM?m z@vZ_*x?`nS+1PV&#Cv_F{scB%(k3ANr6|wdT>35)uQ;AX5a zf%=X^p+p~|u|#t~y498uaV>d1^%hTlKX_rP>aD(}{kRvn?fHvCezMGcc@=5(IJil4 z2c+B7($9F#eAA4BnL~X@fM9Tv;(BSHoi=@=b!=8Wj*AXP9J4FcIDmOFcq4s zkJ%+HY_u7jX`pQ>vR8|Mbg7C4ny-lY%NHj3Ja5JfnVWncSf3>ej`i_;gTSG0rf57l zEILzqk=H}I%pJ!0h!VK@z`97mN1O@6JqGY36pGo92^k6-d`y&H{Q4;}$Br+Jth=>vqMptjd>r zf!~tnZ}1x@BqE1|QE`DyQJ@{e`l{`CX!6a0WIW%^KBAnWFi;Ie@gTjv zac7HZXRZggIG3L5#`W-KJNPq31n%|ld<$y;`pp{l%qhI(!JaGa^byG`Wa+t&yrt!y z;XJ(cCHEWmD(A+1DZii5Z+Gx+Z%MmN3l+sYc~O;$S0&}12>NT|frzK~Un{iNq$o`! z?{Uhnk~PYA+(-PqT2fh1*msiZff5vTB^m?LGw?jnTPk!dD3_w2LHg)9OLUXyZ%`2x zFZzU`+@PAuR+*>+(Rfft75WWGdtOVlgXkF1Z6a~fqzETU0_n3=Ub1}v8m#iDMK-y6 z+)8D8M79@10jG@TNTM{N{6zdE&8|!4Y|l?Pcy2$7P+d3qW%21BWZUz*3l9(){S!>W za@oXlfG((b$)IbBa)53t;%gAzRVw3KLOf8R{4PX8^2d8qwYz5W_?l=b(KM>tk7T<- z#79rhZRY7i`|IY|_qO8DheG*^BJ&MX0(mvkaf57)T)+E>)ryia+pbr{*AaYW$=^eG zJKlH~6u!#fZ|C0pWh~c-bK~n5CSHl&dDHayzrDwK`oxURz^5i{5>YmgzRE2O(&ME9 zNRQ|GWP7)p5btc0tyZF^5V;lch~V+ZeLj`E6nth@2>8y6OE2fn+RER5=lJ;Vcq#SL zTIA1Oc-?Pho^K?s&8jLjw<%Q$PXQ`Kz?EyUB zP{f{j|JWwJ=>1)?9&(i~P7&L9{^PXLrrXrp+d#54bd7jFUrzgGDvfu+bXmAHxOL0; znUdB8?N%jS2-0QYIcx=N&s6BthIk)+x2zlIEB)!VXWQa_cw_Fhctg;peUvTD-}fIW z`jbt*r>}cqyUoNqLL_rLqr99a+hd}r0AF!Yg*u72RQ#SQ+nBf>T)s-d|EwFQU<$-n zYWg^mZ=ve;n}!nTc9{p#Hck;0XhwTx(6wJ=o9@1Yo$M6x5!x4_y7#$M1N-7!xJRat zBW$oD{-Swsu&-xkkVnc}`(!+sRv#%`0`|u?`CL+egTN!!TVL|n;60q>7jt^uTYg2S zDZS@@sw{Hv&l!s1L(I&TM#M)Mr)A=NTOfrV*|Pn7_RCswJSKSr=y_u{Qs|cCp5}Pp zpsjSgr--L}i}#b}c>F$%+=+6E%2)c+R3+4;2|&g+OJZG6ccI(=}@^_itbfD z8s!>PzSFWS4H2)fqTV1~4{xEomj$o=a|_AcaP;?=Ntt}boeR?QJ0N`@`UOZ|8TAM0 zyHpOfPCI#jxqL@?3V|nv5s!PX2t2oOz5t4wa?X{UJ-Q z=@8;&x*@&D{qV9W^48PbtEZ7dmw@{%bSQSFP-%}8_Qf9G(%(fQj<*5xq@H)hhi0~5 zn_L4Jc2}n56mOLt_y>7zE#N9jBI_#Hi~QmhMV$D z9f8$j<@sPG))JF>ia9~Qn_lt;jSex4`y zlG3H;y+qR*niAwE@^&BU%`<;L&HFbMY-DB{`Fvs46WJQPCbNw~K3gvtkHpMmJGa33LNY9QZK-rb;A}FsS zxifbmMK@vlK#^P>JfP@KGhfl;Z|UU)sGlPC_e*a4JB_mO{@&8dIA!BqePjz=R5o6< zx>p4|f?KTcyr;FP(MQxmSINe^q6f4w^++Vj30kSVybsb((kp}3DI2eNHGplCj+Y0! zSmOA{eK%~nUEcR%Ytq42eC;FSod;F(m2?d2nmWZR`*wd}ygVhcbuzYaqIi(r&pZvJ zd+>Z`U(bI9{6XZ?#n^uDYP?vw8RE8&f=$=*ZP0puS-v?GZxu-AVd-wtdJE0}qghqs zGC!mg)*i+SkH1=djg5(S3~bQP9l>sImwDP}?UQk!uV+Vkev5(M73cTN`D;|Zw&4Arr9a)Pa*bP){Pzt_K_hVft%0Jb zul%%4etUR4T$Ydb4&+_ddAE4EbF)ry4qi0LJ)Ezqw0B_BebjTC>4o>ODyic&8|mwb z*A=AWdCN^+x#<-0I{QC+=JIhK?2rGciT(ZCTJma?|7f#HBG*CmQ`%_Qbm>!wUfFFQ zHvR4@=lkY*aOwGOuJqione59G&3#4D2-$a+?K4&krCgN&N*|?UC$mXrS{H1N)f##~J6{XxhAxY24Ncq{S77_k?c$roqzENSB+3HPEy*?a)_%M3p4*{F*+RD_n-Rt- zU^4BI_Nut(7V~N%fT_j4LYSPvt8cZ~kXdBTDBK#e?XC$T)6(DLs zG>B*x(P5(dMA6fYzd}R}i3SmUOLUe<%rI%)M5T#Z6OAX@NOX%Rai;N7hNunENTP3v zb`f1C3Y%rT6eMa$G>T{i(HWxP*(PmXqBcZhh*l9DA^MXjW)68FszTI?XavzxqF;&b z62;9m{&EskB5Fd^nP@!GN}^wgE)n_6GoE9Jaud}f>O?e==m(<1MArGnUm{UKqKZUK zh&mGWB^pmOk7zZ~cA|qsw}~RZF(oKQ)RJf%(R!lGM8OM8+FV49iG~xcBsxuG{nn(7 zCCW)um8dn*IHJ`=r-@z=B`-9dOA>V;nnbjmXfM$fqL)POMaExkq9#N=h^7#&B-%%G zj>u=R@s~=JpQs#B1EStUlZjRl?I-$!C}4@n!%bB1J?tbg4X1ALw6LLE6k3v~K2cYq zQAA6LP7_&{n%uGxH6ofqw2#PVnMsk4s1ea1qD4f9i2fqVxZHTDO4NsFG0|^C;VVpv zf<(26`V%c9xI`?1koj;KZ$&QG$oBD%1l&Oj1Fhls8a-6s-1o00|*r4SV$DnrzOs4LM3qG?1+i8c|P zC%R7*w9}LzfhY@6exh1LpA&T_8c8&ZXgSeFqF;zk5Zxm3+hxj{QAeV&L~DtT5IrD@Ic&TX zAgV>wooEu#DxxDqw~0cI7=Nim)rh_zno6{l=seL=BG*yluLMyOqJczHi8c^jCVD}X za?JSqn5Zq$5~96Cw}^s{o3wd|st|oi^gYp4BKrxGwg^!TqCP~EiGCnDOY|pEP>Vdx4GYU=P~ppg?>Zy6VXMY2Sm=ZCf|}oEsGj|4aoK-(I%otMDP4& zymTX)MYNyj4=Fy(nT*6nWo}jmn(-fw2`Lsz5Y{yzC%5~5>7FNxe& zO&+y~z95=Hw1Ma$QMPL)Z8f4!M5Bq85FH`9K=h0#`nvJ=4p9}Nd3eHB@)7n(67ubs za*E`eo;?)hz2WD1(~kEb;ax^}SNy|Hq`DBKhAn zdUreip9_8;gr6}tMOyvt#}^>I*XaPzN6O1+P(?-ZU&{_F;&;L1`&TEG&DUn}Q16?5 zp6~7X%_RBuPI>G;jAx5@dZ_>N{=Hj%qWfc6qwSR}qOYQY^YC{5Yc~1cnd5XQNI#?J z@5a3S8zZMUi9B@L?6>{I9_6Jg_I2_3OXjFAG=1^_?V@Zlh2Cx9%_+D)_((pEC-_ez;8xH^El& zxh#SFhfsa&%XdTde+bUTbA+ZUl=rdWU1_+txTkpxaZh{eU+z^-!SQ(1%|-A3s7f&7 zq3H#FAI|TQ=>_>!xATRpM?lGe6Hi zQgW%@Eo2d;)J)BLi;VU0_w3Fw7xdWTi(0M%Jy)~~r0aGLp>W7XH!l>Y2gA?&L38D1NGap+^D(BqHe@i$`S@W!eR{ZDQGpGO3L^T_+KYz_7|Gc`zi=C>>5 z4hQ;;Jo#}kZz`S-yv?UPM{vIEnM=U49+!pZ zKP~~!bv)<%?`IXB33==?<>)0uEWVh1b#E%(ON#fN;45UlMrY!yaK1)QpNBr%KM2DZ zSGjr1gU2N2Cd;SO@_*#s3#ajnSw-*L?H6H2G3VdH3HARN zKLn+xW1m{YyVxxqJL?k#)it*4L>I9G*L-~aj5Btk$)n6?_@XLQ+G@~S9Dkix%smO*b)PCIcqh)UU@IAySMaA*u zn*J7`Kl(@i+v~2k{XMpeAZ?R-re9Gh?!l(#rpfcM8>Ot!BYVM|c^V#}Jp z-r~~M0N*X^URXmE9A|90t@uj@xdU*=co|v~-=FqY)FZoT1O6929viQGM~`^=-Q;Bp zup6C9I}SEII(Z-K^!r`wx}897ns^^;Cf>)IcfOvK!{5`+ONjU@4LMH#R3*rt$Mksx zkUnZZCz89_>)z@~wsAzWh`7ah2H_IOV@8h>{%-_sp_T9wkSN>qQeIO6Cb=S_->07a zuD|%rDdVjN{jNy%pl&~28`+HOQ@w^Fzai3hd{uF5-OVJ^ZYk#PSxw3Jp~C z{GM6H<8!T?1;%HQHhIN3MNzho{KbLSsCHTG6sJ}VRwFbP-wI=$f!>_w87>FB=+^il z%;vc&;IFy^;%uHf+&9}E4Dt8GYnEX1tOktFX%iz$saoPICcWY?KetWn{t-oaW!E}y zw!QD#M477T(|%vTCfdAaTUp2^#=K^m^PWxQs+K6NFU z6O3&hNZUT1Xl%2r##W`88K=RMjIGIJ6OYqooMLPrg0#OGWSc{_EMJ>=oc1=^f~K0Z z<3M_)h|BWROk?Bv{xsVrnq)~|U;lEZ%nZ@-|bJ6=h5w{=03$@Er!= z!{*uLf#dDIW&6i28N2S-JpY}^@owI;3HgTBtH*-3KKk&P&GS7Nr}bvL`oboj;%VWl z{=CKWW*a2}{xRR5u>^SjQIYfg(KkTs#{`H`~U<1bBAXeRI5b;{rVY z9LVv!wS9(!0P$T2u9IGw6TR6MCH}LI{E`AZ|7^&49CihWwYd9w)!*gR0MCE#alBn` z1&Eay(#QM1*t{L93*HX!{I?zFTko9!&%b@K&0Cqh^--f70iOS{j}#Jo^d8!E0sdS|h--HvyL=unx+nb`xjY{<;C4|Fn3s&DJ2mvr5PDyd6j0t}*{F zwhYY!M2;Tm>+8+7yhVWLDwoUWZ3ks<@sj!mcy?~#wBBsq=KCT214R7Y^yTvwuioGQ z&)zniN97>_p8IaLc}u%;Sb%3QACBkE-@mna%QvK?xdy3;+UVIaZx(Z|{cOCMG1)eD z;y-PB$tL$$(APuqt8VR&ZSqb@+vIKwtt#1Y97&r_p=>qfu~lhqfXJY}p68mkn;#&) zt}0WoZQz0cakE-_TZwPYELs|*b8~)WY)>+nYn8T31H|fD>C?7cX5zI0>9q07jV(V& z+a{B38rhnDhu&(C-rtMw1H|Np>22O-l|h?K9$$iV9)&g=TMdx5*|r#48c5qlkZmm4 zn(YV>hgzi1*PBgx)@{%JR{dgZoNvuN#>Vjq91IXy+o#XNo2}|0la~EGAshQUej-5h z>6G4|H(S*+0b)nz^zppeE|xGOd*M~nR^G-H-{Ec=ZjOLo?wB&a)6Lix-TS9)?L%YR z@q@|Z(?`a}X%GBmY!Cl7{w6#zw#Q_%VtniV;5&l0f17w*zS@>RPrP~{Jq|*w#`ZQy z+m84d8>h{0Gq(3YI^O;OW8-@C3N*IeRJY;+xEd(}+5uh*J3-C5n(me(-(I?9@~muecD{AUqemOo(AX9M}K zk|TTqFw1lK+SfAvNLTi4;0t zzVmO?$k@`RnS8z7mGfPGSPm2K&E~%cxKr*7uzvxyin+o8OPAb{uylsvNrs4meI7Ji z1m}r{JqT(Q--sB5E`SDzkUX&n4TW08LJWbCTnJqS4Htb1BqOvp)GEFcDF|Hy4Hwr6row&|Y8C5*8+^TB8tgZq zR3bk9S!9y6-D#EQb zpr@?0pm(ixppUF|p`ZHHhvxNd2wmXY81cV_qNjYDLKpcqgEsYR0sCi4Tl=+w<#VNN z{941_R%v^`wy?KT+QF|qxT9Z3gnj|Vf5H28f_C=n0v+hr4LZ}W2Xuj7FX%$QKF~#e z{h&+z20)kj4T2u=8v;G*Hw=2pZ#eX{-$>{=ztPZ3eq*7R{l-JD_)UQR?l%eg$Zrbt ziQiPHum5zY-G3%D%zrjC+Aw&f=f4;l?=O!+m;Z8Tvj0kGivMb8 z4*xaKJpSvTdHvTz^Z9Rp7WCf)E#$ui`o8}*Xi@*|&=34~KtJ-|2`%Bj8(PwT545cR zK4=C11JH{82cb3m4?`RHAB8sYKMrl`e-hf#|1`9f|5<2z|8vj|{uiK~{Vzeg`(J_f z@V^G_>3;*-+y5rCkN<6GU;n$%e*X8MgZv*r2m3#Q4)K2s9q#`GI>P@Mbfo`t=xG0! z&@uiN>|{5|-v>I`-w$fH*`Q&zKxnuv7@ENr3U%1RpiZ0IXD`X-fTr1^pc!p3(6?-H z(5$uu=sPwiG@H!@&0|Y}=C!$@`D_`X@7gj!3)!+j3)`|ntJ$(atJ`uw>)CQa>)Y}` zo7nO}o7(b2KeH8tHnSCmHn$alwzd_8wzn07cCZzPcC?j%eqk#G?PMzr?QAOx?P4nr z?P{wC{n}O;I@MMc8Xi#1f;U|QYJfK?-5gL0mMu!R1=N9kD-{2Q6i^rZBh(^x1k?xr zq%=ohLva4U#?S(RO`*dBn?c<{Euh(hT0wIJwT9*lY75O3)E=5Us3Wv^P$y^?yzYjw z1$BcC4(b6N9@GmuBB&2^d{95=S3v`yQ-cOUrv(jx&I=j_-4`?*dN^n#^k~p%=<%Sj z&<8=|p$~&5KpzE7f+hq{fhGn|g{B2hhvpBS3H=~=HndUjT-2*E)GFEp&xf`RUI1+$ zyb$(|!HdBil=ci>3houW96BI)CG^YS)zE3dYoODE*Fk3muZPYK-T<8wya_rtcnkc@ zgIe(vd>ize;O($1fMOm9-T_?{yc3qiQ2YmO@NVd~;62bi!TX^5gAYKT1s{a|9ef!2 zBKRmYcgS&Qo{*E!ydkHd?}nU(<_|dsZv~(@T0<^C3x!;Qr7#r7V8|6{rI2f|R0+8O zuB^0r$W3s~klV1=4!H}irL<1SJ#d?l2hdR=kDyaS9z&;vJb_LRc?O*k@*Fxdph~;O3!)!Ofr+@p)(w za4V=qvvICA2d5SZGz~nb2y`OQAKOmqTkouZ7lu-VUvcw0D#~2(1sxeWi~>8^RuLZwyPA z(g=G~STZP$wKs!3MroYA1?=%q9541(P?x!1&>oY!G0V((S8y-$$lC-&wds<-+m6d)_wuH&VC8H&3*;?qx~9m zkNpO8ul*);pZzxUi2W|~sQn)FnEe6ty!{c>KkPBIK-d##k+5gb5@FAwWx`%U%Z6Ee z&{JVP(Ar^s(E4FEyo>*NSRlBS($-f5Bv%_;B?XTgvzz38b49^40At=r!;rXDa!t+BfgcpQf3@;45 z5ncp(H@qnHd3Z6XZ$xpZe?$qWEus`OB%(Cb9#Iw=7EvDRh^PonjHnECMO1|*M^uA0 zji`YfKU3N~q82R8l(vYd18x~n7uqVKKD1p#LumVm#?THCO`)A5njvl1h!)^3O1nk0 z0{4h$4ILWM7CJ1VJ@m_nj?m!|ouK0)x& zczZ9y6mVgsMKVl^p1nPCGo(6I>`-fFlq(&=CwB;s}KfbA&;MJ0hSX z91iFxM-+6lBL+Io5eFUbNPvFjaQa%r1Sm#@!v+1?kpi9Sa6_j#GD4?2GC^lJvOs4# zvO;G&vO(uKazIx*azVdy!YDMvHt8Al7~Z;n>b^N!Zgi;lL?%Z~QYD~^uPtBy|4YmP3^ z>yB>F-yJ=mHyyp8w;g?;cO3noA4d*=mW~_*Z5lZQ`dQ>KXtT)S(B_dNp)DduLt93U zg?5M>5A7H^0oo~Y60~#V6zI^%snB7O)1mVtXF?Z5&W3&)IT!u1Dsnz}rPA*s7l7AC zE`)B1TnybDxfHr3ayfKs|r zH1v7oS?G(%bI_NO7ofpWm!Kh0SD@ih*PszmH=r4!ZbGA?ZljLTP#n2Ycfp&WICDka zgYJ!b0Noe$2)aM&G4w#x6X>r|&!7jRo4w@x80h&G93C$7hf>w-9fqok8 zhAxTD2wfeW3A!aZ3-a0u#rZcnEBHq!MsjpE=+DtPVA&O&3%pb5?&v(Q{G#+_bUxT$ zC=H0o4-Sth2#ts-4DA+E1UfLLD0Fa4G3efy;?VsuC7@?wNogZjkQfCj|Yf(FLcfkwyHg=UVe56u$W5Slx-F*HwX zQ)u4UX3!5}TR>~Xwt}{aZ4K=c+ZMVvwmo!TY)9yU*iO)2W4k~P#dd>UkL>}y5!(xT zKei9_L2N(h!`K1Pr?G>eK5;{!zH!5#S>uL7bHt5==8hW;%@a2k+8}N`v|-!?XzRF1 z&^B>Xpl#!(Lcfli4xJh|6FMz!HgpEIam0KTHy^Dr3yN7QZUK0X(s^+UVVMiHh;QN+ zgXb$<5VsVTZJ1=*hS>&{J{ipf}>yBlLGD=8Cut;9F44 z7;$p<>^n;Th}#0oU8qIekJ|>mr}RPGc32)laR-O3cq}5n(t`0jVJV>WeQd~r^ClF% z5WfdnCVn5ZEH>!C`7!<=v`YM8Xw~?m&`;uzLu<#Mgnk--8d^90EVN$yIcW3v3(ywv zm!K`%mS^Nm=#(rF&ng7Vh(8c#9aOs(K9g*xQEhSiTS|26Z1p+Bo>7BO)L!UmskYa zKd~ruYGN^@nx=F{VsTieE1j8G0=z!46hb#7mInU-#r&377Q9jE=EU-_Y*D%`u_EkS zmHwDm8TRc^oD&nPf_FeMlO$Gy?o6x!-IZ7i_T5mN9~0|<_bA<$SQnPPO7|z$hy8%k zgNY4c{}qZ^(b*XMGEu6<*%a#IYzFmpwt)IMTS5Jut)Vt&TWEl@Jv7kS5gO#|1Pyj} zfrdJ}LG8{S(9F(W@SFvT)^_#*XH}Zb*$7Mb2oH}a}RW>b02h#^8j?M^B{Dc^Dy*#=TYd-&g1a26N>TRJPFZST=Oyq_s70J`UI8Chdc}DSeARga`owt?p--Xc@ub^O zd(vHKSkgV%!C53{^DlMNB2Ck440j-$i zfHqBvg7!{|f%Zv?gZ52Ifc8srB5i*t`Yy=@9h{T`9hT&V4o}Jm9g&m?Ix;B>bW~DS z=;)+u&@o9lkajE-M|x5&=;EY2&=pDfpevK|Lsumggsw>{3|*U41iCJ%DD?ZJV$k(T z#i6^CNE5ZcPM82Y(uDYUg~Ikb&y zC30yC#k}EK4Q=mQ14{=euGn4cpkKJwLp!-PKs&oOL3_KlAWk1B?zLUppu=6;p(9*7 zpd(#7ptn4bQ8gxT|uV z1+Rf(mvE z`^iq|2gxpYCXXt8>YLI6>X*_A8j#W&8l2J=8j{i;8k*7(YES6|4NK_) z4NvI?jZEo*yrPsQru2d(LFwBmePGWD#nGD551K7y0JKobAZX!~A<*|yhCz#@42Qm- zG7{P|Wi)hP%2?>2l=0BPDHEVWQYOjPNSOj2sdRM8R9MC+9hWj4_OVLGr_6-?D=1bN zQf5OZrObs+PMHs#lCl8$b;?5M)Re{0X(>yg(^Hm1XQZrzE>Bqvb)>F=W=mZM&7Qg* zS~hh9w0!C&_^+U}QtB31Dk`mpGhpgmJBKnJH@f(}i+ z0v(om4SFl}2K097P3V)<+t8<}ccITy??GRrK7hVVeFPQm$54m+2{h9E3>xQtj?%_M zF+aOsLW{dC`1huYZXakRw;!~!+Xk)X4un>B2SaPPL!mX@VbD762xvXG16to51#RSx zfi`x>L7TV}0`dK$+X-&2w58hxZtYHiwsE_mZQU86?cJH69o<==U%0bEJG-+%ySj5g zySsBid${vJd%E*Md%5#Nd%Ful2fGVHhq#L%uVL<@;Gs&tbQc2;cNd3_aF;;nD0eCF zNTs9QrC}MPbey{^>|>RF?Jf_V>aGZ#=B|u5)1eqG?yAt4?rN~iQaZ<71D4rJ=elcw z=eg@3biUFB?z*siqx4(1{7;yL?uO81?#9sN?xxTc?q<-H?iSGR+^wK%+^wN&-EHCL zdv|;AI;HE~9l<}iJ3%+NyFfR)yFq_)_kiwj_k#ZH?gQQF?g!oF9su3#mjA_d%sm9& zjze*G=^h3>=^hTf=pG5Z>dlf;vNsZ>Yf0-=AHz-?w*3Qzq_Y`Zz#R#o({g{ zo(a9}o(;X@o(sL}o)7)Qy#RX8y%2iey%_qyy%hS;y&U?;y%OI3gkpuqy&C)%6yw&t z2Kv;!4jP-b9vYXn0UDpS37U|$1)7+)4eCtW4oyni0nMDY6PhJ$H}vhaJG8NP7S-54DI&X^+4al~zuB3`^s*C$Kb9 z+9d56xM|vR=x1p!q0Q1PK^RMEKF~R7e$csTHt4*xK>e;gkoa?sS2j7ZUpxD43FxWgECgvqwE zIkt(&{W8WyL_|_FGbB?ZFL=!hni*bF@|Gzgk(v2bGcz+YGcz+YGcz+Y^Y{9lf1Z!` z<9$Bou(7jq&c}$j^eG`dRV5pB*3h<=}sQx%k*G4`u!Z z=;B|5ef&$%)xQk;`a96g--%xSRrrj54SM_6;wb+*e9pffU+`~0KmSJb_n(dd{!OUx zpM_!mvoYL%4o3JlqsG4lGyLaarvH32`7cDXe=AP)U&K9~=D&p8Alc~OMt;$MIZpRq zi8K6HW0U_HJnX*?KlX3OFa0;N?(hDa$hRf$_-`iv;om`jSMr|!R+>L0|MK5Xe_!%} z{|@@UCI9j7BtP`uh5!2R!O;Qxn0y|2ZzNzpz7TK#{Q|l$C!iZA1oU8TKrc=VID&Zr zM=?L(7&-!u<4XZ2@b!RGxFX;*t_(PXs{+pA`hauT9&jFa23)|NfQ$HHz$NSrxQrhK zT)`s&SMlS3YxrNlb#w{5fw6%%F)r{HY65R#eBd3_2HwSlzaBJW|+!i<(w+9Zvoq?X%8TkL7F!f%b z7w!u5#>0Wbu_w?6djm(|M}ed9lR#fQ7U+kc1_t2qKslZW3`Re>0{!JG43MiaNFI*C z@<@!9M`MgU7E|OJOqFXfO`eG9@?;z%PeqG79Sh|dSR~hBu{;YMasyV#MRdx|SShz) zmE4Neay!<@b8wP87i;BtI9XnRz49VFAuqv`@-jRnci?AoC;lq0!dvnh{99g&vY6ZQ+5h3-MKQ3#rYPX{%lS5ON+6EqLKgXZJ#poKUhs1<#J z7U9UCB{(Xm4WA2Ij^lz>q9tfGW(Tc7YtTBh1+`;t&_cYiA-MA#E2R8)u;>MsO_*T$S+!1sP zdxMVSM?oj>NYE+#IOsGU4LXCL1f9iWLFe$(p!0Ys=mOpkx`A#MnMgd2k& z<6FTlPjDUycEz`Y-EecTJH8X_fgQmEa7*w&JQ+L~PX!Ob&w@SiZ16DrGS~~h3iiey zgNNgY5FdOlWEA>_jKU%wCA|x44hNQCe6mn}r(#fBPWROowei@=8 zp9{&tuR;tgy%-{rzmfbl#7uJudEFXf!5>1bG*^*po)A0!9Fl`KLUQSEhUAfdk^D8J zfaVr*%@a~Y{yn6Gd>eV6B&3XdNAhlngXT}d7w1GfUBcu8KzNtC)`c6-_umF$g748X&Rf!L!Mj2|k7V6VaxKT-_CBMLA4SmDjqK2Z!OAC>%8;X}Tp z7=_;{M&o6LFEigG&jp1a`Kls-{Db6=3OUU+$?J+>`ky3!Rw&3f6e|2hp~jnvaQsyf ziMJHd_?sdYZ!0ux;dkVDq0r(VibR?}70Kkg$ZG*bD*2w|eMLIW-^jB@kwJc_(2@U< z{8y1h^9XtFC=B>mA=1c{BH2Z0Cc7#vOt}x2EBE6HcmDlmG@&@)OZ{ml_TiC0-jUOrR;1T6r{8)Jpk1FrucghENS^1D{UQs?Ge=m7k z`I!8>(q#~PtkQK5SK3N9@*k3aD&5I{DLwGMasd9P9EgvVgK?m02o6$tvesb9A*x|C zPf89|dC_|!dz8u>hpC3+(<&bvt{R0SRHK<0sq!WJpo{D|l^=N&a>cF+Adi;xRmo{y zkn~pt)B8yVs1)R2l?p>tYE-DgnN%XLf>n{^P-M?kMPryM7GqT!j8kbbLzRe`s$|ru zQgN~>9qUvXtXr?rk*6R(?NVitr%Fy!8OV()5noi9ak|QaFRQFLM`g#?R5>_bm5U2h zdALwjfJ;?HxJ^}p+f`-wuF8QsR8HKbs=@)GH8?D^7X3r(Fd(!Z)u9a-7TSp6q0=!U zv7wbLc{x8`_HJLKktrzCwOh6}klPg|^{e zq08}M=t}%IbT!Jj{t`9-Z-x!TU&99Dt*{~ZTbL)_4jVR@ zGY<0n4f7)ZA$dQ{o8~Xczr%);AB6efKVhTrVc2LK6z+?I!~O8d@BkbVF2|wa!T40T z0*8gG@ab?hdWDDMGvSfw9UhI(hR5RYa1D+K*P>5&BDY~A@~jL`#`)o?xF9?omxgCx zTeuFFg=gXNa09Lg7xANTGwU8fj#}Xs{3P5;a}0T95pE~{FFc2QT=HaiF8OqL9)2BO zfS1CH@Je_IlRqHu?}eA)PvH)l>&W*u+=(~CtMJ$G8v0wvF)+NA+&7|*>?-LNQBUI@ z(LmErQWeoiR!2;y4?~`V5lt8oF$=8`v#~m24%S38OZLEyEgUyk5 zac<;2Y>B+jEqoREjzvDe*CHR%%t!Xd$Va#^@-e<1>GCA+kVm@WqDVJf8R?E|B0X?z zp1419*pqzskaKjT7aolC#t$Qh#Q=_cd z7-grQ9+g9WQF2C9E=`l^I0(9er1Bfl#7T9kvlG|Gu> zQB}Aiss>j@)#B=?Iy@CskEf#=@bjofJQFn?&qg)j#i&{MZPaYM5;X^Zh-${GQ7!mW z)I9t(YCiUhUdUH}KDw1WS~4hl5ji+|3F@NTFe`dF8lzXDDS9Etb95K|JIK2S(cQQ;x(9bg_hM)C5qvNDC^Nf|pKeDV!=us1@ssEicr5x9 z-iD?sVV=mDPlKo>Y(|aKA zpT}Gw4?q{$pqQ)Vfs%t`uF*UxIW*=v{Sf3gSYmFFJ(1r{jk!r4Cg~M(i{=^RY!Y*u z{H)}Nm^(DXC4FM<(vL)r3^Dh}&q+QXbDw53a!nZXfb1*j7xR$DUotS}5q*H9JmxWd z5c0UkxD4S)65~3=MW&Ec#kkQZB|~HQqePinGCanEK1|XSGk|Q48HnRz2BRfr2xiB4 zqBUk1+G4!0JjR7dIN5ll+ejEThQG0`lYfjsYGVsU$nhDM0hlHDaeViRflOFj{s zOg{j51Y=Xl10@H?rqeu$Ja(}eM8bR(xy$StF^9Eg~nxmSAFR879R#m`O(7AC7gBQ<1Bz*eddv z*cx)Wq#?GJY>cf#F}5BHVjGw#M4q9sjW{oMIXd)#M)}e~ev2z81Rar?0~?f||K*M*DXx^Zz_4=#!8#iemaur2N=u8TW{>*J1Nd)x`! z7>qk<}r@axD4eTT8%3{uW=jdBJ)M|K#e;FX*_6xk!QVT0ID<0efo zzO7NMB*+@H15{K;y#TA-`8kyza|m8G|6~KlZqc|(y>>Q!7cd+ zInHZz_^BofPihSKwMN7X8Z-W&vEWsW6@S#&@fS@F>;9(6CEt>~t;r+*ttr5NG({+j zFG08XGVB-czya}292j4PgW_v&XnZYt#@FFf@%88x-+(^xjW{xXI=&F!g!1@VsEVJB zq49H29p8+x@hzAbKM#}Q=i`|8g_sfFikb0?P#3=h$Huo|R{U~qxn9y3zmmovX^CG= z&Wm4zrSa>qGQJ%r$8W^C_)R!1els@4ci^n}t+*t9J1&jifo<`fxITUt+usnshukjN z5xQ0)~|Yp-Io_8P`$uVcLS2BvFo;u!5M z)N5~}sJ(+$?On{*-oqm8eJs{KK&SR0)@UE$B<*9Y)w+1{z0$hkG_4ypY57xp*-Yen zrS-sZ#OUp%Sx zWBaF&>pE=!ey)|{8Er6rp;h2ntqOnCs?m}Vj_VU5u{|LgHzdU3+X))noS?;b5)!c^ zAsM$Mq~g|ubbK!%gRiwaK}X(&F0#D|S>!#E`w|S~_Y*|={m8p*31;%a1Pl3qWLJWf zd?>+=-3d9^laPxaC*zj%^4!FY*pj#j zUrXGK^AkI8LE={2owyx6l6Ih1QYSu>v7mL#3Q(xkIkmUIrQlg?vJ(gmE9bP;DI zUBb&rm+{A>EBI5=RlJdO4gXHMjt`P<;6F(>x!38A$G* zG8l)X48fr(p3Hb6k6p?zoRZ>&^(o#sHDx%SPVvDnQbys|DWmbb6koiY;)ma-1mKkv zIsT9m%+`KPQIM}nUQ1Dte@ao~^^|b@IVBQrq(tK{DY1AnMT5VlXz^A`B3t-7C7FC* z@lNXiLpOdulF@ zPtC)e)B?;+Ey9VZC77RDh6Sk(EKGG`QEC-dq}HG_wH7N=>##1h9=E18;I`C8+@3le z-%V}8_fu!#q14&fojM24rZ(e`sV#UdbsqkdIv=m6F2tWxTk%HfBD|ft1b1k_lM%p^QGqcm$$uCL1oVJnNoVJO6uH>s}n`v4k=cRSfzlIz?)3#!3 z+IC!)wgZ=^b>ix@UCg{Gxi)PN%^JydY5VBcOKwctPrpI(t+WH=&1qdMeMfRjS~pFH z-%UHpq`cBeMiQ$}Gbp znGXCo(}_njtMHS|8vI{oEn7Gtc`CDx=A`6jnf2t;nGGyGli5iAT=I*|>EtgnoA6xb zES7$SJex9S`h2*Q5t#~bS5&o39gqiEe zkvy{vZ)PsXUo%(Yt<2T@=*X=-eT_*~gJC|RuYqAAsR)09X$b;D^YC98El z^i`5Ix>59#kaL!9G&bpcai-1>XXyf1`Vw;Wu9M?3T`(@!DR6~Og>UQB_>L|dJ9Lq_ zMHh`*b+Ncjr@`$yExxNu#2vb1+^I{&_jKvFTbIFC*(146r=!^``MxfTen0X$S7*RO zIuW~dX8InTg?w1@OP!T`PG`rjbUAolmy2KP^6-ML0Kd@{;YD2u-qe-h?>Yzmp>yJ0 zT^0VRtHFD^TKr2_hxc{$__wYBALttKAKi3(sB6MUy8r)#m;ZFL@v&|W%EmUM%h(of zq1)Jbl@ae2J^vYU}{#h%T56oIk4v>^* zt)U4*_Uf#4Sen(2RaqOcI%^ZwWNpStSshrPwH2pjZO0i|JFqFM6K7`a!se_!I5%q_ zevq{v&tx6IZ?d}ZPF6SmmDPj)Wc8wp{s{KbA4Nfb3_bM6vA_NV4$z;%f%?-pNPh+g z>(Am4{W%<_KaWrAFW@u!i}#dAmRin)3>oTzulJiP}N=m%h- zejpa>2V<#z2$t(T(V-uP6?!k6r1!>J{cx<)``{G)D6H3y#s&?3d_^CQ&H6~3tB=Nc`dEBTufYX+EiTk2;_LckY}KdY8~Suyq|d;` zdL1s&XW>%40o(KLF6L;yWaJRk&_vmYJuf7iV>Fe=;z5x&F8?j429S`f9@T7hgp3%?7FZ6TpOMNq* z*SFx;`g!=Hem-8)FT|hqt$0Jf2!GKp!JGOv{8hgkZ|PU!ZT)KeL%#+e=-1(6eLK1u zHez4HCLCzkjDrjv_@rSgdK$LlQ-&SrW$46b47Q&~c*7~oF`UK;hBKIJIExbv=P=K39`g+su+VT3 ziwu{r#Bdo)4Og(ta23l9*U(|OjunO*=rr8KO2aLzGTg>$!yT+K+{Hjqp{cEiys;M@Q5J*KQ_qms390n7!-KYpu)=rHGXdh z#~%%mc-;_!Y%IWfV-Zd@mSBUi3>%FOe9`E{>BcH-GS=WsV=c}y z*5OOWdYo-+z`4doY%xy91;!?P-8c(djk9ryaSkpuHe;Ky1(zG=;R@q?Txnd0tBkF< z+PDbcG%mrl#x`7MT#oI=mAJvU8aEo(V25!XZZWpwR^vu|*SHCH8aLy6#tz(N+={!6 z+i|~f2Yz7e!~@1%c-XiHKQivaqsIMs!gv5r8oTh6u^T@#_TU%BUi`{<1kW3f;@8Gw zc)@razcHS`?~JGLC*x_nZajm(7|-G@<2n4@cpmQi+I;~3I8-+#(Tyqc;9#x z|2AI3e~s7ivGE4V#GBYhyoGM!ZR{uBK|#EW1H^kcNW70viVtvz_z;JRkI++mj8BO! z-kgI(SA0fvLvPU?pA|iDxHteuhy&3_9E_vIA^5!LiN4}6d_nX=KhYcg#o-tr`e2|q z3gzNx3=(}YSoFgXF#r{!9F<})sze2biYio#Y77&@F6&pjOmjqL_tAq5+dd5mQ7nrivC!6Rnso+Hs7SgBfBjW{P>J6AN&x zScF+(3F^f%G>8r~icS>8Dl~~TXclX6oLGkzu^zL<2DFNeXcMQSU2MYf;w;P&XX6BM z4(5u@I8kiDJaHc8i}SHST!@8YD;9~1uvlDzC1M+vip#M~T#4o4YIKNeutHpiPO%*; z#f?}cZo+DDGuDV5I7!@!wc>W1EbhQMu@k3=yRcr|gHy$Q*dXr5Y2pEF6ua<6u^Xq0 zJvc+`#hKy}oFyK`m&9W@TRe_0izjf7cnX`v(>PZ=gDv7&d{sP$^ThKwU%Y?|#EaM} zUcxuT%eX|mf=k7#*d|`XW#V;QF5bWu;!RvB-ojPlZCowh!8gUbxJJB(YsLGxPJDpt z#fR7~KEe&+W85gZJj=OWbj3}g8@?^N<7UwVJH!FFO&o|j#lhGq4#C}`Cw?Ff!-Jw1 zc8lJ4SR9T$q7Qy3j>042X#808#bcr$ekumwaZ!%{6NB-DsKAq=3O^Iocv=j{Gh!ru zAx7huVk}-1HTbQl#qY&L{7Fp4U&K`WRZPd<#0hO0l3-5^r{8tq5k!Z&ML<{yc zS+SqVj_#%$^f2XOe^VX~Fcsh+QxSTbN^pd!3|}xg(9h&Vxv2_+O*N=6)uPH&hoPo= zRGS(w%+!bxrs)`IYQk94EQ~kJ#st$GOffZMs;LFjO!F|^G#@ie3o+BwiaOIG9BW#F zS*AABo0g;5v=YaeR-?tV2D44;&}wQ&n`tB3O`CAMX*1@SI&gw%E9RQE<3!UA%rkXj zzG)X0nD$_?X&+Xa_G7K-0M?nhaEhrLrOh<6K=_t-H9m6Kmahzp3fiIa( z;mfAeILCAbTTEy1Rns|~XF89snJ(ab(?wihx`eH!%lL-r3NA8T#igce*k-zp%S|_M zh3O`)GTp+}rrY?Y=?<R)rU2|U$?+poFdi`}@Dq~?kDJu^l_?z0n9@jFu@ zUN$A;_oh_5VoJwrrVRYaq{E+0S$M-_z+X%v{%$hkU6Tb}%~ll5b{uBT!Kcl+=w;5s zXUqjS!d!$em`hM@F2h8#12fG|tTtC+qqzpBn`?1~xelAm^*GbqfV0ev_>y@#&NesU z%jQ`)$2=Qb%yV$QxfvIjTX3Oy9=>j#kBiI;ak04-mzWpfQu7jAW^Th3=HOrKc9=Kg7IOz~HE+dj=IyxMyaV4gcj6B7F5GF}gPrDm z_?~$`?lK?1-R3UbWA4Vi<{sQ`ubHpnJ@YkuV7`w3m~Y@i^G*EMdh`gX%+=J2syf1R2X7Wqrwu7N=qcBTcS~CiDh!UMMJhr z=2*1k36?~xv?Q~%3fWgJspJ}Dud}4%tCkF$Z_#0^B@0(r49u)V_9%;pZ(7W_-eSRa zixoFm?AT$+!L62D++oSX-IfCEvJ~MVO9>vcl;J6h13$Ak@wBB1KeyE28A~mGYpKH@ zE%kWI(tz&SjVNSK=azUN=cDW^7E$Nk(Tcr-_n`%U(&=WUt1A>@}E}y$+MI+c7hH zBkHm@vF=#pe3ZSJtd}%qchDFl#q6zQQ}%W=XYarX*`1i1y^HyYlKI(tX!0ZrviH#! zB4?lM{aBKH086vGuq?Y9r)Kvs(;(TH-AgkK`Tf%DBjgv6-z?2ON}hrIggW~ed8Xt` z*~e*SBS)L;6Sy$@6uzE)8e6l^;2YUzaZ&a;T%3KL`6b91C;I|<1+ouhUnIYkeTlqL za#QwY^4r;0aCi1qJdk}24`yFyvJ2TOvTtB__D%dY`xaixzK!2y-@(h-ck%n|dw3=L zKK_vX0B>YJ#9y)>v7MX9evl>>ld648#>oBsX)eDDNy>WzfI5R$yFIatOe39p@brji8 zGQv8V9BuW*7^@$~S_4pPl{1-u>_66E%&;mj)2c$9RgHRUI2x>xXtYM7)f$U7s|Fja zT72D_h^^LSe8ZZGi>&Evd5JZHycqe}lT}AvD!I&>MP6<-;3})g($&aw*=oi$Rtv7R zT5+A#&eC>k4tYJg$TnJY$r~i!vgVODSqtzTYY|I3kn@GL1b11>aJSWg`>ama| ztTjx2Y^^09kvwCqBY$D7r$38a%~~7C=OoWt8)?3h{MtI5{sMBYw>FV4B72K<7WtCo zW$SF3?~tF`Tj!9kNVX_>Y|F_5ke|iaR^rpP)#znggU{I3vD6!RjcjYj;kJ!9!nO%V+BV}TTL&}GAxCW6 zR#e%xV}xx7M%g+s+O`X0Y6R%s7zOn6}I4v|YhU+f}TxUBhbIb)00ofs<`FvCei28*R7oMcW;= zFdaEM+3sSK?H;~jyHDSYoSSS9@KxJGoM(H4uh|}BtIcI3e`$!Er);jc(&k393c32V zx#OEQ5A3uJ!1rteahGi{?zRoVJvL7~U>k-9ZC==A^Tv;C!|{mChpip8jUs=H{Oycw zH2D+BlQv(PQ^;A&=7(o(0r;g&j^}K_c*&-~?`$f(Y*XVews6+EiM+#Oi^M-{(RkMu zi+|cQc+aNA`?f^<+m?)vZK)`;r=yEK1N+!@=xNWwr|bswwu|_z-Hapb7944};wZZv z{p>mDZ_mX*dmhT|1sH5E!Vr52D(qz#Z+Bp--HB=TDonT6;23)?X4vbv{W^O+Ia6}1 zy@717H)6JZI$G^bXtU44@%Gs`(LM+B?9G^OZ@~ilJhoGa>{0gl^b%&_Y z-hx`1APW_zUPi z{vrm9zl8Gfmr*hP3M$86#i;SuxWCcJ(PR8|%o~3L^T*%Bg7LSoZv1U*8h;1d#^1$d zb<^+>}%u(RA92NeQqh|8woN)4W$s0M5G`}Fn z^9j*7U_va0P0(P>1TDr+NW|(1$vAaFD)SA<)zpM^Y@Com^CGfGP0*2NNY0#)MbjiX zYl4CPCFGUe1d;qQ^2%<4nf!|6+zA$%X2}&3tmI1*?09EF4!Y##;=tTI^v*57pxh!< z=9aJp6>_DTTSit(hUYqH!XzVdo%E5C(YaOhQIavaHT0U?TADcIY?50?j+acxt*1$p zOwMhfPeQIma~sLIl6kq)Y4VXhDz}MTC|Q|1i^eHAHFq|B19IPU=a64U?t5-C`4!35 z+!mVGCD-K6Bd^V!kLz+5;`-cH+?Bfscjqp_y}50;FLyax=*nG5K8XBp$=ucCLz0Jc z*U@X^tYt>fDWZEO!%rn!6cK=62wj+^uMxxE(7d?!d(pJ8|j6U98)N zJVz$(AumTB{k(nuKa;l~m*gG5rFmW0me-BT@_O*iyk13(N9vV@3WQoRohT>+?}?}6{;55Ug+fw(t+Fz(MEf`{@wu_u2Rew^=x$MU`LWd3kGo$rHR z=8wYj`J?gMd|$kr?}tC;2jKO5IsTd-jJNX@_-DQf@8_%W-~4cVoF9pO3!>4zAQqn} z(BR+#Ek0F{h+YNBIHDjGM-`-FU_k~37w9mwAPd6_3>Z@&qNc!%jsgo-7FhA$0y{n~ z$iV@Hxj3jW51oYtSY23zGYU(vsjv)RE_C3WLMOgjScUTnYw-2LT5K(>!?lI=xUR4P z-zsdxO@-5OOJNgkEu4ir3uj|z;T+ss*o^xMTkv4vJnSl*k0%Qk;_1Rxyim9Zzb#yX zWkqdRUbGx%6|KaVi&o>jqBXdnXdNyoYR6?o8*y{dCfriA8Fv(Q;Lf70c&cbSeqOW# zzbWd(OGUfzTG1Z-xo98$R{s##hm<_Vr%GH# z^ZrbUEBcnWVNi)XDoQ*sykr1ImGB{6GEK=~Oeh(GsU@B`reqjeOT2J=i8mIM49DUU zA9R+C!s?RISYP6c(@OmCrIG-gQzFNCCBe9$M1hM-RM=Lc#?>X^xV9t`HGt>{*^9fh(T z_*_{h`j+j&$g({cQ??J2%JySw*#Vqc)`hdny0N9K2VX1e#YJUDaB105TwQhy*Onc} zcgjxS*0NK$tL!xHEjxo}%g*9gW#{l(*?IiA>;lTlFQRMtC492{GJ2L@LGSXbIHLR- zK3{$v{mO4(Ncl}vmEXe1^4l0weh0PXcQL8_9;TPy$IS8vXexh*mhwkfTK*Uvbs94Z{^P@~xqj@gb#oal(g0!J*CIW$<| z(BdRVBGx&QvC)x=GaTvI?a08x4jq2x$imYO1ODg`@tVVozc?&-(_uwHsIDl$sEQ(tt|-COiZUEi;Xq@B6U`M>II*Gz3o2@{q@oT>E9$YTq5-Qb8gWL& zbevVugv}MRaBjtHoL?~q7gRLkqKXz=Trm&VR?NrtiiNnnq7`>mEW!^emS9&!8}?Kz z#}6x3;?auL_({bYJW;U@Pgb_IGyUKxYp=>FmWJ&LjA=^C)^bkKt(NaeTpf0_DzA z7~(vQYUde@aGu3j=Q)gbp2sZb1=Kq)Vv+L_mO3xvi_R-J-FX#Xa$dvP&g=M^^9Ig$ z-o&NOTiE8jjjNn@aJBO;ZgSqkx1INKtMdVFb3Vj<&PVvZ^D%ZgU3|Hoak}CcPB%R3 zbjPoq9(chy0Ixgw_(s{!&cS%gIRt-mdg5QsVR+x^h5tIe@sV>l_Nnwi*UC{iuyQmG zs`SN(N|ZRjHU#m5!-Z8JJn6LtRxCTB{6bs}ixP%8WCsEI6miimz1JaamOkF0abPO;vgL zc2xoHt180xt4i=lRT+L<<-ki-PW-N_3V*Ju!5dYz_*+#S-ma?0e$@@=UfqaKR8Pl& z)lE3GdKP+C&&CnebI_-{8K19iLEq|m7+5_Y<<$#OS>1}N>O~k)y#ynx+c2tnIYw8n z#Q5sfsI6XuDb?#RwYnXPt2bgv^(L&Z-i*_#JMg9ItvI`SJHA@I1LswD;?n9}*jBv< zS5@!B)z$lPWAy=itGWvhR(E4}bq{`8-HXSokKn!Pqxg6AG3-}!9NlY9_>Og1Hf-*& zN|z)rS6QV?idT$Ry-VpcFv6hEl=uG|GHC-8@@ub%H@OM%Z6`t**)Uz z5%*nEeEog<_9^unDC^s2qMrxm`whSee(qTAHyA7YhVaSLDgK_ar~2&nABKDVy=3-2 zd*$2Y_CCAiTkw7PyYdNrK9zgRCiMBAe7MZfXK0WYJ{jaAtLyV`@HTl}pMQe4V4sk8 znkab6ad<{4x^_nnmI z@9XZCU+5(Zaa&O;$~12I<^9VwZWGG|^e=w`E6Qb9S>6XHmG{NT<^9Uz-O3$avUs;p zM*xO6{A5XPD;%#mlH67~7C2Jec00DClObpBqUcN^zymFe9~&V@3o+h5K___veC)NN;F8@^k)1mCM%j=L*Y;@-+bs&cpY zD-WtF-QudYI4a$uszOpL-D0XD@R_Q3jIY{8pHTHKCROdkl&bd})ozojSMyoyldIR@ zlxi4a@l)s%Bf>h z-*bzanu!yq>ak*~5i6&fQX~6)Fw<8yw%^c~y!h<%u$Me#d;5L=+6StW{a#t1SIFF7 zU-I?{H}`MR!#!&0+avnB+i;NkT#Rv#>F|=pxJPvaU_^%>#&v`!W84!uROF-%HIC~D z?TB-q)-j<&ba}f( z3BOADx2~%+zjqC%`J*e6{AZUh{?+9vOBIxdyfEa@Fbq9(6~hiabV(H=4n>lq4*6ot zAx~MFkVc;-Br%^Rq%fH#B(PSRFowxAA(P28VJwq5!p=j3-ExHYn9LD&GnpgoJv4;o zeI|2+517mm4l+4W_}`&Z(yvVL zXR=Hf**%yX#H2%r>3-C}pxz zC}*-#s9@bnp_0i;ffGAUVzNq@!eo^&mB}h$8k1GRi%eDtGnlLrW-?hNyu@U+@CuXF z!dxb+g;$xZ7G7hrT3EnjweUKV)xsN0)(ETUYlLM?)(9(@tPz&7ZjJCJlQqIxCToQC zOimKsqMszZ&EzEE9VRCUTUd9Ju#L${!n;gP5_U3KE9_>nR@lpAt?)jRwZaEX)(Qui ztQ8J1St}f7am@312W-Cw$3do$wWt zb;8$7)(PJ*StoqUWS#IGlT(Brn4BW~$mA5^Cnl!|KQlQ+_=U+S!mmtD5q@K`UigE_ zdf`td>xI9VtQY=fvR?Ry$$H^mChLX&n4Bu~IsCwFs?hha7rEczt0)|PNYnptB>9QM zzBuTxr>sGEikSvsDDw@%(@Zu9&oJ2_Jj-N*FoMYjVI-5&gh2Xf!VAn#6a1N+COpqt z(}W-SmnNZ@$tIzc$tGdK;SSkMVe;Vv z{bmZ)OwJT0F*#GHJiMP~3X?O1sZ7okrm?k`h1U)TxW6ncI4pOcBfKH`I?XG>V#%d6 z&B6-FWi)ezH_3B_Rpb_7t>k)|SA`AaSB1C8^MrRK-==v@*dn=&X1?$)dA_idyg=A3 z`5w(eVXx%-G_MOEkY5)Ll3Rttl80#C5I&Urh-R_yKknCJ;nTxcg~h^2?%iVHv%}ZO zpL6dP3tw>W77Jf;?>-Us_5`?pBD~)tcRwb4Kt3iMB!4CR)pJ$$mGEbe7yi-naL8A} z-#w4;pPopXe|voKzaFkLg`ppERVh6AVbjoWgr`2dN`Csow!Ys8&wLn3e)dCO9Py#2 z>?gtaVSxKjg6TuK`*k5(avV*6kIz}FzsF~6r@zO^4>O+b@A1WlI{cC?^!NCRE%f*J znk|g%)YW3A^r zcK5c@>}B#fkN25;&f^0n13bR%mAeOceA64?9_aBsInd)fa)`%olE2d^JpLdnJpLrB zJpPsZheqwu=cE6(??-a?aE~V>`_n{tJV}o57(|Zr7%KS`O_awolK;ooU4T`UJ^UWu z=bU|Ft%HeO{e)A}XR{cVS_7BbXQAXlW~26_*aQv=i-$OGjGTi;mRW3n%JM zqH}TCm6i^|rMPsarK4~yF5PJ9BzjZtB>GbCEc#RLECy2VBHXEW5kshV6`sYV2QA&i z@ZxeLEzZK5y0h@1-d&6>E`4cn5q`y`KP^2(Kyf*d7FRKix~rH%y{DK_T+X7!P0TAU z=g`tiEGRA)(b8K4QtvI6Qtu;{Q|}{!sP`3Xipy2B^b_lf%MG;j7h8(UO|%RUJE#v3 z+o%r|yNb(TS_X*_>Vw2y>O;ga>O({XbszC5n(L$Z5PiFvkN6VJRZM#diVNKFk)FU}Tbd33|P7s|*P7qy5P7uy9Uukh6IYGFRoFLptP7~8& z>Kdns88P*Z)5R?6)5RR>GsHaVGsFVwGsPn6GescvSz;;mSzLc3KI4tgG4KmLBfILO5sHNO3{(z zO3|6*O3{^RR|;p6D}@WmmBN+eYB40XNV8fDB)M9+lUyzO$Cjt`Ah}w2l3Xo@lUyUb zW9u5%2%p&c#ap_CTI^kDb`qQ#OOe-#@(6UL)qrOSZp}s`~7MDwD*(!oq)>g4R z)~fnev5F;b6>DPaQeVdsw~7rcajV$G61RzMOtnqyV5;pRglD&l;MmD^wu@a%wO#Bb zxn1lhxl=?k&z&M7_HLb>;v~=R6j8DNP(Q;|JH~h8(mGV!BN;00 z$F8RSkYuRHAsH$jliVj>#rCVaPrM<&PrM_!Pke|SK+7kR`@|QL`$QqhFi|0{B4xR_ z_4+VTDK3|KmAH-6tHs$-uMt<9vSys65-#lHj@Atqt;mN92a@5!F)o~zb|k}v6UlJV zk>n{cB<{NPDd9o#l<*{ZN(_(7pk*Y*5W`>*5{Bbnz{&t}$Kwh^ueR z5Ndp`!Z&NhSEN+ppESr2hWMwHrg%GAWPEK(i+D@rrl`iVH$@GSH$_dRx+!XryeaCC zyeX_n-W2sn-V!b1>l$wf`}q3C+rp9LZQ;OFw?(V?!wqkXcJW6kotWyj=*U#JMQ5hU z61_=g2{)2i!j)xZiN4G~OY|q1B?gkr67D3kg(uHui{T`*#Ym>g7TzSYg%8PW;Y%`G zj3s$T1n}$~F_GjQ;UCZ6wZxS8BF!B!jpQ9MgXA4Ci{xFgl$N_<0m-{!5mVh2f${ws z-4*lV`%o??c~=CHd?-TLu7@I+ZG0pSl6)lgGu0!pH~w>@MyZ z=Y$0Hxo{%+Ty!M)T(nClQ}?;(O7gjICiz^rkSq}H37WbEVhG6s;X$%McqZs*8BVf5 zj3ikgyh(l*!3kw-K8p~NpT%C1pT+(JOIi++{4Byqeilba7K(ETt0^y#EEJbW7K$qg zLn{=DXp)5@mSmxbCs`y?NfwDTl0_n&WRbW*vPfi-EE2a!7Ktp9-^AmD5lz2|ha|s= z9FpI}{e)q(qiytI^2$?vz z$q!*jtVrFIm`kZ94x+^((T;k_#M+dl6D^gWqC(=620uk5l0QWil0QYY#HX~>Ao)|& zB>7X+BB@C0#8S43tVdFj4M-}oQDXNdiflqskv1e1X-iTgTaeU9dy*R2iljz5kkm*= zk{a2Lq((ZC)XLtpXr&8Dt#l=+m2Qbe8m)9rEKj{JNv-TpQYS|y_OjJUPm(%0oTN^A zB=)4mn>pyD4@sT$C8%W{%>8AMVqSCKTzEs1?>jdB}FqufE#D0e0Hqa~Q6QHGE-%Dp5_@*qi* z3?pfhM@X9FF_I=3LDD26Nt)zIl0u##DdahlLS7&#)YYV1N<-3hT1-iH)MZj_N{b{*rHrhU6lz;WmLpk4Rv=kMmQC72OBIr3WHpjy zWDSyKWu2rFHf5zX$+EH@$+EIRQYl&*kt{2lkSr^0NS2d)@TyHY=|HlabR=0$^3iv+ zIFT$TJCZCXJCiIgos+7o<)sVB^3s)LdFht)8!f#_mY01=mY4lWR+7F+-FhnOvK)bh4#lBU>d`t!pD4NZLq8k~Xqka&=mq zNZQDbByD78k}c%OBwI)yk}affa*?Km980o=^ds3q`jfPm^O8rY_Hq_UdpU=s zy_}KkMau$`_Hq$Pdl^Wwm3)_6WZg=BAlXWOBH2oQN&ZetA<0(q8_8Dk2g%k_P2q3F z(vZU6ilr$fmr|w_XMj3?03( z-wNf2l=?<@S(s9$mAm}LRPOQzQ@Kke)shx%svUJTwKk<8)lwPE318PZSX!jkHx8Ax zcy_3)mRgarMrtl)&D0ls2WFMjXOwlAYN)hkDo<%&Ts9%;DQ!r4N?VeivN?0`lr2bl z%0^5zOgi!GFxigeFzJ};)oPgRm^zBGGs$7HE6HKfnYoRS{Yj3H15<}q7$Mzxc7zMj&yJM-#icj%87X~8j+DNsRW&2!Sdt^9AIXt&WNKxNmkcN_r;zlL(@1*B86>^r zERtSw4oNRLkGXlvMI^mtAW3hzl%%&@PSRTjk@S|UNP5dPBz@#Il0I?=Nguh3q>l_H z=_5l(`pCT`edK#m+wf`Z-;>`Hx^>`#4}97uhI^q{^% zdQuOP!>I?!k<>TH<;CSvS~klq#pO0yw#Z$@#Bwj{%3^Rzv*v>+KK?U_%QY(?^@?95b0Wml3%r8CK+(uH{*m98X@N;i^6Wp9$< za!A_BPT|snWVrMs87_yXt)^up$#CgSGFU^B{3)48 z@{~*_c}k{|JSEdeo|5S#qvSo>qhuEOD0zoul)S}MQSv^?DEW|Nl*}P{TIRFur{!~! zr)2@j)AAMDepY#F3Zw#NmeK>%h7UKR-t}bR-zs)>lByPv~X0?y}4w#pM=~(!7nNH1A07;VjL&NJ?`sNon4c-rd>49GO0t@+3(M za}-Gn^O^L&XgNpH!hC_Gh4~V5voya-U*T+NenZmI{Enoh`9u0jT0W7qG=Cv!X)YvL z*=(C}+qts2c?S0+<`x;;lbG!@vT13R!99uDA%lAovtx#(Qr+y9@xr;fxi`t`=DsAW zoBLSlM6)y+dl)-?NOl&2g^vZmROWKFYwMvN981#L98c2P zoJg{wHHlFiM-Z_gJd>_^7VJeItj*`K7Hc_K+Wa{x&@^AwVH=4m9`n=g@UZ@zG&y>ol>6_V}E(Kk9! zk0sgO98a>nIg#WnvqvU>DK&d$az!u)WL8w>nkQy=2g@en%7VdH1A-lK=U@{6KLL&Ikab>c~|Bz%3$UYXbxcx zf#$u;VTt(|nI+~UnO^24<_M-*VvfulMg1hnCFUrSOU!3Tt}*8@|25{v%zu;l8}&`* zAJjLSwSWIAmB0D>o>?s}4Yahhc$l?MX=#y@Rgv;>RxV{;)@)r%i~KA*>d&)kQx;@# zmu2CX-CE~j;h)W2mc_(u?y@WbvfI!yC7Zh}i)q>1Wm(L~=HA2NarQpSJdz_U@=1=c zc%D65H^QQT%U!z2T1G@Wn*Tz(TCR2JFCI9KlIk zL>lhk3Etof6uwx-1ir9A;q8x#6&k}1ZQzQ(;D^=NfRlv2v-cmaEw6!W@8z)AQ%U666cYOTX=#G_y$#{D3+*(dayxT zxMBc2;DyPUk05M7D8dkl%ZNrYZsH!E;1xdMCrm2)36=3X8lV|kp#xmd7eg=-<1hmY z5rl0BK@_ec1$U5x=Xj4IsCq@IfcmgSYxKlq%)t_@!B&JI3@30If8!CJ<2{O?GboA$ z%Ap#p&;%{e7G2>6cMQiE1YkA-u^OAP8wYV5XK@ut$iN-s;x)eDCrn0`iR!S1En1@^ zdZ0gs!xs}V6AQ5d+prhMa2hvo2RV3&Z%|Ea7s{a;>Yx#tqceJ9AcnyglQ0X5u?m|J zj6;aTdBoxxZs7s)@fL;93Po90ifwGpJ{v~=!S*%uw*uNUs?wSc;e_M3fLItCs!9v^ zVLi4Z2{&;IRT`DcZJUT0|fgy7sD45*6_q>Y*t%ViyvSjx1Dk zQk8}nh+*)>B&@+!9K>-v!&?+W%ivfC4bc`|-~n&U#v%kE8p-$$wIllg_85kVn29S$ z#}j;lu@l>jYFL2HIEb^T)S3MSKh*A`Du2Kp?ct0AsNPjo`oa?v5Q1Ykjk4WTKEayj zF&(>c1O@nsmCp2k{N7zvY|s+k@Ixq$AP#A`Qifz3D5cik=vZkr;<52*nYc!X>;#A@=oAl@HMOr7t5C?_ui4 zaT&n=#&VoRsezme7zTfL`ZDYXbNn$1=TTz_%f&kn&bgr+6Hiqs4M#i~#(o>lKE*}U z9l`jAZ2Z8Hk*X4j^Qh;=F@illj#8CxIPRnJt`m;`XpTR+`*J+++Za``#(g|N@K{wj zgbCvq%h1qIRc!GTuMj+*FlFA3yMUlB!$_V82er6jf=0KhX}|;D!O1gnCoi z5Aek#%)(-ybdep;w1!?6y*&@5t%MVZB1bKnMd{Eb}L z26Ap<2=<}s63!XepdWm&8e0$yzolHya1dvaiq9y$jPn88aS+$wwVXWW;|h{svx4&l zf!L2^+(9mkLCgoXa71VH!eFdK;98C)3ZY%6DrUICAHg_;_o%dtOFXL861#;8^}h*gItr*9h(r0^@o^0qLG3-$VG)P&OIzeH144Y@-SmDs$vMd z5P*ePiM_al)<+n_Fctf77B}z(7Du^0z!Q6sh>FJ;H{gsxn1j8DMmA))sx-nJY{YJy z!Yw>NsR+glY{Nx7#cLEnJx+f>P4vW2EI@@w#uzk&13F;8562LNY&^n8 zd`HO>%m;PR23;`}zKBE|((nbF%sQYi zv{x9X;fqO_g-{$v46fr2-lF7H`WHfQ7zr2_&9wM4hI?T&h~u6C-QbDQn1~CA$1Mzr zr{7=?>LzfG;T{Ggs>%qg#ARgT5elJA;{F45;ed|lf&LhZ*2#Z{!^A)HcGr4JTh6C!X0AMqX4uQASJGxj42uTeUU=TH|d;EOAG zk0R8&&N+x?XoWH9tmh5J?wf2A2Eh|!F$r@Kh;`VGLpX`6xPfdu#7BHb-%Rci5Qpp7 z`#1LvIFB2+gBK`5>04Z1&>h|wk7d|~P#i-XZr~2SqwH<2i)f7w2*L*Jz+N1|S;XTm z3Q#YL-@(uct{8w}@Wmv|!YXWrbvEY?R^uoxArplteTV5W6sM7hY&^$`yQ~9_A_kf8 zxW|10q7aQNeE)}Q<$bQ}7>1qTO<+nFYhSKLM(K0<2rN@dhSQ?$b}tie50(CYd7mR|9| zGHk(pJcXjuD+2p*8Zo$zhxmZfs$QvrI%td*Xp1iBkL}otaMaZ6l}_l1K^TTHn2foI zzy+kBu0hXxuk^}a@WWKB$38?N28)e)Wfe9f7>7`RkN5$jNv}A=2Rjf7Z^69q1~(+z zhz1sVzk7-zdP@F)+vUMObS7smxA@~P*cn#}Hdc_O=NJjyx@E+JM81?JD zu-Jxh#Nz{G74|(^AfTFFnTKtNLIU2wT%F^EsmMXC8q5z>M0K1X??=e{c<-@e`}s z@Eqzma!%qisUq&d#bmUlII_x?z z9eSWN{hGVlUcJ(&*u5P$)0>=TSdIP|?Z7HAAR z%*9rmfb7lm_yeo32{CvNT_5^9%EJM(a2lz2gbsc6NSR&7~2*etkMKoUE zBdQGJxS=8J;0TxDjFIp|uMzZfMBpr12gfjOz;Z0(CR)M?-O(F^5Q?MtHjZ=8 zPp_;+2qF=UJb(JY1okl;u>{*tY9jk@68j95(FcFQ3sW%{>#-f7h=4hOV}vFcfpM6D zjo67WMB*G0a2?K*SyxQOBCN$lT*C`|ggQm9lz=sC;0{03o60)F6&~=z9IQl}X`ELW zfe4&IJi1S3zhE48BMO&r4fpUFrWtyrBL0LgwqqaSa1DQ>5Mn0#9?js4f$+xfvlwUL zjG^$u9)uwd+Swd)%$mb-MhLgg?<9-JqSX zS1eEs12F;15Q75?I42jfpAfi+@eJXJ!*$%oGyH&IG5r9&FaoRaC6Mdd63#Dlz*lIO z(jS)TmFg?#gLs1`YdDtc*uTicbC}lCmrx50(Hs{yGL~%8E1frUyzv3Ew{TA3I}BU( zN?Fu^1D0VO!jX@+D1>es+l=z)1$UgpP5gtp+d22q8Z)sU;kbmq@ePI@97{N$BYI#o z9%9f=#(Wgw@h+}G_yXJA%o9GigxjzS=2)N~hGHe&q7aq#&_B=s&ESAV2*x4A;5|x& zuq~*AXLt)uDCZb{M?*A68+1kht|J>cc!6(dwU^_B$(VyBh{Sos;u@OlV{FGP?8JU# z!eu|#D~!by%tPWq#^pn-I~?EvA56e{?8JUtM>cX$J&gU2rf7wOID@N5#vSCM0H5#^ z;||jg5Qu|_#Ccd9;d%#qv`2R=z#4?&D5CHH&+rZrM|q4{$2i{*iJIZ`-3X5Pan4g5 zzvoQFt97Al<1huD=lO{sgre>R#%m10N^Hh{=q|FI zI0xkt=Qe&reRRiP2*Y!{$2X{#>5Hg<-w}Y>2u3*0;wcPQ7>8hmrf7p<@Wo<$N7<`n zPzMt*0}HVh`)~|d$bn-t_uufxN^C|9?jRRUVz}1fG7^!2A~cR=EW{Q>;4>!1(f4r> z+IXHv2e@M_rXUADAQL!t_ziaGjv)v~3~u8s%!!O=N%VId#cim`dZi>Pq9z(32oX4o zT`3%cRE{AkT;m*tQyTjMGx6y<=T$n_5RAuk%*tSVz-HV=?Hlx01Ytc+;TrDaHHy&b zCVdVb_?*eU`kVcTmFRbiZN)2mhVC}~0Bz6>?ihoqXr09|KrhtHrr*O6KA4K@$cEt# z>jhhkxyQMJ1z3S?F#N-~hq`EivAB-=c!JLm_w`C&%*7VG!&k@$^c&Pc8;n9Y&cN~^ z+l();e#AL}5FE!j#N#WpIcz(&qI53TMNCEQ$NYWH8p9D?;D#Y+@R9z4bvTMBTtO0U zAQuJL{fTqrGsou(#}SoL3k}g6PH@2(Oo!`N`UJkfuaJF&u0<>t9@vZnC_s&GY&Uvi z143~RPw*DsvEe)W6h9z;u-@p5k=TYkIE-_M#|`9S#81v=%tR1&Vt`^$hGG=PV<+|_ z9A{8gV^C_NIj$fHxA73q@EOgt24yVHK+6k?wjm6ckq9T%prqjr@-RVfP)=ir!Jv5I z7zP^+yvE0%1miGHAP$vGEE~@7#1t&VQN-X448ow4ga<~Wx-{@k3xl%7%<}OAYj}}U z%Mu193(wJ{q(S);VYmW)DTCqyV`+oZ7`~`nhV`~ID4*~XR=h~6FE(Ho4j=+bd4n<^ zq5}I1hbkJB(v=L#bv#DN$_B+2?QjD3(5#9zSXLS7AnQsXy+vZ5yIg_Cgq-JrzcKAz$WX4Wz&8*!vI#}D~%tz%FIU>xRP zJ1%3Yl|jis3u~5%uJA*h}I1ZN=NKMJcc$Tj|JF)Fbr>O zQ2a2X3GE2MVO&QR8vem?M>x*lDsoYPFVNT+cv~LJhD}q0(h2@JkD9i$VK-_wW7#Ox zoW6}Os9?wZF%z3{23KLpi{9#C2-YA89se{a3DDUa6btmh5bVP-WMg+rgK`kZ5s#a# z49Ww%fZE!ilz^*8~GHmozE;NnQ1hK?8FS)eIeVFG4gJ+7d9 zJA-14DX7<;96Dn#Mxu@r=TQfaJx<{gZsQaF=*aodiT&4^<-r|3n1VdKfqNH&vJ~5J z4!L-Zpc)DYKZe2&Q?bXH?di_GcH#WSHM~dN9`sr4z$v^%byxNWE+Yj$ zQKqMX@AxE-tGJ1;sNiN$enVGyAOPo4r59rkR$x6Ma2;Qv?M*+&6(phv{rebr%?tge zFZ%;6(G4MpMhb5C;~4a3Un3k3kcW8#*f;oN5Yxd2XAy@CsP0UMa;S?A7>uP@i(7br z&4W2-kqONZ`Zg@#h&^cc7u)H7VXV5p$6)*7}t7g(iaS#P?oW(rhiAW?P3wd}2 z`#Bs3?87Oz&gIym-#mU|HN70MO^nW75i}t0FD7CJj^Y$9;yP~Q0e)Y~dSS{k&KWGn2JA+=WjfQ(T1{jZw5c)7a;7Ta_4sY-c&GvFmqYv)jJ-Y0ppJOy?@8@0$Ymkmd@I65P zL+OK@bC`w&2*MVa4sje&6vjS0%-D;nN9bcm4ax=Rk8$lnd33=!d<^H@j$qtHJ+y}p z{Ba!T5Escg53iHlKb+#af}vQ11Gt4(C?7>%JI!{%13s958CZxgXwI+>XbC5D$6~BP zz8&|m}LuZV{ChW(mXvSv* z;}EvQ(8pjK%f63e+v4fhSb#L#K`sjLS2ANxDt#rLex6A`M~_<^w=DWzHtUY;yKKij zjte&85F-CEC^v8yPw@tY(B0?!dc;0PCI;oQj~{dIm1j^IVct`&E7*x7unL=@DQ{Hz!2`b7gyR*AO3NxnMO)3N)P_C2 z{Kn@N*EA}naRzgKH!91~tF}=YgA_c($T~*FAF~h#ODm)D8@lmkhA{}h5iF@^R5G!) zKI`1Ts5mq>D$kJK#HbklV0{pQ#}GC~B?udE7BR@el%_1-mUYH{*fldM?ihiwn1M&A z+}xmYXOsv6voWV6bfQ22~i-u^0o^Zz`%)~bA!$rg)6HzUU%78zO%0#ThW<=l> zKBJ7iQK^F3aKLOV!CstgX;f}wb1S0~ij#PNpJ>3FK2~BAE+Y|+4o0ObdchsOn2AMr z1DvP_3 zM+W9Pvu=pOE!cK9DqS!i;fO{S>bbDZNJlPe@Wz?`7z!VR!RSiAz@Ko(SR6;`o<^k; zdY~VsVh=7N9_8HV-Od`OoQ`Z91qMuAhzQqexjxa`wuDj zhEYQ~udow|$VY2W=7%_Bpu{ltACAC0+^AH76((XXf{=|oyoX_gQ7MTE=!U`Y#uO~Y zE}TR%a=huc(2immXn@x6##|)h1^WBY2XGm3v{9*w&hW-ugy94R`qGET&{wev$M71Z z#~KwIbVC3ZV?QoH9nUtQIp!i5W`Cp79RawEEa)cCm(d1&Fklkn8J6G%-oqn+?Lz{} zPG%gz5P0DPo}%g$#$oiq5R66$4rA9;`UZ0F9{s1WZMcpibeYb)umUepgr+mN4*W8c z{t7Ql#!@8VBg)NUEI|m4;1q5l9~QIed+@^9IUGxTMXR|+UMJ5!!WXoiXH?41XN<)b zWTNTI7gOpj^QAzmKl`^NW^_qS;4V@D;DB0 z%t4I(*oPPRg61nZ{#b~u2w!DX&f{;~$4mS`{nea{*oE$Ej7neBT+7&jNmz#@xU8f9 zU>GK1CoUo%KTvKx`)?y-4{qQG+%_4NjVMIJ&FoXO*upu7l3VFls0(L!<0}l?j7lj~ zLvMKDDXh0Mejx*QQDz7I6f3cQ7yT7JyN${p!Hij`w1<6&0Bl8>5RL~NFbE$|DwO4* z4Q5~=K112dxP_Lm*~dKs%I;_1qa$2U;Q(XgLFR#qsE?*_f)|!z3qo)NCvgF>c!g4j zxIUpo7}Mi-*uwQN=M9eI9K4Shl{Y9v!=gX`e72zAQ2fT6~T229WVq3aSshJKCP+m?9KO$i)Y=J;U`M+t0Gk@g3#P zF^*#r=3+gf@eO~R=UAd2mO^uZ)U}jP=-oefWS1 z@kZq@jKXR};VKI70SyvZS4_ezEJh?QAp!UB7Nrw8PMCr9h{So=Cvl&M!SKiOU-e{` zhef-I%1K9e7r>=44G^nD&sATe{(N~RAk{9%H5*RVl-ypH7ea^ zc{qiuxP~vNltl*1u??X(f~Odh&HWMPA{xKlp}$}{hTf&mU^2F1FT#@&6lcaV#c&zTl|kcHRqd_fLtaU4HkRlxNWAxOYe{CLZDy<@wu9^YVk&pv}2 z#$z4Ee&F{497P5kKXU!YMC?M@Ppmu2e`d^v3&vtG?&2*P6|yW0$4o@wG9I8o5$8Oj z@CnPlv0PO9&idjE($HBk@tF)J#T#pI9@kJ-V^XH#G%U0xr9MXE60W16&ZM-*0F1+0 z?8a$a!*2$YvJzWy6lr(@X*4N4aS6>#CM6tCAcRS20$0SKwlpcPP|<8s+F=N$VLn26 z5iG4VV zTWD=*QhFhiH|pm@EzkPHA9qo;0?UF`MU&DJi*OSCDw+6yHRgrmh{j8lsA5vwFann` zyej*R4*-b5Jv_#D7^|~>Xon2s!c@bg)Ponc;uQk|8Cz`lYy_)mWqB2h)f&pC zR$C}-t%50=S^atiaC0lA4X@X*GPUIu23DT!c#VgZn;-vMZlxUMbu(56kMYVQE4K(< z(_nSx1h4L~8pvyQ+E`sV&HqMQ)jQ8?;;a%W+gYv2=>>HKS{|Ni^0>-np7r`!MgxnJ9mu>Rlu_3xB5 zi+{|&@b9vI=h43{Pt9C8So;5IDMiMM4+#A~Ejjq*L)D|MrXuJQ`j6$ZhGrk5&{vx^m;+M@RpiuBs?bUN3&MwB^5#%;SH} zbE)sYkNOrrs>fj47CkX_$@~n2A}KjX9W$d6_#xzJ(M8`#a`^gejLC-96}hm z!#IMYIEHXU;5Z_20w-|_Q8371xl4 z3?*H;rTneb(bU#7(lpdG)7Wa7V})k9=7{F7=7Q$DCQEZ$ldE~4d4hb+Q_Ty?0=&X& zyun-A-%)O^(28lX;9r>N5~9W&J#>Kt{px=G!r z?oxNE!Rl`HfVy8jh(id&VI08;HBvpJo>sHe+iEuMs&~{^>Pz)C40^r3hQ7MKw!W6$ zN#9Q2o44=u)A!Z)#{dk(Ah_c%{Sf_7y@%ctBlN@dBjJUy`Z4-(@I!!pl76awihdeq z>SyTJ=vV94VjVW<*Xx7zyY(0K7xb6)m-Mmv7=0N-X+sNxo#9W|qr1V`(A&_<&=UhKnu9Kba978bEbZp^QJ+X3#O5pi@0R+)?7A? z(p)i((_A(AX`)TbG%<)ZZPUad9tlV^?b9Tg&TEoQ(V7&bnqoB9kY-BOTt_-GOc|OR zrcBLEWSa6cf8&Th)2jlE*|3v@=S{M zsY#>FHwo=CJjVtI1beh$4K$cl^Ll zD8g5(ffhQb(8B;kMYbBOwtx;E4i+cR5FIH+Bh*jE#Xe2gj8>0#SfDM|$7R}Hcc4&b= zVULz*h1PID8#tmZ+Mzw1&;cFM37ydeUC|BB=nfb3fGc{!4ZYACeb5*E&>sUZ5QE?@ z_Ggw96$Xi z$BPuLKPF%j0z|rYvdGX*5jonam?rYI)5SCG4Dnn$Q@qg5!febDFST<;JJUSzQ#)Ts z-2yBWR=P!^u5K{`MSa~8EENrO%S0pHa;!iQR$>)ai^jS&!d|x)>#$z5(rv&-Y!VK- z&7z}ji|C}=ifz~~dgykDUb>yaL$^yz)$K;G2-58lYjq(A6`OQ>#X;RZaYVOYMCcBP z6S{-ql(1aT&WQ)Q z^SFSExP;3hM|TBR#baHxxGG{0OFa(pNI)Wzkcm%U8+XK4-CglhcTZ^4e{dfUgkF6pDyffov5e27Y)@9!dCq#+NhuK8DH=fg`%xmgm3tcAHqrf zDLU|xIo(tZw6d3~ll@c`dKh4oo~j7~5@tDEwLl4!ls;-Hltvkpg{7RJmP2_tQLP{Y z)QYGir>J~Cfm#Jsl?PQ@8KE|lk!o`pr`n-~Oi=%n&-gZgS87Z7MQz2$ zHMEvGy#v}vRqu$lXovQ2LI-q|CG?$SN7-4H)OSHwbb~Xx!v#Iyik`BZ-c450_mWlh zz0n7K(GUGGK(^Koln(kqaF-qQgJnnk5ZP7#7d$W&p5U|T^~0sBeuV6&A1V9mz2rc> zw;ZG&CEfKt7%e^Y|AVjhfRCc;{{QdYHX$2GNMJW6(u?%aLvJA<;1WV;B4LS1fItc* zA%rF%$c7GL6fA%Wp-K@!f~eT_0lR1vP*6cdMFbRy=zT~n+}^1KF2*1RtPJC%?h9IE{4qxU+OM_&4JAg zU*Vnyn;-s&dqMbS_XFVz!WZK2BG_WsgRmvArLc!!%U~f`DQr1x1#Bg36>K$Z4QwrJ z9c(@9Vb})PBd{{qqp-(d8)2KmH-x~Ckr1GY1~*t08qo@aOX1D-vwz2Qqd&%ySEFZJw)9e^DSU*mZ`e7)yT z_(snQu*0w;uouJkdXB;>V8>uD!H&aThP?uNHT*fx3D|3}*Tau^-Uxry^Je&eJa56? zhP?xO7xo_PWcW$XDcJk44`3g{K7xG=`vmrB_=ld;u+L#%z$#&1!p^|X!p_0IhJ6$M zk>@<@0_^+nPdpc4mta4@euVu5yA1mo_6zLS@C%+Ru-{-;VZXz!!LGw@!2W>!8UBOk zX84buzhJjuRpCE*{to}yb36PO&p+W;JpYE{aWC(`;V$nrj~nKJ8L%)|HCQ;z>%HZP zfYpFS!D_;yVfbEej~^Bby8{*ni-+9_s{^YGs|TwOYXWNuYX)l$YXNHwYXfTsYY*!H z>j>)v>kLbTb%Aw-b%XVQ_4M}e_VV`h_J;Mr|9xToU`eq4uw-w4?*RNA2pbF=;vMV_ z;O|f{6@Q0=Bk^|>INCePI~Mvra2)=ogX8fx2u{G?3@{6Sv%!hpY;O*99xNX=4K^J% z!+YB^6IST`*Hh$m7_(r-xB$f}x>4fw8gsnWjk(@h`2On##(Xb+4Z+*aSO{C>?SOB$ z4&Ym@hZ;+~6OE;?hhWQKA@5|P)SGK8hpm9Egsp`m_*-na1gZSWoZeHZo~>_4!Ruv6ZX-uJzSj1OQRdS5U;@_y+3 z7=J$jKlL6pKJy+kPQyNjeF3Y4oq?T&or8T1`v&$c>^s;+*d^ExupePRd0#dzdw=r& zjK9CYe)Ya;T!H=OJz-ph{SLbZyAJykb`$oO_onw2>~HVu#%ZO0kDA)HNx(O4T^{i8w?u~5fye%gfA=r z8wyK-rAGL}hQrceBVZ$8qhO<9V_^5f#=`D{jf17b#>0ZJ2@!XMWkl2oyC0Sb%ZjKQ zmK{+qY+^+Hut~7V5sky9L^KJT8ZjjzH==1+Uc_Bt`LF`mG}v_54A{(w=3#{qt-^{T z+TdP+!uszd>;6OoOW_+Z)gitwf$tcz6uwPbRao~ba@7S(l}OpSQnu7mu~_XiYsNQ9 zif^Z-@J-jEo)`53D_Ze>K@GR=a2%1;qxf_&MT~Eg7Ij=wUlFxkn~~yMskFUqy&PXZ zZ{7ju<@gB-Uu~{>IsSm6*Ib7k=?=#j^oGX0pB;{%)h{ne>PbuC``#TnR_e!6%cr7F zi~7m&u$Av;QNK&7%V|dtWhs1Hnsbv?BGzd~A8#p#>g@c^O6_7Pe8-@bif_(iMbXc2 zn(g8ny(D#xrIcFeOnbrH@+Hn76!rKL=M>BLkoX=F-*Wa*nU$hei(1e1Q7!A8v$z&~ zLz%R@Nz@apD845ozNaLrEt2mU@jWZ*uyd;wUxoNycJ8u#uZnt2)ElDS67`O#_e6cn zilYD6`G!^Br;_@mD4)yTAF-mEiF(Vm>9E<8Z@Hd;BHhYumuTa*_jFsgy&at`g>Rd6 zALSBCb+vq2^|Q)q)n95EDr%Ue@J+O$vfLNB7VLdiJPzEyTfRc^6^d_`l$b4Qj;O_= zR!X~@-1hj}@2+`-wi3S|AY1g7jk41ed>a?gYM13jhoSWX= zw71Sl1h*vhANK=jjZ*({KV-G5JoYGYh;oVYu%Z$k&kCzVn52e_iV#&pRFtS_&jzdA zXwPP=mRjPgB|e|{eBz6fTJ988S5$pb4Ovm74Y?LNhBcI08cV*WqMC_nC8~|6wh~KQ zsinR6+KaEFl;|v~hi9j?y*)g8peU9eo_*Gq_mX^lMD-JOkH>yj4EMZb)iT^;A16n6 zPFTJX9{W8rN_?ZlH`ZgnkH&e-V>W&r!ebw^$BS>g_$Ek+`$bKZSl$zLk`?vyNsoON z@)&l^(V}XxqI|UsJKsLTj`@J39uVKp#%1fQ_Pf+_%eZFw8iv`ajYUlftFlsa!yHG^ z6kgNAC>CmWdYIi>p_Phn#M?K_6(=uX@+o8v~BphWXm@@+&r@48W`zQuq#EspSVzVP3n92vIde#aRl!)!{Xdo%r@k@pbXqZFIL%@!Klm8*V9=8X+Yz zy!Je7qIVcaif>}|rbE#y*K2Rb0m*kv)a#-?5Or46x1z3y`cu?xQO*cEg6g7TMBO2( zwWzM528s%ZN)vUTs7z4>qDn+96}3*(ub=v1zMXB}G_gVX>tol2adV*7FzkN~N90&MD)*AMR$f{wVYiHFk z>%;fV*09Ig982MMS0vv8OX2%}IhEcE57jWwzjz0TFI2-ECHS6K@vW77>&3UeMtgpi z2=g`e(Q`=KC3U-1LaT!kL50-(zEuLh^-{y`HCLp$ZCc$KX-7~$(w_S?6klWUH5Feo z@wKvQ!P8`-+KOr)Nk=$(b!0`eppKDt{|${iVr|i|$hR#uA<~{Vg;-IEP^3L?S}wlj z;#(=cmEzkJ`KeXk7D?S=rJ@h42=GfjkqzTCAEmyHYz0NHOOZiK{Tn&YQq`i$Emb|r z_SJ~8&vZ4S>@!{WD7(JyQFeVj#n;pF;oGUB%&o+Th_bJvLZVhiIpfVIk5)$2fTGuD zQTDOq+o-4Nnvs4l>XN7*qwH&|AEWGRs~@B6cR=f!_IMsv^9ud^6?%7`_!iVOucPn_ z3^nPxhtikS{Bxk@8O4&Cl~7dTAxV8mQXk?}{CE^n?bbHbw6AA2)U>Z>%EVVDzQ@G( znD{n{ZOE(=hsi_E?)JsS_o2qNGmdREl(p zs9aI`qNa(OA*xVRQM7$TnkBy3qUMO2Cu)JHg`yUVS|aKpQ6W*wMZG9}@M?75!)8Cf z8cpv!dVLrD)~lxPyXZ4e^!hp4o}v6EWq%iSUDO|1k>Tgjh#=bsMG4}P5BgVdV zam3iyE-vx8#1|Hm;BfGM3yVpFqE~p#SW893*mL=a7<(>XLwq&F7ZqdA@1tVu(G(kV zzuT;@Zj3z+o{O<(!-rz*5%x~Z_BYH3-ig@*MMs9~F*HM_(RAI)hhHxe-yh<;DZZQH zyCuF`(uS*+J{|8}!Q-{eqaL2G6}4H^ zbG7XA`F>FcMIE-3Qg79=XQgjRRPT%WO-lSO>bj^uYF&HFi5^0~)Uwz0Zi?@w<-_l= z)w16ey0)zhQ8h)y*0%RYTy1-A)fH7=R0~n9M70ssR#a!HuZyT|qI!s0AZmGSdj_>q z)M`;{MXeXLLDXZlb&mPu^CnSGNb0WIp>^hSwYzFR2}Q5NwHrNb`VQAlfTB_NYHfSJ zy(a1nOJQ$GiMML!mzlM^BffWP@3DM0WsCk1rF?epI(&V%nC&`zqoC;J5}(Vr2R?oe z_>Nhr9`@1r^N26b_iwpbOPnuahgnNq-y1tkUtQmaQ1oi%Yy6z)YvyYQMXwgVQp?xE zx6ksm@(tf-=4<5(LQ!w@uwusVB#7!G+tJV0^|)E0pKl-(z54sMTfY9jla_CQZ|2Kp zz5%|CQ1rUn*XI?}ceigS6upLW3EIk`k}t()ug8w^^?lDQF-mG4w4An zJtn@Vd=0OgzNdVHpy;*5ciHl7k$l^Iy>6QMw)?W7=(WS=`pfj~@U?`Z*M8sIRif0S=`aZR`7rz)Gd+W3h&sK4-o%TglqY^Is#(=#qzwjM|kNWfr zU!|2=DXCwHI_LYfx|#2s?-mrj{`L)zF@1mg?uVk9J%0OI!{@iJtz!N5F)Yqf__Y-) zAMS*RYAdR}sE(pKi|S%2tcUsI>YEYt@OOryS1KO@tQ~!u*!L`7o7mr==+z^(&u}we zkJx*l=+!IsNz2zO_BG4bCw5kvnXgam<52V(5bGXk`Ub?_0Y$I7V`;xpe0Rq_Z}|qt z)*fa02FG@TqSrmKzgoU~Vq->|zM-)fps4K7*qcyvq#hbub4)cwS1dzg+d$E4n8Y_M zHvV4IH$3)9C@MQV_JHM^Ed4w=cH1~J-)!;Cj{Q5`^v#RyHr^~dPx^FmY);VhEtdXU z5^GE_eM@5P*?%bZ(+txWioFFzuPw3mOm$1_%52m3v9$Yf?2#PPcPY*u5trlWs*R$* zEWTgjXx>D=UpSR&z9POW?4usKA|QyOmO?=m+#5Jn~e&Z(IJ}19!Df||09s6vW zA}ZBV_$3=rrFHB%Ywf!B{R+RRJ4D5cO0X1u!>6v@MsHEcb#LEGTdUL%Q2|N)SCq4! zUDnNt%DC&jCeir?OmeAUHQQ+zSv^NX*Ms3xLX*0ZntTZ>8%)lO6gRuoHzdNix2 zS10jx5?`YD62;e5d|k!YU3}fyM|-+^J^Q%ZQ&M|MYEMb+EvdaFwYQ}9mDIkH+E-GO zIF+JL7Bx`RAW=g^1w^HYN)?qRYNV*qqV5%SpQvhl5dUVTPMDC z;yWfKj*EIl)Cp0qi+WSk+oIkT^&e5EM13IYBT=7-`b^a4qAEpwCF-oGuSJ~~<*jeO z->Qp>6jf7HjHue8{G#p<6)&oesCuFrh-xINiKx3oH5b)VRBKTQqS}e-AgYt7?)B{> z*C0_T4eSw-Dk{5yz1oxAz`k}q-@v|W0t++GP>*4$nR zEEV-Yiz&zG-GSdWZE5HGzNMWnqm{j4n9<5!F(;g}y|uj;GDJ-kRUm4*sN&XkPu6Z@m%T$&yEb-e2T`3wC5q}Qs=KJ3qI!$!+r}Od zecRY)mn88ei7#1v$>JL*zJcN!B)&oHqqEDPHul+Nh@=jY)FF}@kko*r1|&5_Qd1-~ zMN(6xhtfD7jk=MdMvJ;v)P17TMFmA=h{_a|Eozde98pt6<%uc~HC@z9QAMJPMU{w} zD{8)|2ShCr^`NMwqLzs&6}3XtDp6}htrPXIs7FLSDr%#s-U;@2=_@KpRI;dntms`h zFu@+rgTyyTd_%-HM0^491;lq;RQI;#ybixe+17kl#H!-9=6o$ym5BOY)Fn~Bh`J&w zrk!23wx#eJqwUhpnn#dEmWov!Bwr^{y+!qvvO}b7K+2{|zM!ZaQBy?~i7K`fesfmp zTWTrX!D_$Zdx{UU!w$46Nw2FN?DyNX4)!(n4N-rJ`m2Mzp6%>t=d0GyKE8NGRqtre z!XrD{PZIe>-65&ME^u7u8c#Z&7_kC5cKF zHBi*ovXzZG*}XQhlidf;clxo)JeNJ+>1QZl(UPylHaw9 zUE+YKk3=2mZl|v5Yp;|aOR{|#gKU)BkRwgy%%CK?0k(xH4$}}sOF+tib@w16qO@ts;E_>J{R>!=Dd4pWkjh* zMfJ`ae?Q&1P^x!U78LbS@2n|Ml(To%G$>lj@0~RZ%FSvX6n)!E@2tg8bQi66RtSn# zOM7RnhNAU~-dP)3>C@hI8+oXd(`!nNc&2peI?Sq z5@}zFv~QLjX*?VDvs+BeINv~QLjY2Pe6(!N=Cd`S{tlEjxJ z@g+%oNfKX@#Fr%TB}sfq5?_+Umn88eNqk8XUy{U^BvB>K9l`K&uOH|1c%Rq@`pu{pzVi_p043t;~N-P5K#66b#4=D~ z87Q#~ln4e%1cM}kK@!0riC~aKFi0X8BoPdf2nI<6gCv4M62Ty8cZjq*MA{u9?GBN4 zhe*3aq}?IX?ht8rh_pLI+8rXT1*Elrv=)%o0@7MQS_?>P0ckBDtp%jDfV7b!ZKOyW zDbhxYw2>lhq(~bn(ngB3ks>vxO3kTKbE?#wDmAA{&8bpzs??k+^`%LDX;NRB)R!jp zrAd8hQeT?XGE!<8DYcB0T1HAOBc+y+Qg*bI9W7-?OWDyUxxTHq?Qax&6LzkNzIg4G9_QOC(n@X=A#yFp=Yt~XcWn=kRrm-yyOeDfu~`4ZoJiEqBdH(%nL zFY(Qn_~uJ|^CiCd65o7@Z@$DgKg*sq&zDFauvC<)%CfII9?iDZ#_XJI^NOJNM0>3u zNz@Qg_lmmDQZ6-pvi*$z^vUK50q*vRDw5P9@jWPNsi@7Owu;&&Ww%*Atk&k-US&r5 zc#i$#RJr(eTFRwbPO-Obpr|!du9TVAIBTZdfTCCV6#H6yuc&=f?7934qK=9>ChEAT zS45o<^}47xMZGQRT~YrLbxPC+qApAH)pG4Es-184flFoN+xKBJMP*wGSGeN)EZ=@E z?X!IQxwJ}AXC?Klf24 zwWtJ3DSX4f-ENYoM@4NEwRyVT?p9IHh}tb`ucch-sFZzIQvW0Bl&B9xeI)7=QJ;zW zTvVl~uSA^{^|h$;qP`XNy{Jpl2S1AMvZzmH*!!qbRPC8|AJh?*XepNp%rtw_rBVv* zJ#($lEa6f&ETvSHs3EiLHYSOhD=NO&PQ6Q1VzK>c#jfn5HHEI?yI1m+ih5j9pOg|$ zif^anJ1**!sBcAG7WJ1X_iQ`9$k}#OHQ7f|)f8U`$=6p@K-5UdH(JV$7T;9KS1f9` zsOLqU5OqparKn4yu8I0rlu=@DM@>=jqFRa?C@M`YAuK=GgJI6xCH!(i}U2WcE=6$>JL#Dj=x=@!c!66p30Rsq3V~I`KUt`SyuA zBB@8E#8L6RE$UrKeOG*+OD*4vx+=<;D_brqQPe?O9tA1~X7DLgiGGw3qIxV-K z-|Z@@=W_db;NGJ8ib}GSOKn_XpP3#P^`xlHqPAKJcQ{ttk*0`B6_su&mvXML^EFvx z--o?RRC7zY)RpySK9}lQW~<(1=2HSL)mMB;qLM`olzf9MrPL$a?dKSeZI>hFcDv@P z?e-^|bh-U$CwI9WX*E&JMGYypYbh$X`|5c4GW_y1Kba}2N>aT$?0k(_(Ku+d!+wIP zulV}zu+ISx?yzHCDr%XfTxy$?*e12?6W_ia<|oqd>7*U0_>F6NeJ<*&9T}GItfep; z*=fhOVy7L|DpBip+S~iErLg{Nr7E>i)RQ~yb~lT9W~cobn97~@w=H;gQESu(-d*+` ztYhLkCcf8q*?VE@ZnHOB>eOyCQjB&{U+uPg?X0NtqQ18j#+6k9=Sxw4NiBo+*fkHa z6wbAxZnL78Z||{tsKH))I~we@eT~G|Xs_LCO~ltk@;xKIXTI3`DUW-+4i+a~mQR@5s2YlxDykFaI#vG;ovV2j>dB99{ zsh9)yyQ201^IZ|8IvtqjH_Ij-SZArOqWVf|$^rYizLBD`C3TXh98pt6%{*Z5^M?;4 z#hR@>BI=YCpHi(4M%AIzSe07*&83WE_SIN5QC>?$soKZvTKvcCTJAk&M{wUUyWMr{t5Uip&J(&N=+x~% zFEfUznSSPM^#)SwGv_clA$s`Xz4hWv12?Nl*_+aN!%bDK*v6sI5z-F@rh{I_RKnNwMmr ztt)U4gF3$*ZSOiTsGkSDoac1ni1se!*O|;5aGT=*cslVEsC7mMBKbq=i;l$Zorr@$ z?VQB=C+2TpDaTx@|DaS|r?X2{asC7+l`7RlCsQ+1n0dNGSC=a0JXLCWH{8 zoacVh&j>GhP!ukU9DpU2MR4O&cLG8|Q&^FF-v|#^0Cbc!k5rnSh zqW(;Cn4~&WG}WJ?k0CYANoC`ll(Pztg;OL%&3O*_j`pEGybZRYDfypvQk+k^Xm5tpfPOTVsNG8EaOiT^a^}-unqw!v6!N^QeSg|(Q^89dr`GR5 zFVbhgN@tT~>RV!!i?~Ry1`T(^0aU|kFsPT_4LZueRQDr;T&hSvHH6|P2K5oJNWTJB zI*IGt#PcrN%RznN9^zFdzKR<$P-;;7S=R+8c*)a+OLcKyg{ORCjZ5ztNd> zFV=%ur?O6GJ(YC{>&2`eX1y7F&e+9zKl_ifev|b_tiNFW9qY@i|6=V(r*>n&OD>Ap zt7$Z*y7y1Ow^oI{#H2{3g_$wD&Yn-1)cUkAGoEkQa}`W=-)3D6*9FtUsP$=K)Yh~x zv-K$UH(*k`sqWUSdx3sFTBhhvGO5SD2UGZ%-+p!DY?ta_+`}9L4m8e8bg3c6KVXq2 z4l!JlNE1^H%AaN=L8lvEvgaz;el;=8a8D+G8JKG91>3JCrWq&LpN3B#rW(0m`_;rW z;~_BJXf=iW$zc1{#55xarW^RGd-&tQ_N$3$Mgo{_yw3hF*-uO}er5lnT*|)*Y`>bA zW*h?3jZt~z&jZ`9CZ-vSz;vTlKKW_8+OH<28QtMYH%_wuTd@6VVw&+M`%4QbKkdi% ztBGmGet6Q2{?o`q<1NjY2%T=Yr;~?9PMUESbh_~-m|u;0FTWb~Rem+nyMUr2QjX{fpyMQ+gC=;_FQil&Cpcm+BDP@O!^~n9G0T{AmJg}j&=;cU+)-dGOOHI?MkMb-a|ei)L0o zL_M>dVx}{18K2|IGHHexW$&iw2i}~>1~KFqa0M%%DDjRHrrf`xtsVpM^szYCHAP1klf^A+?J= zQRU>X2WD#0PG(TQ#r`QfXj|5TS`&kM7wENWShkbOt^yDH%p*Y5F3MRSbTYMW%bK{& zdlW2iQ0g}CC#=bzqNx;SZs2Y&9YsTm{6YQbZraADz-`_az&!m9c*>i*hfk)V`V*wMK4W6T`8{#FNe}>d;=qv7~`>38ou+m9K<0?g-x_o?2jL`e3 z{*GXtChg~%L+UJaInT6T^3k!*sfh>q=$8{g`jC%C#X2_~&krhMNdz&da}H2#6z4WC zY0MR85I;CbrASvWgW7l=5k}DY;s!IMO5h2p#mr@3IKKALr6QOiwU#}bz=&94NNr{h zwG|O-_UaCJ`j=5Z*NCMEqnYKdSKyCgjkz?JjXFd%_?V5EEtm<+Rba4s1+&Eqq@M+g z*;8DdJjLu;QT^Cqm)cyt#S!#a^(Elu>bJp=N_~+$i^0v+Z-OD!^(cA9f}dD9Ygf3G zyT*QImt!tfyT&@usi~J**Z3a#AordTMq6iu9XU>YXr4EJewjuoZE6298cS6?qN;d| zg;e<~G-By|ci6WV`s8lv4Vr8=VHmj0I};4470fdB)3_a0$BaMm9ZDUK6x+}P z#1YIY-fQJ9bL4-EJfqqg|DpWPfivomKIOgVB>A_4GwKi%oD~0yycGqW%=c-9#5|wU zRd7(xgC~WL51D)g9a2BSPqV+qMnW(6J4Ty3Wil?CHkr!R*DvYyqYEw4t+VKW2aC0A@%nL+aga9tH<9?_myQ z_OC~+yp&)@yMuDF=N{%T<_P8(<~ZgAW)}0M1Uh<5W}VBN#w@f_>F6<=^*qZ%v)P5L zmoP*1DDsyQUPS9F*|U~CA$1%c9JRog63()|$h^Xy+pIkwQ7X-xLn@MW9WbPtvZi@8 zMjh*(>>t3IX5BbGu+CtAE@?9!H4pk#ORs}|!_r%!-?8*z=#!Ry3;IJ#e+B)ir7uH& zVQKX-R);Jd4gC%42;SFG%v#J?=AF#?%*M=S%vQ{{%#do1de$l0cf%SGQ{7pglBPW} ztO1SuVGZh^CN>32A|`+Zj`Yvzikq0gD==FUmwthHMPid=m&zJzUeP~Z=~CBfesh*c zd+^Vi*Pw&?^>d`jbIC=if#^=>=?Fl&b&U(qAw_FJ+BxT2ItS58RFK!H{Ja_#Qggl| z54BS6qIr(i#8ciq-xFy*kjKY_tg$qw+89Yu1@($cq@M!YuU`K<9p$!y?N{$({W9|; zh%3ZvxGv`FqmcR-`mgAk*NJtQEty?GXUxDG6zz|H5HI{m{2M%kZy+JkbCJ${Xjz7@jo0``Moo{0% z(EKAj#b3AiH_R){f0!;!{upLUW;f;_uuJpHOj@Vv#kyB>(yLq1wZQ6Dv^KTQ{e{D= z9%_!?yi=j(^!`fGL1@et+-|IwF7&uD_gD@d!Y_xp)pso)tmak=T2R>(o@p;=LG$W7 zUZV@@bK&^4Pfau4B4$u8!EcHN^-cO^QJ%*ZSt~Zb*PuGPMiQR{gL*?0<=G1c^_$=! z)f2yf8`NjONFN^t{#3w>mY7uMSZ)Td9LH<@C0@L zST{ygIrs|}ajZ%~o^Wj+1>DseZYq}b3m_g^JjgfSX*3eqT zC6Cs`(L4`K;1%F)j>au864XR+N^3f^%xX=?iX;Bd;W^>Iwp7;*0*uvUD+rBzj@4Ot2Cn< zbh>c??985-v8~&>)za8kz;11*mG-OY?0g`0Ry((PH@0Q6?H)6knu71bD z4sJDyYZ$})%wGY|4gWy=UhQZ8Lhy$F7jQhMPO$Psbt3-`@H78^SoiPjR#{f+BrsH~dGzT+4HYJdf}bIp3nRl&^P@5f{$6AhWNGV8~(Lm_qcb#KwR@aZhRBTL*QR=F?}(@E-!iiuwj#>bxqo5T-Ka;t>+ePH+a9{t@aDSjasi2oZL9e;1KTV=*y1oPqt z4sfgD_&32t@ofjX)vEZ{!KC;zU?9HF-IRYgm>K^qm=u2t48)HgME+@DX1pFu?Z$#l z;^%=0@vFh^@xOyf@zsV<{ycDW`~x8B0rTQ-fyMFJ_fWef;Hvnu;1?ltPFQ~^j-ouG zdN6x2v1S5)pEfk}@5k)V9KZ~z&PctxO+Roj^B(3<=5VfIlvU3VRp2KkFQm=#E+J3{l2>SKUAl4Yc z3T8;%WKZ=}^4AA1xoCzTQa#y|#>`|EGFLNqFkfSS!u*l>7qixIs%JpSZH3fbqlhD!4}zz>UyY^~kB^}|KY>`ixz~;JEFHrW zoYZ5Le4nw>*=Q`Kb^

4h5aM5Y#&UKAh9N?V0z0mt1s4*yhcJF7Q+zhf;heF@tAf z8zbqQb;)IJ-5R7idG#!)pM}okc7r-@Jhe3%45=o`xDqL*_fF?x*ChN($`rc0QNJS{ z|Lb<7dFCj-S9rYxd781m1+x{i4YMt?J+mXTGqVe`8?y(q7qbtuAG1Gm0P~3d@I)GE zeJ9b_%LPyP9g|5n22c2Ru)fIrgFSn5us4klz;t8A6w0{{JmGILmGmg^g#UB!V5h&p zF2&)wZd?(^GiiG#wAz%9es(sT>Bby54-D#lg>H4MUJ)47rOb&%I665^PwXt(gZ05c zVoq5BtIx=?TUd4;5i`C%7oE2N5-;w-+}J2Qgz?#E9oRi?H}fcnvs)=evJO1h=`%2-US3X~<|}9$ zXMpL(8E{-{S{*v%qx%#`{9D%0{bv*4q3O66)Z?LpItx6cD!{RPZ8C;=%G+Wew&E_jA`2<1A*A*lpuVbLz6oL-82?QSQ2Rl=ePxo3~~K9kI=0U~|@V zwhBaMLZ5dn1S_2;pFBpf?FGLNr*~OiGb&Z3h!sinp28I(`rOa+_K>=9+^zO^q5XwB zW!Q?4s`fHPRR(%BT?OC@5!~9$)E~hgQm2`;UqN}8@maHkA= zKZW0+<*pgy$H-Ig5D|)K22KrZ>Q`Os%Pv0tfYpQxms&cf3LI zyaaCZ8gCLGWgZ0+`RXai&wGq-N-G8_nwZH6DC_(^cm zC`!>w->0&4&ehHXAJDc>|A_jN&go7*mR9lp`Xl(p$23De`U&wZ=Eux)%uC>kxbHuu zIS(C|3OtpkF}n_L`Z=8)7J*JpEbu)11@+R^N}2=szNFedV4h+Az`V}94X%j0^9;RT z=oq!lq0hN-*N^lBZ>z6KUj#3?zC4e4Z!2Pf$9sYNbgdV3P$YTy@g`cmq1G?CD1W(Y z{zW<_FZqd%#?>y9KOXd35ib0hB7FH*8uOtmZgqd)2=i6u`(Rdp_V~mAUAa#T=-;R; zjp}k2jr?`)iNDh^VGUTsOmkd;4m#%DApc4*sGlM_%GpB<>Oa7|W~6^?L&Q-UtWuPJ zOX7$>DNp)M(i8q7=75)6X}74(tyMHmh`3J&I(3(Sh@-$X2ls})23_2WbSYmWr)Y{N zj~Uc&I6R2<6d1$pI+-3<`!(fr7t#ESw-CioYF_Ka*xkh=26m5dj+{QeEO05Ak zpD|0?(F|cOa}o2EcC;T)Fe{y;FS)3;Yc;9&Ru0?jr5Zj3ogBl;VV($&TFw5|!xpgq z5v=4EgL-nL2dz_IUE?{%wVDlTQf+i}y;d_b+JmkBEr#MTdyL`?>O1j-W>9~{ya84z z=N%rra~p#hyruQ->K{j2M}1qw{d}HRQM9I`N2Svw9bqDUG%7S74=bH?BphN;TUbSj zr#MMhI%%BL=|EeG*%6)qE#iLm^D$(IVb(zJ*)53~^*tERpEV$^Y)Caw&!q7v3hEad zQRL-~iT`0f*o5?1aQP@YhU0v97j17bxO^1tol2(*?}aKwtyemU>)gbg2+Ci|E0aO} zUNag4bne*ZeXu#@q}fh6-+RT(ttEaCRnrj(&nQBdGBfyH|5PH?ALvMXvr5tS#&B;3 zb&qx))IjI)piYHO;C^tLsr>BUHt%yCv8B9H8q}^%l;1pFQEv<}h!ea`;7@R_082G7 zsCR;zwO3PWP}l2B`;KOADVm-GIqxE_Z1p_+qj{CD+;uzAgV{UHd2kKVmG%O~*1OY# z-KaLoubuyN_oxl`(fLk0H}~-1*!UkXhmYhbyuX5aWKZOGJ_3dmJ#~hAQm7}SXnx}5 zo4t$?M?Lz07rA*h7|QMwg@9?Ycn1d&dr>M zS_$fttb3v!?WDW0n%4}kxF6_4W0;7$B-pz6&gQJ6XJ6`>;h>YZ)XUdC8}2io*`VhE zw9}PDG1LG8kw!1hWhox45K_!3-18xI4W1ZHdnf21Zu6cTMtwr> z-xT(1=jW+Z^OzAHc=mwN88j=1&Y+d>=!}m>QlEUoyv+QAsYh|2gR5In>#JMQD5_F) z9>-mP(dd5%-JQX8D;U&k;Tg}X<>PrAj&GVW#-qk%(0O@0b6f`Pm+=;9v`l9I6y{|1 zPq9d;Eiz~pkr+YsH{-3Y;+a(fKZ`r@Ufy@Q-B=Iq(Z2~+DPpSQL$K0G`ieW|KJpW< zxa+beUU4^OO}yf6!J1g5yg#cSI3bJf369UAv-W~4x;wBS>&S6p22vMf zqoFcNUE$KRB~1dCIbh{U#C(H_a}3 zu^!6|sfF1dHD)5MEnF|8qbTkR<1X#siKNFc$1>B5dXv%TMkg@c_y-I+C{GHXZF_MZ ze>WP3DSWO^GYY3t{^el0aSbfxoX<{vBG;pyolJc)V>0y#u4?mWBtHQL^~Ycyp9{3^ zmrtG%V7V)Zz3JsO6Rj(zlm8^><$EGks>KWsu5HJHJ921C4|ci%UFm#eCY^DJPEDN9 z>LM73^cGSLuYgW|&N`1$(?)!)RujgKB$~{jV|KV7|qCnfVU$J?2T~`^@jd z|16=cXf%h8a$Q={nUtO%2s%jnyAf0LpGd8A(*3WnT-v{3xuh|3TS)Jz1rJj15w)Ja zgnDB!Sj6?Dy00#!V{G_C#71CH(ZF`weEbkbSli+nm}p2??uYV@jF z=>a2Fc~rYz$G~$1l=BVdT$<+Jo{=(y?BZ+Iqcok#VU-Z-1qAF7~F_;c6O zC|Uvbn7)DalVG}W=fiZgq$fiT`OIf2yTKDud%?p6R9o5f&;}geS`+as2eT4PH`YFa z_Y3EFjPp$3JndIg&hByFAvF-Upp44W?4o;In@2HnSO?PZz<1WDyh|7A+ zgZmvTn2&)s{2exWR6pLXExe^qGj~m=cTL%JTG9Q6&p6{+UqsGxyyh0v4?Rw2kPTq> zxHrH++`uP1>O(I3F_-;;^-s*x%x{=qGS4wDaL&iLl?kn>Eu&ZHN!labpQ62!3I4!& zj9!J%Ke2AttMz7@?NINfI!11xu|X_lRys*zP6DpYp{=;on;24ITRrMW)>oKUd(&RN z#@gFwHd1T%@jgxah4PQ%cwS^}^!gkAls;>o@u)jzQmNnhDD=`a(s3Nsoy-?4lE1){ z^(@Vq8*HPIS+bqp#mhlI^X)!UcF@SDF@LL&@?&M-IS zbfa+#(jCBb;}P(P-_?>>9X#Q$V11JL8GABYQECx*!r!8`f%j2=aL+OtEuZ;Qp>O!F zf~f}W%@>!^_p@5E->BL1g5$x!M8$JSl3D*odBk~`>-CtdJ5|YS+8fko%Kts zKVyBF^}noZx21a8fDbG4Z1oVd)--p*9cSor7tJ(+`a9?tp2-(D%&UND?F{%Af<=5z zJmjONrmOhrU(K`P4coW0H}EvtK`_<*BA7YwJ1~17dCK{T&7khv!NA_3=N@Nvr6X-f znT+XZ;GCWY;+`@X)XTtwiaZ^cn@7}soeZ^~pFrzkc~-&GYdQ5~KW3HnJoApuR1ZDF zcEvp}(ZF>95zm)`hxi%t!`74Jr`dmoNq3;|gl89O{Sb&10MwAkcdHL`&3^V&am|^0 zX0PH;Dka@*&K4+txocfF+FshCK=gm0@fzQu@cyeVmJh*Xd<37?@jyK+@iVADVm6@W>D)7z}7Xcg9V<)`%>9w!2-`= zFc5tj)cS7_PcrwTt?ms5qKiPS9|y7W#{P4x>-Q&5GI)?ba~IV2Lu+omg!>9l^23Ac zGPHTPnCL@{j>)|>K)eaGe2d1$^3?S5e(`t2T`9q zJ(yy62Mp@p!TlU(siyk(^Z3Ua%RQ9m7qHYK&C{w})_R_snj|*y$iZqdHM{e{N(A)o)Uf^HHkE9_zS5m2ODWrKYg~P+|?A? zsfnrX?O^6Wy8DpIHI%#Pa}$P}nC778jh%Yp2+Ci`T+Cd{q&|0Q>TTSS!DzwLI~W^I zP2-p%*+IHB4}S+a?#cW zq8}SWd0qzbJQY~VD@8dG=GFJx_fm_rZlA)vQQ)}_&&I)B#?m`+eLB_f6?61>s%I}4 zi0%+Xs)KqgsOLiGM9}q!ldnet(TCvC`b!Y&NE4_xD5v43cv3X=aFwF`1)di(4CPou zz3o^-z3o^-+rExhn=|?PC=fk-61BLU*>Ez|JR8KeGu!8oXABsKE(0&Qs8<8gbEcAi z3mDX|fmM80BB-layK*VDAsC3Bz}x^{a?zd&MBi6H{2bJ}^)%9tGp~S`T(s}-)YeR5 zi$cn?5DY~B%IsG}d1zlZUPI%s=^A=&s_7bfZt4s_C)R8Y9W4ix(Vc<;Wwg#epp4dA z4)UFyK=k{?RGVWq)nguKsKlGmP=5qYXholA!8sJa7#q~@ zf`RD8k5Znn$H+4U3`BR^NS?7^P|qeh9%h}siTnlNDQ^+zWF6F`Gg*h!Cg_mb0)ETK zL#L*rmY>h&fyh7M$0~Y9v=Vvwamrcm2^!%v-ZJ?PGR|@E;7%NqJ}tOhnNKFu=LCoG z=Ld~2@(*P_j6XkUgi-2H)*3Pye-Fy&L-4(AU9# zhYs39Iv@OZ=%--CE_#{^pE}%2Iu7)wP(61r5+@9|aSmnONF&M=2sdFC9ZeL3@9SC80!HSxh=so!8bBkAkB$u}V>%Dz%+G<`FOW8jaY+U?BQK z)-_(I-tGfd@x24BZ?MPx2JJyAn__v|!Qz@@_@-XumdW0`fCjlng;Y2Wof zLc|D!C#3p=r@S=x3pysUCznY&>j34P$ehfa!ql2l`}1c*1~X?I_zCBQ83$;qXB?p8 z{EP#%cV--*ZJcp{R_|vVpl1VS9H2AKi~|>#wD)HmpgG2j19Tn_sp@YVYW;y&CT+|5 z19e$b{LoC=I^QWt(U$>`-p0*QdC=}rn|;f{PcpC z=R%t6%!#0WDB^myd3&CuJxs#XNveaw*+o$n|BoQCpf9*ZQcUb zbf*$y2D*rOP?1jLR-BrSV|Z@ieOhgxUNzh_D>K{_xszw?Q`4w#r>0R)PEDhpoSH^` zJ2j2^IWLX&`$_KAJdPx&*MC4UQ$0P(C~|y`5+1`%&vI<@w)u#9jLu~#98abd6~(N% zPY$UwAJe{|$kQCu+ojy+PEN(=KtG}0GvlQAOZlmf1pW>Xl>L<69qKg2&=d^nVMGVj ze~|kvh4ZIyJ%Q-&KBt`FUr^4D;AkBH6P!!HOud0g8h3t~q>DKf^Mp$3)kEMxMcn4S z0j6lm^Vsv$Z;w4s{pRF-cTm0Z73Dkwu02L;#W@kggZu;zK2?3jz@5RDLCl;%Cy$wJ z-aF5dhh~pC5%fd{&g}3UQmdGx6P)z)X{IJ_^Nu)2sguBBeu~m?(_RQf5BtVYFN`<> z;;aV-^}ozM=P9aOFoE+YIB8GelMaXz-&O%Xt`1N$W?AgXxl%ll@hN-eC2+aA^Lz3%1h;wPF48!mBf~atFV^(l z52^2=YmcOn=H&bDK^^`BZAD8ED|n#crcqtWsrz}w%}7fAtGi@DBeBrn;}O_WVjZ z65M{cA?udlj>A-csymVWcY}D&ib-o(yAGSj*oZ6Srz2RZdnfev!xdnv`vmKcS>OK~ z`DcQu?oU{M$9m3H@~;4~{>J(zaP2Yb^ZrMu^>uEV?PGraJ8AMCR2kQ3>mC5{Nm~$4 zr+_8=xkat%c!)Kn>$G292k{veu!>9J=@jI|9cM6xkCv5A@@P#StbyF15jY>r)Z|aG zNP9LA-Q`cpIUWo|KLKW%PgQvu-J+bd7Xs0npz$eSuJa@4K(wcdxER#>3oxh~{!L|R ztYT(`yo zM{6SPUPXrC9cMmYaUzOx{tDvRjGAHCmTq7gKk0$bXW?8E)GC_tGy<`P29`w7Y$2$> zfeu8stj#?M;we)ws0aGUGr>=ur@)~85X|JW*v3ejEo_XWGeVW3qkYq{G-qf!mgWrS z`ALjGbmbjX_Fpil8^jUsW9EaId|t@p8D^%Y_2f)mAI{|O95~3|XXUr<8`2TAl=~`= z>E(0Zkrf#*RHk9CM7eV(0-n4v#%XJmsakf#oh5rB#Y}-bHi2D{f*=1o5zszLUgo(;gX6 zM(=vRrujKODPNzWGPNJtqiW(8bCU53Imzly73Ho2tE*zeo2&Znmg+;Jm73sbt+G5F zRG#Xn2C2@lF0ih!Zm{m~_fXH)?T5VmVZ&i*uo0?HST4#gRzAEN>gp|Ol-`QJPph$d zyGm6rsQ%Rts|ET9{vL%@Kp(^3H`SS_cVHjEK8Ae)`%HC-{#?kSY}fJkX06}R-VN9-&#b$Pbz9gL_iX4n&~tQ+ z$a#7YN)A#BVT)l;=`OA<7wE6_oiRV^Gf_X`Z^Im|*zd4wuIV7FjZuzz6x!jvmnX_y1%gn3+j{LNiocw4%nbqCjB)P847S6B~NUsr|mKG&9r zanR|o@pvfpeprsHW7rgzD{?9<7nTRhhZP{tG}v_53|Jw2Mff`lR_vPR3&9?PmBU_u zy#{+9RtftS_A~4{tO};x^L!pyIIKD>5>^vd3l7g70$_?KK|*j8J-dTWu9uTQcn-pa@Y#k2G0b~ zQ^>O!w%vpHVLM3U55SanO*M}*ssu6 zV86kx!hZLBXk7EuuXi1G1LgiiJvU*0L07^4hTX>h|G>0?{br1-=Y+YS-T3P)5T?xydtT6wFATm7QPMcgCcd|Kmqf zImnIJhGXCVzx-+0h5xUl3GM!ml!6&5IV;cZpkWy$xdj;KOT|5FfsU6?()P>TLf3N?yN zwA&n&Gc%_U+xLGN|H$$`*`!zP0!X#@9rw2FACs4xmN^+)GWvhf_O8usDGnFXhsfTozS~`+Arbrbj+17me=l9PGF6SJ|?%vrK5)Tr0AdyI9 zCKCJg1G7rHF^GO(gl4&jqN#@m`h8fukBJsK1_CGO?EYbWxBgGdgNywZZ3s;&=n?D9 zxBLBY&^o8CFD#~KknQZ#e+-uohZk?&t+#(HeAQm;SKGs8#W0B^EM9-A1xBwK(3t_W zrN)}P+ihRyXSKb$*bmT?*TeOS)io(*@nIzzMf*Mu*Ta6;UJf6JyB$qly!qpCwK;rP zJrKEF)D{_SqS$O9En&=VcUP}gn@t5TMnUi9zda87r{gg%AJ?0!VgKC(zik=Xrmm*& zDB=`s+#eX&XH&iTb~)TXpXBxW@UVtXJzLJ%wFvgJNq%1M56>5Jv3o~d^M#ylFE@`@ zM{0OK>~DsX!?QWh?^o@B1wJ%clGcpI{?%%`+p=^v89&W=a$q_xp^%WH_?V@eB(vnp5nhr{32sxk4NJ^pG8I)D6hux+wjJKB?mk_unl_Q*!+x-Bv~BoFNA&-8%O=ufIv+MY4G!{g zdOb$=nRPfKnKlX|*uuhR`zcjA2WK`-Q!MuwxNyK+ek*vU!?hJNk)!6!rSKYOVwwid z#Ex4!o5TkD{i>VFSF6LrWWl`!Mebj=Gj5R4(mC6+7q_Xbi4*7|Ag_nR?lAhdI4On6rdsklo=oqpO}wH)oQyNC0~d!2rVcGE0J=caz&bsE5{ z-D;!t(SR7hlg(k*Kwtqj-6sA{cyZftZV4i-G3ZV9xBG#4*^e?b(3w1wLg?fKcG@B* z4|F$mzFvP>cYLWyK-x~d=iITr-?YSL%%8zFJ?uGWHsu;i(1d>-Z?Bf%!{)JV+ROFB z*Y#nT48Bmc@@;4PCcsus8S5`Y2W1eNH2?Ov>sU;%Lua}sMaO)WW3O`Z!$f z_E$%bYI*iECS$wWEY5FN_rujp2|8au$_KHc4+AtF_F->J<$HxMAcgD8v->zW!VElf zcC_=^i)@ac9mn~9h1Iv!n$m+=S(Y6|y|@pX73bi)`}GDY{rd{>3-Tgg?vi&sT`24) z%S{OTi@&I4`>G6R9aJiXDp0)^MOd?`pw3F?2$LK%-4=-FIz{#1( zx?bNr?)@M?Ju{D!XrOCluRj&mt~-Sja4f4QYCzywAHE0gdk7+m+q(gYN(a`=b^ycf z4x)X$2h{WZU)S3!>&M+aqkGtGM+u#P_Q3t_aL|6=L0^Nn*F7YTza8++X1HVIdzeW) zks|a^J7AAM_aPf$1jQ}T@}Jim2v?UZ&ww4!5Tc!tU}U;Pg=6ob2je(LFk#^cbk_G^ zGDglAcbVR;KljsT97UIe?TK?AQm4y4rO0g&7BLc&208QIrGbpMS;}r$L^yr4GdW|J ziFiBUzdcG8c)cD?#CS?S4hW`(E8ppfq|pY_vb$a1|GN6J<|IU@D_pEn4`3U8wOKtv z(q4ZOuhhjtc~(6n@u8jlnk8j{Myrm18-Z9R7kMaBGTH$xVE|lE*vGtvw|+pN+@`Me z!~*OAAy5RnL(bjjb}>K?bKDv?BuB}GXI&GJ0+&Jj?f#01=?hG1JC7Q+dTOKVdTd}W zkxQzpJuS5r$Apb9rnwQx<{%svNY7DMY#*wG`2Vi-vRxsONj*rEz1#o$Ult#CUl+kX zckP(&1;|WMRcHi9^3!RTUPOt^RqgJ_;S(f{O|An$5~0~txW$SwUiEhq4g_;8~^U9epzj=U`|Wa$^E_ajUR`V*7J|F z2&6vgIqa!VgVgNv(F1yJJ^NBt?nxeu7PWx4VJ!2RplzNc5O$v|x%U*=qmC z>F1JAAj2+I=5S^6v@pi}%{SAp^;B&yLpGWbP2;Q8!#vsN;kJ(bjsO2NK>D!&)kqC9hvt(gL=FDByUDD5MS1i|C0U9w|N;UcF^`}uYL`bdG*{oHJvV_Rr=gi{9I(zJQ=T&M=Z=-MS>rzEb*YrR|8@{+N=bdDX8gs zc$*`J?Yjx+-J9(OirbVwSI%k0tkUt4PDoPY$C%e8E1A2|Q30YE{hS9TX(#$lG`+C= z(40Cr>YC9oN`E^%j48?jl>NHeOCmtjwkR%4kiNpH^o4VuiuS!@^P;k5+TL7RT7P3UtXp4sC^( z<}BW0@-tJXmo^iD*s7>PYI!8I{UZ97)8N6^M9!4NoQXwa+z+;p;M%_&JN#HdKFJ}_ z4IE4H?x-*qE3zWGDuVN?&?>UZ4s>ZX;vXNaoOa7yt8a=@ zv2zjB*rY1b`imW;Ack$JJ+6#U=NX(+=4YZOl~rsNs+@D`8FD2D4ghEOA2>lHgRu!{#$8w- zMg()jX||e92C*~e^vqK6NGmmQ?*+N48EDQ{b9DN#5)t|MHl%|}le^hpSDTl^Elaj# zt(3YjV5U+NjSiVZh=SgLb8HB6U2CP4$!=k2O==T$_%8HnhXN8CC`LUwkSU1qZ-DJL zF`RNu+Jr6~6b-yv{B^tgiU8nd2yB=csJ4A3EPU~Dx7!S>?Lxnjs!_W5&iHh_1~5#_ zHz9>bs%1Jgps1zU8a5I|EU>Jf!|<i9~>@f zc4P-3TFR+S>7NN1KGgzHGKO>>!LNTMBr7MXxEWQ$%MZ+$U6 zJsRpmA9pEbe`AbXijoRE`*&&t0@;)=cFS|5yUF+)sH9!TWzz2{7=UdUND+r}YgGzeQth4RrDY2#U_*%HG zmJ#X-VQSpMRI+1OD3VK$%--P0071)5S>tnf{>SFU$@vA0@tPHEbVG8<&6DfM3|lR1 z`Z|>>od+!x;vyp!9m;P@l6rY4Vll1)Q=74i(L}hnch&bIvC3^d3rPtw)efi0 zUbO1W?G2mS3}Qvo*ufiWwA<>iuX5OP%NT76z7^ZS(SkYF{EC<~1I3|sJUxI$iQI-Y z+UNmq5(k>5EKFawvSYNSz52ti3w`HS)EIjg(*Ew@`DgR(IW2Z`GM*x0ZLv5=kvQF|a%%(KaAT|?sQg}%%7y;Jy?l@tZqttTZ! z=r>yy19LbmdXzItl!#e0_8s&L#egm~r2u(Uf{m~h%6jTcIKSkSNi+9Pi&INcdzh5f zYC1*8WJhF}ANC?)q*p?Tb>5oN`c+|NBt3I0!9^cbiDoNj$~@WLFx;m|@3!UggB3Y~ zdE*eiqieDF)9wA^1IXDlB`Xr?9Mzq}>P2TlPvmovu(AeAyM@_^N7j3I7@J=gs`>Xm z_dBo>TP#YNm!RS76pwFz0;th@`R^J+>#=_0lv^$=SL7SsYN9qBS|~Gu1sBtx|~sza6l; ztL(7G$>!YjtrZJ{qY%qWx9L2?63d9uboPMhX2*b)ogmQ5{Ti;i9t4tYIJN`Ya)03y znYTG@o3|y~oIs>e$c;M+Exr47c=(t9#z5(k*zr`apSCMl&5K>)Am}l+m#OnK6Dhv4 zs<$tOyZb82lrATQa;Ymj-jvg1J&YQbenc1MBdMVBwniRa%3CKYJp^Q<(48jE+U|9oo4nqE+opk38vZ5`@lR@eu>xKX2=O9fxX;^~^l z>krXu2vuiryJl$aw|99(T4mzoa^Fc*mEu+zj^Y+|S2nUr-g(tsrCFsCrruujb$fuKjr zzJXL$Oc5czs{F+qF`DXaC>ANO8{2e)m2H`nn-QgvlN1-+!TgG3@jZ8^wX4XgJEd$5 z1*gM^!ep414G2-$Ov@u-h)#6q|txBL8f&o&wZ z`5iG*HMuqZ(mWM72MP)mNlCeKQ=`Bb2CGU=9f<&e(een1j&zkx^5>7;@)li$~IopbY@yKe((T42IJ z4%+e$VhVQ}Zbt%_OaY!4#S;KNXHcM#X9s-SD5$O#& zX~W$&F^!tq{XOd1$*HKNNmN39MlTI^xNfPoSPmRA=CR0sD(H(HoE+y zyz(m)MJe_(F3rWDerO%8D#%NyVUf*gDnT8EUTxOkM6&k*Om4A&g-?B%HN>8zYgvmo zSnlccsr!*=Zft5|;%Z_lX1YvNSxHtXNGf7V=;MkCX7|sbjgWDdq?f`h6WHlvdtJWI z>4(miWB^=3LEp{D0dgK@Tt@SCM5hom3#Aago19|}g7(spQo#!frzci;rpbdgnbb4U zn8nXH7fHpB_1{z&2n*T*lGoRzlpv9`GLl#P$urToMUxaX;N7sg4#cFWkY3g=Y(Qwb ziAYe;=+Ytc_~G#&%i5~1Y4j&#oho_+EIOfatJ=)Ws9kKl`c5Jj3{z}1c2~fyq`l2X zafII{lDOD&=W^iogAhoAPV$T0>){fm6?T~G73MEU;zK&4$o*qZhnI)Hs=mkwPXrd! zd51zFue+GsQCfmZyUoJW5X=*yM+&isu?egM_kF@XzziYE+Q~f=pRsY|eicLzEzK6ab-96h@>M8g2I!>~x(W@#56sY1=jz3Jj})JQ+G@M+IRj?PNv|a_ck`l^okl zl(-+mbD>QcSi@+|cE~{sE7hkcVvupXb`|~_E+8@j40*0jypo+x-N4y+`UO_sqCxm! zv*6;ju?Hc3mB*_TKCrnA7+xPPS@kM4;jx_@jm9J0vABxKR-Yvc?VmR->#)Y<02_lI zrh&DD9=g4J+)MPS(;k+VyGy$bW`s7&^crlR2)s&7MH&ClT(p;KWC1ct-kj%WVn>lPJ;Upa;XnB2M+K$<%l;MR~vB2Qm9L(qo)%kHanbs)w&VvM=P zC3`DPTwq6sHsx5jsK#=cXK}VYgS9pMSk$jVa-%jj!#l5+$%u`j9AZ6U@!J6+pA9Gy z_!c_@s3Vz?6Se^KiL=m;n6lKe>d=t71~g8ia9tL}aEWVcBjle(FPQF7LYCrPCz&IX zV6LKVR?ba%2Su?W!*{%pvRsA{Duz-l#imR;K! z6VXp-jI*9RTk*sOvJ5z#RP2e0AB}09VPUIMtnwTwi0W1?%?ys&QXO0@2(6@&i zx^~X>%^3L&LIoNuRnW9Pxwndkz)~2I{*_^5U|R79sJ=@Z6$_oFAn85gLZr`Mk}eB;HBcbg@WXgB^p~+j-SN z?de}4M{m*Ar)kzwv~x^E3wis&c-ra~THhMFg)NDx^=6hPxIi3CC)SbDcH)z!Ie$b0lQ{QnkRy^kuLJm8s@XVe5>)qgR(4u;>GUly zR|Z59!BnP*h2M5HbmmQe*jKado_;(#4vj@TABh`R-{Y~(Iz$yy_M@++#l|4D!-J8= zK+&d+@FAJG&DNx7!AF`J;5H?FA9u)`Qix$zYlbBVi&V&?iBpHo#_UGu@8bh7GcU8) z;Z=<*JG!)v5V5|D4QxA?*8U>rwNZ^+c=FfUSlKZQI1H^?$i5t^CR+{e;9dcup!U%1Ao zo|!S;-QKu#K@(?Jpmm;X1NvUc+{iN%ln7=K1{ysO>HnSsJ%sEw9*Gp z)F(VJ&93KYbCu}EzDs`_SU(U=MADtUfp570d<)mBvvEjJp&M?SD4O_rxC%SXD$p}B z*-ojS43Kv_&}>wt_T>gnF}(L`t8lf-0kxo32>ZzY2BzrIzvR^60n^>f;dWMKtl%N3C0P+T(24R<(f4Mq9A;-iuxtN>OlJ1D8nkfZY^ZW*(&d^fw<8!jd;ny>#wPBdojWgPMIWbRV_sRFStjkA`z z7xJaPi6nWs+3{Y1mWet@ucQu;J&McURQ&*`rH{7TQ#W>LV^%?Sma_d>nxY3`z<;X5zDkvdwVOLrp1;4U*E#fz(SGZ|%B#=o4ts8{=W7_-Q0>w4i`T^aHwR#PReh$57bt zZuJQvxW0U)xg~zypD5Jy>|VUGDCt4U0E1_s44mvS5~y8FcVPwuA(024PiGGtq!J*D znkX$k`WCzL&J6(Y&%-Lb#8Sajjfuy$3WSj@ptR@RaQ&c&P?Q;6jqhV=3S9Y4CB$)t z&@tLuBs!<)Y(A94`KCNv>FT3A5c~PfKfCQFqN_bMWA!aE!J&W(uEhu~W>zGj0QHLa zTgS_mX$~K?39j zWkO&9xnqc9xs4^LjZ=#%8LjZ9L97U+s&O(0PfH?eDen^aqG@A%^AbWnlcw<4&!_Vx zRt2DaiFrON2n|V=8-;J22jw?|0WDe%)pJ_nP=ihNPUY6@6R`9PrZrDSX_6uV6^*a%43l+nb0iixyDX`#Rgt134`qYw ztdzS6p3AQwM(hID$t2*T3q`KPL9!zwb*;5;1(xx*1=wZ;6WT1(Acd#_nunqta~X3S zlNB>5){@ilG(5Jjx57S|#3ocxk1`*Jb5hx?DlaIq%i1VtQaAcF#`+qw zW{M!}hkBK_1DJbz_REz5lxN8diqVONJ|qdLP<`g&YE`LnYJ*7=wUYfXVuEs4dAxW_ zr%HcwWhI~t%Oq*jTdfPtP%DlREDMQU+-1KBv|i3AQ2luUmP}EehUr1+mJ!#EjBx4< zXBQQBpd}++-SN|K$i7~H7;=ST8a`o3ek14ci^ems#H1A8&m;+B*i3m~ef#mPU9PRK z&D5wa&R5rpPIpoYXZNFa6)GUq&%2c{%*aV(U)QQ;qaDt4x3jFQ$!Yh+#AZxOY!|QYIBP`N zyTP`)%Xo({75G`3O=W+ya99#<=Zl4!i2==#3O$X3*DEtHlIZV|6N8<_QV_PZ#3)K8Mit~n zJzVfhI~D)*7B_?uLtKaHq@@!^6LhJtxbV;HkWEC}mvplc;~lB`tgoS`u(YB0?c==m zFvMxhE8-R{W3CqXJHZE_;g~3HKkAL)+%#E^Zr?i zB2Yq6%Yp>8{a|G8J(>)|1R#qy>_=`=?%~An30&HT;WhH>hd~Hm4=O2uaYi|$cq+BM z_)ry0%?*^K;C>IARx(0%#N%@=84Dq9R`Z}i$!u;s=A$ZfuDCIt&84xCDnzPwnmylr zj#M-)J1;&R{Vww~jd()tjpEJUo`5yhrvT`6j^#{K3|%y=wGqWy0XhB3Esx?i_-&KQ zWRxR^cPN=6P&%G%GKQmn1<%+KpU*%zLlK5eIy^H#@$VL4S<7Lw1(J+UKGm8l)H9B@ zMMdU?vZ)r4jmVr|6iRa?SV>evFL&R{VwVSB*1q^_FQ8g{$Cs%7UI=f*|7ZVT~AV+e0x&s3nOU*W?<*rjg4+{DscnL zyB~f2g!*DVZO9bZ!#2a}yvfNCwQLfY@YLgj076PQ%}w6DIO5&f#1u22@}t(DNM z&|=%|c*sb2o7>6J_#7P)6teDzO&1j!d_Ujv4#Dm2p+SrmbLb$K-%PBU+fnR0tV-sw z*@U$105O;TVc_}e@Qs<5e5~reyi>XV6jG}FiACGRrj@?~o8{OzQa=)xu4X;D)Dq>F zaHZA}>13vvWfhlc92vFzXtocJpYTvO z$>hG&g5?}HWVQiq5jow~hzN)zm3_7;aoS_?9FC!Nhz&vh9Cau`u52$!5XnRIf?$)# zX2AzPFwAJCzLWIo+-NT}uzl@^!>w(j?ee1~kl+@QN67P))O9-EaL8aG+CMEo`!MH^ zd0L<7Pur1k5?;n8Z978lkFZ1UcVibM&v<#`pdKS~)e?DthG8i1Lvhvs?JOqI;8kW$ zBiI2OH&$y#+AhoNv-?HyT%_;q<(fB0qyW^w2qNEP+7tC%UIrrota-A{lx0BW4?{nB z^+jL7JIuk1phc3J?X{$KQHFnsMKKM+eGytp7Z&$xj0I_e&2C-O2*`UYS6*P~G&pLh zv939bUS_a~`H+vw0@FKCZAwiH>Pn!>peM_0$OyP3Rx za#IS;N6DFuh7#yJL@nKy@kju@X|=CRN*Ayso1{ge3i+)VIj7@&XKMv;8C}6BFe`SB z3qP_^7^?@+ND=V;sNAigDoVjCz!fo!jZq6V*iH zH*%jftnM_^0`1UyJ5|#n2c?VzDCUtD7I?4WYGHkN|5}b>SIU#GGTGC~-Bwqny^t2!H}JX&D* z*>}|Xu4_Fyxs#-s>JU20I6x69DUElM!Br0LqkpKU0(AJ~VNak|5;pYaR}0mDn)Ba< zS=t&SQTHibb-qHtI)&KrG|`iaxw>Ak)q>j0&hFLzv@W*M$<=7hyYqu0-^|zA{g0ZN zijI#bkLJ_YNnZ_#+L;wWiMK&CP&i3e=i2QKqS!$EqG%n|f)K`Pb4uFn^NWmSjn5=2 zJ3kxV9R{~iXRr{tQ~3}W^)${R`MOua=*pHy3vDh>v9ek1&*j;05pp9B7^7g-1m$)x zi5Wou9;2tF1{iyhx5ig5i~Y11k89F$Z}CL+1XvsIdqm-54CBI@JZIKgR#MP3X9wVm zaDkxHj1BRqpy>TPG)HVwGS#<(k?2NY#Dr%Ldt;WMsc|rf(jn)xA9@)zwa)*v)L~;K zFz-g+-(!p+*R2YrD+r>E&pr`;iR<)=i36kwsp5zIqs}5_>5;-33M>-k5N5eau!4#v znEAJbMc7#NX2Gi6hn4`7*0@}2pq{YOfLp-#)U49BN?$3l`-L<_1vEQdBr&eFenaMX zWP^P+>_Yt7tXI>4G;=F|wC{x34~LrZ;-6S-%VP`cI*s+cni*Jf3)ZD8!x;Z;2C6DO zCkHO2_3?^&t%UfFO@`j*dL8?&T(p4D!>k@2_2f>~-3Dng9|7hLvb;!zglFnjuMzT! zb(pyDlZd1(CU<@Gf4oMdmvf^0jCi%tn=gJM&f(Ho_Y(-;NP+X}Xkid1fVz})>=BbT zg=D6XPfuEt@jfV+2Hy=|(XO7uWQv?*yV9mS!?q*7lD-)XLtdK4;_MHkQQBt2qT&YI z6g8$k;a3hVIaDAE21hgI!Fg2RIUA!sN{CX{^}yN&bU3#6C$n*;A=W*$SF6pXZbyis znMx$u>UFu-Ky!ntdB8siH0JQ|yBjT`rEn6FqFL*I1VDh+mFP^Xt4qQ*<;ZVZQ$`;{ z`ChCiXumgq(1?g8<(iQk2wBw47Pj%|!qt1gmRwjnk95pVyMoyw!78B`k zl!a4@5y;yYDPobi%gJnettIe6r06gU4In!oHyddE`m(gBA8i)K-(_w+YYtlS9Ave! zcy+ki=+@Wb+&(z`nccOx1e@q+RWrqvhiHIcv+X~y{=te|tPY=>1g{X)^8VAw*VUSn zJ-F2aIBOg}$KIw9h(i9Z>Lna$9pwEzjkcQNe}NBV)kkaRmT=SWNW6&OhBOqS=kBfd zB?+&By~85v@@Z622c+|MsJeq1TneGyA<3!oHl4RDsx}4oRR^U;?=PaJNqD`!M(67U zCaD|`*5>jmpaMyAhq7pe=BxyKA#p=d>g$os}gXTdUt9arUH>ox)!EU#PS|$QBIq*4RO8U zi|~&21ykHCrPrU{4m;dt-QPYz=*#!tu!=SVBtJ=8%$+{c>!hnNEy<@wooVRo`Wg6GTM5mI3P=+VJ154xtU09!m>YXJ z2{d1)CR(kfn#D5n-+{YuDF|z?xrpR(9aCIeXw3-@z9AMBY)3F|1ekC?ThoMWT*s}B zrCMFKMkySi;w^v}njT;s7^}BJnOHrxxMnKBEUKx_OL&}@()s=tOW99LIly-C^6L<>bMJ};lhOp&eX5^}_ z9Hhg{8`Gj|zT*Du#i`0`@Gh=Q%yJy6jODi>S#+#NVaYnHlF|R)r za{S3opAxy}ij&k%@&N9a7`?BHw)UK9fGe<$la z%PRX4Jmq{`FOuu?^(zz03*DZxB#BWiOlXlJd=Rov*ByG5(oK@PHkCrlrf($M*1DCJ z)SUq4G!S$ZWXRWGqb#2T=4iw6ij5-h2mn5L$UXrVnCyA#_!o2>fep)ImD3Zq`;Tx+ zCd=+L+N>-n+LP5#cNZ|a>vFJMSrCgU+z~vtn@1{1d{lF@bJhHs=^Bb; zJ~&^lFzSW6FXt?W&t&ZD)$=^1O(Go+*~0xARyL*f;xLJvz?C z_Q$y7uA|1L6b|Nj!OQ4lwW4Hk03T_kG`U7tTqF z7M=6>arIRw8j8abuMzQX)Fr6nl{(4>3j)og_di3L#wWcM*MIr1;Y5J zx^rfSx^aRaxe3;4^Zk?`2lpEA{gfIHT=(m+c&u@=&H1NLI7*VV`8zFZFKxy=b)zA} zDx{(!Zr>}ZV*dA1zRr>OPD0jMEp)mh`i5$1{iT#2Px-z2wKv6Gzxm1W)ixi;_J@FL zJ`T2TkO%xDu`Dbe)}4>^RdgiohbU(^ZtZLArLzmYK!{&am-jSe0$C@wTxmk{>Ty@x zKZUNM7m_d7ZmvLIq;J7fxKom{vy!O_R>~32bSrad^2`zvGp@ho<+P@tihgBma^&Zd z<2956PMOuYB<$*Q;PggD7zRJfNH&hJNq z5HnHrTDfmeB8<3Bpmimh-lCRMC!0l74-xR3h1{vIAMTVV#+tzuBot}_pXoS9soAiw zlFMMkY69camQ{!iSlLxxTiQw9lqOMa$cvka>!s?m5l~rkI?+VR5QT--K(dW?O0O-7 zt~Lo%`d`!3R?nbFO@>6&=cR&5&XnSh6QG;IPJo=hZHI51N$svh`k*hliEqj@H#v7m znfIIZr@-1UwZX~huzlb)uEXNOq_7uWfo6nrF}^#a2d^OGjdA4SVrhydly)>BR^cP+GhC? zrOB&KPJqAZ9MdFX93KZ8j)H-Ui&(y=+w#fPfklj69kSG89bUMM*N_`&;P|>S%kUJI zARVbUNMl<~oz@FeVk|DO0;7wI3w^oLpvm(B`gtc4F%0L+4Z_8Rb%a@#7*scuWbc5X z=Pi~pcz3$?7G~SAq~X@o@ItnV@~EtXli738cpcR+0=tNnkXZ;;!lEg!p`>IYM@=L~|!)r}*!nE$}x zug-xIdM(}YJ5vKJuJW}yjBKyAE3_fo2cOsp1;8$yYFW9XU(ng~2iXc+ z^I?DxvbjFI*VGB8fCsL@<`m0f`(Z#H5v zQO@ryF0w|ZPVUV4xd3mL;T-m2iM8rlwE# z)L?0AIcn&Ydr+{QAv13>OT{i6Dy2C})nMJS(iHVH)^!>6bDt(rirN-J(?>-T=~xkU znFLnlvhMkjQ#nBDKx%E`fG)tC@()~aTj&_7TqamDu=k7j=?xnVx*QcrQF7$`8+x2_OkZDDVV2ymLjxCcaFyq4Cst0k5b!j%W-Hp>mG2p!VeAk+K=5qF$@2xNd2%hNQWxdwJ>|n>o=6iiIz1 z0}&fppEi^tr4#;yNV_3&g<7{;zza=E-IvmssIEpPA&oM6iJfitpD??f%IR9+aLVp9 zNV6h1cJ{G^jazCVSF7zvDO!d2N*oEl7E_T|E5EF{d+8OH#=i{Tyu`)wK4r^7`vctm z;>D%hb8w5a&YJ9u(af4U1!uHw%_G77gTPl(B&-SllZ3sZ`}?m0Mj3`0ivG zDeAZFSFHE^dd0?>JAYxvm;b?d=MgTPj-k2RSfQtfB3rbuE;aDxru|@|Zq`(Jb(J1l z1)L_aan6UkWNg6tmmCDGB94u8$yXtH@rcNjR1XKU+B=-_2Ec=v&|}|1vEht>zU;U; zWR3}(LAO1av}fDRQwrKVMuRhjc;;+yO&ROI0{X0nwzM3d8JK32db9jyo`Ev|zpSrN z9W~(hJFzuRzDaVjEyQ`IoF~C_ep+9)ZMfLUU8-qm%|A`dTZ2T5U=ynM5{;8ASbnHS zX6W7l?&6?dw%xz&1V4a0iY*O0>KuJ%?!RTa-X6tq|#P^sUo7B|Dg zQYG7myLg491U-3!qE1It7A;6cJ&S|ml5*Zw{_bE zRV7RaEy8wDEs{0;{lZ;;w-A-Bm?fU*c6fQRC(~^)oBjCmE{&79T)A>DP|FQ`6CyI! zHX3ki?&-~z(==kos-&9|wJiPQg;tI5@0^i1(az>5s$e#*63(*TqS(rGdrp(lJU~BOgjXX?Fth6Nlf%j6i79Vs z=E>oRW)f-4*6Dpt@i+jVcLH>f%sgWyGf^ zizERv$z=GFf;T^NzoCoO)zvb;_tvWtc)_hsL zD#oOwOVprui=Wzp|JUc`QkH*#?>=^_(&A9hc65g)M$P$^3qt<&n8 zS0j8Rs>|gimz0OaPd@t-wEU^-s8C^=q?z$)WS#zL9GuF{&EDLm&qc;u&qc*l&qdW~ zo{OEE*tv9W>)&;LE?KS-pV(=N@!U;QlsV`o@|kppNnF=TTdmEEgfXM7zh=B)P;x0j zWn&rXr@_7s`z3xH z7!{m{bb9T%lp&ZZh^`vSZGgE9RFcx3kHeL}Fm$$+Un81%c3lcma4vu8=cvujgk+yb zk#%%x`6k^cePVhPqu z^_DNjl86+>FqeiKp2HHA%lMN_;mF*~lGpgX#6V8WE?bY{s@}Qy9V-Ac3qyA-mV@HRq ziBp^-lO7pU+0!KR8I_)8E%x-~aB(}>;q4#DPisUgR7{RrgDy52W9e-d1Y zVvW*ZrqRik{cwgDqMS`tRcTLOm*``>$AX_yW9J&d5{;Qn(70q%gJ;q_i`#AbY~*)_ z^B>G2nvQ(FZ`$0dC<(J2ISL#VLRD<;XejFW6w`u|?letTi^j!dIPpEh*^mqy{${rl zIG^Y*sz(EA+moH%o*Uk`jVErU!%rw^S}{f|%fw4;&a*hE1LYIv?m$%2%^aYF*-D+8 zD?%WxXXro=0;8bH&zo0w3$1N_3v!6cJs`@h|CNIN%CdY6t;ce{5xWHKXgWi}Ku zCJh!g`pZa{y6m9ar>;wP*=UUZ;VgArN@Xr`rM4MDUz=BwXWM2{yG-Rf9U(dx1kJ~! zSl>8}i*RGM*;LIi{)0(f2tlSv&7(41w=+i|1r66&9#$qx@B(_Vq~6T)VtpDxTK6JT;K_*xpdRD< zj10S{=qII?-@{AsJs4E;n5@+gSW!w3oJ&|v0JAwt>|EB#$;JBDS2;@K#WXuc)Y?Ei zN$O$hT6TElIdhy4Tnbr7%^w9zKaRos{*78a$~20NhQ*t8HUdheX*6o zmrRp(BLBT)O`$PBBpgTHA@bMM@LZ zwAuRXDy?1yZd$I6FjzextvSP4ek;<`rHl&1AGi*sS}V6ai0Uyu1mHVP=zHn2kd;gR z$>G3W8#ZxprA>v|K?8Ta{)U6A1OA?l$D5$TJArO=oLfc~$a&30P88UJN^-NQ$b|1P zYE;XMHn)p~<)H_7C7zFVyiI;7MC~={@(}u5F*+-(be*>}r+3l|gmDg3-yCI1J_sUY zaYeJaJoE`JcD})V@Y}*Avm~%0+XFAXqMVw|e=LnnY@mm4-oL;dqQ|m`=HSqc)xo2a zHik7un=_*drJ9R$%A=BJN~pA9HquGUGf}>n`vh#uWtJ+od1o4$-Dir$k>`se%?)}u zlXbKtpHBgynMqJ=pWMK2spn&XajZOBrk-S8CXTF*)2mlx1>Cy~!7vq_1WvTu;rDmnBJ|{ zcs4BIQS@*7wMCkR$N_gb7W$}ndt?)ca`X{x5PqHXeX)K(4y7+m)qed6vxKIC23Tro zU|CffwE8RWSy~V|{1794(WW|z_~ijB)e-FP1?WDLyz!V(eEwxGKfN?m0S?jSTew^T zO7#xY&jP3&R6aM7v&d}o#jw|f2?l_D{RVG~Mq(+kQAW>BjwcAw&TI-97{M@ba?vK$ zlqW-kF1(bRSd%H}Qi18Am?7*X!!$t$B{xcN(f$nF$4lN~IB);HlaPU#U0xoVb*7;@ zES9?&*d!f$lk|Z%t;9Ln;J$9csZ|~_vVF25I1+^vz$S~{`{8TUG&9(k#Lx_l*97jJ zF|)%XamR9b*J!Y=Le1ul&WlW-#-<#9vvb_uV-aT0AV%Q?ttg%!tAeK+!I)fiM61i^ ze|h!EQNtFTkq-|$*$W4CL4jIQSZHn3F_WaCQ5V^C>-#C#_KsJeuFS;-tXxWrn{?K@ zo)*vLo=stw&Y2|6x$}wWThOp6qoQZ}opirXIlB!p(QfJU zOz$gm;w?j7Q9Pk!E2FBu=^bzuG0H9&CfU)(?7)%erl=z+e8T!dU2jw}bREtLv&AgN zIz4sq%#W6vt(3U3@B3gBI8q>tV`34?>^CdTmV}sSaCwlUjGg_kk38t?m`;u9zg==j z3t?U8aibY)s$C^$!rqg5nm_xBx8P^uqdhXq#!SbG*}8Tag51`0V=n0G*G730?f30oP9N;Y@Bh^F1wo!Nv)L%Pr3+VZ?W- z>vZpVm5Wx`_sIbh(o30DpP&`pW?*>@8P6v}mlzWtbO)1bCG4Wb#&xm$#DRu=@$lG){n=){a@%1yPTlG5)XS%L>uYLlu0@FMES6}t;(ZRxJ4>Y(4U|RE z25+>RU)^bIs<>r)Jc!*J*^slWJ7)ug`zzF$VpeN!Rb-7h*PCzx>F!-WdV;zYZT6NK zA3>Dnq#pw21AGHDR$CD+pT}H=vI|vAl&IPb1pZ-2+%_{8Y8|G1@@!I~l&-=&84GWU z3nElxQW!X!w=iz%BEp&t41A3P*{)jv{w2Agx5lQ3S<}_cc&&wb68?aIi+6I|vpBo9 zxui#WMZ;cDTAY7g*Qb(<`QeISa~&c(!`eH!`VS;B$Z_0_r3T}SVg*n}UOCyH9Ga|& z4WOJ5()vmh!r(*Mu$4ycVX`EDL8Sqd+#Z9OIhMylbod6B{j1XB*+>RKaio<|c2>lk z-(h#U*){TJKZGVIO-gf#XwOO69~)Z@WAzLP~^Am=dB)vnxu&cu1#_?a|^St1@`a% zz0Oc_3gGNcPs5oRKB5W4S|Bm^26HNv0LNup;aW{Ng0XqRqPzUsn6Fn_%ElmPYvBy~36@ufl#DK4BFl2wVd9`Rv^(<+#);w}Dbj=jDpJguH2)t}hA$*hH^PRc!EHQ`07cr~L z<-$bpiw}A-1}Y+fc9IF0A`v~mlrWp3iC%8uq%D;85 z5EPboiS3hQ?3oVE(0DU(O|NiA(ZXS~a8gkrVx)#Y9tSKLI-rk&ZDTDQ-un~#J4GOa zNp9>4HSwn!+`F)(M0@(Sl$y4G*?m5Zdt;b1#doGr|7yvrykI z*(^8RVmj`9%>L~W~LTn%M5o|_HjAaJ`n=qdZ? zM9!j&Cozy6oL^-G&4LmGhZk?Ew+$8%+j!%%&T?b$?*8G)+@Ww3R0G+I zbt_k^sH}-YjJ)!&0o0ZoAA4BpC}b=ntGmf$K1DbZon8NJ7(S091UtLd;i<$d5AOC& z_Hk?)l&1SV!HGE$EWr;eU7dGL25Ypy^;&EV`N6S72DvN?+6H0yu=+e;a+J@^F)z(5 z$(e9HhFE=UYl0e~N;OVKl&bKj7Fz=4#dLuLoYYGaX2-5!=Holr(}X+o?IH*9|4|BC zvhHJucwOphKE#RxLHA0ooI&d`SC2g(WXq-_E>>;43=eUt%ZfoHaXgO4+3s*T*by_= zNaDM%LA1+dJ9eQX>?`+S16%28-o34m!m1{=+W>FDB`Fl3ep!Xlk2pmx_cF?IN-s~4 zcJ7E^_;W}ZVDb!6ePmKgxRj~$((+(|gRKVXp3nwD%bOQhKi3SPGiMtYBoIu!l zt|k?LX_Y^Q6Oh)j;8rAYXQ~~masJkCE&TVFwaO7;&w{gDHIZqX1Ls99NeXVDrA?X5 z=Y6y^=Q`1;DO42{Txqfb_SESg@+k{p*g$O^3q-DBs3NDHtIT&n(Q(uztZK?B14>h4 z+Af;hBOC42i}GcmLMCKSH|xu~9w4$VLV~6L^-*s7QO@TJ%c89-wNfO9c3^=|Hms;G( z;c0uR8mw?#Dt`UaY!>sQB+!uMq?9HZE|FWKFJNAx))d%0c=n%~8JJw9Y2u_;vzcgS z!SG^*38{|7h$DRiUVdU`zzqan_nIU=1@Vbneqyc!;U^%M%o-5=1mr5F5NLj8jL)MY z{43!$lLFgEK(95c0PQzmH_S00{RHHIo>!^tH(+ZW(Geta;MBw7OP=%K$Z0nG4@p>Y&{CDj|x85#96EDt46R~4a{!^nn|+?(MJV4KW)kVvqqJd%Ph8px&(Lj zfSI*z*jd1%-4@w~+^Ca{q)*Ml`{}J$Q>|rgm{VxuZx~BO)BL3+?A(m)vJoj%HSVvpLiT{#j|o9SZ-GIY`V;C9rIp0?wjr5Q4TDEGIFYt0N_DmlFw7?sI%NjXU>p@ow!Qi{xvCN7E+ZOs>(8lQxqN~X2D1gs5+PwOkuF1QOyU*djygzRYHE~qY( zx7;@ej$k+U*3rCr(4?epm@boBra2^5VNGJlCBf5~Kt)vDK@(AdOI$1X@~*tR-TIPq8tKGj zb?kE1-ThKWhc$eggM*G)5^)0h$bG#q)S)+S<62N``WEebygtjWX=M`f4b!5;ZR>+s zgUyaF`0V(C(bm^Fj5JKTeLB-^(>ChlD7f56ezM%l63+(DVtct{_#dp1~!ldHM6Go@meyFleaKI z=E6<6sE)lK7si|knF_I`j~f(TxKMQtz?uiE z#2$|^rM+#a+6vXpI?fhMiF?_o5>T)<0f-LWyQn42fF2_6k)@{gkQILHnJbFrFkxpRfEY7O16makjJmpm7ep<=zH;An^>4e$=ezhJ`ayuVn~e57twx*aq~T80?z50MEF)T z0o!&pf%^88wfjQ>tN>hfA_s(H zkc9$TvEAX|Oox4H!+{alv-!S8*MYTN7$1g}vq+oNPWX%-_LlhVUe09p7q^m(*6*{u z8@2%3J>I{>hy}0Qo+FfJ424}OKf5;XY`q@l9ZDE0GCxXrW~w4HLEgIHsh!Qv{j7_j z!YZWDZ%)Y308M!qVp&DjbnkK*bh;H3m{X7x9oPC}XILN?kSPp(M4W-#!fQ@$qUOUv z);kU8a;Oe*?2cJ7)bcKfV3eWKrp2~e!eU8$)5Ll&R|fk`u0`8|<;oj^WV2gVX>PR{ z*+jS|PC1Hnf^t6XuAJ|DnIG8`%v)^o+)M~YSk^-D$olyo{`3F&&;RtFKmE7(<&``o z`V(xl{f3j>KSddT`tJdc!v6F>qNZB2HKqoa$Of>}(5iAaRht!C^!ln&VOIvJZ(I+* z5sHyt)8>If7OfOR!7Sfc29@1G3-{PTYwlWLm%s|^AXZQZ@fA=DFxfOh9Op!(QDc^{ zkz-A2hU~y(IBN;xi!+jcU4^8&5BaeuV16!&fE|qd`)1hPpnknI*FFqX9E~E9vyp#6 zum1F}u1yfLC{p8=D_Y0Es$H$5aeyGxsvpuIAYN-Y15NPkd z8kxkV$&Ud#(xC8{gD6qb;*_Rz+cBsX*5H!&ucBSE+L15EM2}2@Uw)mlkM*wug0lN!sC88Jp;{QLeZucLAtY+2%t95nIs8HqoMjR}*A}9Bk>(THB@@=TnPKDz?sF~}!ZjZq88b=3 zsgmu=o88o~FKV=3-PrJ`sEXu%b0eVT_C|y+;WoKCK=)MguZ&~{U$3vN53;PkzK*K& zX?5wtE3??BP2X9a!<+gX&{QZuTjNJFvqdw8)cVzcPXMR`uHnmYp+M0M83>Xo14Won z<%xr=c*6wQ1I(lQ`3W|v|Bz0)D>QANiZt$`VySTjQEaU!Q;IdU8ht~N?ettCpTVI1 z>YvSet;7z4+7IHvvJc6c)*U42dfi-eGto&t4})ULz@?!2nd09bu}znbY+p8{dbr3$ zc6i7@SP^B=`2b9HqkL6ahoFU)B)MuU!1}BmF4H%=T7t@+mVi9%WY|th8OSjyCB{ye z@iY5b6QzBv32JA}W8!M#o17-UPJxOuvD1V?mU41a^oteR7_pGo9gDlj7m_fNI46LXlK`dVhZ=VP9+6 z$E{yE4^YaM14>1Uc3C+&0li)G@&PWw3=BKyJM0Q)l5U=EcH0Tud``}nV^On(MW*=@ zE76=(CIH-`ZU;=dFoI{jBd~UZ=*B3f@5o%_ks`;P8D;IeGm2D)-r|gb-uUsa?Xp8A zW9#5-OwL>;F5T-R`rggN&6hXsTc5G-S|8U>RkkkBt&T$9nK68JwmeJUp>alw%`VMG zK2vnxt#R(0vR5!C99!67-INcDh|o=oR{A;U-qhN!;nucxtuGS1fnaT5fsvp`=_dza z0rv&9Izt8*i3#FvnQLc>@mbAFF-ckqA*CG0+Zh(eBiV?uXa{)9&^G{KkCsE%w#0RcOCSp2D5F>09&Uz9{7iBVc?*3ja8-%Owvbju@>os+&*c@3EKo*u3jfc@nBFn zyxw2ybin}{JB;1lGTZP(z{_YM6y=+C@DUgBi)k4uW4I9+&nroOYSU|PyagOKWgemhcd3PU%8oiz&0p^Ojc)%t^Iq6EeFCDNtyKJmmusjmV@;J zku-}-(v9V3{ez*{iv`irYKEwzAp#qaNRQ*l|$+A4V1UP4V7cg5p z4!Y%sAP_D5S5X%}u{vD;r&fb(ImL&_QtrUGNbznXexe)X2ptCN?=_dsBVg(Wv&^%v zV#arhwdnRi*V&#-jxI%8(gOAJIy^Kn$@z0rsmv^gpNG|Xb8v%KcQyx(-brMw2 z8uOOaVgn!wmd>IvnzFVVpDMTbX5nr0%_GW97aLP6izB4vIVl%hElxDVJr!9nM&3}u z04Vn5=q}i%DoU`{8VPO=UpMf`f!Pk{(GJdE_6?TUMG6bpiN?M- zUlf^F-{3B!H^nKuZKwg7Mp`%61SE@HYX@wm66`1rkW@_Qxhh7~_ z*T?#~+9A~~EAr~J7v%BcLMY{g9;|wTd^KVoa}ugisgRb zb+4T?lu3B+Fw^Ha!r?f&(DVx7c#{-zE}4Or9d{8tQ~A)76-L?>9d?BUwzTW~%+3SE z-kQ%p1R516WR|qWMhmW zo(FtKZyweWsfNG;>{qtwY0>IFkME3-{|%R%H9c56fAuf5;Vi)lKuA0WGe4VA-OiB7 z-xgAU2!~KfU((75Sy~a3kFoRa_dA?+91bfarYcl|*b;p-U@}p=;cs8nwA3(#O^Hhp z^v6ZtzY1g^Hg{Z8%L_E7N)Y=>4MkAAeQSYc&KCTa|=DB))>s% zQ_W!JefjpjNv8C|Y2ypFY`=f~r(46S`g(bPu3ysJQSLoK6pDcbN3Gd3znoGG}CM34o z7?Y3$ZE&>H(4PS4bu<8Vt9;nXjmQEi| zN0{X+zd(}}PGed~(DH_!WULK+()zjhxFNs%Mvu#y#(QA4V>hIFZ1Wn&+y zWKHnDa%AfG|34f1w%{Cs7~T1it>c)<>!_TvqKun)$6Z*g;IQ#(!y2hk5;1}!kVuGM zxIq|eH~kRf!fu(xC+35VI5Rj~;2adXr00sd8 z|4V8Mbg43`4)I&!dz8sEBdC>ghbNU7U;Ct?TnpLIEj@>9-@}!C{%u$xqe^Xu3ouUn zj#IAb^$H)RjL9WOQjTz6O&5=?XMWy*;6XZ#EZ9jb%CK*P)~t?&G>O9?haKG(&?g6K zMD99F6Ntr_#dbxqcwE+yiy*K&)&K%%UoC#Da!mJcUljfwHNPBgS6@(el-u0};N7z3 z6_^(8IHMnt;E-d&`e>k5a}ZTxVzhJ?T2AQXD}RIi1RLYF8<$cT0i|?w5z4L zMsHfu0y0-z4@niYU;^vX1r-oWl&e0!dI}`s$z? zuiS6ODufHjB8Hzt33Wn^F<$uMF2O+crpfTk%~V_ZCN?`-H`&^f+{iTuNiWberc@A? zA=xv?q9&2cI)zM%2OEc{T!>P&44KY^QNC$5wu_&dLMEr6pC%u|_N?4~1q_#A+`+E{*ZHNs%1KLO3YrT9|EDQ6Xb)2Xfzk{{1hDi;I;RiY2c2 zy2n|Y`)e1Dr z7x@i73^BT}W2#DtL8{>r+s2r)1wYz$5>QT#DIB#nb<#w3KpACX zDe|~=&$^HyW;}~K0{7xV-fJth9k6KhWZ1e6)U{C1J9UcHaZIYCLn#+a-uFOXHoL9Z zJe$A{@YCtlr2e1U6q8s?=i2y%NSoxR<=~;0m#rfG+VrJ~olRN>tdOB>I}pa2B(Yt$i@LVRx%9&bUxZ+qMekC8zQCyUhzMvi?~7{q^qBZ;L)OvNx3C0M92eapq&S5A zm)IDh<564s0G$tox`Oy3|4TtNCjd zu1pb$L3L+4rY+(Uf1Yf6S}HO!zFgmXJ zZ{N>$;OIh~OBs2DHKP;DW)%B`TKFKYTRv)+`l5|H)7V=$8OQM%j8G3t1|R(?7zdo= zl)-0caI$pUG)$J5mcQc|cZc0UPwZW@oOTtbAr1LJ+$!_OYYf4wQ8B5+wCT}m*$WZ0 zkGjXQl5$Qx33u~>{F6_F-iJ!zErp2=7&8#gmZ5^l9oTjC7o*}zznrABv z89r;a7Vh|AQTk_=-y63%>I=XEVPh{r_23KmGIPhX+9-b?X?YUUpNX30Tw?TUkLt<{ z-z|O^UAKxdPNIaG!M5ro%{S+*2zR_2xgJm57es}P!>nxFIW#qQ zbrML@<&1p0-r7jDneaUM^fUM~(S7b?lyqFo@pLM0j$nHU^D(+?S!qerx5+-Elt()H zT-u|}oo1SC;Uw9y25a#iX3Q>K4Jh8v_NrdYi;?0(V^Cn4J{z6tV- z)#Z@ns|UO_K(0zR6r6%QmC*$+!9IaDO(UWSxq_kryxQG!FgGK+_^I1M0M7Qo#Eipj z$^#@()|mb~jcE$;Bn8l>y+mp&b2^M5@%o{EZ7lM`Hh3w2do2Kmov2htK<*6aJh5FC zCnUPM18DWF0UaLiBq5;v{vlr>wp|#&+=Z8~KF(c>TcmyVvEhH*qWyamA3j_?L3LbI z>!wxHc4i@?7`1Z-bR@Mkca*&A!YIz$KMOokLp=O2&eC_YiADA+hao-_O(2U0BO-;* zNE@1_iJ8enUDs+!IYXIjJWB+NSOlLO79Gd&*7TxJsZnOx%;%xqm(XKI_w zWM=F;KbO--;dsonwfP>Zl#eokyWHrSr{1tdR(tu`*-k}uAj~!&ux4lBiYxW#3K8=a zn#RT@xTl+slf@>c6{~p60NL;x1Y9oYI8TD%czkT)We6i*4%6H>!S`zhNOt!eJpBVFI+5EKg$L|WDw#L44Y=CCBr**6 z>ra+KZY5Y|;)O}Vl`tMs;+oFJeEIuTH#kh#rH2Qs6xR?%H}7pE>%4d&QKVV@w&1Fn zoTCqG1GjhzKFbyP0n*&c=0kkHN^HYAD7RsEi^+Ao zu!B%~hh0^mGEIO=Y3jLD$thI_@D$~cUd7VZs@I>|;qc5Y#BvV@JqJs_bRSdGVCg1M zf2$^B<(Sft z9ZtBlE=L~1YCQmAk1`?SMMn-KupYin$HOQeNr!w)_1Ry+_MxhIBO|h5zjOh&-_wH< zb#Z2dZc+qRpiKArSk8NErnenVIXwx%P%}Y-Lfk~_#)%nuJhjh2@!CEE#e@48nonko z;juYS()+eKN$n2iCt##YrlA@~n9ry&(B5U~fQV20g(W}JaZq3CQWokJv6DKtk0QW2 z?pE<^aE%Ld>CilCEIp4|w3sTHB`B3FLrimT>=m#m_qn{(kU8>K_jMyDy!kgfYKu8% zKg>$Qb~~Ejp{8ltACs-uGXaOg?#J5oVRyMJV=>d7X-|~npQMQ7fyVZPLU&B z-Dm?4n`nfp*Xt}-TKsHJGB*(yL3C6aA(@yMMlx~Vo>CkCW-DIIoWbH~rff96cbE>w zbA^vN?Mt{<;G*1Nx3B=u!0DNkv%Lqk0I2t%_t72VYtp>i_7TCsiKnuXYM2U?E4Ytt zEqhY;cS*9EXEE9iy+~bv&eCPe#e_>m>O*cxe0=N9*aGYRpl;K8e-~o4S;BzE*1=l# zB7&E-{4vtsU+1IL4USD$;3)0vil3%2m3LFFk49~vV`-bOpza*7#oy&>^A%r|7kVWt zzTH8um3h9w9GXJz{Nn$FnbYZ&1AQ$e2*C!LF`@7fYW=Ers=+OxF(GhNH=C zPup^hBUgO?#T|^<%#bqSK#03`I%2VD*gF`U4H*%JfW%F68C7wu*;nCT z8~({^pNK0_-$iYcC~t0wXC|yAI`6Qp=(J{q~ym}V>faJkfOo;@a&p< zVnEj@$y+qJ=}X>3v}C?B*gICQyjWR#*~8|>M!Vq*(;sze)N&sR#b41p`C7HBk)tGx z=N(3aW2meB;^`MpQkJ~DAepAG)Ka48==DlYwwAgZ3oQ)~3K}e{{jUjrxxx^HS`?#S zf0N0DvIHT%=u0QN4x|0+)}a)yv|u=p=>~vYu#J z7HC42pFcJ0Mmhi50(>3g^<%AVi0lWrWKR9L!nw@5yIk84O(RQxc-gDuM7F{k))zbe z@i}k^gxoa61nHQmlBJA8T_XW|c_NqFZjF5HRM&JL4qW@%-m2$JnOz++*H>&hK7sV! zjFo*_1v ziglP~X}uC}rlc)mhoj;}Q_ex8r)y1wttA(`U$@t6!sdzNqpW5ZZ@8<3|Bj)F5FYwT zo3*^fAFTXc*`8rvzGFC$lpf9Y>K~NuAMh9cu316HD2JO3jB=ySlZ0#7mvt&KYq}H{ zbi`d+8&%eHc-}yJuVIEfx=L_Vh8E{+)Z!;AdO}Zs(xxZ#RcsF+1@4YGAjR+UQymaS z?8ZFjX!U7_E}J?rTNqQ(m~m9Oi)}pNH1@I_F*M$jcnw4BQ1b;SLEY|-mLa}*wt33W z@Fw2i&tZLy6`^Lh!371~!gr?cmE~!2*w)m98#Jlu(+Tk6r*85mSUoezA7?SEV8*j! z_MP!MI##b7rOx6fg6AH56~E$^cK8urV9T^P-Ri%;*5Zc(6m_tm*XO*ajHf!?Rmly= zcHtHP4h9_wvm2KW9+%g5EClD_{q!*_$jxh0t(XLbZIZ|b1YDR6Jw5)H$^ycM{RavT&T0}#uhX37X^-pEGR&-!6^lsk$+Rz)#HOrVyJbJakB;x*+&r= zyPKh#bC;jRpJJI~xnCVby5KSF*Feh1C1v$PtR40~`aDHz5_g@@i8!;P2x&+>R90Al zAd+gVWz16EogTiFu}YfJ{U*09=G!Jq2+xQLx;M4}l!61Qy50GV83Z-!J|ZR-XhJO; zr!Rw8*zAA`VSo01fHa(u;ZFPVAWJ1?HlLc?Wbrn}WuvacUJdmzx;mnzEfZ>mQp1ns zp7bxT1bE?1i=H%E+Rq^wC`uXIMEK#xv3vXSlIL89_dzLp?)z^XlfZCF8Byu$lrQ zhYD38yQGM-b9=nIMv1B&iTbH2aI)k4G@ogbuGTc4q4yFcKMp(s1?|@nT}+Cf?-}Yi z=CTgBISA>ULVkU``=spqkxIw>`*2Xhn0%eeACZN92#z>s=wkE~B;keH5K%v`2UsiY zI9I$PR<%~HBP;FWnS=kIx3_JM>&VeI>j!N(w%s$`vk{7kpd?D>v?QuU+8#e&xD;8U zIO1DZk#ci?{a*JCAT!UYL)o6$XCrK}4)Ps|L;^@8Qrbp!5?YXHH--|!yQmuxY_pCa z*50BjK&&-ZnGQYKsV{F>+L%T(j~yvCcfJnsEzl$>WNaxg;e2|SEnM04XqaC7A#X0K zT>p{)HI@G@t3o z`1Imtl8r)5t66}*YNs^BnTu=K`a>Z^Yg58le#MZm0OO}(5b(^- zc7Kb%JM*sRtE&tWtiwejDXiC+ znAsXI8?j^MCQ*0r6^PxjjJkIdLq>`YK``Pis`Du+m(@0wl^j;)8waYDUnDGm1+w`krp)tY-UX`Zm0UC{710Ts+QOYXuN23?tLj^s>WLxy{> zoAc$zg}mb$Ep<};FYlRvQLs85cy(u1(=Zvx6)V+ueilZ-(6%S)E6RV~ z`FbRK`IbUfDzs#I)kemSq5Mt;FUV<@3yYiIu4W<6LQSArD|YtKm~?{hT06d7NOnCM z>k}iGr7tw=&c*EROU0`t6+UF)s(}D`dVbFH-Xekq+W0JE4o%-P-+7L3v3l^9ipxgO zWq|E>9Ef{(%!4ffb-MDFLlViEzg4F4i;qB_CpEWkZg0Q*co!BB+cLKyk@8^G4E%d_?!`**SEYSaAO!P#Yckp9|J zqC|b0iA;^a*^&JjlqR)XN|+hRxa5^Il$OL$^^c=pg5^yn4l^tQMWgyE-Wm`OP~p5^ z+(+19Oc?qpJu83aA5LubWaotvIAijUy?n)!&-i)5K&~G3I5eg({rqrw@wt9C1GLgx z9nR6d@b9>aS1ntnp1}{$$PULQ)Fjc8{I^Ks81gUA8hv8DeRlls64E=tE|n{KCjTt6 zd(5^P#K(_6DY)zR`sdI3=U-NeV5{)^T+Du~^VQrs32w%gjaADaXm_=AsP< z%=&lz^+PXxWQ^M%$`d`fX9Qs&^fQKPPF)^Av(J;OBEgeOA4<3!`gT}Ii5K6?N@aoM zP{(gHG^44fGQSIDU}}oLe0BP;U5oKVDaYs-VDs-;A>&{MYimel8^Wd)IZsRX!dyo@ zXt%x6TaLYi9%i|E9KOZ*Pp=_}HoJPtNZbyU9=5`BM){G`IwT8%L969p(udSBrM*-c z>iz{TPInzseo`_%ho77{>*8nN<=VQL!u0g5Aufh?R}6Ir=Z8?^lr^u8_8ikx2q0wV zxU7$ZgC*&6Cb@o{=*_HPaQc<}jj%km8iifYfLLhzP*36wrPZ?n?iimk!vQgth^z>O z2CI|zTKsZr@$-b&3=lD{+|&uOwgYs9z2PO-;w! zH&JU4`8G{d>b(4GE{LKz1%(@Mq^GhLdT6WQ>T0aAB9}!sml*e)r@Uc?JsJ(%sB4J&gRpqJAB{cHH*?eT54lkN{U4G12NkFsy(99<( zKdf=I;kmEl+epmLp2OET#ax+oJn z>E@#o=seeM4wfT2JjW4@*Q1ntxx9;>UP;PpZ65AqRj-c7ef01#D)3rzq^S;?W|$>L z`_Y=al1$>xPGPnu3>%o*b1$ZSa+wa_+n!;~=O5yJ%ZE0*Hf&ET$tWBAx3uYTv@VWb zIFPfDSa&75S1r*a9%~g~*pc*!7}M(3x3`5!4Z-{el)3XQ%UD5EIck@4gQ;Q`tfcDt z)`81Rj8HKMXa?PdC|~ZwLb5m3`L_+%t*sHsu@5HRV=B*a_~Q`yKE4R=+vYAZtHHQJ z>Kyu%k6|>COs;sgjJmJW`|1Q;DLRV26hHo@e*A0w_)GoxYyJ4Q`tg6& zk3apN?H4*&)byuT`JY*7r&EL10zi;(@-|G9m z)%Sg?@6WBiKezh0{#0ma{rhvP@6WB4e{HS(Ys>eqE#JSkcK@}PXzl)M!_{9}5B}16 z@R!zuzqB^EewDrYOKamVt&P95HvZDu_)BZ!udR*0wl@CS+W2d0SQ zYvZr2jlZ@w{;jp~Z>^1gYi;~nYvbSkMU-eQ^yD0KEkfes<43L+ITDKB0r zFecp7?Y-pWlQR)E7wk7*R7I=;e`Ut|TPKpq7evWhi(!3p!Hqls=W*SPUu&^8>hbNk z`c{_HGoqXF_w1T`3jD>a@4q*g%UD;u`4n=NBz6pMGP1jp{{3bBNaVY7gv-l#AJMGS zx^x2_5D_0g*4)T4O($e2mfk7lAwSMeZ*B=3g;VD=|3>CpOQ$K|Vr?yMrL*En4f!k& zTPZVf7NAY;mtVvfLmN>S_ktP@^jl}+bdh(Qu!{+|imlUoaJVUO)BbuQg?lP4)l*Db z)ugf?Z;+TciW%ilwkp}~_CCXb)oW@ZUgHzkQ3vmzN~8fi0X(Xe zM^{TzBF&AmYiQV^TgGik_w4=YBbuGmYsl#GTv|%dQvyakD?vqllYE^%XSqfi6*-jI zH|MTjm=6j`qcAac)SY30jb$@+mm)){sU~V_o@k@b))N_ah$@zI5_Ax7_IGzQ)rsAa z%u<#{QCSv7P)Uouuf!*Mez2#A08li(Cb+2ZTg$|u-TlS@eMQ6P!YZbG|3ZaB<5y5c z|A-maOqf`K*WXC@6dJVhCZIEVaYo1%L;o+QXJ4zKf59-xlH(-FO zKX|$S?)c!WfHGXJHDmj_432k%}Sud0FlH&i59d;dQzg75z)IgYZwt5;NgOpC8R9KKz> z`jP&<`jOIVgK@P75-;Pns3s}F}iuZ|cp9Z@?+ ze}Py!i10-TaV$-@p0sXa$+`uT-AZtD`r2M?b9I z?|*oqc|UxAvj2De`!4>xG3X6wcz^QRzhCdu<-HHTxFY|G+J58j)vj|yp2tVzr1*jLQa|8sd(YqOdwC&nNyj4>UI)DY@XIf+ z4noa(yZ4{Rhks+ltWw!}sOP~Mk)vXnK0aFf&?Cu6A%1)X=>#_g1gkI{OBu7_coB4@ zg=vPu4mpT1#Z3(51dRuJG53m{-TU?N{443=nA<6OGok%3kWeJ&*zR!1H)pZ1NK*)= za2b5@61u`O06wLYIJ&aI^G%LOtAvODPwkkujh`rM!w!9cT(opJ`#{zmYR(vh9d zFtPkNt;CucS8aOYlL?-p9OA(ZCph3g&M>?Is465wpFUuC7(VwT7W&Y606E-32SNK((JBMyDf@~cT*xLVe7C8Pl ztN2Nh3OgOHJDNyr==*E}$oSC6*i_{!6rQ&O814b+wx}^np$6AM`fhGK<8l(l8rtacd^SS>qW2%EOoa!HXXyo#m2FMOi8UbNB0lowZh++gJp~^ z^`SKoBQ@!Zns_X>w5+m%!66F7a`lC*4uN<>F7HX3N4y%oRFRg!_I})h^xVnqjk0jM zjO7)X5Zy}DXg1Z%fc@*Wyqs#aDNe{H4&H@dSHYb}`R|+Uq}{5eG0=J1Q)LWa$gjHg zt}LC&ks>B&_O0jQ=k0`Ld7*QWu+S2&3)5!Oc>rCaJ!$P*D8aPym1_bZe|O-{cQoz) z^B%JR`W)VD_I-J3(ElH|urR1U&;nk{Qv|r{Ggx^>{11`xzZW4-(bE428FNI4Fl*g~ z%Xue&zVYnl>S^ILH?2eTZSN0X8BHtCG|N&m(;U5t9P#Lv)%{;|w{mFax1NHFJyi5Q zZSCK`OXs8ie;Rwe#*b~dQa;s9J@tM3#R#j%$U~#;>xta3W%g?uBTlbBo}XI8lXpEe?t0kCarj6u?%Q(sPrP}JP;I>Up0he3C=dn-lVsJUdd8jSBh7})+S$*r=4Y5;V z^i)_hy^|I9Q?;u(5g~1}0PcI7yp8d}lX30guDIFq`e4Gbo1t9P%2>+A4vNt9z(M-u zrt*a)?f>}Q?8Xw9x7L5(aYVC-$u`#Z>pnXQAMsxis7R-CL&7U2SY^_%V|uf6i-4K? zJr2>Qdcs|^M!+ zeEM8|oR=wTrz0!;O`(CNCprKHZA#N)#Y#!6&rxw~KBOa1d=(VSHwRs$=Ap5)@CIxS zDQLCn4VYzIRf7`xp?v+#(w@xJx6Em$m^sXhJ}=I))BT|@sn(@wh9+Q>^NB3IjvBc6 z#n7c}dIp9NZh!sp<{q|=JJl6Y5SH_8b)j!5UwPrYZZ>rdG_D`jXuDTqLSE`QCOk&- zlkw#legaG;Knc*mdLFZ~#isG03U>(aqdl4(9QXl%kR+%v)O5{$Uqjz0{nMY4wLfQ} z{K~CT?-%u?#83szWq+sBER1Tvh6z=Sag*IsSb!|795x6|B`Zej1cE~q=zJwemfRL1D zKz81-P)41o_VzX`i)&o&&g?N(-MxCyy;x3vIU-FMH}ZA9IcBp!E8-e~b`+WeF^Y_N z;^LGcEN7csL}$bd(h}aC2_@FHBc7=5BknVgb-DuGbuojeUJJU*T8IVAsER%+uU(I^ zA}u6IBpb2VEO!zv6v{LFgAgnqaMwzVjj-?wiU~@2WEf^4q1=kP#L^gX&#gy%yqlP) z4mVuFcaSO6ejOSit#|;60hpZ|yuWrJ>R9F5(+z~tyLn8Mqiu}OP)$@9UI48g zIYCeJ_NxeSm0`#|`jTb$Cf;WWbG9)7hu3o`l5?rdVJ6aC)J9H9_UctVJ+>E>d9%6dB2-I0yOn#wvXqK9#V)KLML%xajcIy6CuEiej)F7^?Q|l%o)Znvt3Uhm*%s{*Ib&$%l*{dpw zt;j18j|_87bV$x5{L`tPuaQDZrAvK=8wtF;;0*8#gov9*Q$#?ZgjkwW>pr{aP-SUR z2$+t_+gJzvvT?xy#%Kp7;3}q+$xW(zR)l5iJ%q`1UdUqWwNPZX_C%hx)D|-x zh-k31+xPT#ryaA^490U6!Et$Iuc^|o!iYmTz$T!{M=Zamm!AEFA=Fsl2iv~cwVQKd zkc$bN>@d*v4T6Uqajy_UI$-bozX*15d~2*aM`^H5kX$(=5+-!F=^agWDHDPC)(FjM zRDytvm*>2Wr=wtz*oZHMjP+hGVzn6!hI}*p{*-QPojAm?;{}f?hXuZgLm8p!Eyr^| z-q>WyMS*iw&*L6du|rLZr@m+BLw?gyg;{0GQJSqXg?-4hqt9_;)i=xfFaP3HW*|kE zSv@*+n}di3f%`CPd9-lGim1h-BIXT_O%-XsrAs9*nT>swVBI?61yztQI;HYjJl3U)O^1Lu@>i8TI3%yz5_$Cjm$ z{C&5u0PHOmIQ~_7rQDi-+;>irJe8f)$K>{@c;Pc1VW1`wmci7Q#0WIy1avc z_ihflDk!6K{~9h>J?(Rip zT>*))sV{6A4g78`S%C26)C+M(Sk)?wl&^Rit2oXdNB#n{gd942uu_3%f4aO4OL@t% zLoU78hJy=F0*!;^`rhFu&S{B$I)SH9!M!Y*E5;J>Ube^wpHZTW+#j8Of>xO4!%sS= z2vfG{Ysk=3MuWuaXmggdx_Y^VAWh5iFM5CQhN}|zH66(r>F13fbJ7*D!%rYj*OL{m zSRwQY0tJ?QqO7RgI?&c%FrXxN?Cs^2xFu(wGZdBf`%}D6&Z`#fDsF-wrga~z-fKE< zACl_Hi~DTBtnnl$!x#?hMJm6aGa=IY(Zkv2B2C|QRR_cAl=Hn!r?*r`n6=!EiT!5&7#jGpe>=)eglEFBZ7)S&wcs^b5D^^9& z*!#=7wHP~m7n9|O^*@MqRja2ObJNs=SY2Hjg9Ugla)R)N{)e25jMmOkVx`0sX)@PD zPt-|^vWJ(yo+*rlMUGbogxkg5CbXBe*PTUht z&ND){xHX&gsr*6zJ130sVATKUkg}>^akZnz&{rekz121nd-${gUXR6MbK0hx)5#Y4 zy*gL$N2n9}4euxJ6)S#@gSzeeAu3E&tdy2PsOTXY2_V^OT!!Wz4PqSw=as|l;P7#F zdiI&9EBG~FFT$A$xPv2V9iqI7LC1IXo&EY-TyPe?^qX1FLb#nX($a_9lEl*$QYzYz z@4W;$e6dVoBb;D+dMRSK+KdJ_P-XGlTEr3hnY||rIpG>pYtm<=a)CS7c5-DuKnpSb zjf|LiF=BcHKgID1TMekIkghu7guWM2BFxQF3JZ3t*DVN=C?~COB#Y%UCMBe*p0yO5 zqE(-*#ST91QRWkRAX$<09ZAK(wq-b3ftOcAcV|xxPqbn~M$=+S71_yIfN=oYO7O7E zY1Y9PlB_MVqZbs1la5Cme%e8=L_hV-ZY=^r>nd#2q4$diZWrXXUw`d4j)*$Tm289% zVoE}(U~@#SGH+q8J-@w!q zfIM|UGTN^Xr4SB<7zZ(c`1wpbxiarG^(->)z^lM2D~msbxnEU^ev8#`xyAe%(Gbm% z179~3`L|WfN`QuSsn|uQ@YQQMOYrc8bPk<2uxaG+&vF?g6a|Z3PDIoDeYLdy{j}bE zT&~Oa#c&4(W7__Y*1s>?MojLQEfn8u$!}P!`^uo9}1d!nMlEc z>Cxskpx>T_$dg!)j|D78Ldv-9;q+)G(st0f48Dv` z)uvQ9$IzZey^-v&C#o*8rhTdwRd&*`SjzO*bWZS(9p`~yW7J% zmw9=+-s(r{6j591;@LBPoKTKM%+^^K2gBynj_A|IJf^2S zcMxKaLe6GV>#D~!2 zQk;Gz{qNV?%@<@X$z0nNC7c7akB`-toySqqTIMj8^&q{QT(Sd17PJr*hqgk=*eR{N zZ*YD;lV<|0XZoW(HHXpuE*+XbmME7Ui^!ba97T@!_Czw;9 zL-7X>JZI5K0vv2>a-g^NlhX-=PDL1RX2_YDrMe!L=aYv!UG@3>`OgWe^9S;~r+=(V zDiX@+@9vd~pxFG8j)gY-yIc5!9r}ZvX%p`?dh!vQuzkP!;*Rhyx|BYfzw>yIeg@@| zB!MJmK!h1KkSP#;Fri63mlzg3JAU*}Z(wq|xe24p*<}`ni>J>UkLS+CYf~ z+b||uua2aJBlTVj>oG^_T?$bXS&g}Vp%Vc0YriZOMVBqX2Q<^%iJ z5Tb0$*lLTbgQR?)NBC#5)9WpC{w4Si{}OEH$S;bAm}cau_vy83&kTF(r6r?g%8q+)A<)?J0!>`EiK@%vlFntxPjXVL3v<+X-Ne6UvXRDs{oa-Ybj zDrqfZd*{Xkwt_a-#Ddofy*rhKXWjZQ_1A~VwnMT`m{)mNT(PROha$luv zcasujy9tT2-Gn6s?&g{yZ8w9lwF90NgF{NM?uc837fFictL&t@6z4euAm(xta4Ba9 zA>2NTZ!OG&ZKcJbOZ%#qxC79nsQ8??@tM2fzrvLV`50vH_I!RO*QZI54vjjdL&>Ui zh(1k-FEP{_^^kQ3yo&%^fLsJ;zOh3cYs%8U^-7Qo3v(>p564Mu5@zQhgjg_oUzUo<5DWG?9J`-X` z5#kkSsa&{n)H!pEF@N+!*a}&?-D%TP)vKtYuQS;>V1(Q&L87Sm4@o)_??IHWPSt=kDc;iGSHm+n(#nDsB-md=WxOHo7(D7^( z8P-?smQv^g+IC)hj!aLjv!zXUHMR*3w>6Yfc6yrQ(G zyVp$RMIBl6o=#mF-jJI|ovx%U5YsznruX5+RXFax*501D$4V5ov|y1*h?0sG080pP zmt#+v5zo_P<@t?iMHV^HmG0HECn;%%^*n2xH(BkZKUou;azc;Tw9y;cy=4UDW}9Xc z4G5==+l%;!BdYjqgKYe4k@~{A7}R~R{rU4H_L4iapB42YC*Ul@`P}&Q&{@yiK8=dc6U>arQ01e=)E=L1Sea(V-tb!5 z32Ga0w#gFyY@86h2V$M3T-gkOwUQ~$&OG~N!+ry0UA6l5d7R)HboT?sK$c%FJpogJ zwZdT2{KYNd%!4g}{+|3$`Nc!phf?+kG?}xdwBa-4HZrfCb?6SYw90xOII}QTmo#*u z5ne6gxhHE}!%axG9mLy8b`ehxNG2RP$!l1W5x5eTtX)P9Ak0|g;lx;vT$Tql3oq^= ziq)T8J)Coi>;7|PS~qQ5BE0W@f$&pLTl;JDKhq z*z*!IFE5no#O9cTPwsF3!13o>VyH7<9OHCgq~k9;Fa%53^GobfK|JSab3gvuO7UZL zFs!6buUN|0jw4#HJB2wl<9+xfTV|H}<|P_x(fRfO4Iq09bFiwM zwC{WVtqPnKAqYstHMC9Rm<{Im_9xnaw?TQ_rO-CzH;vQ=(3A5UA`PAKkJeLW)z6m+ zdcof=jrM_A80FU6m5Fqv?8>STf4<9%c;{O&stdev~#+Z_#F?sVF_ayfW6q>{XPD68kegPHgrvwIcec3YzZe~ zg++@7U0JYweu_jw#9a~dfy5Ietz)xS`YpQC?=4Z}jqWoL;KSeJTU&JE;~ER!ojDzh zD@Uz0#lGM#-4rwS9a>DgMHs~OOMPR6`WaHt04O!KR#dNjT62r#2Y0mhQfzE7&p&gB zzusuOK4KAPBOz)@Mu-!+1W#un4w;R#=-SU4D^vl`x5+h~(_-JKt7|eT7_vfB zIFP7rovs%q4|%4Y(-Q9Ls-oy%Y4+*@haWHjy!$ZIxFEgRQj2vEWl%+6nssu|uPwe0 z$0x%B^qCB**ar2X99}})KEvNf_XJ-Vk(u38s~MF{WVOh?}Mz{jm2vPfw+h-XGHp3<=tf4vKnG zc}W6`gE9ty)O^OFA4^oDLHYBrx~CXW1o{ew#aH)UEjv!cNnyLcuD6S~{H)VK5F(%3 z&;l+j_{7!eV96}DoI{EEteVW996Qel4?i_{=H9M8!Q<~S%AVaqe%^vWXYSFP{~K|_ z847^b;hg>Z634lCBi=hnOCX%Q4`m@=*Q$l3HG-G+CsdM;_j=L@hx1Q)V^1Dk*f$k} zF00eoYWo0X)n!ePWd)W5Q==^2EK;1IL3hGW>&ZvGbMMs`d21|5DYa$c;BEY^wxx&S z-=H@w5j@N^>XW<0pv~Ls^=aB5+G9jqjt{HE0HIGi8IO2C5EJT7_Jrpe`n`?dx`$u( zIt33@0ST_C6yiLmDFAp3j74-rFo<|xs+Ew@rceE*9FGJ}!n}v+G zAsZgv#QoJ=jhUqn=3v_g!nzm-(FRZzLy5ZIES+A?3>*(3XKw!?J4X|7rIFvA;wV-? z#6nB{&Ou2c4`3#-i}g8n{qiR57BFhg&-TbcIuKW+bx(u@~qyxpigg!U7b-$4nAp=tb-bZBbpq1 z>XRU!X!Ke7)DYD6Jyt%Jgki=M3qTVLIV@>duzX5Ln&T|6O>-8C^Iq5uX1^zs7ZU2E zabDl5A3N?OJw*e7(B8ESXYt}n*PKh+Gxw;Ej@M*GKU@ltAbNQ=0>~j)Z5&EV5*&Xc3p~^P@?zWJ;?s~Rbavj1E?$$HcK@1{1l16G| ztzNO=N#DdYo@)*pR2}uh9X_#L_gbQB3G1=t9_KOgJ-^fSwms!g$6MWOep->*% z$}J-Q&HVEkuxHSqn9r)JME~3lm^GC6nHK?ykxj$L@@YXEpw923Djng;t}>&_0A1<}{ZlD5nHF=?zV4 z^obZZs`tpOb;;1HeVTmRsVq?W6OmeV)hVx+>bLzy+K1@1vh_9>>exxFQmat5QRYb`&ORfr z_H_;n98nCZu^DYVg>|auZXq5_NGIiF1)46|4fY`!TV?a-g;-J!L*VguAWAt9l3g z3$u&WYjvM%_net2UK_MJ%k*7Ok{fwt3#la)rv|OU2ind! zEh}cHfD{Qzem`u(DFrdDBhb6u2oNKRIk;8CnujfWK`$v}4i!He{{`&dIspj>mO8y(E!RBMipC?Q_ZQ5zR1=3f`hj^((Ma`X zb+j|QV!aFq#}y9SE~HaaFtW`7kfIF_TQrDt7P)ps6S4nM<+hA6?p0!D85mRw!@pxs ziS~-gu0KIq&7%u?xjAbM=ia9a4js#~eRB`D-wgj_Q#@(C&*OKBn;QQ#DIY4yLG77!?E7|V2M4Qt!-6{P2xj2Q|gOyg+seV~0@1)tIU>Q0q6#G;&Ob&toI)oC3qbtqI8J24_F;e&eHHPxK*5F^{Q2n<#^}fi4@lN zJhORc^&l&dFIvxc^yTtS)_kt56^;a|-@;D#aF;D6Yw^)r4Dsdd8B_wZ7M`kLBuxhZ z;t6xsy2I}I`SRoC&}lBu&ajrP^+Is8$rSx(H5hwgnP*BXm9PN8{jN;C5qGqesZJFj zx>#S%YiwZ6%Y)^(=zG1aS6)Vg3p*6OQ01(wJrkPyd~z5s zrdeek3TGoljT*@CIU!XIu+K>(Av@-68>Ln)k=DW@?Yp2O6ow<$8n@;Vv$g(2EotH-i@yGlVGl zDc?(}_e%!CDQoV2oTN=Y`xL5c0~bbBU~gQbVCB5L<^2FzubRX)9HaUwYqm65=LhUc{w>Rom(h zH;95bl@P>>qa-0)*ynDK!XB}&DvZIrr-c|@?Uvs_>$4~-R-X(ramGj}p~^qQ5iiTF z!(ke027au)FitB&`9X2BQwIk{t^3E4;z}c}`IxoS--@nzcyeSosdi_*krjM;nl_U`SN4z#hxouZWYRYO<+|~VY{m89gmc% zbq+VNc3@@0A~W>XBKtt{>L%*I0EtFQXc{>CG+T->7VTvgW)(gl{--x(Nc;zf{m!%` zugylcd2Vm9iaq*+E2pPd7*#m;Q?Ri9?uHZtDm5l2&_2EixNs-o3)LNmPaIJ3M!dee ze|!bAS^eksJo^;l*PdR>Vlnu6O|(va{EU)4*9ye&N7{ zrau5^IShE}Fz6A>&b<8WjJv&o7NAy4`4h|D9n)QHk}jl{VYi>1z4FUQX4$y&wH06# zaBU?o`a)re85`&Q#sVXXPX zdPx(z@ss^X#QkP}GhZL+;RFMwwIire{WAx^+f$9&e>x(;=&JgNBXf1;yG@KLIYNtN zpFC@PXG9J&?S>M``b~$vqW(fo$mvAzFl9NDY!Yswap00Rb->TPlNL-=*;xjpHFX+=cDbV;S7p@`>?%#&Ru`5IuX9pdpl6~DSTnB9w(K)lUF0?05K`` zY3w_1N#zzc&#Su%yO}{qgk-p(JG#S8xK?Qhr#CmZJgf9|-4@%nE$QqlqL2ED-1qL5 zem8tK+NtHDmfHiNg~CSXl}mLkW(+f+WZf!zxT#+u)M^CypA9#Un4H~W%Jy4%8Y7oy zr)BpvLyqmMBC3bZ&TUVr-sD@4GN4tO_^%v-DvLMoIA`fQngs##+$MpAxFqH+tIXbp z2m|+ApW|iHe{xxTi}R#9F)afnm)h|GBd7O4Jqck45?}ugv09iW^3jc%YG6=~h)KHx zhUR&EbF{P5X>yc9Bu6rYUp#-{^6y$$47%ZfxTN}Nxqz!rng6Xg+EclU2%{Y-3B94{ zL9b6YVtL+$N2R;+Ay(fMsNz{wDf}i%YddP2MRj*Tj830L5TY^OO)^50w{rSXOD)C*mGsjt zy(}(8w=dq3#}4Cl;f9)A^sRJsBuXFLZ`W6!+S73$ig%#CHg}1({mu77M?|PCr#&-K z*_{e9Ug@G%2+PC5Vo+zzKc^~Q1WxMflYd_GdJFr%B927gZ(uEk>J zkQAV+J-Rii31-=+4AlvFAeLFy5JNM)h;p_*`(_%~bZ=Iht}n6ey;|OvT-vj=irzYNt#S5yX)ST_PbaYx^cuFxpgk zIO~$u$oX|!NXW76lzLB_V@RMoT!QA@omd|Zznyo$?z8g4Ptg`y*XOk)9xkn2_x}1p z#;Mqmn=}X=_vqE}Pp>*&LA-b3oXLjyDOx~T@vcRTRPJ$e>8GP39Svx#LVYs)81%@_ zdp|ofdbpOh7B2)DWsNWEwp!S;h|zN;odlUmK%-?)qGj~vHcsNNQjLX0uk zY9pcpIW4VI!9EfxoL;#vIzavLuA2w7Bb;0r=&jji(TfY78KZCdkbxfMTR-2i>73&V zn>(yPef7%!qDcqoJyto*tjSIH+zAX>wdQ<9Z20c<;`c+lpR5XY5x5zOAznQStKGns zcxIo|0v7c(>`!I5aqS=)I!e^HvLcSzEb$iI7sb{@7b??DpY?XbZPss< zoq<$PuN7$IjYWWwdpd<5{Oye{XBEcmDm*{u=*`-gHyRcSooV4}QfX@_6LL1^;2lwJ zo?(WYd9tFqHa1@DFPkK#gvJ`({*?m{h0UvvYF=ww$;CzI1*Y(peL^a|(%rf2O?w`n zoSj8X4@S|p36&|6nT-9&vZ|Iw$|hPflTFUF*Mtw~)~95>Le_sAxlP2{-tl4kdb`#Q z`$;~GWS3`YbP>uOq@@?0EP~z%Q7T`llx{P?f+Wl!{w{TTjRs+}rqzhGjaK1i_XCrAAJs>$BgZ9%Ix0|`Et}eFA4(AeXueC)cQx3o zgua9t@K*mT&RN>d!%e$jV;l)2HxHSpq9BMFse(>6tpn=K0+?%pIpCHvXuUo=6$iX} zHiuUyYh^sE3U*GqCumscl7*ij-@P2z>TmnMoV?tBbMW@yc>jZtJ~MmS4etv+vnlnQ z_yQdyk=;_d5Cf#L=(7Z)-Hbc8?NviyU?-_n8R^slTs5uo5w(2uk~3gwnKE!qTmj^Z}Z&*DSys98Ez7(hak3ZdYIB z#VI5qTRPM>=iBj7(s+KN$RUML=)o?d$TNe))(EkkxQ3LCyot*%fpozMclof7hwJcB zz48}c8|Zd8)^RAZ(OJ)8mR)%I%aZV2HkR8E#>9Rb4-<@sHcP|#&0Ufmff_skcNo?k z*h+iZJOQ-aX$-q?$C~x_H&4@XEZRC?hgVx*_^q0QcNAJ3ZqF z*|Rx9X?};pc7SCJ9#4jC8lb{6 z+KRH2F58NQPvlLpQ@Efc|Hce@a*A77&YHmY<|%V^sa{+t~EK3dfZ%3{CK;tCKwp{u>0wFXtT>GXE5=b|jvt?OApToeio3 zLi(T>h&7HfkN5S!bJrPaFwf>WcV_71dN|qf1ba0^g`-;0XD-s@RIW?o)l@;7;8F?C zRN-#Bpe1iJ=(Yq$hzN#wi}xa>4!I+eR37i2uW|5|=YP zLY>`hUdZx7Xj=8Co5$Qwk~+Cez@g+Jn{S)9y{54H-sei^!KXa?q-DRr#}eQ;d!={+ z`Lj|EKYe0RBru=tq?!kv&r0yYbLZsZ;WF+A4lo!H!L2wgGsUw%gcPX$2;zlR&L&|+oI!HlirQk;4;(k?pR2m2!YDJw{4$ z;G(mc?!gz_N^_eMtYwpl#x0EjFD^wAWOW3~YK`cwilw9o-(c&H1%GjaALD6M1+~sK zlFha7Jn>xuj^`n#{%+>jqGL;rlUjftj3Vt-Voi<|NGpGYK4#;o^ucqSEq8j#0JK&y5WgYr)bGeF}!imz-y6HpV zzwpi7O%Bu*k#~aHdaub;HA_oaK50MVPgFTa&Mpco#}r4idD<-|do(g)h%a?Ca*gO`w8ASArih(t zBDuNW)DjJ_J>jMxW-MMoo`MlZ&JYi#Kwl16%6-JOUgrRHs!*=6g@G? z<7Op@u{>NKAVf;+cj#qsSSL#&bd-w0+5G6?6R}tndiRr>nDsfVsCW+d!O=Vb>^u`QS^hiXv-9LO z>Uo06dJaqqo`bbKeR4fdU=zFi=lVR*(i3Z@a#fmM8WD#07MtN>hM3vqr0^YHOcU7< z>h@|ev8H-4QR35LLX`?Zayd)T+G5%(97OcG*ZbQ`9=nV+GR1|2vPr`JKYixXwi9U4 zJ4(XE0{pG*#aH*qu=j~ottYC8OrlpWNW+e}d33~$$n{j}LeYK!v(4B5qHYA1c1Kff zNdnei@NeV6=_YK2t@v!YXbf>uV3KOt%E}z)8sUuMlf#A#ZKh>-Fcu;c@nmf(wIQSK zNCl{JOK{Q_E~mPk6l7UEkG9H?9+Kb6BAc(98|tnaz=A9~S91PN5u4L@;={^s{Q}lJ zaODa&kWO8`ci}u16vm7yn9>6zoGvdY!n3#xp4rpt#)OD+@UIwSa>a zbRhV5TovExg&UNOVJD>lVMXqr0M0HsL8bsklWoM5KbzOFvm-~2tZ+9~weLbFk1xsG*(AXRpqNiZ00 zkK9+D@ptBT@bF3>>X>wQ*42Y;>*lPB)9x))3%xKt`Ex3eOHr-PUq@sRl7bdQT(ive zs=*WBG^L#>BBA1Si_YHMUUZ_?2eH!#9L`Mzd%n}g_`6*Rtr*M_Acmmj#AlJ-is*5V zE7etOJ7w#9j`)(3%Y6mjbkMc1)HX-sjHv>JzL}*&7u#~= zMVyCg7?{TrP>eH%X@#i=9!3aO;&tHFy5jA}|H37&OV`M3=cCscj|BNqH+A)&wn;{8 zx%$3fr9^`>cQYEueJfd}nml~L2b{(sjU-2k)t6P_h4FHHdl-L*l!V-74yC|~Yr3+2 zv*#I%fE7eV_YlWk1i&{l+vbvryS;>6EToWHhE-e@26e0Jho0bc)T}Hlejl1~K$ey6 z;b(oS=tQlx(s!zisvS-;RQH$^Z1SH`-Iy?D6fZozyxEc-E6NWh{B*hg)%%`)U`Nq} zu|vfevPfJ|wF&o$B$e{s_*A(k6ID{QcgT{-o-2|uTCCf9B55oI9uaOJmKcimjw&@v zQYmGMWvYz*>)G0^21Eo{80K!y>cw`u}+{^fB*{MChSqa!XN zzrfQ@@y>gp@0$16*S{h?c#RfnQ`z9$&R}JqfjTeY8HCty*-39Ol~`6AoDEHj-5sjD zw^T6^-Z{;FrZ;*twp5wCB9I^~ zTdKh*H+*LILWqx4|2AJy43x}}m~qJlj8b_(z>(T_|0z@X%KxU5j4aZ;IavYob=sr7 zD1+m9q0g#ozM3Hmvorbu$2!6EB-BS{(a5F&%4S~Ut66HIMH4LUE(SdXMP$cx+|pHI z*?@wb83jQYLL~|3<29TL3D=)QTi$Y1%I`%9M;|5)3xZ6)RH>4VzkYIEjHz}h zKdF|>r(NaIlG4C?XNA(qoZ-DJh3ZB|@L80zNtd#!rF=QwZ{%oXq&T4X9n(~6a|vSc z_HnUZUqzekq?49op&%Z%7Gn3^9nAy+(_2J$p_)nFoV~a{Xa3G1qWH!89&}O|R$sMn zc-N{{NJt^anW*OQj>f(+g+$DDP#`$jW+am>FTmlz z=KFAy!HDH0k4bhFJ6#S3CUBs*~9w^O25>WXf89imSQqpd_K(uN`&(B}tYbDs{j49U6pO zTh=$)<1neIQ1vErSFTx7fYGNzNjtt>Oiy*~iB#rV0`N}iPv1xFi|No-kxB^MYS`jn zj250K(@X9Bg>T^ziDC}EU}A>}V)Yt%FBj`j=7Ys*mh&&?&G@%VJ&6;ur4${8;KI~) zPi)2Kwg@a2c{2OSX{Sa8%lvq}Qxpi=oo5x`N$bNx8}e&fTU@U7$6vwMoX@CgS-Hs( zceJe>1t+n91T#CY%S*^JSDS$~Lg&L5udoka@iXVv2lLZ(zG`FU7EJ%0CHC_G$0x*- z4`i8c&Udn@s>8}u!<$}tSnqy&+u>J+sOQF^nKVoD+Q=(1^yTGA@3oOtU&&=_Y!&f# zULVLyeUKDtwXEVbbBi7kI4mO3pV{mwa9Z)^5~L<6wg;^=lGz+1+0nzbjARO+`T{9EZNKiE5tVCq3!%>*KlbJ@ikepjP$ zzBy1ikFBcAa_#_KCw!Uc3!Bpm-$$EuBzF9vo}D_v<*1c+m2J;+uZ6}~(xuGDR}P|z z^4L)?*K_XV8fSJWQBkL>I(XS8j}F|6Ve*Dj>h6%Dt~&RuRZqwqb}g5fI!=&!n^uKn zk2T#50V&a+v~#nr2z%$tYTBYGt$+sSd|BAH2LYfVT9>x5d17dNDWfkr4Y(pCF;| zw6El8!l%hSznmVG$m$a^vx$3;yVcp>i}lsjYl6<+?K6Z2I~od2%f*zUvD59RGr*Mk z1{Q0l`Hl8EqZ!@_#d;q%~OU{u>|%cJe9D3STz*c1A{?@BShL@K!^Dr(XA?K zD+>!%L%5R0lc}){sB-*7Jh55cgDd07NG-41aaLyrz!p0t`rmEWBSHF5Y9D|W)9@AU zvjZThbGzISg%`(;!l^sf%V`ip+ui6-G$zqM5m%gQD6)jd$f|%BQsW}!)7MiZIAY?XxbXQRgjFidnCLKd;)lR{T zbP9-8Gic?6oGafzAte-*($+H?eZR z(+xW(w2(62Aa8infLKjS_KTl+YI|_=jq;WK8(C_I z+vd0P=D_|)-e$u3cFir@a|PHs{uR6Qw+n<}g1N>R>ul`_bRm@|uox90J+2sgJI0zNX8)Vb* zB7grZ9z}J2*Q%#1?B^{}lCxJzgX{ptqhk*B#65KhN?W(r$@cl}{pW+5VClLh5$Aw8 ztRWmIA{4}>@VGjZ=nd}X#1r5q=;m9wYQ(=)Thk5fXS`EmEu5g_o&6UUQaRvIapcS5 zhF(vKD6lhiG87^RlpBjYJ z3W!vcr5uXotzgA9hiKUxiJzxByNnOw>$T9bt^SI$y0e@TH)!uI?;bjiUiR}1;o>as zZf!#&$l`NFX|#V0F}!0^Q^1I;bTRjSHW#CX5z_?!F3K=FRl4XVD62;Y+@Z1GDxhx9 zJWlae;1jLd$Qk zW5m^o`#jq`{l}YY(9Kgr6ASAyQo7GYkxr8vY9yYSY;#&AVJ@2^W<+Z}kL{HiIclzH{iU;jM~o<6cOM#bZmykvm@0YV(CRHgV1^ZMF|}z!=ZM`hI)* z1?DL~qV1#x?nLfZ%f)M6iR%wG=tKmw#uB&>c3{o6Xbs|Tf?L5B^N*0FZCcM2MK|hT2-^tbF6}2In9<=Iqo_c>czfZxWU1cf;3@ z&MSUJxIfn`Et9)jjhMMP9W$**5heHK7l)M&jm8nAg{dfzlOjX&=iy99-$CbovDgb$ zcPD+6JoRsZ_vEVG7Pn|7Mz3wU(X5YQzJ_udMz+37lidh1d#ljEL{GeJ*Vsj{nZ=7u z&bCo77Hh7N?sTI9%Sl7|G=OFZ;zhR$DvnF;a$6rbNWTzY%XmmEQ1&QdMkZ7FgQ@j1& zX_}P~2Nd&J`#n>ht(N*RuVN`Vu~dRoO}~0NAaDeuZ7k=Wxu#T^&_3If3M}wGMrNL? zdnlQ+Fm}wmU7C0}4R2px;)ZJN_LiSMOYz|Z)(hMnBvtN-@v5jESZ#9-74kM5$&>en z8+4X0=w8TPs6n>{XZh#NwtA!2xdagPqzSV9ksr1l9}G!C;8yR$RYpvNs20yp&%Sh4 zg5UVvxlttTe6pdazA~F{5XZT}{-_OU*a@b)03J)Hy27Igwg>sA)bH4H0LKe5{63wS zfdO1=X}1kPxx=44_f7<2V3HPgg=PkH`)m5smRO=~5@_37b8n*xe7gtUPy)4f%4wgv z|N5NH#o&H}IRYT$h z(5Fj@34J?8(wCbCk^)?#7-r+q8vq@F2oT435s7BIU3 z*i$BS;}I7Y?JFspl5sIldt> z6so6}rV2W}G*!?L*=ofVw7#c^SlpXC9@}m@E!Due^DPvZr<4$8k@(5-O(=7=f!<++ zy%8Bo`q%Mo|2+||YUC5(GCfSPEKyn!Hs@vBxW>OX_CDEd(k6r$TA7+ne!>EyjpRF$ zp5JbV*!*SkVPS7qhj%vfqR0E~INoI>2&NZ?ArhUCt^FIDCAg7euRjrvW1Xol2(EFH z51$gcEzLkWgxK#Q5Z1~vm^i5>D*;aeiJQP%*Rx|Y* zxI89JYhVJLZe*gn&hSg1r{!X7Jc`NTzau=Owsf~zTUu1^R>7YqNw!S!q8C9Zd;aui zy;%VIW}JpRp~0=OFcNQ6;qWz_FhB_^Gknr>?hEzENqpDba()W=`GsnePX-k0@@#`9 zLNa7+`&vDlc5Y`Do=tkXo80@kleUYhgE^W`bm1gIBHzV5c*UZ)+|9Ow^@;y7!(p1w z9r_@YUMLuIOm_%?t$yUyGuZ)J&JPhIjfcMO?Df9Aq#NB0AyS>-Owrcrkq5a;eCLbIrUAj+pj%3PD zhvdmQ-B#~qD#$^jOO6W9D5dGO36KYkXZg^L3uwp_&iN;pF^d&Z?&{5E&dd z*4h;EVST~L_Ik6pPsu7XX4m(ejODYtL&#c_gAee9oKkb}_)y8fqr z2_(ZL&u`pb-Chu!W>xx?4PuD&;~%dWo8P zyOD56&i;5UPf2sDOollm^oV4!oIF-=otOQmd`aE}I?C=1so@ZDhny1YPW@u0LoyJ3 z@8%++^l%gN_SaQjvLkMG1+t-MT6?i%31_ber3uq-j;FlT3(r^y#iGyI!~b@3`|C}n zQr{FV<{3RnA6;+ykty~B??xFj1|~|hLpl4$>!1U;xvANAeK7&6(n7)5QnNr%d(z4v z%gwfmQ9z5NB0(k*4!WBjOLByJNyXT2c^O-L5+a|tV@p`zy!1babsI9`hleW|TZe|g zn9wVp=7gOu4*A%mznR@G;uUY8Gy`e&dd zYDutbOt@N0>Wn;+G1|g*PC<&cBTp4@VIK-4Jbn+JN<(in)2?r)b1h})Q)C)DV?QE2 z0H9WTa`kK>IlDPYi6)+`wDcs2AJxw4 z{q3D!H-Zd@mk5uW z!m*0ZPB8_F)T*DMMdi^cK7++9eQw!Kb>k7aGFFj}DK!@V~Jy2`LeMH;Fl!l&zd|c#Bn*ohiZik?}~4C|q2hd@@RXy`3XOMH8@^Q9pXd zCR~g6Ts8@f4_=?Xe*#bMl$4c=*Tok7Kwxz1@2P6Jlkz(9Mmg0yk8f+AD_&puCK~9| z**c{xKPaOjS|9eN6peyo6)1eO^~uLG4g zj>4vzk*uTwNb2`b;-IWvKHl)oz?mW->pew_2ltMq;h&%JQOiTq)~Vk0zK+Rkb)k`Z ziN(C!;Dny_>6B0)UdmAdL#CX`lS{x!N{w-4>>O(%>c=}~ZUGS_)=YSof)WY1xr{tA zfeyC0EBMV}q2yFHplyahS{A!tbd zx@TDVh!;~=?QP-W!{-H`vWVshzdnPn^$wAnmSUnyB^q=mGQx{aFSRf#IS}O6^h z)S+DLtzSiTJ5wR)PX(&Jp#*Uq!Ixy#Hb-qGioMw=8n=Jn4?-R|)pG_OpEzwzsPg=H z6O=1zT+Eb|v_`Y3Ici8ld&Ej1Qrkn_=0%W=cdRnl#C3rWIeAJK?3Y;f2x2)0Z`QVAoXtwWO6F9l`49TcjWd+| zL3wJvG$UzKs=c4g6PCjx1GWpn>{x3u@+|aQO_sV&2i=r!GP!$tP+G1upo8^Ww_eYn zSOpOK!ZR#j!rMR9lX;TEquGIksfvp=)0Af5(^kl)roC|PDAQUWa4<#`aT$E z*|H=dx9$bs;jP7+Gs;8c$ZE&pi2NI0N+P@cyPdCZ*D+B{%piSq81+T%zP%TMO?u-D z`P*XHMTwlz8=uOm!b5#JhO}imsiRvs)-CKxRd=F|I&a6_9aB0hI15z_PlbaJl3uR$ zc1T!(njw1%Jk;x~Q_#^G^1WH>)YPfgG+Ob7c(oCx@eXoCEInnwyDC?{JPbW?R^UiW zA`#dm?=?n9RX)G6Q(deT)7B4?*zs8|<=6&pui1hauUnVu`S(fuN=7q#- zXMGC1z?8UV=x*ToW3x&lTd|t$9C3W>E|CeBJlR5^E`=PoM>lsU_-gBzV4~Km8C>%P zSCkqA(FpO{)rmYeYwCqM8IJD}=mwN0I&BI;t)^iz4!C+sT!zz|T$T*VQFzd%n(RusCSVv-X1+xuZ`Yf!8shWsz2VcN zPN|-A=Ca|Pmy7U9XECNCw^k~GvCDblv^C$}VENV4eVkz7%YxmV=t-K0-R9t|h(QPw9W|nUp_tmgvbL^IK632(aWAT=^_?0#J_U)5ZjX z6<24r(@&+gSLbPC-)%;`xToONVrT?fqCu|(H-u^0C+e~HX|?%eV)lSq)JyQuc#zia z6ow%45rwdTh%uY{K%Rdd4cNpH>2C5(yv%rx7EXP+{fuc@{E5ArHER5zFueR)MO=f%B7yr0#D}kGNr*~rceR0GWbdDqG z7m+ooYN3o6O4oNZga}A8RyHLo-YLBG?IvD!(i+POw2IDZQL|*&yw;&xlHiu2lVOAw zYY^jI=VM&aB~f1d5}DCz6v+WAMSSwPx*aJ3g(!iC(&jeyH@Y6&Hz8UlT7J7=;Rz8# z*4D8@4BdyKtLRJXN14kDFSdjuNUZ;PAlGO%=Sd38maE;T%oQQd^7{Oykx~xv2 z)wyscoD^u&Z6ySAS#7s9iCZ5Aw2P+kt~!$ zw>=6v`&?Pt?^&Kp&f<~2u@F4h%^jwJ`Ys202nr86p+ok+Xf3Rn1B^*2FeNwJsqn&# zx09H@C*2UBQ=`77Ycnd?kH$EQ49^8NOK5Gk{|lf=Yty=66SI0lek)3o4y&72TB4kK zYWMSMjY!%iHksGh1#j7j*#m!`EMEABGzwi#8?+e>=vZ%v#UiQ2r6tvWU%7IvEs=F$ zHA;lA!D}EdSPjls$F@rMV+8CoO<67V~$Mz&D89a&L@kf7u1Mqyr zgGQqncN&c+i#C#kQd6z-^$^HNf z1!Vv<*ZJ*Agw2Y=pV;~~hi<6;+fTd>aVZm~-)<5PB(>~;^`rImrFg$cf#*p6lz+e1 z-@`k*yq(-*;&u}dKscuu4>Qp06PbGC=y12wkCrS^2{)G?IkolrD?Q#dHaE?X&L&$z z*oK3a8G2qsqnA4p!=%{BKfu0S2wx%{b389hKhJYqkYFqlMs3!#PVleRc+e;o2{KI0 zjOt!Z6J-QtU3xtYilI&uhDuv>N1;iiZ|#ylp-LKg!~J7#9M(;PG6pqukweKqetBl< zi=DOeyZ(e?M0?Ja10`Z0!*c>nWvzlou)jG=0vyw2JV@!(3tW1;RFUX?8>y=RuB|dRfh6 zkkb<>XIx(1ND=Du9|qP!?4(7XknCS=>+#@uht%EzKBJ##$7>r@^;T!5WC<+T51G8_Tk-cF3m9-bO187ar zY|QB~#MudRkq5+-M$$2yswSvbwzck%7|YramoI9-G~AE?f*^RVI}C}_vb*U+;c3Mb zgx8~U&?{z@Js|c9f0q6&<}yC&Om9jImZ3}tVB^J1BMCr8>N6^oa-53OYC5Cr;=60F zue-kH=Ic$8&nxWl7J>G@-d@Th{Hy2vT1+%7WieIb)XSMokDh6B^+v+q$;KixW22|% zgtd%QDyF!Yszn;G82bWiQmw>>@b&bPeFKw%JF++Z#O!d*KEg=Cxcv6=CO}@bibCoI?|CtFu-#DR*`Rv`{8%A1r8ld^-yK zF!G5R|Bz^P*g9*?EVRd3R|(N-H55WE?f0GJ_!jhSjv#czueOn!E2KO6Feve*(UHuQ1*)r~e(Wb8N?!#)mn~I{;&>MP;ssbvW z)&Y||>IOXUAE6Dw*e0p{SubKy#GwIMn)Lp4jdhW+Ps*6D2d*u9sqq6DBDj?=ZAkxw z*QTM=2Qzj`n1TIM9Z&E!ywy6^b}?qOPVw}VjTnuYlFj^T`Sj8iD1n2un6|H?|8PF6PW>q+ebS`a4*96*MT+z>HBzYf8!RS-Z*m#H0VK;1y;6elgzr$OM@y}Z9AsFQ#3dR{d1I)X*i zrxH_2h@Y=c5hb;Fu6{jz4DsP$JE(yONXlrQqaP(~4BXQhVrBUxBVvjncGw46lWu8O zrQy^Y>^Cq_Y|*K|hm^%~lGQc)X%Unr{wqCQqN>rYibUi^#;8|e?}#*Me{TGB{9d2v ztK$iI*H>uvjGw)R8{i(j2e&k^g+YC51nvZr#stc*j^V_hLh4p4ao(fEu)c|@NI=+r zxx8y9kXFh$bxK^wHhm?>TwyXkuny}s6N7h?RkJXj@FEtoI_M-XIq5dvRtGNj0o=xs z6xM1_VHp`UQBp7>8+#jD-OVxoJ6D`5vSkKxB9n>)?(rXIb!uuQcWMWk!$SgP;4Zqi zwV_!?YM-33_P3ue@3zsIOts9~OUPjMWP#sEWZ@+)`Vbd~H1D0{GShmIp&@r8s`v>0Vy9IakN zT{)7W-~DInGv;V*&O#RxZ`-;?r+)jR{UC!5$%a?&21vd1Ml~PVOSFQt-0n)+Ga3NY z;mj!1>EuS*@*p!%i%b#|6u4It%f8+A1des@DVuEH!K1ag!F1vy_xko7PGV8P&;iwI z?QGJ8N#%QNC=zd(+!l+^2VU^hjgL^aY?7B>Pp=r;PnV~-{*1i5%CZqn&Tk2~c#Ypar+E7V3l#|YDUvkQmqct4E9>uoltdW;Z z#3U8fjfLC9F9BU=lNNO(YzL2R8dpampm@&H;3OkRmt|r>#0#%X)Th1VfwcHaZj4sut#=R(<1HSLwqwMOueJrQRTM6mUFw(~pc z8;zqmcH2^W&Cef4f@ShKIy(|-0xZ6N+t-OqSFm^R2D@B8ugVZbH4m-mK};&ENIc6 zTpHxvxC_6low=pf<~vVxhhGZ=_I!-t=N!xirLDE2sE`1U zYHp}#xg2z~PmmDJ7K2F{WL9r>jf#$w!^VWLoHmb<7=Q;~p6rkd7UnQGWfEu{eZfQu zz2L0SyudWGynJvEP|c3P+g?NyM3M#(`4eFUX%f9~>J2Xg$!y;v%^!Y3Dr{B>_F4-i zIQu_v9DmHg11!=jgl8@gV|g8fJBS-LRBzwNxe!ibzs#)Vj({LKkxoLR#wXh$j$Qt> zZ(!Bz@l`*u-aRQgOS(3{w&fZAAl3U@`KfpE9L^w+T5BiWH_Z+|l}bpZ9Pr|K=9_e_K>)=nf|i9{liNFsWp^Wu;`Yc9Fw~X9y zBJH93+6wo#)eTLeFayF@L8dFck^*%aRTL{WOha7x7jm9!#%&Oo5Y`voZE3lcdl(iF zH3rk4mJocV&6cBLo_qa*d~yfjM-M(|J!0(Mjm?-HiHLkEmNz=_CuS0DXc%vs^W5_T z@e0F5{>xv`x}b+BGtUAoO@F5;27wNX>;(lZW+S4hqA?{`pr}&B6ms?n0T{q^Qte7$ z2;Hqzb2;8PV2jHPb1=yid6Q#fht2RB>P>iwpk1QEaG2DAgE(>0)K0FuBmG4_)T1|T z8gcEgH}`Sm3;ONfShqBJsP{o(X}7CwuW|_k7G8BN@U!jb)du<%K(;t7j9XRP&qR>Tjc zQliTt0XZvpQNV;sIMs*U-V@`KEyTcOUVclDu-y4M#SaKNfF^RCz#u{u!{s&7wD+1= z#o67x1iWMX|-J-#k1ajC+^O45V)lk{|FfUNU0pWD9L(OX) zwt}_5F$c9k?DWZQF;qCiO!DAi0(gsHTYc5o5981nhuUt8Ck8^^bS#TT5-wHAG9{0G zMr|EUOenSzO*D2~z=;?Y))S!w_TJ63U{U%@@UvBjEWbtQ4NgK=$M;48A_hc%ugT>3 z>r}t^PrunCq}%;j7DGpoT5Pg$Y>uuYl}>nv=!0JtCEcm5Sh3W=sP8`NHiyWv=1o*; z(V%19R{$FBN=Cp)Q%yt;T3tDHKJX4#>u_Vr?uD_1Drzz{PM3(u@VK~e)n)I0u^*6D zkDiP#_HbB&VL_G~7z<)W*L6=UY{mY`3!uAjnYAZ~VkegD0LE*qTV}RDrAlAhPis7e z%H_fQ8#p>{t>kdq8iGmZYqCAyBu4nN1Rb(e8Z1hKi6w*A0E68idWpt4S_WUc4F+0ZdONQ6rt<(%Xk-UPqLV1s$QTODl z3-`}^Dv62S&PsJbZ!RybNRMHF z$QEWUYqd(0k;=9%WB7}d0X#-Eq#i)JLZ#IwKhWA72PUH!6Fd|EhF=OWVPjG>(}&N$ z!P10Sh8Yjy#fRg!ug-rv`u*t5Yit(&pLeg%e?R)|H5}jWepe6)SUPVWWy?F?KO%VT z?H{X;?;bv4xxm68;j%dYYxNPm6DIFyfbkgy1xyRvOrVb>%Y420vc@CRx*rDN)aPz5mg98Mvk{a&;VK~I@7c>Eb(iIjlN%TMr zJLWC~b8yh|(-yHz?|2K1K^a&N8kTlRHQZho!er8o3|yvx$V2tMRK9pQ0Nm>URkVtX-c!V4R=K4%9s-lV>k?H2#pI#-%DG!@J>sTXar z;#l(PMx4ZahWB9L?)uyupHgp-N<$tH8^XA+GvAw<4_dQGl(t8afoC` zWvaD2Hez&T|}jX$uD zy;$z})>6!B=!zB~iP0CC5ni2t^=OZAl!uF+L+PAv+>s3h;{p~#P@qPC``e@#3}+_S zO8vsQfeETz#VU=%gHD=D*U~xdclZrVBo62gn>rRuc`@UKP$-GMf;HyN*jnJ*d`h%E z;u`$YY}B;zIN}AT9A+CexRVRh@Yph(14XU-{*$R<&LP*Er`rY#h!Ki|YVwg3M9gLv z2gu*Cr9ZEE32*-*&1fr%4r#4V!4uHdO$?SFX1L#PNhx_xmnH27>gAa{b(1QYS zwsjItvFskCo{4~x1D52535O{Ze~1TVll%Mz2a|x_Bbb}{o@gj=GZGtg+?M3mX=LWG z%VrPw6fWejdv}OEbx!X`vRe5kKevc?tatDCcVBzpjC(skd zDP<@>@RT&e#YkW>^^gP_k=u%E-m@2^lBRQ6?C;yt}$U06Xq%NeYjy z3bx{Cz3S4)E3Gz*KHgza0B;|lNQW?oYbI`vvm{rbV=l>W2M%R%zTU6?<{0d4ptnZ& zvY=$VF$FKR+T?>pj|o}qOp*R@%!}2hCF06M)bC2XIzKL0UvRn^U3hYv$Rv!#?o1G| zs#&osg7^m$hk_`rh0DO1&?%%-vh+6LMB10Z>fT()& zAmtYuXc}pxwJ#H=eQCDgwk9IS(KW1Jdpb?|#Ga|XRo0632R>ORh#HyM7&Aon#i*5s zTq;`Kvsu5L?R0s?uuND8_N%`kI?Zx-@d*pUMNUAQ)0SG1F~1GB%JpU;+ldtFSi&IK;4hbK`zVA1``N zIRjx^>A!H|1t)SYAVC0|AJ`3k4*vouW%%uaAKORf@bE*Rqi5`$XV-LUO10kVSUMDq^yR92l z;FY8U;LyIgw}<@6^PVa@N-5&hCO(FgR)Dy8_%xCsixO?3^9wUPyQgXFJBG1IWx|(w z49t@W+QX<%QqKVL2alXL{hwF-vvI84I zpZokoGPgKX0jIgu)Tp!-+JS>(AP92jB{={9$P6Or%T(q`C5pH^18p5o`b0Y>*z9~H zmPQ6B8fX^-sA^FSxX>npO_Ol*Z*e=VGX{j!z#I*Yvn(s+W&P&Bn6))aYoNYB!XZo$ zEw2bViwADY7fT?*2&?F|?x9}$?CYG?#}42m4>vqaN#|9I-OXcYin6HF&(#DzmHI8j z<;xrFGSZNWZO8+T%HawRANkF7Z67;%>WQo>eiQz7z-9Uf3;Yp|l_z_Kdv*QWEG-4g z=4QW!cx)h?Vs;8T9A|MK9G4eiQYFRVMb|{ksaYom5Ci}*5lDOQ%243hz+q5Kl@gZ0 z8U`#h7Olm2G2b@AR24oKl=SIZ@JnC|%K)U*J|~bpCNCd#>>ug!08{%0Cxx+W%TP{-^a1o@i4a5`5~5b%zqhN+H4LzE ziS=}ccpPrP;ksVtAV2B;4n@E;A-FM?WIR*E#JW_l;~Y64rqI>*o7EN_M35}_|IiX@ zU%WYi{S$Yg0eZK+dAyb_%uuAE_qha`$?B+m{zd{;p(hbqBkZ#;Dp0Z*1N7}Eu({l0 zOANg<tE#$PN^BdA9nR7D`KegoEv*DJ>sN`+vhY zo<81w#P$3Sn~&QEh%1YvlpF{Z4tI>P1b0&bOXAho4!~e-*rm57``s$T5|OPeP_x5` z3tfWq(vHkUh-tXJjOSvy+OK7KcR2*W85Ytu-{nf}bTY_?SgTIAGN3mfa0D=oC?{sS<~hE0Xanf((i0HBUnuP&a(S{ z)7m!n8JqvEzp_iDI%IpFPKSa({#bRYy=_*OokF&^-7p8H*VOj5cNu_&?UNJ~_w3r{ zw6+-5n{wjbos}k{LxEWJ6cpQ`&!=Gv*UCXR(OlXUdKmY4E<634cc9SFy}GF^f%i+C zc#OS07Ygcr!qYzKi&9%@X>@0_w~xB+jl0xR4@aSuSgK+IBzjBhYxCrT6}A(rRsxk$ z#P-Yfmu56zX~GlLBk5q(ScG0#AQ|jvUhZ)58-pa#Y(ac zb@1$B32!B>cRayrU)o=qyMa>u`wKOHm-ic9X_M~_oQB#ZSh9_{D1>UbL zLXw&cbvD~zwXg&#Wu;JG-q^5qY_Z5~_r^9Nhgv81#m-_99iNW^Z5n|oBr zO*Trj-P1$~qiwCz*Y+Tp>kHDaibmo3oxA>+{>Dm}g(rKe$IOL2`Sqo~;JTot571|$>>*c?7{g}aOs*GLf0DEKm1D`(6k ze>m7{cGqCPC_Dl1y4*kz+U&I^7eJS)E6&~C@OK6#j}FGdE)6edmB8?0Q4%{7AW2)w6jJ?WI&GV2q7+6CAx_cUHL~B#P_9I0!7~~PT%ds1bf$u z@N|?7l9Z?sJNs6)E~y3Ow915$X^qpgmM{G(W4TjCuuN@JL$?H4!pDZ;rUB2HGpAjp z!FXj2*&p-XZG}!Tv^56z)8?`?4b!hrUb#VGzqsrCBXO(}J!pK)4L0xVUYd*c}sIN63fp!R>13O6L*V$&N>CxSJB&kaWJ) z%WHRZ_uSXKqwN+03pihQgtPz!pSJ4U1gx6;}w`B=Qmmk56%#bG^Ov zb2c5W_-{p9KichrXsKBpTec|=JJK# zNjuxZS%kS%HMRp>&ajKOvt4-0BS_=wKW`D4VF_;qMu==>vmpT3#?3#%?}WFI()%#d z26d8oi>odl_iFkkTI;9wT~QT0qfgYjKVUpV&{jq?x&H*I4;xy1c?=Qk?UpxseyaiEu8}kX z=5$qwWZ1&!E#Fv9WTwTc+a(q;XpWo+Ep!D}UU_cmDiCN80UNE9YbZxFH+mH$k|p3r zh*VSM;)}_+>#@6!C%nCbC%GN?P0eh1QZkex6*>wxz=0p~TC; zFyuB$utlh?bs}y>V>7V7MDPJbYC()6ib%tKJW4>1#9tqqU-PS4z`>4fu|d6VbljujX}p^I~sU2z;L!^eM~6# z@noP0-m=De(IE~RZ(#ed*R{L{Jo%{#&zCnlEcuVh5n->lyA8d~=MStFiLt|Fx ziVftEJlp&c)nU*~&a8F=n4``WlEGDmBopa~S7zqb#sJ=<;|+;o-$N9MSS^2LKK79to3%xR5WZmpc$GD>0o+|TBjlmZ-fF7V=!WMAfVuN4MvBcG&Sa9 ziEb6y_f`9?+n_exA8}`6;I5aaTsvIV(3!N&Sd=d%rc;<$Yn%(lS}Ogm>|~&&E3A=& zKsG!1V_xG8iUJ7Ctf@ERXe4W(#7YsB^8+*Ie0$;A3!Snl z)?Ol@(Hiy$e#O{o=3QfrYb1rw4Y17yJB1RL2wee{Gqkq&mFmFq^MSgJ5j)g^$hbBD zuz^?;h_m+v73RvyK_jzxSB;QF%&qP7NgpP*?+J!2k}kMRI9=atKQ3>g*Va(pQnBTi z11r2E9Ub#$#*TP2fdmOj;RdV98;fUgd6e#$16`%JK>q<2Wy$2YW$5JPu2mQ z;!wBv^Z+RoJ1@A2Di}a)2+*> z#>bV#?S}gjn!V4qUJ(+VfBA>>o9f)t8F{kN)5AZVTB$JP@??_MH&6L_nqq33D%)XE zONA;SU}ulf;2^cLPGk0jX|3%NH(rm^`iz^5^u;LtOHu<({}Cvc^Ch?U6fBF#VtC?2$(gkcze3q?k9WrlIVj z)3BCiT<7wnI$iCY^wf4%X3Izuz9WZmXoQn>;ZV+UGYK1Lh|k+)HWWMU{R)oCG+yJf z!ecCmxdd9U5g)%;6&fEjN`xW+Ymy3zC4oI9+etHU5d)b(Ed@~~_6X|Oc!ju74kQ}J zB~JOF(bJyG81Kg3cxUB)%E+_0KOewdP2@aXjGWKgnygcYi^MzyiuN}-j1nh-*N)(zZ=u)O4;uN)7Lc8fTEMtBc94t>9Hy$~w_@U%YIXUN9S#$v+<+MPIz0n? zLH&~tbV$g?mV=`?-G~s18dXH_Mumli$BJc&3=}4%d>3kZ7q3$F;5XQ|)y6_!AsrdE z>$~8A9-Yl696Uc?*611@-+iNJ8cYuYM`bySkrL;#Mzy+qkHvUbPf{n!voNW8=`UJK!@QVQ*F?qt-!WYZxovUqoz;WLY zJRhfCRuEj4r?7ep#xv&~81$xP0E3$|u@%-1V(mMRgS`-)9;eN}^S?7)uUULZxO&JQ zhnj}xUmZg1Xhd>HtFVfU@rnXL;?DRXG)R0?ZoIM7Y1%>9*fuC9bZp6!L8}P`oA0QO za)+~Eol?cgvLCV{!)tr;q*Vae*%v%a!~2!$m=AwmY%4jO$k67CVs{oijFR4C3q#Rr z6f)W5rUpEB^ig0u@{BDaw4oeY96N-+QAj2_z6Dphst>lXjRlxJPrh#+55i7xi9LCD z%PI1p1}IocmxSB;aA)<~;=Ccj({(&)aq0bS6NHD%q@?h_sv zMS-aP_br|XT*`fdU9ls_@VNrSsq%Yqb@$6+x?erOZ??<(88|MdBM1z34qYjwF+K#j zA@grgv_CFp6S<8;Z(XQNA$Xnpc(0J=9o7H=7MT5-gbT+XJ87}QOFA^`fkBkjO_P4O ziUVFZcEPP=mM(iYc2s}VQ!G1W{H)pTM#c}l);RJV#ym^5%rF(MWIw|y_r;E6v5&O{ z0v+YO(Jl(x_?@>nEIeEDA(qOmL#{E!4+woSwH$OjWX~Fe1`Ef=)hkafj>{!oj?c3> zWjxK+od0BgF9k3K{XF9QlIldL51D^q0b}wTrHzoECy-yDzFe;SdIacgOL3Or7d?w| z;;49Hg{NpDYwK)-DaUy0q9MYLbaS=vQ&+3AovGPQVT9TV?FglKzv5-?(DEQS{U;{K zKYm&a-ylj4`FZ&M#kCPHcV1l)e6I__oRJA1r zi0^o;ERrMS8G>HHBq3J~NOb7wudlACY+=6*`9k-dy>SvgWBI2S%Q>TRj4*kG40wpk zG2vTZ0@cNRe1ycG00Kd}NPMKC5`ffX0wA5IIHhE{?rE5K?J`k-+Ugw;Ue}4=S}$?G zD84l&c;C#f1mGeS&q2~Y5?;a$kTa!$+>OpyAd89xz2fo3W9TlXU$%r4sB8?!rzNqv z_H}%{!8S;=Y38{_zkIO_Ko&T;rhJBVN4^zU)5sPL3WJoxz;W~z$ewXsr^i48*xt}K zX=g{f>wj7BUx+FE3(4HL;wD({{1)o`+w-)|5N||U;6ha&uqDWvg|)u{-3OX zpZ*mbjzod+^7b2iz>fUo2;clVU#* zDaC#$Rtg3}V*rpEg5!Er_k#No{;Ey1=?=9S%R5%rdyBUnA07#=3(Yp9EtZ#;+<7Z= zM2_3(O85lap;7A9kZ+T6$VGDn5w2ZiSLFa9l1~@VS(LRgdB5Tj``8k&_5=(?6yu3p zYadR-p~3=l=YbODQc=(~)D!623Oos?Ngk|mBue2}IuM4>v%57W9;;fMIUI7hFT(>o zMq@aU7MR62tbzyl5}reN&J9P#7oTYPbpZTApm{?!@aj=cJ!PFFMTmF$s0)J~d4Dkf zT&f)nE~$!UDThlKQ(PU%oaZ~Vv zSC=!PT@I@|()zj*svK;-HCn&AvIR*jE0eIkJVCPd$*h&>Y6^Wm0Zq(~6Ab578T{e~ ztADUlc5K4t%<==6+8NMy*oJT7^*9cghC)271*H&Ue%X-X$d;!2O~&w}V^d>X`uih! z9YuDDYz1UFguw4xO*e{z#0Vz}yR6Z?p6zK(-?aN<=e{oNby%biHPI)Wou|QThsv9z z8Eu210NGUSgxvX-=g@Hs6yoyyFFn$8d175&$*bSrx4{~$V-AYPnXE1#XHw=fK;<>z zA}^GKxqCD*bD@1ZHtJSJV2}9wC}vu)K7zs$l#G8BNw_Wnv(V-2k={8+=0i z+!_D3+ksn!|J}Urr7SG;dcbCbT?J0$P+a|Xl$UfZixt8;RY?u?Q`fMW8~>lpT#DrL zcwt#y*x4<};;$Of4|j91y1Rz~M!J%DKGhph4ViEHV8OQ4b*0d>d@cbe#WC{S7=gJ4 zcW{Qz#ijBM+<*gtjeP?NfHm8ujXDzN9sX9u2G4YT+Ts*5`p?yy8?)Lxrpo`LkNavi zp1ehN2utKWzJe95i8q|}HRX`v4z~H52kigE=-9RFJ~x`QY%pY4s75cdNsLfc*m-Un zy&$9J6pc)KcsQZ9G4>EA=QJx+``T2VsaM*eV!qrnLvd%b8A7%WE}la23wzPkCvbD{ z64wav{uuPx-`mYcnvPO*qS4-KjFT&O{3V7LN83*v?81x)&CeVRoU;tjs5X9=Tn))c zWT@6W8#Esq$TG}A14%=1y2D0>5IJo*Ji(itu;}#T{zm&4J$mG}S-&&kOM!|d-(j;2 zAFVIkajqzpyI9L*Tu#hULaU6&=wUOwILUHMQO(_|h81#0w}y56NUy$O=P|R^g81J5 zxfzT;nsLN%KrAwBk$nUk(`AeUdq=N!q~!}F9EZf|u2x`L{N67A zr>-hchkg$)p8E=zn+y{L7ffP|Af>bGYcwbIxKW3j(cebpY3Qfv`6Ml#)RKlir*vO+ zZ3+!MN5!*}jNab4B;7Jd<;hquKVLlDd^T>Qd_IAY#DNR0|B#L+@ZF4U0*sHI0;9lz z%KC~h2Cf;CJ;6TJC}39!g09pOLX+@qR*#HuIkXQrxgPsOcHh{rhqngw@P;oH=Eqb* ztB8wTSLm}z|9(i(Y^7F`>=lTpLV`$h-TkLjc(^j#ajMhg4QoLGf-SsNW_l_~4c{$9 zC5t>?SQi7zX5+9so9Ve{DuuGbe}1X|yrxdc@K0>|SQw zO7AIEC)6{5QEDKGvw@|>`d9HS#wT*YxP|q>5WDRkTiR{12xuAv>1?^gL)|)8O%R|S z{MTe*qg}D8<<OI+06%FGZ3i>o=H3jarpkx7^mzO4T$2S)m*+N6!wKUtfJ@A3ait5#G>hJe>h@5WwwM27gx+JM3c+}id0vJDt@D1aT@Y{ z&;v?mTa=rMAUkw(6B{RV$9Kl1EpB4=-fzKQStiO?Tf)7`<}mlEu}1jqRwjk(Z_{!dR&d z&S1Iu1KZ@-G^b0Iq-!fcTN@4Z0h>_SSi|Q?=IL(N? zo%C!ruyoamNr9{KWjfw(X}kXdt1RyQU12X9yA?)P%HP+RVk}uJ0=%F2oneq3J2ZNI z#nh;;G6$0R%D(q1RVWIaDXcFj1iY=r_MjC`tRoiskUW1-ApABNy(oys2Y9#QW(QA9 z7j&SgmBg!AxP#nM?A8NK-HY?(05L`MocDwZ1G4^5?s~b!*l>f{=@C&9@g8A!v@?qu@)&CsGK?fA9&FrC+ zcL;~=U(CjV&W|6-{Q7cjJyvdgeMffdE9J@)-J5N!P36{J|Nf3T*+su7>j%J{PxUvF zf3O0)wSuSls5aMf8}vtu!*TnhFo%6-QE;U}2CU3%P=0)8W@e44XFaL_vJ){Zo&`^b zexTTvNtEh}!IV3%vvFrG5f$_uHG#`)*5;4z$;8L8*(n}M`LFNDMgzGPgzq7N@vgP) zJIXe6wW<8fjA07F8DY+EstBzmBL)?!r!kCIsP0{!;;`j#Q6TN%L^B~DY$#VWo?;v> zKqPu9A~Iu=&&RblS{S_!S77P$vFowP3BpNc^6=^Xb~_vAe#FH*Ye!YMuGm%8m3mlW|amhD!&)vj7bU1vo`|O?OU$(wy0H$3Mk-mvU zc52fO{ykZkRsJ_#pME2<`k&YU)5(P^Bx0D9uXhjoPtLTb7jOeyyxZP&-?sgG!7w@{ zn;8I10?79Q8$UQIn+s<3){vb7toT}cL?B#f6Z7t7xzTd&p2&!apzue)%%=sfu}Huf z9|5f3P|24Arzl)UzJbD0{1jrEpNZx|3d$fE+w$v2^Tv{6X@#1;E&n0&F=1xhF&g?& zJ3r|`O`Np7CNd{!M2k+L9`nqAO;IrG7dFV{7RS;axN}Guz_YSTAa`Q(hp5`(P3vfF z4btnU4Zeom_wa=g7SEp^kckW1^T_~AP@Z6trz^wGRZ&%^BR{Ehk(Jc0cE#6(nNh$! z_06A!KhC$ZnTSqV9rJ}#7|7}dIiEd7*fvVgPq1%>iOBZmwd}iiUQ;GIT&YRG*;b&p zh_v%?hi56^wTj1n%H-7`+o6EZbU_lc0{0%K7SoUJdY9Nbaw_7Mm|_c>aA@1{7DU*( zqFb2Y--6*B1Hr}zK`_ClX&x)`2?V*XG(ldAz+Avi8)*->cLU?kvWpeYyvIS>>)jTVyvE$~*x33$->k}e4ImDT5^dtht? zU4K2az90M{u?%dpA?g)LoYC`DnOfxqw)Y6rIPr#aq08e;zICy9js8F2M>5pnHBQ$N z03w(Q_O7?<&lVRbfvtX$f;JxU4S1lHhf62M6ThxkHpBI*io^|zePeLvJ*>6cFjr+8={TIw?xWJ_7Hy}2rLK!OaN(QOcR>PN2K)$~H$JA_ zBnj)i1?%!Qiw(mpBBL{0ZvUD=lT4_&*-@(YZetU(mG9QS0kQOoDfEFWEnT!KAVKbK zaLahMP`hOb#(+ia_Vz&rCH(d~q@|9b{A^Z4@Abjw7{`U(GhBP(6;8}E^V`f!Qcg;H z7Ug#$Rp8-R7#k{EH zqL(JH_En|mD5J1Nyo%#P%n@Ea!?yXu<}WxtTCKiTk!_rW3_stZrefCGYe(2z;+`#} zuU@zqfsh`GHSux_5xrN)P1XhWHRtgq?&LGp?{B>ouKah>{xIRTHz7=^vd|omHIg}QyJ3o zQTO49jJ3o4Xj{`(xYP9UXph}~UybKiO5BsOc&c3TT>VQPb!IsOw{K zm6$T(#}{~=mVSPMlokQ+3TMxMKCEC<_JKl*sVDx8nqYEo2wC^dP6P^< zn#^Y2+>nC78HiJuEiCQ%10HZI+_RQ6!u?dJAN?1cNFJvU(~J#YL06fvpbqK(H(mqh zOb3f#+eb}-koGInP}6GnLU)FQ>)-4e6c{K?iHY;3O+mEJIlSfP6^^NJ;p{AaWp_TW z?=0ywenpbnSc>;=ANB0_JUH9v$pbNFp<|w*ruibCM9LB)!bbuW{2{+|+`7l`CB&p} ze*U`N?P1|?p#*a(K2P|rHs9YHJ{#Iw%*Fnzx?ei@{APgYfj!m|~jotQp z4Q2lx@%c79W#y@rf3l1Uj_+4?eX?X|5PxW+W-A~UbR}nlpwil;(v}Kl8|rtUjc{wx z9Og8|8#s$>mqu%nwYWl}4P(mks|dOL8VLSrbZp@G4l1^k21z28M8D9=v4mWLe8I1% zszExsHiQA()32e8@R52AbDA=tYe63A8hvPVZO8*%PakecNc@S;`lskv!13)=EGZ2V zbghX_SAd*~C9y#&0Sm$a?&w$0M)*Lzf;mkY=~|Hox*};xy&&6=as(A&d9BIsKLe5U zb&zN}Bv+VIcEISNLGuyG>F!{s^nlbuE3pT}nWT>91NvOrK=~oZeCjwhW2RwzJb8X3 zg8XA@#OXm$Slr2~Upae@_R=~PTcZ5dW^a9gfL-NY$k~?mX>1AZ{hR`&LVNRNs_BBU z-okF*l&OO}65CHxf=(JZBz?{;_6vWcabH z$9tIQL;&_w!zXouUoYP-A6E)Q!!K7@ukbQzgUihaEMzfP6gFLF1=tcW56Nx;6BJDt zI*`4C%DaZ{mi+@GG&4Hi-`W2rjS7AC&Qr9L_(2L;8GNcY3l`x9>YT^$d7_1g3Oi;5 zC6y*vzNzOSCW3J^;5##K$d&}SanBj!9$@uv$rg(3P%3oBG3gU*ezC3Q%?5Z3p|%Sg zEt%&SHhT#^rB#+sB1OHt^P@-@!yw=iAPodCFvZ~F6@$htuw=$;fE~s#mAby>KF~=4 z2RH5tR3W^}oFHWq%KBm!2yY^dNYbQ-9$`}Q>edLgd!Pffd5G4oBlH=sI?vFpL06I}M5UUe2+HVvRP77_wgnu5$-3ongfRf1 zmy?#cHvG`UGZI@y%}Dk_CxS`=e|ffRN>F%s%}71-Mx4rDdiptSxc@!%JGa^l$H&PP z7{VRr_d|-0x>g6Yznc}2AEFeOm{G>72ZpME6zS09Dp@%xd2isb!dgR0Z3Sr86`!pz zZkkWib-!Q#ZgeC~u=1fhi~=kVcfS8p>C@i`9MeoCsC-Lr(AveCwm-SD3_cFSw6UD4 z%NLKj0GZys&iyU94H9tzUTb12z&BXz@V+Gk2`a|>ZZjAa#Oum>DnK;qQcxb3kPgNe z(n&O|Qe1HD8Y?(jjNqyLbylN1UODI{aAcj$(%69m<_jVhfAs!jheN{MYKgFPl$1P^ zu#5CF_Z3<>)q9yXUc@8iRd5pE5q-sTb-D$P5Az6~PA9&`Obta#FK>?`dn?~sR)i=l z66D9_c;oyZx~ywOi8Ao(@p%mk;S!GeJOu3Mj?qWI(M`(#(lEcv(TOG)q3!)!H{nK9ojtv=yROTIJAssT+0bQmi6ga!s@RbNWc z(HD;m0ngs@4zCe0IkIBRBGBbI+|>VA-`vPU`|9+5g~igOM3aRt9<$t{KpwR=NT=2? z(eIm#!5LB8z*cT9fBkzRVRg5uYsAFD+KLM&Z5^Z>&@{LP_)!M}((6ItP9?BYGFMin z`bNK82Gb4P6Xm-swU&m?f%$Ijo2@+(r!~v`R#_SZ+dbMNhJKAxkWf9_iRT`UKR6~^ zUpy<@m*?NDWd1w-hJ4?HBa;8!@?9f*HtEWLqaHNpNBY6B_o?+gz4*b>qvRQRK~R+u zYzQJsy5#fcWFY9|MlW4~7?CUhjw)cpj)2bPr@apnH;MgVkJ%BR5uRgv?V`zvt?;hk zipFfX(gB&()Y909DoxHOZF?!NrXoy@0c{W6_zxn2yJX7zoa9BXLZ|q)fNtEYU-6+% z$UEfT;uxcV>D@U=R;s9nl1w@tN=3#hZ8iP#&=RU6X!R9h4D|4;DQxbO2yAvt<4VXu z3=l0|I^Msgp&Su>(L*d5xD^9mfPCeca!3X&T|ATnX`acYhi%uh=}?x^%7gf=SPidj_~@?lg?kb^Gek~svYn_xY-XO; z&K~B~x8(hTzoQE1HDgl+z2X6H zG29V)6~&ELFju!qbG=Ge2=lfd+lD68`h+jahr_|9rS-XM-?;V<7SBmHmxQFv|8>i zUv)qnWP?A|1vbpxU-a#_`#4f#df7!Y7v-x^v>~=4VZIu$^qNzLW-OA0W9JsW3kfq- z?rVxqP@;@1>W!z)@~#>TMno}r#clKnS{?)C%m zi24qE1Y*y0%*q&*1uC2HT_%FYhZ83$ENjB3Sr!)WBoHsc>BE^KK3yior;|iX7h*@V zD&+`d%K7?kd$H{xHy)a$1JZt+kLuF}Bs>H_a8 zqq*>(}Pd&QVy`T3R2zKH|N^0epTT;bV%(oV)BO04Yi# z7ptDei`n9M7!@{nnUJInkTJ3<_d1-&E)Mzi1pTC477}o2rD08 zp=;i=0V->EPfAdr2e7^ll5$KPH`?TFX~Qf`BCQ35(yCONJzpZ89>hC4ui*&0#VLS3 zP>DXSu!NmpiC*sc@1+zI9ZV@Tz9Z}EE0NY1*Q14nMY6YU#S->d&aEu_rLBh&;Qz$GH+&p}Kkm2s#viZYVS|N-Df$79;!QJ z;H8Eoig=cOwnhE$pW8jEO8Z&d5Ah&5?xpSDvP0rpG&#QU9>~Sb@&Q-xXMt{vV6SY< zVbjS8j5OaRf*U#$LpD|C za4Cnn3IAO=U;;dx2}2aR*=)T}w5GKD39Lz*zkxfp*3q4?)KuAC8z042qbMTt&4W3e zxzCZMcR=aRAfHI<$}j_K+XFHm763BMJE%06rBW0l{6a7UT}z2Wd&0MHT;O1^%g!4& zznr(Cs5t*9Na*Q^)d~YQM`HYqqS$gnEJ#Y+pR2`7-0HQT&1eaA8niDlW;tDEVAj6i z>uDC_J7n(dz?$w@lFMwva%S4lZffSq6o}%d5YeV1%I(VI8LXOY9DZ?LqE{q{dQ}H&W^{mD$NrIu#10 z<)K1I0707ulHlCX9OR5Sj5-{Qn3PS&P~|qV?d=z5sP8MMY^def!d>cMS`YeWYx?X> z-#*_!n1%c!wJ0j$yZ*MZ;BpuCChXB*W0FDW9^2u+5Vr+)kSg!$F6lY0!2-TnezEB4 z+SLa-Yph*X4$S^3keE!hy+l)U&)kbc+iep=)>I;QiBTuE@l3-DOo)>%ebOPc!Z?x@ zkzeLjRWuYwlZG+{quj{a7=z9^eC;lzhL`ZYvEed1J09$me@3FgLzkg`mLhaK%GotKZ9JNAS98j%j!k zw!_nD8panckvDi2Z*wg+1)z~KX0}p{?^_Y5jS`ZBI@avESi|)u1o~WyCV8yB(1Fbw zp3-c8+}R6oRdW-zbS=5I9GHzmk{w$cvx>-V5yQOKMIe}%&|~(Gb}SVK-56m*fH zfQ7xid+=i)nn7~a@mdb1GVjq1%t&!!GUPmzmea9b31?w(x?JIG_Z-~2iIo;lbc_F~ zIe9M!C~<9_=`lwb@g&AUsG$fJd?1Or@GK`LT{!s>xraE8y-qZs^*~~xtYN&v=Z7U9 zPGw$Bl#yF%?x)fZ)m?P>Lk%b>he}Cz3hMob%IS~}_or0HlIA;AkXVxGY$fKZvC9mY z*nC`~cxtJ^Bh2u`=2nW8h@t1K2#{gvb%A$y&}@Bi^zPV;8-Rux+-@71H>M7$A>z!A*|Z!(d&)s~q7fN6pJ}%JZhgm zbCW1NL|8qe0I3I9NtGj5PW{#)%T(ql=wIzWUq%NW3&g)7H|F@QaR3A5)5p!ERZ zRIUI<{Zx7zU!=AVYYDxxAQRvYl?w>tA!^7*`14r9DjV!4=kJNumbw|7Lo3@9^}td# zMVyS{6lGX-rU>)v%oML%VrG*&W}RXjTuG*=^Ac9$JVl->xAE5Z;n#&=nq$5>Pt`FM z^V3oX`96nG=j~j2KRM?x=BDHvUh9lWzd4+4CQcD%CGZqY-8OMNO|0{*%Hk=eo(|`M zM9$&~&g|q32V1@)g%(R&MI5aID(QilxCpXV-ElG*t7aUwK>NvoZC12E`fyAL$hq>dnpL zf?HRawnBBp_8$AyFRS>DS4_-^088_w0^;c=%3E@n}ytOdBHhXwf zsURF=>a6Y5j#&JjA`0fouwPWe8Kr^BLUC-AVQt13)y#ROp+ z&8CDSR7CRl4Y4rjzZ*T`4qIpPe1b>kYt5vGvhG_WZR2mR$jr8n%H+WWc4bOHa^!#T z{4tv=MHS(-qC+x8m?AuZ68ETfih!uddu<>O*%fCKY$*&c7RM`q#4KYH-Ia<=iy;qZ zFjii^o;U7?V`q_kdmx_o>Bek{@V_&I=6PpQPUgm#Z9OUUSY5(l)LV?J9l9QZX&8)R zHzjzv52A{b5C7Y38kZJSyG$${`TdjVCJb!NW6REtx4U9K)GY>#o(}4wK3@{HegmYd z%G%<^TXRn0UCL@U#)3z)leG%dg0?4f_hYysy*)t`%VOOCR-eUPIL2aFxu(^K&GJD2 z&Iu^l41x~SnCv4!oabm$z6sYO?DsMwCji|^Zs5hhN6_5mxMZfQrq?I=V+5te*ly`W zqIcVf)A9h3D#Dk%xcSF+_j!MZBNtMy;K3Taqz_g{08tkkYn@so-HBr4eZhMfs6w=l zzeWWI>iSTms08W}FZlkYV+61(D}YwkL3B%YtFD(P;Xx&dCMky%lh;tIMQ&Z@nxTUn zUhu>mjddhoU2SLEf>E)N0BH)ZidKMwEdOhJMgEv4ASvzVfQH^HBxXOa#P^(OQy#v< z$X(}=!!Xk#7YxLV0d7bEv|4V}qbZnX&isCCmK|rqs4}7!Q@xl0 z6I*jfJOQ<%;?E{9$2WCb*7i*#FA0OR=R&oSpA97G3iiv3RqDxJ*0<22G%)(^jtAMG z-yP1<_S?;*sHbr7WIY$;?--Z~8$X{Cc#1Pe)G5}th&P+#8zh>~^8_s>8NQn|izy|{ ziFRZ&^z$37=0@t}6OGKE2|4r3Z}=7hi~h@61?ay7C64_+xWakPJCf3xO)SCo|!M*a;vVWP@c ztJU4h?H$xrUaT>P`lR;y*6?0nb27t`ZG~$oICntP+f~n4vj~+G zpGop%G*E4^1HN9WFi!+t(1`R{T=ToM(AOL>i|kcLdp}+Fh}QHw2nbwLH-9R#JHg_N z+tid(bYcG|G`s0bm+(-Ti*eb4`aD0=E!3g2=8=0uXCOTv&UTO{ws?EM4Z17rv-{2L zkUfQy1#vQ5|2ZCSf4HIHYS8dKva*NF*7X*|g$^@@{1zCiltuts%U-SbcU$;^m@t6* zQH&FAu&Y^Y?5mFfMb>K!I$cX1{{#09b*DXPC-Og)#&E`18Y}~3r}ls56NGAdfNLx4 zgEVkHI~B*`(ry+RP{tb|of=P6>bSOp!9C&=FYo(3M9=$TBd|8(_h5tf*0HL}ecPINprHWzWW&+K#!4j;T)p)7o~&nR>b z#amH*Fy5Ew{tad+)RGK0Lam3kVR=1vex$GxUDmVO-w|*N(vU;1_Msq?2ePpYpo(Q} zcaJ=Zi@@y?YK|FP2URSSOSQlzsko~O+qIqes+BX~TH?u#Ii>VH3Lr6$X9%tm4$z!w zMe&FmvTXDW7>ws8o*8afbe5hu1ZM9TC9?FuunWxF1d$nEh&eCgMCav)qDk5xDjg6JStYGA$ z9q+KOFJVmZ=jwNZOS2VY$*m09IV=VJM0grZrq!k5Td>r*ma_)A_Nvj-3AAAJmjh|) zn_Pl-k1)WY_~OC6K&!ww2eQV&PK-3%3ANkg7I*kIP{CVA}j~3|qx0 z3i?9@r!IPPCvrv-UhY$gIhF(#c@#vXXzK@m562 z3l2~%)e7XKu(sGY*rL)iR_iFMDTI+SkrMZ~5Vw7`*4Z4`#8*CaLlw*<5x<*SCJ#sQ zQG%3W4M}A(r7M7(&t+Qt;|-NA81~ht(tHwaH&^heyVopyhsQFOo7Lu?G|Y)}idwEt z7=jD(4ac?3Gp|>X_6y{{+U{;qYy31B2?HkgFL9U(PIsjgzw(6sDWrS~nPLOQ(|N#` z2OM{Y+ng4h0CzItcr)?ErVJWz?D~jV?--HNHz>rsh8Bl0!075C3)LErKp_S4K+^M2 ze{GB>CYemP{HFLG#`;#e*kGD{stHeVvZ1a4Pcf!C>=b973=_PpOyb3)DJWWrkU-xI zL>7~?(;g*$>h(Qu+J31_HJ>diSI2K<(}msf>`1$nnA=`F1MV+5oL^)#*ajrKyu7?^ z=N!VZzG&C1nX9KDFkw!fOtomUC2uV_Ha^_lZ|MQy$AwbE6agSG5|S(9B*nZ~a6tgF z660a!gq3K~OkT8+ZRof`>jXBAYaKe!?c*K1Fp!Pc1{6cgsLewMnct>hE)Z%B?|U7< zk=@2@6GT6NWdqh4nW(mMvJDV5W&`R#W5({NnAz;b>pxaY1ai4V1N=G@ZZumULOP|=x=mC@*VIt^um@73NLJCm= z2!;M2KN4Og%X-?nO(id zsPIa92#=x7JEzw9F2WhTC5xP0}a(m zY}+N#Jlh?652qTt5+Em8d^+pC{!>yAM}=ItJ|cV#Pk>KX*oxe*FZO!Tbv9)p3t6S* zMb6FYX3>4z>iYEQ%G11dtWJQf};q=bRjQQ2!$290~t|KCSU?)a1z9H@C)BozQm8+DuQ9eu13!;o2|btd1de8 z7za|>$gW>jqjfC;P?oMF==L05u6GZJGUGD^KcaglO4%>sFG%&3Qf`UxOTNM5%>9G_ zm^O<0N({V0rP`>3#Bag96@vS3@FH-{ z_D17We9-ie%Xk10v|ylB?Z<&O7w}AbqkS;?sm;M8q}qCe;nNSqd6)PB3_s=h%?`o$ z-r(_}6ij=XU3etBmV>C65s+lO-z}YV@Slv=eojK)z(k4}wSjdeVWfHYF~z_Iizy3@^^c<6le{4itmxAo&!#bY9JT87`J!)M2UVdfRKkV+XOhL$Dna0@DH^!Ib z4MvP6I6b?pgAy@6RlAcrGS;H}WLB+%DC7%;vX+ZH85cU}jMi~81y%fvu|mKmJjo}h z{*Gj_o>=9WZM)Dqhb(FahL}u*6lY?rflO;~TNeqNnSu_3uU%EdCNpR{r&Jx=UFQ*c zKR~7!cp1eyVOu?wgYlC}z`yLqQM{iiPIwORL^bG9usRzl^{$RBYKrO%a^W>ixPV`- zz9#KRiBt+zVd{5__KSk?S3E)@1l$M0PYl-b9@=pGeS7|Khk%!#iU4wdj~6rWIhgo_ zdoMpap?Xa^n29C)AdkP`q1{;n|Zf0^NJWG}B zA*$rDOewkRe&&!IG^3ka`dZ7Z$5fJ0k{c*Ngsz}zCexLzf@!MHTX0sFY!-lz*)6%};@z`e{j4hFR`#mOv)7H+>N3@E<2?9wSnJD+z@WghMtXahw{ z0-Mv7A2Z_~8<$JmM?xbp;{RA(&}E3OY}~e@R)~fMw-=Mex(VkOR;iWzMR`tIG)~SV z%?2*X`T^R`S4C9XI}SE85WG|Txg7LB%3AZtF3b}K_EuvQ!KX!qzy46mP8d?$M7c$&+|s6`AnRHvAJ__%uGHu3gM62 zVI4x9dMrG?wKBthCLqunPwv_$Nu9X1P=ggM^SFX%Lfxu$!2Fo3^_g;J%x*RO>J0B+ z9xA8cLJsCvO2dRuiR?dMR!;!+i2Mk}A_3G{%xgJ8Z`YqW`+{~jYSW&xltHTo+!jS`8Wlf}Ybvg&JwO|a-n?Dn6dF;B z3G?dh!?vJOjg^=Zro(EI!g6_w-Cqf)a+L+Y+xn;_AisvyQl{BSmdnL+uACF)Q_Ja- zD<%_twX7>8=E5G!%lwLcw#7-(LeWUdy-)ZHl&?P+a}e~Wh5*IscFE;c>!s8WNH387 z)x)h;690=cdH^))`qf4j$8kvE!PW-Ljqi8vF;HfIf^O2xqCp&yk%Jj_rXnB9LyeF$ zM8X0)pYF<8nl-B;g9c(3L*-_JTbgbsYQTGHF}~qZud;dgInl=v_36hN1LGXFFE65wZp|B~>Z^Vcst zLzrnmF{Z)^5ob|rS|_ki2ZOf-kakvhtTe!5yNPPsNS=3cOJVT?SBhlN(3u~JJpj9f z2(ZSMv33b}?&kMrTf#a3cH_9W!Hb0S!)d4@eJfgLoO;rBuQHKs|8R>2;9v+Q5gB64 z0SNs4aeWW9-!>B1I-9LXV0&o{v&5b!S@I45U9vC@X(o7yJ--D#J=(3XFtD{SC*0|v zn!z_XU6(LfKz{2@H<;o-p;vEl`9aao@t`DpX!op|Ze8)gW6f1v zP&L!fH|8(HM)(dG{qd)pTOqzNkh#7=ojPGF;)63hUtZ!qLd}51Dw*MDja#)!wO zAXF^uww{bf@CkGWLfI+s`2|v&2hjMrqZ5fS?l}bB%_H22VE{o26n69Z2!K7)lIhr# zplSJer7d-S`b#ePy{0P0J!V2E4)f#A7R>zKWA~dM@$O0jU=^f*%5O#kxLIL;D#4Oq zJ?WBPdpz_KA9mphBcQz{BAD*!UWN~<1yHc;L%X0O_p^ETu>aKdPJY2tROE3#SmWy* zRLwnvWS@p$h_;(b>ys0eE6mv5Es-wS=XK_f)L817v-T=R~3j%-=1 zr3BiyDFRj+ZJI~BYYY!xQT&1?r$Y?<43PtiAOnw~4bmz7(t%_gl-)uVb0Ao8wKfSY zN8A0U0`Wo2-5X30ViQN1B*zrf+8($&iDL@+ggBW!f0k;P4Xat=#Sbbq@|^y)MrfY1 ztx{S8X-5DjLWWTM;bd0#opmgTZ&(Vb6J!7E#vu9C;e^n(024UIpB#U={R=PN#Zj(` zaNAi^ZM}#Ie83LYn4m|(fFFh(Yj`Uiila%AF~N*h(W90D@)|RHC_OqnMbDHWhfmCD zhDaFjrGtu-hlI2)j&17n)M-6)Wi{o0ieJ)73+Nveo1Zqa-Jr~)h>f+L$qvU)$&&nf zw_Lj;9yjzd;@#mU3mB5p#Fj$TV{_9Sh&BKtQ>=3;%1>G2cdW4Y!1~O~g|2-eoxiPE zA-C43PtH8+29us;6~48CVODdPB!kXD+c?k>QtB|S`!;Q^ovXA>ptHH{(6e0a(fz@+1foZh6uF_#6hr5j z(e84fG$z}bm{*^BlnE9166S1+o+y4=^t9ON5Me3i76M)4ZRM-&OrIM{u-8FUmS7@( zQnw{xG{LMXRT1}j7)`Zd77Cq-JAnu60=Pa-yP~WlGL6lF#_!qUG?K@S&uXRu*3?!3 zd^e9%*K}eK>^*`8geOl*dPjW%u`dxpNN;YmLYvmCXa&hvCz#FFU6&x)lJCve)rLg{ z<;d4&D6gb+In?9dx7nbvpGJ}nL7Sk-?hnq;n@703Uj7EB=)B9fG?#cVRc=Ij1dJ#197% zQ^cF)Ts2%aTRPgr`#jsbpj)%THnsEbFv{UBlpKs$!0WGe6~)wO>dn#^TGLEqv4HmL z$erD(BV#n~5iw8p9~8?CheM?~&nIQahh%AYtm~*Wz;4l)9{zHvQH~zQ=ir<*uZ5d( zF0O3!2u(^gzkuDRoQhEE@pRL!=a4|b8MR)}168SYZjF*Y}+(`spXRNP0cQ)8&YG=l5`Ai4xTmZ zcKMDS2GptGUYUC}xvfz2GLF(yua9ill5Q^XzIF_{+9nOinO93bQfa^ril!6@Wk`e3 zpze?5WS}A6y3Ea{Z!9q1FppDj7u_-2;cE!e@rNGdLMyp-j-xkZ-Y+n*aKUD6zLvn; zBLWESb6~b>cCGiXzvBAWf-XFZGrTp3eaw!BPY^Bth5b&hwd`bmVEA!9cYy^kELU7w zjC@3-;m|*&SitE2Wt9n8)O<0v6u}>ao|3rMzgfZw$D3oJuiHH>iVYW>x3Cikk0%(q z1BXsW;#CyGkTp65w@~3eQf!d{M0uzLOZazU2O7r?C})R_42y$|S$)MA`RU$2^lk0f zt&qCscx1b9zgvsl=9_WkZ|tG9)&yGa#@@f$ih6FkB(b3m*vh9dJ%vgO z_sZB2X%l?(aLqlbjl6^*%*QzhW}zN7(~-)fB-@F%;VWYbw=^7JF$|1cykx_pzWK1* zben}et?9Y1z!If%9MuWwPO++>+3riqCSTq$Y#A*u?~j2?aBpKpv+>x zEQK1Jp;YUJgUhmDqUj1d&~X?GmIyHz+`hWxGsHN7d%OKFDCY2SS<@|wbD&52$9f5o zA*T(`A!|2VJIRL;#X?KMzIY^p*C~7Nq3V!l?zoHIz9Qh!zBSp77sa9ALmeVyB7!kr zu}(+@P5zdE)<+`8PtL(08py|vMN;6C1VZVJ`ujyh1*21C%_vd0i0nA_Z)GADj`KU- zskY`#Aq9!7H?&?y2nNFr04LmF*;JzUimQR?+s8b#j*qdCZmg zC$mA!CH-tkDOIMq=8`;@Y!4c|R@cw5Di83PCKxg28fPhUZR_%MP3!V>EsK=0Id$&$!b>6V~unfQXzVz?9jCsYXz3EEj`h+KU8nfdNZnAV=t+mC!|mB z)8ZagT`|AtxZYOJD=Nmc;eLR_`_6Ax!1Dqs$;q7aMvNd1;Ea_%#Ot}=YNK) z%A-YJxa~j{HK>1aZptZfs}oeXGnig^awnc~rwV$1D7>wYlWzz{u*C;ZJY-j-;!fuv=ib+HAQtd=SQH(3Yo-hm)xjX?exyVryi@n_=5qaH1-Hraob* zVP@M}>~@h_grKlHQjKdwrlDl14=CK4Xk3Ov zF@z6gE?ilG3mD_em&QYtFy)5yV}r4V>)IdxLR*wv# z^J>PEKoGG|iTfN{}|$Sbo_f`z>^hgYDwc#ADefvQlZ-ILd~*l`#^_An^xRcNF_y zvPD^-<{1oTltb+vt(?vPCDDFQ-jwxR*x7cb~vfGzua<3S;-Y#FmQ2eiB(~0cB?X~vbK;_) z6Wv!1X=7pV52rGW1S;kp9;+HRIr=`r;x7mu-C~>)0d0jIy10l#N<+DZME>oGCNq5~ z0VH4TpzO-M=unzVocW>=4B%i7CyqkT4^%NhJXj>iba+e-l%8V1_O!pBy(ZVYSbevH z;{zPfhP=Ae$@_>jLc!JCthXkYVli5NT*FMkhwU31Pg&kK>sY?I>xBe(0oneUyL2oV zn6bLs4WWX+n9KzD(g$lY*%k86M6fn~xic}@1=AO2ZVw$Gr|9+`_84vn(Qz|UXyJf^ zi(d{$Q&bszx5gsTJ!H%pFnu6n{QO(?I!+uY6xiuQdR>}0#hPjkHgk!PwLO>uk`P{> z`xQ}8IhC>;*f}JH1L>Z~oFPE!ggsl4E>eG6-I)1o4-Z@PnE_P7LW(H8TzHH4IEw?wLWalDl>3FQ}uHs|P`ensl4n zN32K~Q<}h>!W`u@E`R<_JNyx>^W;KKQxEfHWGAwwhxu}cr?^HB^Qjs5IV9yyn-IW0 zF-8s1#lj7Ofy|_WJ7taxZ5D4nvt5ih%SY)YJWlTN-i4DaFLhy-a}DGElj;C{-q=0% zLR;yJ2m+vcCyUb+UWTgE9>mi8XtRL#b3!PfEJlROPYT_zE5~n46A+d=!1oACjbjOT z?3e_6WmCo-*BV~6L%@cYh)m_cd;l;+wuw0JZKKHKooN<25t32#F-19EO)tNymeaoXGl_(ah7i@oJ+waA(@+N+bRD-;p~$~q>4>VwT1CTZ4ERW6|>fd?Bpb!8Kr-T(nW9}2b(X$Gd) zK2XvSXl0t=JWOw^Kj1+En?0OHQjpim)E--(xro&U3{YYE9-WxJ@I>uxQ@>Y1kt`G1 z3J&NNKt`qL>U$|8TQ(*baiDqEBB^J)#d{_t?Ebq0SxzPio&%=bF-!FA?e^N-?#E8g z)Q=d7_psmkm>fdLBZz5p`T`E5Xa1R1s{o^18NwKkVZf^dh(>>3t|>OlvU>Rotd!Ri z@_VS=^+zXGtJmQJHvFCJ-q-{`Qs&%``Nz%$RyGV!s!d!Pqs z)X83$PBE5MjG-hfZF4AL3eDxk%>32>6_2{@E3^S9XI(Np*Fr6^ZXs?S^JDoEk*#oJ?n12pwZu7+txG@{0?VasY#=k?!p?ogd$7 zr&9Q1GxPh-g_0xhtgW6suGKLkgPoI>reSys_jn(w!GTPr_e~WOh zr4DSU^d(|NCl(CTHrHBVF=pFr;%4ZD4ZsK_RtBDJbx#{;CJ1{7NMyzIH~i)htM4aB zbO@8Rbp-E-m2^1R)iM7JeT`N(OFUF>cS#M<*@9^dw$@{a$f7o2kCWmtCBc!HRDOS% z)2l_2c57;hLZQN7OtNV0Mq3O$;`Q1IAj~Z|(z!ofUeRA{l5W`;o#A`XAZ4s^HexL8 z_^Oza=t)4UsGaS{9VE2B2Lu{OVRIN}>tBB6M5gWM7Jb*jF}Ch1O}3IuF>8%>PsP^W z(U-WK4pZtf1!r7wc%|j)P$`E-=m}!OuY7lUx4Mv@A{JZo4rJKuLGt&X=((;Jn0Rk# zJ-nR;^l-fSg7+f)LDxu1*{FietP|H`Tw-&v+MXh^t_1w;N6;M1r}I|W+{qHy>0^f< zHW>g=dIR7k+M65bQ6n5NWZ))ihxWk1Sh5Wzyc;|>w|egbhoHa0OJK{Ju$SgdYD*d% z+;ACNPeiyYHKP;L88NJ&!*A3<&5cSsWicvo}H4R;2U`)7p!0{ZOnTFY!um3FJBZLbuJ@5j9 zWWA-H!nZ9QtdjWGlqaH&?s2cw}&O$+5eIK!K{N z@ye+xZC?G|a~x;jb1)4Xgpdl;hm(kf)Nc$orx%YoaVHwn$_D(~D2nUg0rTWv4avm{ zu|44-SOm(?#_9A;2p(KNQ&ziZD5wM9cQq(`Ji?5d=Zp8c%|eGK8pfK`hD2gX6BNv5 zl4uS-w&a@?%oV~)U2>D|+07A#aVelh`K>JOw9?qg5lBgIr%spg`)YmtV3*ZcArT}# z`S|B{CnOQV7LiGTMvX&>%sHtd`!t`zJkZm>tT7{v*@4Glw+}szq_@abb@@EhXLh*n zq*~DG$nr~JFrYxNtZt+lhZ#|DSY+|v+s{*>9evN!Cz&MYv!zfaRFDDt6JR`9BQ#wV<)DA4XpBArwJ*`60 zwS%~EbWlc?-WC~VQUe0ii)jsXhRc+LqvKYKr&!4IW*hz0#nz<#GwFuXU9eAsq>_MY z2&2$6UV8O0nBa7^`=a>xV^u{8p_g1Y6^tZC!B_&jSkMiQX7_wefk%=eH%_8&E@Y)q zD!h}S8U6gP|E6I8Z?vzYo9nH@mEr|-JvKM+7j94~1PW%s$(@~W^5P}6eeO)1fopx{b z>_7|e)E_$i9)2|^H?Fytt$I{`sd98|6>z|pml%Zpnq?w*37%0 zzXj#@&!DyMpnm#s&a>lJA2ab8TG@t+OripfpYUmpBKGOLnt9|No&{^6E#@YVVX+ZE!61k(1WWGIybi2^&8 z?W2eL?JfB4qP6t(hJ0xY@e|3{wthrmTzS0lBnOB%|o= zzLEa785$~v!+b(%EEiTuphf`7C_D~^MS^&9aQ3~y8+Cj91~*#O(XJ_&2zH$IVEO5rb8r?45mj zyvpcAi{T#QbTBBqXFNt zLvnt&!(xOWfLwg+mqUC;E&Q*y%Gcs-h|9lIYzuFfA$lno&R4g0_olx=V%gr?L}my= z#5tgYmqg`lP&7w~YwM0zHYs>q&gqJ*h5N%&413t95a3tTh|g9Wko;?c?D z8xU9Bs56R$5oINNinxc@%Zm`->f)s-OxAfkG+2d~_dojO-pP>NeEw9P1ZC*%btq}% z0Yf>-$8W30)TUlAUM#P!5aQ7X$2x|4;RZ#t+SSG9x88cwkjw{H@4Vuu&n-2KD~M$V zJN=U@bX&SJqZDR4y1^FbBee%QXXWzQcr95q>kBT-6l!hjO;w!_pzz3o!D?K=2A61a z0ZrVV8iFo>z#vVXDa`?SF}}LMkNZS+)s@nUszc)>Y5+SU4;qB2CEXu zky1~h!wFM>*AV6{-)vz8$WtXLR;?dU76K^U2UA&*vY{y2$)3J+A@k@S_Lh&35so4t zdXD4XhJ>KoDL7ignlNdwL_6NVqPns&)P|y&o?h%8K8lzc9iEMvTBpVLKOVL;d)ic| zqO*zhw;7c+gY}{fb~8MErD6!_1XJPW`e6y*UIhP31q;S_X=Zk3AVsD7t$lznP-ZTJ z`N1)GRf}e72O!4VsE(=mp}bkWGUgZ4LjKtlr7!0`<{*(f!1MYwStYZ%UCXi|ZKZ2f z*7AbNJX;8fs&S$2NP#*5&TP(!+rUzco%mL=FEi@e$NtGN2}9`G$bpt?%xAmLtJr$omIq z*SK}{ut5aZzOj>GBErzbS)8F^6P%$Q1mPTuC1@xGHX_EHx>{av{U&8{2K0kYvL8rd zE+2t36mjsK4d(I)TRWP>LA*L64M$%jtOwSwX_ILrY&HTO2{T+ z1ygXdw6bYvFb)mY7T^EaujfO?Ndun?Zvq~&@zDm9%Nl(19Ey-yGQyq@fJyN~de7~W zY#oye!pi9-!jHDi>mkHBzTUv@VMoQblJtp>3u&#V^u?*8&7KmYMF)`ormy&nD#R@z{8xN?d& z-a|8S*By4E!Sr+*?kP41ZfcJ6hJwKW4O2$f_9;f-spIwnR|n8SxrAQ>MvP zAj7j>*l+u{Gz6u&ABZK4 zAkyz_HI~#@;g^&!a#-^Dv?M1nzV>>VRSqN=NbI_B5KY>EQFV8To~+yzzBB{EOGHYb zIUEsC_n)as9R0P#LqX;u$2+4WAvV`cf@Tct#fkiu4Eg~(#;a9@)I5|t=JTuC@daO) zixq^8PH}Wa5PY=w&*VQ=bFyQrEnFc+R4;nMJ59rkVlK0Tg*F(HmUG;OU~7TAW}qu+bX|;X%NI zm{HjjgI~b}=h%TY;f_qJf!M?iZk3V3s>N9wCQBxJVVCP9mnL&R0|>TvkWkp7W!@`t5Yroa~GmhJZKI~!HGG1wc!4;*9GgAXdq~Eq;_Qtz`jhqB8p^K9+C95-eR2eW_gUvK(29o9Q4rbmXe&6RM=vz@{?~%bQJ4k4n{TYymGL3 z0m_<+ zE7@oonGXEzrE%0sszjS*+$?24jxt_F3_9~f4YgFDpLEkhhb@Hbl;U9*9ft9?6CxRE z7aCm9bH%XfBrxN6u6pnX8mMYamFVrH+d{y_uilcFl><1e2l>jt^wSb8%h|J0d!v=@ zS*P(a(4Zw>dd6_7Yydol3LIk(JPpBKjB-r~rTznxyrrbJQfJ+OzSZ{u{-qm4RQaUs z6{mV;)(SD!^xNGH;{wZ(m}tDk)&UB)j^Z@7%zU_8L3qFLbG`vn;?&2?z>I9<`!hf+q+Yu%33znjXeB4GhT#*Yi;t+?_dGj4s4+s6JWZ;&8peuKj-T)m|+f zei!j%$2VsKL|El8O;;rqCks2;#eNTGm;E(F^9+;;Gu4PN$O}Asd5PsHbJ*un4>lcH z3_-723ZgyDr?JhOoE83OBoW3xKH1yqlNVR03l527u}7NZPLc+!Cx6+B4Y1~1nVYWW zx2Yq71XeZ$CU6^PI)>v6V-xcma~ARs(9nL3aEJ`a95Z;stAaJfJ)ruenjP+?KkFop zn(Dx$ZkigMG*-zz$$4%r>}H>ucGS+fQMpzKCHb5&ZXX1A?UWNsdmQrfVnCl1TAs@He|n}4ri zD49iF`p8QBD@*IUX}hGfg@)}4PLr@twHFYK*a*T#BfhmkAm>QRpB-4d;Gxgyfjt(M<)sLWY!jF0SRhl}3V1nUJt8s^`T8=12S2sDmI=KXiOSz%uz}h=g0=i({KXhx6E<^jOOCAtcX<~$+kL208Q~(emMs0 zjUFiBq~XU)toOHAx%I*4m0^Ry1b@Ijop-z84vN3#;sbLqokIi()%n}{$M3w+#adup zjgIO2e-FOl<^U$Nl348bJ2b*_8ddl~KJ0NI?p%duAom+wwv7VfMNcpW$POg(6*{l+ z#@2cVr?@+W?x{cQYL}&upCeblE%V}#MQxqI5{(o=cmnhyG2K=8y|Wwd!1xvu^>FrW zvC%=7tIk;=aB-|CL0Sg2)wGwE<7a{p*cZyC3`J_;X?$D_WC4;c4suo_K^msVcg|Y= z&Pi*4CNo$nrYwPUI>$tLCfOV%e9Tw;rj7|;583pqsf!%VTV9Bnn> z+^Qz*h=Yg(RQv*t?`6PK}6a3y{Zm=Y;3Yo25|3e1KjyBy%-5UlcHyC}>- z@4mr+GfCD>U51z);AAoT{^cY7yPw@)<SEKyk&hGYwN|RkeJZW z%o7L}Wj~wQXw&ot@1Wq0=KbR1!F_1;;lOahgjkRjfoCN*5+67ajhPAuKQ4+=!s0i9 zXpX=#Ly71=Efoejd9^W0GhRuW!G{q+yMY`ej~yKuxE3zk$ar}bV_WZb0?%)(Wok>2 z>AmvYhhEU?^L2seaz11ESjhwU|NS@Hh`z&_)rb3K`Eypz0T81iHz5*`kb))-4l~?x zrNbIe&h20WkJ8&c6ZTQe=->74*Wjtu*EpiV`CU*+{u6k+3jNzH)V(hK$@S_afwW%t6w~H&ViAL$kEywur%rAaKV`fYnqR^%~msAZ!Ga{#*{GcO# zf&>o4B^E-z#Z}uCC|aCx6EDO&c*XY*_`oE!(`QxX%1YkDWlUF5E&)=fGzpi(|jW<4q|5>{IQr4mHAJO#HryLg020&PKBvZA=zz=RDU21G~E31#>!n1eAYINu}G0*YzINY!BIT)yuh80X8T7^6xR&FSiarl4rh_j&|P$$JB z=$rdKS=jAJZ%(d)ft|lJq1&Em2B2M4F zsvl<`DQTA$MH;?yp~e0F_z@dQ=LEXQvD>y9#JRNJrLgN&IWK|c_1$NOMsz0mNm>79 z$z;KMarkQzuWBB5V=h1a`9C#BLW!%WN@a+#T0kh)b*O{oa zbR8KNTf7f#N7*kvT6NZ|L7@s0v<=(8WFDDnwSr{E=G+cR(0H3~<`yJda;Bj)BkOv$pn_~Cfv5@Y^RWjk27TyyA9rj~u9PcZwz3_Jk{&f`)!oPfj1 zbk1dorhzto%(L42_lA+-u{ z#cu)MzP!2y!{?GW$fl)4mi)F9SV21LA8YvbLv42T*ii(xdHZxnPURLuNq6T#3!|P* z)M*HS6m!kDcMpsYdHD${gR$KE1rDohA7Kliz#?07txCrz`qNHk#3{80>E&f7FsQx; zWaagL5>}TSik^mE6TA1jB_F&33-Z@nUTC`5UO@nb;mF|%1|YwWk&{M#=X2QlX)lGf z>Z1}mqr{U59ReR>J8MV2@J+t|T&)CUJPNgKyNgO|0>rQtFnYvO9oCq}lCL@7OM{p* zGAJU{i8B3kXb@BDuigHOOk;CWL>0%ea+VwvsWOu!l29XG8bMEEswrPz|dF-?DKj4cGaqo z;>ZwEDLW(~6Cw2wM+radtb=ZlKPVV{0Z2n}At!6?6c8z8^=XJtX!s#PfzT<&0%*H& zC{cjb+x+*E$Kt>X?tz-`aZVp2VoSqwMD%by2^_?!1m5}asCfzmg-{F-Y|at2d2Yv^ zTF_}?eF>8pc3Ct9%#Ierjt$$Y`WheuDI6=}dre~>;K(*pk3CuvgS*rT))JNqoEX!v zz+-Mb0d)B(YdqQ61`;#z-A+5CV_4^&%x?!CMKpmqZ*gx$+tiHgaN%+E(dN-w!h(`J z0zRz*J}P?cFBSju-{yEh`3NgyySY`4-S1Bpd%wGV{JMjK_GbB%lAs6IJ5FeB8IBgQ z5kv{wHP{yBXbJBXir^pS4w>g-tDvZSwEbvVwquj-(#P&3i$TR1Z@zeRqK0|HHH6IM zlg1D7#HkNN_+%U2I*1@Dvbog4P<^#h<|EbzdmtS?vb~ zCYOtZ@fRKv`PHfri#vpXGxwiQntnaBs=9D{`TwWt{{1OEEtrtH65R~vu+xV%NQFydeA$j5rx zA?*CAD{&yp*5-fy&y#G-!QROsAuik@$T^%2njHWwPOuJtU4*}ktFWWxh(|UsNG?O~ zoTP06CLIV0cl;fm%jAJVN9UL-12rcCW}d_g^;S!mh@@}R>EW4+!v)mm7Mq`}t_ZYp znFR~se|w!i#t=1GwfPo41>dozL3av-Vx%28>!U1~h`f8KTyo@7w?@b6NVOn%I-vQGxTdQ=WybfJeSz)}Xl! zUX9@-91|2a8bQI>BB2U%38%6--;g2GF=9X0d(55(`wTvF5$HGy#MTph`4V@8%$AV8 z0=fGS{4xi=NZWx6LBFaoSgaF~Ba2H|{doFCf5Iku6i8N#H!l~sRwvg~*jL##8vWA@ zTZ-z27HRWl@z2LTJfeKwa&L`WqR}7~YVGjD#P_5c>JqG>uF=nJv1KVw$hq}hV_D_X zFGlC8q3@s&c;&&b;O8C-qv3$cC3{u1(7Oz^z@90)+NJo3Fj!&udIdL6(gvzBzMG2n zOe)EANW9B=pPIv7s4 zG-VPW=b*e_pJGT$VT+IVtOdztqN+|oH{a-jHX5xEB`psxc3cu~5VE!+BfA{LNy#o+ zGl0#8PbIN%DXaaPyHjcyy;T^EFxQtOy}{dhj;QWi`Q0}2#QU0@Z{2iYQ4%@D*Tg+0Q&FlXXeB*lL zQ|Z(IqdTf6;m%fzJ6P4maOT)w1Ow{yXpDuwyywo2L=30FAxYYP*fG>m5U)l@hR{BA zoG`|VD+G`CAOrEV6=KPXW+R-iPVv+}EfaRR6{`Wkr;xOWwkU=pINfWg07os9JROw! zMTk>i=X=I08+Xh3o=@GJAVB495&TH`H)>eR*@ZfS9u;gSA09Ujc#Pq)aQF5`o9vcyR^(brhW8*k)h+V|1 z^>^4lbtj;y!Z|sqG?1=7ZKO`OFikD>`IwwXH6x%kecsveR|9Pf^a4*(EY~k&fNm$? z5GM;$iveiCK5W16LS~{Rq1-f7@n654r60uJVkiA=bE8p?9iyr3V-~zFEa%oYT{`k} zzNUTeNLAvvxYKYK_CF%WVme_>OWjm!5V}Ce`w{KM z)?5ZUOah!qR4^2~utk3WOzjq@y>NWp^8S#f;E4AOwb%3*IHr`y7LLX6 z2~bsC)aoW$tm;ZAT+#Y_UXG!SbuM(6txGd61yBi&0&DVRn2%HUOKwWIw@Dh#qMDDq zVUx+FE<<@(7pj5r9rq7>a~HK7!euhgT;bH-ufk906M-!1!gy4rrC&WD0t%lwRQw-= zy@CI7)c_7lw&#z&6?%n3H9StvYi8#-h4W6p$8>kIWi0&Iv1A4u{lAg8G5sLd2H0Q= zGzC+x5b1hKX>PIvIM=qICt&rM=NLv)twD7Hu!5-u_H>0E;2fnsk8!Ue-atgiBzTrN zl0#q0Kq%qy*ezVus?n{uJtsmlKrRv5@g{mhUsCw0AXM+y#qAg=Y^C7#56_Bbx|wUL*n15Zc|26Q zC-YJs#xxvPMNgmm&->lO4PIq)#$UVF273&aA8Q!Z5L|uP+;M}s!=o9TSXCC*2c3iK z_D%;2Bn8OjUN3eh207%mku+ai5C!|-q3F4W|G4xR{(!Bq5B29c_B1+S)@loB1&)-# z=39@z1>8Ak8uX08WtMQ|fE^4ks_(Y`ImQ&r0~WZ=f$HF}7qHwN&E7!?K2m!3-DKAZ zAP#5+qSZ&3oNaeooZ3I=9HkmUZnzNNqG5d)D^~C)FT$Xg8~#?gYZ`Xg_NwxdsoJY1 zv;kaUTNPU2unKq2>KA{z-rvAWtjaXO0H!mo{1#`}=66uR=!7TT^=*`1d<=P+mdex# z$@y}PvwegpQK(uIw7Ji2rh>XSGM*WL#)~r|WECp>CWRdzpy?zEC;K3op^z1y3@q zFj;E=%EO>lC;KH`_w1Smsqf`YDWOMzhP6}f|3*v{(Q(`&B$K}!9_3J7I3n2&!wWUW zzW{DdeiwQU`_^7B0A1YYRmC1huT#-lo;Qozw!$&bblMYbmX^Gdnvuv5 zcq50mYHXKXqmvp8z0lTsU}tf=K5bmidxg1SNY3q}TN6c=!ob`~XbZIC5y(P=u*szo zT#kwtgez`9d zBZygxu#F+=%b<2ONxKd!TwHE&sqC=~RmH|)Ha_@)CjWr0if6kk+87-x@VN9;6B_{q zZA#UN&yTXD3Eti)g*1#yPgUE#SjJNlRZf~%!Dxw1@)t%m-raOWEeb7q>{rUwcaNAv z#YpkYo&DL&pPTh}P#zm3N&-|sp9Pauoi*r4fNW_#+{gD^7T zK`A}mH_w%~!cV*Igs^oh(DLGNxL+uc1D6x|R^-8I7lIgv za9I8dO3(jmo~eb@*$}er)vZpRi_e<`j)Z^D6c<0dof>?MH%GBfjHXQu34|bO3=Xs~ z>Rj(Y`d-DoG$<&P*TfTmAuVb_f3z3CeE#|Y=LA@TFn&18 zFxP+{7Pio7n^#VU6W@ycC~>eaI;?TOjjHQYVCL^kjwWnMkbYJD?5w4cz&c@!m%9}K zNUca7*E3qI@%B*gg&y(w67CSX-s_toFg)ccj+mootmh9z9KsVOD{i+Tb}SkoiO9_V z`V(^MJ63p37-i1Gbp2GfR z@OW}B2@8IT`Fw=+4DzWXNa$fF-|e^~#4-ST)IXAigWuv2i^KW){`(py+%SY(nZik) z1LtFYFJ1XFMGh*14w_=CVBN?(%x=H;tpgP@w8g4*Jy7wXfR0UYAG$1!%T9QU9cBEA zuSk@+R)+OLzQB@*3p0 zwGe2oqCJ*cO7$T*jmoA}$>=&OFy@?9ypVK@zA{*iAlujg5ZWb1#|V}Ng!`Nlb=K3 zq{<|YU2hMxbO!y``lG6ks_AqA{^rW)p{RoEeJ=CDmM3A~Dr4ROnzx-jMJ=3FFevJM zY~Dif8xQDJo`#)2{(1qR@z znQpfg8-v%qo>ZNPbnap@l>@{v)jpGi#zf;E)1y4sBK=O~@??;)Ax`CAe)@DUg{#-b z(HiU^x7)zke!qBxpW78qdT$Xe3#V;3VZ&Ikzmj6>d@chH@%1fmOwR}Q7j)BkrgRND z&Eq%;PV~w)y8@Tj5#TvwM;91(_VM7^n$Zs-Nl(|FhuTLA7$)y`_TU=Pw3Iiv^Uf{< z;~DYfRZQ{>Wn;Nxm@D9n`J^OnRIk2vLGUh!#hN47%o2i9IZ#YJ9x%=7*k?;p7bw zWUOMgDUIqlv*-!4Xp<{RNe&@d=aw3~xu*3*mKOfalI=Gm9un`xTbI}Blb0H(3&cBe zyd1?IBz^$m0*%Z~vF=3nP)1IGQNZK&$`rJFezGvlwa0-62wI&yi8zkqTq87rUxXF# z%3@J)=&6barGBCTI1O2x!U=pF57sCX|8ys7D~Gx$_-X+^Mj6?rrh4a_sN-}i7xs^} zQ=x-#DmKEYrXisG=&kAAkujbwF@OJ$``!D0Of^-ZcC@FEWVuT_GF^t%nWd$fdISD7 z`yiYRq*+d(`F!;iaaiO!H^DMc#^8@WRh|a`N6_YUh6BJFVOSnM`Ypt%s#4vVpGK;J z4ZCo3<2W|O6btPiFPhwc_Ht%#nxugr1xEf$?BdZWqukFGRh!aQey*H1`3ohX*0_&w zpg&+0j8aP%&u{Dxa#s1t3Qlp>pjk==`e#gW$jh(yclVDJ2*BeQ+flv+s(I?1wZhwa zf#@Fd%jW@u4S%ptBpn0#_ajv~>Abo|bdRev`jE0binHzhGy-l%+AOhqcnY|tHH0Fz zeNU?1;I%f4s^`wOB3Nrbz`FqhI z&#xG~-^C4DMQjU;9T&7shSzKow+wsW)rVeU=8PyG4OzcJ#p&RIjrzPbOC?YdVJ(wn zmt$E#qj01^baXrr?hiO;C8D#8?&?XK?pU@tp6ETX_y|017L5k|Yk|I*$qq-=*^EUC z3mP^32+h}G?t$Qbldu8e+1J4o5xKJHw9zb1wHVM+#x2TxJek$`)9LepUNk7?+1$8i z=dvxH_{+=;dN4G6qp)_G4(`Ybio6(QnQl<8StOA93e{sSm(flW*uG@#XS|AW2a^{! z<%wQq*VbnX=fT>?a3%2fkXBjM2xNj@*#%5+I-D>NRi{CAkT%j*KdLR2KX6S3vlk8& z6p@KX)>XlVYE8G(tDbtV2>E9comkSi>#y z`hruGi8GY(6M9_scb4RAdd{GUq<@+aVs=ux!d|KQcdAI%5)%4kBf(|icOWY(4IFi| zWb<*;FyvrkhEUx5HEdJdukw+>lmhCvScGqBLg_Nktu{ZSSk^vqL$X9e++L$&{yJ^W zXIP->!x@VXOKmOOMCiBNt^=`ABT>DcYusYr*6GQtl+{DPNIRy?AiNB!zhsQZYk$PE znoj2Yg~p%1`9rl^+%gG+R>4Hr8yLDQVoJ;wFo!$;_&7C)bW6lYYe< zwIoFsxHw2Y;9$94X1d@Y2UfOCdZ!<+db+2h508&94?TV?_~+Dly>s7gJ7)lAm)>`YxcI-r@)B4G6C zW}0Fioceg*lOLYe^H@oK8X6~CPeerSa@XHCIDk1i2#6~BuwB6lYRpl|qvPeq%g)he z9K1Agy!Iea(p7j3Rr2nbx7?dD=(<07!dVt{jRIq;9qM31K&+)=VoOvobO1|6vVSF(V(X@X950V-loD%8D1^AtYl76f&) zEFMGiXu)FyDMG;sfQcS7g9x%Y2h)hbK`u=Xh4%hZ5$lyB1<#SPC}g%pnIXDzJ#cbH ztTuH=$+A9R7J1KPr zN5wETo4IkHqOBvC!YGFZ`*DXAIq(uO2fj*JC-a?zbe2C=05R56k5r$zoff8De8TyT zx&vJtVe1MnwLSrYw-`no#w4c}ctGI`DJE(Nc$qLT=fvnc^HUZ>Kzj%Ib)=Kf0pY!D z)PghOKn)#H5zG}cxFukhYbm?}Tnq-Zpst2Yn?|c@h6j#|JtI;M3FySY0f87y#<^5K z2w!2}gT*^MdjpxO*?17*)`YViYjVca2MMu-x2EJIEL~~61>DV2g7Ni zdz7b~+6?o9i173-{IFeWj^J(T6xDc#u)aS$ZqRS(zS{iwaEGSgpZG(UJ8t@7BB%?{ z7*k;abpf};R7UYkr|5jD90tl3u&D~1^CzfcB;!PI`UtIice(_xNqZTH%IFitNUA90`ZYWMrVRHM1kWwL|wjJ^PNPv-mh?JLqr)=R{HNgXqb#-P<7L}64HhCM@B-&`=xShv^4^I6 z9(Ohe-@@|Ylou+~kchjoTeAiRaxN%mnZ8r7Gp;UK+O9bY*~6iPkJ^oNCch1sa|h^B zT913y2ftqPEr*dF5N#w9r0u1fK2d+fi5XDFqPM1zk7UX1W!uRCBu|pK`=GL)J@FrfgF*cep zjjWtq9P;aR2x5SxI7iVTJ1iLS_|PhrE;?w~z}nunf< z8fberS&V}m6JgjjZ4#jOU?j9YU??UzvR-rOo*-p;fV<&5g5>(pAx=BGdh&QYqz+UM zkS(uc&}`i|CYO6yjVUAhGS#IR85~!(DSq*i=;bFoa~#(+u=RA+zNK}GIBAE77Eqof z#RepCSd#S^*!A~#8w?_XD-?sXm|KXvirHJyfI@}=IlfWNzWff4VN=0!GcblKss|@7 zu<&ieF-T|WrvVQz=;LamGphF(@bP-XssNSC>K2PtoeBU`Gmpcd5|zXZrO|=h&~68- zdQBkYyC-%($i~Ij=@kYK+eB!B2q3GgTw@@^io$FFNs3@EhVV-m;(x-ACw7n8UU3L% z&V_yU6o|BOb78AMG1r}Y#M^B>p2NU;d6#$+qK^twvn(rW%OiFZ-phh0^YLi9A??{R z8pTT^+dvwj|A58SO-h=3c1~bhmIi!yR8kC32Utq#kq3ED624(8ScAh#bzq2P?XXJP zYaR^wdLaBtRytW(SH#8^$g!!@iCqD4k!e7zo4BTXd%b_m^+r)FFYn~~LvE>C4yG4O zmEmEp6Xontrl3OwegvMJUEM`A%;TPBRwQazUZ&0CK3@eCMaY;}U3{%HxIyvb7u?bsUk&lIZ)9sarN%svYuR1CbYh(?NtI+rZaI~x^@<9b zTw>buQ?!j*TsBxF$q_%J7ueKAroAQ(0#&+ck&V2tyP*swOMF1MPA6%lNdDLZ-4 zgrSB%9WSpJGtv+*t<8XjI4oJ-%dnxuWQ|*pPO2`Ovg>twQ3ns_BV_%l@=3Y@9^L4W zTt2!L_VI|m*ggG17ivCud)>n%Omsooj2#owtM3TG)-H&T($)E}LoSU<7l{}z*u)ea zK#K4b!AclW;t}(-(;njv@#g+Ap0-UFXe=;&_(D1#;t&XvR4H{{(0u;_Mlw?#>ysFk(xsgzzWXlP+b%$$7kIw;2YvE!6b5RWSV&{)5L!-M>A*%A&$9>~57Xs~mjm26?hOtU zhJ~RNAu>m|bhsNFDP8;S#If)ePG3U|{c&L|gz71h$Nd~dqx;@UNdWBcTdqv;vURyMqekQ~@dNL~v z@z{W2ohF~n`-cE+CA#m#1?6R)GD9~p%XghQ$ zfNn#{3|Aj4HXmw2%vulB$Bzv?CIfcR<(GfMj+L}~c~~y6~&TC++aTCC49^YePz81~)46PB} zs**&OlD>PmivepAAq6ZJYox-c$+M}3g~rsp$R_o0!T~#~s37;YO~Pf4Y^6w{yS%+0 zfE6LU^GxA0ay37P2?&K_ClVFJchmPbn=i>aZ#J-i;#ziFrsacS zXcwVP9+G)*>ilq9eVU)Enf?jO?*pzb!K@T5Ow8;-a?K|$h_WMCc(O7+f~ed*R)q+~xDIS{QkiS-Qd2*61=uwI#6?<*2gc90fSTlt&& zwy0gkfwBBhvUcY@ybEAxY}L=cNUC*?0$en=dK92N)We9+ew}73CUnEOmaJuTn2{)7 zZRoHvo^X7IWyHAGyG|OV!VHW@)M{+`O{zvGu`=#)r@G=~rPKp~mrii=)rVal(01Y* z3k4qYvJU#r&0_AqqaA0nthq|--e!5l_o#oAh3{fpq@t?5*uKU~HFp(t;7VT+9j0>_ ztCxIM#vgCc@c1S{i)ePy6Sb!v(6i1mOK+r%R*$KS58ICmM3~1rY>v40J*L{hhWz;T z4?2F?u2wYF_>&wUo1>*;fpOSf_d`T=0S4vf!H?j&H9rue^&ek6|^w1DVwE`15dHz?CIFOv&=h0yw!&$)is-UEKcCEze?Afg^D7IcI2 zil#s$@dc;%sG=%$OxnN@KoUja{p|v*=4dRG!nZaBMaJ%vVQP7H>lXHv`*rM{M03l9 z`Iuq*$P(8(rX%2Qqgdetba8+Fu)*RC%Uf}t!Cnbb^^xK=RFcDR1(&eCl5WRr1KTr}k7rw(d;)*Lr`<7%MlN^+SxBRFFTvilo>y8*X<;TMT^|nFqbkb& z)mY9Qk~gm|}-1}|Ix3x9fR#M*jZ_2MLK{Suo{&o-^Dfjld% zTDGq&qF7tJpmV;1)yXyDQoiI%Gpd-i3!{U3HPg$U?nN{M{y87I#^tZ&X#Pgrc0j5_v*VHcI$;5)N(&uA+BY=?tD`- zmit;XM_;IxL9AceEgNq(qEuQG%Fv!N^Dzp)SUkcAi`DsarcijKS;Gh_yy8w`-~eyC z*o8#B9@D%)P|>)#NrrPco8$~J!~O+yAW%fWC?_YlSo(nnUC{2_;N+G2MtfLR>{jF~ z`e^3YX!Um(cjGrqB=QBRwR!56uooT!p(HE-c#i9i6@vc5t=uSTiWZlu3@5o+g{0W~Zvd8ok*`el>i3Ud?_b5x~LGm>sm z*T=bVhIcDI!xHG0H?M>_CM@)zVU=1s0$w2)&0ntBI9S>iy|+Y{OA7ZvLvsNiz1=~Xx@9UpD&+OUvZ-VK=%CfUsm;?Q_CWy6;i=)nGeQ%Ckj zhppLJ4(5sbB`FqH0BiLrGS~X0ld`G{Gt7!u-}ieSw7Evhc?Haiu;t_n$aZG~BMvex zufzhLIWMw@SaWrfP@PbbY2L!04^xf~9CW(+uZJC<34Oc`?WyD|!mwA^KF@3At#<`g4pfNMqZx`p zTnk;B>O&}W+)BW)Ikbw|yB&XrtPiD9P7}yOsU2QEUEDqiXsVW}^!qcLo>Vw;sL}aM zCKZ6iJv3_=@~K;YR1%3sspBIReZ%_q6+;Vmol+kH$N=zwK)j6hXxb@Pz>9-f3fEi7 zr&}4A#z5w;&;YSOu#iV)-Kjl*7Hr}iGYSEJ3UMji7G7UyD;AfH0W z;jsPH;(l>k?7^0(_b5sttoq9@T$?_D%okgO5gHz9>+C?4jh?@S=Lh*EgZ-*AWdg#Q zc&J2_V7&5DvM7tTfqDLSM)a;*UD9PfLW8MlXIzxz;np%&NsgF1bvO7RM$0+~5h9b3?8dxVyU>)m&J8)FP8 z)}`8~A8CY2(Zse(wE_LKYS{r+M2%CiUE`&IDLhy}=Eo7}hWc8hM;AVj-cpRb|h2cUYh!dPJN%gpeA8fOmSCLCIboW`n|+_VV0G z1Fk=hy=*MOy<~A(EnL~Lbu-iK`X1&{8JuE*5xyPlI9ZNlpFCibI z{<^OfoOLpQfZgZas_Z*4K<)CvUgp{rWDEw$Hr?5(a)BKSU7klCfn!6+#!+fj%OR^_ zw)WjsZe~W;q2(YfyUf+z z>0BPP8Q^}slrsqsHH`rf2%SfB%y7j~8(^$wk(?b3B{$G16QO|67E4#rQD0o_McEi> zC|Mu2-{Gxh_KES#@nfs`pSz87ypuZH48F$w2R!BzLC^4fPHq9lpyUf^OxFmH+W?YD zvOcKRW&y~QMiOS~7%tB$&6p5O{5n>B63N#85uE^oTr9_3DoTYtf5d~~Z~QSYKwcI- zRooFk$O6LRSX_-OeAWP^n80Y_(A@3^pZQ^jJp_^HOBmn{Y1|O=N1W7DR*`g0yJR4W zTVc{`O^%i9Tw41R8hZt3GnMc_f866V+j1D^ie&KW8$5cUuA(g9+vtLI+?RCNjIC3?hWay?wojX^j z$EGLJ2{uW06h16Cf(}a7B}OY4Eemk6LpUj%SS+=b!!T;W&Ot=Na19vs_7btfPc0J& zZmc)9@)&GXOGp?9BFfffQWabhNr@KcX|;9fZA-LBM;8g724imQ^QKd*n`n&d3 zj)EPQk{q)zAJW^}9*!%QjM>ArL|{XI4ff{4i&wcY z6kk+3kET`J9^H~;?Ss-ZS#GDqS>ANjMU%*##SmD5HVZOpyy(G@s2JPmAj=N(IEAzF z3jp}>dcB{&G;U??^K0ZIZ|(NFR_ym6fCA7f$2y%#3`AUU_Tv4Vd=E4I)fxsp2n`tD z6~-*{F?$s~wzYA^YK|SAsb#E+!SdHDYVD zZpSLJ*lXOa!#&Hd3%yz)`&O%tvy2Z!Xp*i=u4znjib6u1P(JvyX5ufpC7hgoZ+p%b*6^C z%5@7JaU?dpP9owm;Wu>+M zC2Igp)zg+{Xpg*(77D*r18$AuO_SAxGQ|A6trV_zR@j;9G;V;*!7nOzaCbJ&99c@N z@=PnZJG3!i&H%392`ujAaE>Z5r`Odv-1G1Z247x|K~v90@R4gV0K7H3UFPH2hOaUg zXsheT9d=-#B6-bN5*+L6D3KdXxdc(^D$_;*7dc25#5&+5hcz6G5K6J0w&d+H{ULtn zjN8bV+>D%U(R)p1!}KfOAae!;YZ z*|NuyslMIn7~4-g6PsD6tgL(rCZSEACnz_zxWI#Z(Kc+^`YeG58KrEtNmgmwoSiSq z-7IW9^XgVb0^QrfUCRCDBRzPWFXDA{u6KG%{Q+KX;>9rlZ%#~P+39}rFv!KX-9Ycy z8Ny5^6KQ;V?G9+>Dyn1e5J3xMQtUa0#>{rM9})4~RtACWWJCj%77?WJp&{cc%AT;bmIbz8=fDQa}H%#eU0Wc)A8( zb_8K-+K2rn62%(B=ZEX94@Rl}R4x5Num`56HZJ6Gdt;n8te&$>E&{r5-K`9X+>8;R z=BYw4nQ8FUI+$HE*hvi`fqy<9FSg`gJNzp7TqLMGLAKt<2%(G)pk#7a7h~vlOK2jH zv0Qxl&JgWSFn{K3NKbaTqW-bi;-OpDw(+nuZ3eb_bl_&t%oNL#*kDNT9f~@;1>eV3 zlw)%E^6M@~JPoB1i-(eN8B+q}FqrwJ%IdYfs-Y_N-HtU#4isMxCbd;2_s(K*wTa2M zuk)UQhNV^p1J)dVSfaXqYwIe@{P}NL>q*G@(_#O8P^&d4QHsz8=MVR>Ie}Zl<`ZLr zV&XwL7!)&a43tO!6vh0oPvS4uK@j!QBlsd{)8`6zEDS?|j>fbV35Kkv9Bc!wwwNay zzK;zHrcSC2sW(D^+jgJ47K72aji#|JR3tQmv&hPeIdR5RNN74dUEl?C=NwyGkd`To zPp7xr2as^((mLc5O)D_4Ow>uvD=;_4VtFVFQ?g%Bk`2Ycz*o%10`oa2nPa8#@z!ec zlJp!p&q{b!jO}>q!fUxc0!a|uT-T7`33+Y$3@TS|PwjCk#Az*&G$iF|ah_5UCCJ_7? z#C(Iu3w0Odpw>aipr6>`J}^gC;wV@wb}>E#5M!IEp*8-+BqED?!2esC9&>k(rRVC! zo8Wh;ZwUPX`$ZiYDh_r+-jpj%CfqrU7P0{oE#L6KXpKdc`AnVb0l)R?>`)-o$MP9% zSqrdfuwLj#>Js`~cS1#DB{wU)TPn1`0@SV)RU65=TGUEofD9=TUyVF1J?hF{wcYJ1 zse-1*grSCqj>aii^pssH{SR`Cpp1fEt3n1w1r&7C=wS7NWoltTLy8(! z60)G^IrfPJ!ndwGT2+g;#myYs?>}F)8NX9)8XSK>e&ZBoWE^5GAiTb!D8c) zv>TK?SIs8x)<_nM=Uvs6K1A9?EmY!3APbWMhVkp%B&%bWs!Px@6NIHzooOSWUQLB< z=zoZL3UpZ+=x9!ogGzhwuD-kFV!A+bUDHxEHksaQ<$$ZjUog315}Wv2uek6+0KP^% zGbw<_*)@Ti z#;wCf#IqArwAX%oRktFv?R~_y`AUmg{L>mZ2fH_K18`PUjAoqSbSMZrLdr>dn2m4;)V z?apqw)0E4!dYpTQ<`IE;3c88>!1Y)ijf>ogdW!7DDiZc3E5iZG;|gwaU=pdCZL*0r zflguEoiG=1X8n5s36T6ifJVjYx%Bh{_p()95jgZ zVHJa_KcoaxbWx=Ic!WNr19Feo6=whqpy^r|)**T^_}x;fKE~+cfK}`p-r1IL>0y)d z`VxIGCk=Hmbc^ENY+e(ym#_W-yrmSL zkwEk?9k#G4-tjGQ?AgH|pEfsmzWfD}U>n>n@lJrkA?zzWv!JFz7udVb-9Oe1+L*0s z_}Fj-;cc?>HP#>)7W`OqwfY@L8n^5HHN2gW-@qfZ0ul4lv=iv<-X@iu#lh_kVjQa< zV2SSE*tS@2K5 z?IK){1u7I&JhbDKDuqW76z<}&5hQ(PCYs5tEX{SU^1F-8!-e!#q5$5;k=fyKYq6rL zjF>9}2yLwF@Y(Mvq^1l0`yFoaIF6GUkw~09-0vh1cxXZs(*Pk$G|G=ygYzyFPI{U( z1DR%NA%uBbh}l#`XCczuIMRM&=SD2+oayqkPOo9j#A!Z)maT7Np91=54MlKjD8!Od z+Tx}CdG?04#lGW7q0cFUt67BJ4ehZOkstF7OB9ddA8{K%p$2Xc4|sb3*3??ZP`F05 z`HEed+P6!Zi!BbRnAiaiM?$DNi^onrw7UJHybSF=7Gz4C!GT*MIDhP;(^f}uNl!ho zt-UH{SAPRC2Qw!wxxtqwJ!s?+NMYFBp6{s^V~Aq+^`si(T{+wqccTQE-9TTtK{Ukafa!A02TO|!G$-UR3EW>|>{<>s$Bqvtg_u$;x&EZg_O zREQCHpjUd3RToYb2X+yiZrUp&FCM68`ZC7JMga!nIHIuO&fVb90?2*(gt!b>cl+HE zVYZ=aH^e?M|H+KGum@+-xR!AgeyM_sn=Oja3cH~P@(y8U+*EY}K`)3uc%2e*;b+T-)tLI(R28X#7U@D$BFISVh#rJlIqxiRf@SD8+0|EZ>mUWtrq=b&nMZv^e_&>7OE*XU!POSa2XSLNSA&r6*yq z7M=3Uipni{MaMCf8b0A3BzJ)IiNnv;@ofPowyEN|g2gzu7=RLSk`Vy2YnV!3>>i*{ z3`77YYRSx_dDMsjrOcaTF3=|@g21uM8fu~;rb~V-^WPxe#^5a+Hx8KF&`K)$pXfX$ zjeI#Mn3{1rRnD9@aM9~03u3F6xA{T&X#Xcr9@gM)Bv0@2#Q~P;KQV5Zd|``VC|Lf8Cohn>kP)JTiXJ(TRrR&|^EHo;e22o5^jpOVNO9LVea0Wt(%&04wardvycD4K79*M$W zxmiim_+38uv$z3KtqH&5^7CT9{QQ{V|6Z?oh9=WeZR9TsHGNyb7z}PwDY@pRT%ks@ zk#=^nn;!D{DSdKt!+=Bd=G;L+#l~|0o=O+AX9zE=1mU=CISb%fP@daBI$^)s>=ltg z#@)>=e1CM$yoQS+L20y2@x$$k|D|z>VeYU^6$4Oi6ri^+udW*fwPXcXSI|Mr+QwgI zM+I0CUHVRz;C@1?XSe}?;f+4;7YCq@N)sfqw4hshh|BUy7Ip+-D6*qL-|*p1!bdxr zt2aL{KE9-9E0?jn*(_pC9ON=>;torq83D0jTIux;<_ZHznLwAVdzoRdXXKgC3YRbq&{Vj`l=l18Yliv@-Ivd?!Qr! z85;#Vuy-}9ODvuaz;>~0yvBPyNkC*)l8#dew!VY!_CXbQ^YEaxKT#EUit7$o0}o-k zO#Sb!uh2cwG+W;(Jja|=^*Za~9_Bci(N3o-vn>59okdx&70ov*W0=U9y@bIFcgA2fz~wWS&2INZw~^pl zK6RMco5ep7x3&lCuQa`6$luAynJuWR$;L9D|d8z)N`-}DHvmhJZo zC@mFSarCyyrPYlU7}w$#d4r*fZPl-ey68?v-Q;swle2t?zNu_qh48q`%^J;l1LTgw ziyipl?1ttR3J{BP6pmwrC;%iyEbGkiYMz^oTDVhq+g8?4@jP8<4!5_qSQ#fP_zoI) z90lfzHB|)7aZl4`*EVKZr)5w&3Ujtv+<}`~7~4-4{7{$Q-D~=mmYU`?y{(E`id}TN zI9wrE((M>)Fgfk-xv<*ML2eeT?3Va$Yk3b)V5&dkWdsV=z`;|f-!SEjv!l#JV@a$_fy*=Ni z@Qd~8VYz-`!AqOIR74ycpEO|3trhh26j5i&AWraqFasn=2#4Aj+m2AMmf3qfT3>@; zs||`O(E@gKZEfBe;kiQ9ct8c0;3mPt^$W|LcdeM38yt+*SW3h`QDI>dnjyf19l2s9 zvE`mb!XUJyS?i--jp~qW)}qnyLRE(#=(JhIN#mMwzAh)%vzG#Brg8BA7-i;uiq^SN zu5Tzk1DlZT`J-Rdc?J8^?z_je9hb}_b}$Q0*~S35I|S!(6W?iFVe@xz1m1kbtwKZ2 zEIVqJS2T4;-R$n^81Ik_aY0c6=VF0-vg_5*D{ya}>lh9*5axpNRD{DF-YudoK3HTI zZxn(K9A|=XNM5^HsjZ_|QPJKquOR(kFCUTDx8LK8w|tEDEJ$J`1g_z&#(kzaB?%dt z*5EIFZvkPgl@}jlhFKvNnZ3Lv@8D&5t=)C!G3iN6$zFukM>u<118G|Et&UoW=Zp;3Wx3HW?NbrF;dRVEH#@rx6X0$FUC^Y5 z2gY$jIdZ~sR^Ok=uDMvT6*yD#L=6hmAxz+yZ?ppBrxZLlkMqp(>*5>_JAKJ~i5YB} zGvWFHr#a;lq;INF4-(jfRJbCUgDe}nK_n4D!d^qAm=4LfCI>4Cq7xkc&-~@zs^SzF zf?^*SC+o?;PXfek)>CjV{}!H40DCHmsF9#gsPSp&0m?SZcp`{~+7nbq+fV8d;Z6^Z zK|N(;2w8XN-Hy>hz_7U9^N*Q!e+mVuW!2{0{bQA0oHb$A!xP(3^6ln-DGFnzUCQ$~ z6D7y?4lIaWk=@dua>tFr1W>PjZb);R=#};0z^6=h2%8y$wz60Nt?Uwf!6wci0ASeT zf(R_x(!L5*p$cns4V~MyC|>o?(K-$ki0f8wRk%q%Xcu0v5aHRAVW~p*agNzwV`=M^ zHV;*bb3YrdtpV)?7%V$f$h89xRWG9)nWV}cTY18`P;b`B<#4-F2Ym+C$gM}p2>Svg zqG;g3Mc{50$4ePshYzXpc^^zn*BNGi;nK`lOKDo>`)?(x=>0)+AY zob5y796q`$e>ZvHaHE9Q+@^3S+5%TkEu$PwET8;ilL$F>NZiZ87EveY$MP)xK@WmK z6ME^cBaO0jqXxT?D=1JImmv){3S1K&Nv20WFOJM@M&;og9!jnQ*pdVT(cK;7Kv;z| zLa>iI&{TG1|589;yU;cTEyqggzNYC+G|8rAwBp(jKA+RDE3KfB&*Mi}^%-sEFogyh zXbZiBnhE>a&lXc#;Q9w>2GM>fB~*$*zNw~uvJ|&MO9soDYKNQ?C`fhZ%9p^2g_;#? zxWYvtCQ_cxF%{-ghV5RP>VbQyaRKaDx`T=|abOiWs$wSRdAIp~rc~(Rv-o zCSba7KD~(F4o>8u3&O;-yr&+|OWuo>4#wEWu;toR%`F%#g4!t$(MVS?EacdlxM4@dPtV~{L34ytSIL7_H z5tWnh7}lxs6wtIU@YsITDE8@yC<*StjR@O!_~d&6q;Nl0B^EdJ+3sD@*L2TqL$_)y zoJMe(c6$(8Sa=or4*(+A5kvuNoeJ1#Q~_$}T~ftV#pC7;Gn0UB)AY^vC zBhFs+U}97UgQVW*{<~Vb*jD+DO0PB`63CO~!Hx9V)7a`T;#bO`mp0vcg`I{I1R#su z-TSWDr~ya?a0E^Wxis!oNC@{omz4o!MD!kbn#MX~4$OnR?{`ZM9L8$862r5uC*%o= z`K9R-rt&^J(vS7BtO=#Y%f>rb6(wbzU8&Lxd2Pbsal5jhT5SyJUu2sN66i4iL8beBsh;hKt3R@du@>CpPh{2A7c-j3tP#}0;#MZ=&7i&mqJ}omKXaTar6VLX0wcNK?K7Q1Tj{n1R*Xlq{QiU^HtePR zAxQ*ugJK0`WEg9!vaj^gYBTLEDcCPFa=mF%wibEp&$ft~L(GFfC=yvw-W^O`EII#C_3YO5^pT>GJXM$FB0eKW*G1HbfK0|fQYh{u{!}6BeynE-iq#s(gM=d-tt4ikf^;n?`eEadd@nfJ zH?qWpX_3$VtQfT%G$vc7pe{*s+E{qVu*O+7wwp3N!n9~gQh}>EsV?H8lu2vUf3%!a zV$ZwFs@YjgT>#N>8EL}+#p^8{O6+i{U@+HYa`%h%V*x)r{jkgvwO;mBLzG zaH^`B!DnjJHb^5~k46G_9CBwM*kFu_VFlcMcTp`co%QK77l$gicq1W`Dpd`sopRbQ z!RKcdb*b1n{YX^t*=f~$n1cv-`V-H;>x+*TA!6tQ{PK}`zQ!eD`2OH09~FwfFBwJ2)8dhK|HcDh zfQ7`TwDJRLt4~&F&$Ou8q+vPmw}MjpiZ-D{mo=aGfolmkJmZfI-R=1+tc?8mH*^@7 zJMinUT-?DUeFZtB=R}pLO91u@b{Ydr%|%>=qW-!$!KApiBwKwQv_cREo+qdV$bP7M5o=hZc6u%0~N zp;}hu7B97}-v>B`;NXCH9j+fF#TdD>t&oG@QDKI^OZG=%_5#0+j`$HhqSjRP!QK>R zHRW|-eF?8-URW~1kHxqKCn-wY;!eGkQI3#&pO=3*ci0y$Yy7Q8Q;}|BAbFagN|LU{ zNWM(LI_Q7KQ?OoG49M(mR3n30knllb4X*f+|4?}lcf~8Kq!E1-bXL#5C9BN zUlRC^boGToLwTSN?q&3_cpDSp{orH||}er0^ri!d0b&WxeCZ&x6vGJkCDLkMQojJc&-) zgW)KOBOjb`!|hLZ*rPl|={Yv&$!v50p|nwW0{qe8ghMEtTOgY^Plw zFX4s9j(RwbMiB%7KfF zAR5UtGj@x~)|XpQcCbCu;^E80Zq0B^2wBbyDo2BK5F#d|RT;`Cdk{HApy~w|1B_eY zkjsQMsftI=zy>-Hh&ShbkfJWag7x!BwV{+KZ_RtbE52N>{V$(afF+=MOWqQycjTe2 zcHWSO+Z}^Sp7q|3FL~|g!4FA=v}E!oX2o~vFW;H-J#@Zej=ukaqkB3b+0&zlWUyb{ z;;a&UuWR1E+Kp-`5OSHd=v)(ZR8yNsgp{0onY{&)36Y$rAF0EM$NG>oc0e}AL+>3R zc83*U>YDBYgM~z}dQcEllLVIHasoOy!@R>V)R6x$T#OM7z+-p@OjdIYm>9|}tOJxz z(`l53i2Ay~jT<`plQ!*>>gs7tjlyPJ5pY;A{aSj~8%GMft7P$y*wCwmV#4v&(;`g0 zDI(=BbvK}+XSwTK;u0E6h(m}v=$vRRXKWx7Bvr24$>1XrQaw+jSXg?}2^a{d>1R)c z!LgUI1yCNncCB+j2C7Nj7p_@anNGf%z>|Gt}KfH`33-YL9M~G%O3#+*2`*7!I zQNNpdD48A5(n`-W4fez%$pz45c{8?F1%@GF8Y-aysUI0G{6Zur!LTMgV8@Te<|x=` zhEpY?&p_|VV)g@M8&1jwhht9_v;6ck#mtS(N7w6oSZ<$3@+H zfbS-T))ntm*|jlHE*5NrDB^>ix|>@r0^4zj9$thYjIT#cy^~8AeNB;dH1$(&AZ+FoVya7`7wMT8k8l)_AapFh}+v|6Z?7bWMV(p z_e(Q#%sBZ}VlPmR)91zM#{)6^7P58tq+gKubUdB#mWYA(wFu4ulkYnf#VNF{r#;Oy zF6Z%djM->8;3ABsvD_Ac(XQ$4&i$)TEIDDUMam6`i7{SyY_3udqn8x1z|79Gp@VRm zO7w&z1&0MJyHM)I@w3U=8p2EvUYmT_qp%pWivoPKph?431uucE@(vozY`%L6Ne@qo z>JcPsL!J*V9S2Vxu@|<~J35F(PZRFH{1%YTXhLsyX9cCTF9+4*&1=E#)npRF;C13Vv zMBh%m;SldPRP9L9i%~oozQ4qp^e)1|F`hKg>X{Px7-SvtsEX29)isC-Qz{$7Oo!74 zUrmL`uWlSbU53TR_xxJ?;!fb{(D)RtzZCi23v$-~T-5uRcl2zLmO2sf9@iv~MzyC( z<>$tO*yl&%e8<{)DsnSd$&A`e$3iH`rkmUIDGLju3>8N4mpfVg@X6Ki9}EAhV@ro;W!_;wA}BVBXr7&)^8_|kThnFLlfO9*tx26nz+JV*=n zKo&mC(5_g^zt-Ca1rtEVT@_td?N)Qapl{T2Rh$WQ;waga%ZEESLF$L9$t1F-y>R#X zcK2~{TfQmiedHks<(y^S_xg#YkO5TTf5muyrWr_kfs5K2K1Ooy;GDMm6_z?e-lvqI zT98ic4B`AVT!y#Ag2(Se;Ooh;a?}!O`xY{|hg=|M`E-{|C;2?*Es5&Hnt4`Tx+IiatE^AOHDfj=;6cFW7R* z@)Wb5ddP2v<8SivM4-ptxFPxNB0fcG561T!N4?4T)r#6m>S{^m$mQ=>n=KwNj#r=L zZw2botnvp#C;kKisIAuzHu9QrE-+l^K0c|PT1aabl20I0Re4oYU{|bNhu>sI*(`s% z;Kao-F)W79t}zuLR{s;3IAgIZGw`(OHvef4#~!o#uYbFE@lnK?sH@JS>(2EH_+%kW zyAAnlzA2ridZhcz9E|!xwh3u_hDVybIN54o8GAN6I_(a6N^fe(whAq*G^DuZHQ3zx zwZmQE`R*gVBay}_Uu8k)>k_u+iO*P@TH|DsAg%BKfvehh$q5g|KoXBjC&IBb8M+6M zr@7m%)-M=wn~vivk*oS7Ik6*OZ_BgERqi0i1$(q;Rr?r4qM>nZ(aIum=HI;v7>%E% zV~|sKRuA@2n_)VcNxWmVy4=z|qb}CZnXIf2K6lMk(Q8ZwqdyrIpX+<5+L6vR4QyK; zSmTqXHK6UDY=Fk;Rve*qDeuJ|kcd8j$rh?ovml$dT2;EuXz*&Y8cdjVIcQd#G)Myy zlKhNgqs7j6_zc0cztOGNSluS0$i_;1p6UByKpNE3T=rETN@9b5Np5hjtItURF2uQ& z@#1T&;%?oLfH+W|wkZ-sklS)Tvp4Im_j=?;`zV#TuNEJ}^qKQu+FYsn@B$fVM|XF00nB!pCo5htfF(BIi~~vv z3L{fb^Aixzm28`(e4wHP{Eb$uNR<$Unua*jqeN6<63?%dLOh$UZ>i{yJr!6d>Nj;Z zySELI0Wh9^W*EI9MXqqJJCZGuSAmA8QK2RK*!qTdVYK6nqdlj|292RD-!#Y0<_4To zUm?W42{CDkgmbu;+*;tY;4te{;(PzubA&+K+ZN7mL}KqbbJeg^St*t!@!7TU?|=RV zvXisXlI{Bo%!z`gYtOi@g!R^?UEM*~*D%P{WI$udOQ0w|=(vspFKmMU$w!50bg+Gr zKJ<1`z|Bde1R0isfhr(lzXgh^!u?8z~3cU_nq_Y=S0|bHz?r&+>Fo72UnlDy(0>G58 z>k(aP4;v*~=Q|mkRQUi=5jy&Hz6SLYArMumI-vm1i6MZD72>W7W4%~GwZ%hGuHeof zChGUhAmX7&8n<{lZrNj$zl$x9g> zp)?j!w3Lm-Qe{*cXO3i+R#&PuXcjEQhaJt@nO^YC911}?;}zunW>qZ#BBq!*BunmE z$En7Qp&#%)S{ldPqLL$C(g`2KdkIBUBMYa<&+FwEA0{%Dzm5o91L9RW#$kp*S*|Tk zY7ue&;BApI1X2s_6C>)o#28JdhsLYq(kD%WeQ{tA4F0@egcW|kijPpGxFLd-4t|Bk z_o4>-QTDq*sG1KQnxYPUz(ZDHb>~_ds!n+a5#W{mnAN*n@Oom~!<>mypjrsu_&EV7 zJQczOD%)P#nY0Zo`#F6oxiVU~pG{ef#*j`VT#&5nQDd-dcAdO30vb#6fxs4fj)Zl; zPqU7=7_)Z=tteQH?-Z5$BRByaLx#!I8JX6&YKjqAp;09+wpjDp7+RJ@?ZIY6QB`1( zvn1QkQhsp9!ed8c4_R|lO%Flm(AKWco2H)Ja+0H}4W}2BAy8*{P$CouI95xw8m1Vl z692F4Ex52`>#9pKguPV-2BrTe#C)I8l&DCVHbavQt}~*i_=iORr=Fu62nOb$NEMJt zpI(MJ4uq8P6K>o*q@(yM!jjXMCgLj2=4X41j2NF8u9oINLM+>q z&$&rd!JnqS<_`)-sHHRlaBpTOybLL1UwAm4QydXn0Eg&7P@g;jsgVSCp7=m?ldp{U zwydgD#1>WeR1?>K{ss>XUnz>#8ApQF5oq6Eu!h^UqD*E;R=4WdwYK7|V&%Z^4^-ED2_po|@G8cWl=%Q;JF;A3qZmTdID~1Vl03!y%C(4wtTEQ(@{pXoTL=L=Kj5z&=V7|qr>y~q zJ_`wW`$#|pi&$1m?R zbx_*G^KFdL#6t0x^6x?iDi+|#vzeSl=CH5=pXyTZj7iP+l9y+1o1`5syM3eGq-+2v z63bVdQO%e120;s#Sae54uri`r5eaM|-^CtWR0eRKf_Eyi(W0>FX1_O6qKiCQq95YH zk#hd%>IUuR9NZv%-Uq7kkLA_=qFF>Wx|U1UEg8~$-XN&#ZKk<-7+}5hXuAUUpYfsr zEqJdR1(~}hp2c>moURTt#D%!9hYXgS^v0^(1841Iu4ay}*)}(4&nBTq7L-XyQ|=(Q zy-tZ5`<;|A*T*i|1>TN?lCmr{0;dh>smu|rEV)pm$15C(hmW}E8&?;GwPFcPPZTmA zO^LUQ$E*wP3B#05i?ix{r7F7C-lX(OJ9+F@GDRK3Mi6KYsfVNlE7Z_ANCR52!u*SS z8`x9W9DAH2Pz^#&eATG^y3TNUL0WKJWmLq3mu?zHO<)uNFpFpj;Gs<^fn0Z_h3bZ! z+QWGwuXV#|fDV{6YiUTWsZigB67TMY}`q)HyD+-P*%^Cbxl@y|slA-rB2~b<*9QHF%j>Z+dQW7Lk(2TQY`>~n2zs2Y4GB$%3Ue?`n1ELU8~YmQ#Rx9CfhtrX90bB18}y9h4QH4nqq7$dJ|f4>(X;}S z=36Z>&v$otL`4S&Z3eYK(Ts-|;3hp<0qKr+zMbQ|1!<81ISC-;keq?)x@#HzBriD{)HAo}oV-P8luEeK2(A_!Ml}{4nb= zEGD-tT~6BII@>FAj@c5_%Z`P1c5S;I=<*6)5#bh&mN8AzhyxvCdHcYVMunnyZTliS zMc=!56P?{IH+Kk)Lki;62{0Xa(%<6&+6S;WY!={%yT^$PbDF~N!Tt6Y-7a8UmS3!C zAxE;Ifn!Buhyqnw;ZQoZY!7U60*dGYDlVu`L32p$k(of^MD^nW-qKVHjELG|#4lTECdYEUZyP{0wK2D>SUyFxjwYk`VH&$Ie#H2w43 z%rU^6z2_vz&oij!kN;f5AcL!|pWw?;#9|kx!W(?OWsl=^&bz}IOq*L15{P?)>tUK| zA*_JER2v0~%%(X+8Brm0o=E& zROvi^89!Nu8hqC1GUJH=;cN<8QL?rF$eW*0scTnryw-*_!nZItSj_^UP7__Jm=XYX z-6{r~DXTt;ejAWb+N@|z*VRwziGw82uB|Fswv`pHffUq8=*VtV#)Jy_P$qUFodqNQ zO3uy9sdna-UK#Mv(V(2jdW};TERLTZBTGHRCH-+~L8K*4wpp09YVrdjz4)lF{PLP{ zcNX*2z5PZwqP_2$Bf|#xJQQtO&Jgwn-idTZZh=yP#FByVhD*i)ODr1F{DJ4G4`3Ob zT-_H1_24$j6eR;r9_4!<$S1Uf@vc>eZA*5ALm=k-`>Y}EXg=8OjAX-6e$*Dso;=fX zCKoc?pvrn?N3gc6X^hz`ySebFH?MSwZj^w-Dc7}}u{rx7QhDQ{Du?5>ZyVg`gW)44 zKy=Aw5k(7}_2JZp9}zlDAD8k^UfebxxpX(FsaZC)w6IZkfrZ+<`Ue(2nq#s3IbiEN z#5J=JtieE+MNO?Q!267C`^ICbd^lOIp4?2raTnM1d4;5iKwE1jv7m6mLDd9~8ZgTZ zG^+xUWWze{qUp0VmtejW;;4qhlfg9=imufq2dk`)~l901vz^zFq1vfUR-KP3P;+;1k%0vp&M-*2RURxz2K~;q(MTfR42GHJank za3DS6y#BC^%1(2I=fvS{ZKk8>!gE}sIbo|EPqhT9?lum%y{0ouTku=4@Fz{$m8HEdr(+F|5?!p0 zrU6$f0PzaIMiCamBXHZ|jhVEzy1JTOHF8R;IBF8hOz4R0g?yv1{sq>qxY4Z^0cp4E zYR@PQN5U&qV2Pe6$*5tukFmW7Y^u2%2{1LFw+UuKFCMwNOvtqy2Es{iR+R4 zYR_RfUb(MDc9%rTk4mwqN}3)oFQqgKnGYNWykq2lgaKi^7H1=T_|Zqc-Un$eWX>^# zq?E7lb?Q`Tr>=o69%h)~*wDdBWz)3G1ISsH1xH}6=g=e~tI?#VNGP1p%WgSf1X1d4 zIQ=-6UmRKv@8U|!O+gJ`Ehe+0oRVUa`$Ig_1m*122G0i$)Ol`EI)`jrln}9~QpbP8 zR~(Kqq)XvnPyI~?lH66|u&87Ir#T=DE|@AI-@G0k?b5=+bu&$7^E*Gelz8x%o0_cQ z%n||1D%PR#?|%8Y=9g#-6uZOG(LDmy;!zxg8ygqHuq3o^Q*E`Omc~_wKDVBNUyx*& zH4Z3mH~6{1)Lp0K?>QI~0){e3LY5N?4`J|Iwm|wIR@x#~==Bz!rq_2%_4(Cif4Ika z^Lh!({SXL)k5S8 znAW(u6zz>&Y_iA%Z2}-h^#iD%Hf$D!D^8T?MA>1|^)61m|Jv=pSnLUNKS1w%8qo;~ z8WbOIqymJBZJ}VDG1Gd9a`|!j75wk;O;+g1?#=rg&h&l~3hd3gfP=Z%KIuFM3t8CL+Ip1RDG#V#Dh5it0W$y~!Ul%f zWeApp_ys8DUGGK-UL;P-0f@*YcrVAo=Rlk{4M5mu4e&C44UeXRAQZA(vVfV6Mg|jd zcD?(3gDa%_ z5|cZW!3q4aOezp4J5nszD9@cPKLM+lfKn@nv`H^#UYP+)Dwx)0F%Q}F>->?qR1w?; zV-^@4GNNrXgMPWlAkFEBEXhH3)(dN+iJ~NJ;FmdH4DL-#rcs0I8K#-81__ zB37(earCo$cytt{X({i>kr-JwHPu#bO0D*qilYj(a;0{q;*ib>Ju5ZTL*I_ywNAS) zJ=b!NGu75!siCe&s~@DIaRLgg`?SuZM)z46@xY&<$phakqW!~8)92Bs&s*N`jg%!J zo0a+wsed~s^=xEeSHlYB z1+8v>(ef+_2J`w%2YVFeY1kwd=YO6x55(VhChH};8zm1~;;9eUcvyh@nu+Qa7eIUh zURw#oGPA0*vM}i@1r#iWi*cdrwk zqJgfQC2lAeZ@UKCSeR%L+sZ!PQqN9*d&fk^99I@LCDV`rJFGg=u)41H~S< zKG=p-Z3PE?wBl~ofi%Efb?ETB@&z;W4dk9VZY0frFp~E5D=bcHAIrs3GS8kR2S>vvS1^?tN3yE;a%@Tz|kp^ZwA~a zOts<+yKChfv_d@1(|DOxYxAu>LzC@-(6gHyK^}^4ALi?gf}tV z%PIsxjWoi`i!>;3yYKZ?-I$3_2ohPz3CI%iF(KGyetCKWgt)njA|Uxmy`_#xFg_b~ zGnxAoDa%p{&LzKG6zxf$`Hb-NZ13{257vhv=B3&f5dtLfYH3YIbNZ?<_|}d$X*K(d z$t5aHmPh|!0vFe5m|!U!atbg@7-b(ApcKOutD~XvL!_C;lI?%ID$xP2$l)UCz07* znPog;hN)B9x$!60=blJhRy3JuMdNIK3Gy%yWLvAO@bx5d+56`Eb`FPSr$lafGG}EJ zTUw6P@d4RxX*im{y>Q?AuO{cyuOzCD2Co<)q^ZPUm-VP4gu8VSI+NjJtrctKPG@#T zbZ4uvW&pKafw~MnhQMtT$XxaiB@vnE@SfK-U%_e5rdJbJ$OD!BUC7{k()Ty%`V3t(=@*0c1dN^Drwi^wc z$wBzwA8|RzB-fhD7PoMqm;qr`H^rakZg;Q|pJ8WGc7bWtzgO!>x|$T2 zXFDB$ToIX3KxW!9`?=K4%f%WAV?>22(o*Ls>K?N5n44%y{3>m}uMJ!dZ|P%8hXs>) z^7lrB)D%1a&3{YVxl=14@Gw$G+t|%5hlI>jJ&vhprfS=nuO>mL6WSSx1vYI+$aUoh zqMxq`i#w=}lzyMJ^>$|H1WV(i1=5~??klF??L=ZzN?nM$S%S&}m%i!HhBcW8_Ctbh zFUzD8>!<7U>z}2?C0})q3Q#r~$&m$w8l(4E1FP; z$7OvJ)U?aR(e+i#k_4f?k9G2`T0xft`Bt>fowNy8?Z2+g*N$RrL$>2G(HV$UF`ssW zRjZMvFzDcVhk2?CMtM1zil;Lfg>s+IzwL`Wa)i=XYZc;Hv8EK%!IgrpbJnJmGNJaf zh_I#PESOd?PF5TZtShwu6GXD|)ZtkxN;V~$T*HpuB+D(e3i=h2S)R-Lir3Xve5!M* zy0eAuYvFpeN})tc6FNeH~kd{!C{mIRSRtYS-o zJC{eXDSvo;RMbB&DRE2Q=lORqkkCrxDa7qh^Ng+`>eSf~Cx0lNW}{Bv;`!u6F(X$? zVB`}rItM!}txbGE=45$d;Dr(>Eso{1FAFpm#8!Xkw^z%wce$wi)<`%ZO%{}u4uCM; z`JrqFS5ELYsfg+(0?*=9{ps}V=y*Cg0$e3^S8{_eH<6+RV?wGHL1Pa8^jqMJ#dzsR#uil zGhQJ93@-pLSR&Ej>}c`ndU=iX87C1KX~~(Qx^XfT!3^%^2b~yL!vhXNZ!s$YJE7!R2+2uLWFnv!FI`+l7+ zIMayaR@nY}8EhNTGPVa?M3S*YuYNm#_{yaune4DALvI5W=ocm`%|y^?s4!^yS2QSD z&LWagyq}0F?)?H-^T6Is0RZ`q{CmpL=;G9{^ zB-wuzG3$nukl&S%kzq;Y>1hF0kN0>k>pwKWs9Z)5oJtg&nFh@@$}8gBa9b2THAF0b zQzjD)7><+7=hXbdYiR*k%iD_lD}@V@m43jN%hhU6$CUS_+oHVut#B2kKGp?4>AbXJN|28u9#BnAU9#s_)% z3rtsmv05)UdMXKVnPfTgZ9uf(A0a~;A_^7KGJ_#L80-WbFga!jl;AHB9pSiun#+=W z5&_q`oG~)cRrk>xPrgrX7%EC9mNdXF2!$4Ladv&C@zBg-^^&D!rKxWiW!lg|@dW1t z?}9bKyWx|pe1-}{A*Ut%t4>0)ffkqv=2e&HfuW_e7+j=WeV@;+wF)R$jF(jV=8%_$ zc2o8+hGY`^@+HGalX@xH8ilg@loQ+2n^Jsefq+n@$*wY)859 zKuPEYQ~}^ylIk)lFQN|r1KG%y=&p*=5XEtFS=N5ApkBz05)YRvw~i+#$~Ie7SgRW} ze6&O*8H^7>r)r4B&Ds^H&1f^f{%X~1(6YQ=y) zT`sQ`iVZ6%{EVNMp8#2ucrA~9c&PtaF3w$o-FAxZ_>F+2L#u^FORll{|USnedvlwTULMoY^cikPr^kb*CxfS_gQsVMr=9!5#~57ce`h$Ho#A+Ph6CCe zj%X)_6!T1m?uAas5EUMSU`J@mwG`=AeEE zD3+Rk1;+|v0&Pod;TJe=l?GrA5-qUyFOdf!b|_mxDEj9@GEx~U76Nyh5=CKu*&Xb{ zQ)V?n4BxQyh+s4X7J`*;_EJ6Y&?4F!t!rMPDzLgf3hK&2yt@>IZ9}IIE5m8zL9`dk zg#WR39a>BNwbMFc5lT-x?dR^~m}^KdOv+kX zyPSWIbTlC|@5G;7rs0GS#~pc|=AQ4{sDmc4{I++BjNTw*MR+6zH^E%BGHBnWN~FL( znF;VY8LmB7XOi)dPhJ*{$nCy%t{lH*w^vbbud$^sIw%BQrDo)czngRV=VANFJj>@* zqjjAePrmdl=FIj4t1fc>af-5G%oB!$jn=;|3v)=jnsIDkpAP1zti{*iOhq_uzk{d4 z3gk952Eh&yLH}+O42IarxB2O*v)msd{;`4~*J8i)r9k+jE+95n^#*p=lG$)razeF~e=ulyBi$w~Z|cCb{^mqikCj=B^5B?M6e{a0(XdVvxurWjC=HF|tF{F45cGe?TGYbJ;YfDBmK*aLRof4kf2L=a!NgvgsXIDR8`bi?v-Y-oR#Urc zue)cxez5lXf!OdoBwtqE`m&@lE1DArSZG9TkTRmAx5oAqk6f=Y4NZ?Q?4tS>^C7b* z<^-`1YB<5KIQuN|N*t6ZMEKamN1yc@wJ;47xVd5vcFT_klP?TRftfT={0_NM!STui zqCvRLTR}0QmJ-Pj<+l`#@>{Y)`CX{|suaK=0FSv72!{lUUiqquqo&s|RLQ0gQ>8-H ze}}Y#n4_OPrM3_ts$B%?kWY#mqEd88x6TQKtR%VPL>Gnd)_H(d3w&huZL)@5m^fjD zD!jrDU1SslGn?(u!sGfam|9Bp@XmbKDm%HJxVOPhd_ktb-~$O9s4$X93aBt1Zn?vT zhs{ZnHk7+#m$fr1A%S7XamTzeY+QsXo@Q@;;ZIsUW{bG^ zx&)l?NGJx_$0t}*1Q0eO6l+nj9<+!Swk^DdCpyGYpP-8f^!1TY^Kxwt&2s2f$LKD< zE@tz6sba+rA>)#cs7TV3^ixbYw%qWnAz>iXT9euJ__Y3ggH?Ba{C2q%8>z!5b?f3B zibQMz!d8qk%4EwcC9Qrf(N>6R;Fg^rFg0^!Sr0*>SF$fCeuMXGi`JS=FW!DL*%-3^L;BlXsfGpPC|Xg=9nv`JBp;ff~g@l+H9G2aQ3SJL1&u^1W4~{SpHd7o8ju2 z`xR>-pQMyrz3H0B4dD^5CN&Btbv zE&v%j^cjTCOZpl5hiUQOi*W^74jfwdFg1**0Ig@9<%?~pk2W6xA?$uv$)y6#xb^u; zxG&wTT2j24EZ5Mgo1AP=o&dg(wzMth$j=cewrIyC(wLMVwvn&p5UGLz`v3HTpjMEy z5rf#EZ6k>{T86<}W?w^8hA$u^HYgxDe6Czri=XtzZ)GNIu^9vJx}!60ONElNWId}l z{?7Vfwd592zRuRb!gmp7+lN0aZH%};dlg6p2W?;Zteg!^a`ua&yZYke%@d<5uydmx z^13ZD&|od-z_MDrqkCOoQpn+bNsz4G?$0`KI)N2|j%f#RxnevF&rA0LH+$SwKs5xo zie~}?A6*}oyrKm;LZ}M|Ud$@d42S(j3ovuJ(vC{56qNsIS~QL@wJ@aklVwIx9Ry4gcXL@dl_87er{6N!)}Tx!<@tf`%d#$#a(*G#A#)H1t!Lgyw3g5^+2)~n|K0?jT* z6+-(yC2srrjKu9=-UTpTOJU?IiNtU@nWsQB-EHSz=N{b4qQWaZwcNUwn4oAfU`iVt zw?Q1g&a(-*GfwNFfJHlKBxE-KdDAZ^tIwF>wXbO?SXQUY>~y)Br*~)ahY>ULbuS z0Ehs(fSrYU?t7hWAL*X?ZtqA$k-^D2*saEsnhX?lMJ zz!r=RcDObff01A_^H|+${H(?r*hgGH=$Fe@uZs5;e(YnD3X3H%Z$XOIPRk*0t+z%W zhxON9;zM-HG2MJf?B6iLW+j#@?%3|-+r?LDVdm5!0twY6RhsWr+-0M*z2T-JNc8kL z5l+=HGG@s5g7X;DW2dCJI8Lw)z4vl?wY*}535KA0Vm1DuA|?FKrf^-67Cu)TuU%ANA(GAfAYV{Y1;`tG2VNZu%~>}C#U=9d zwS0WM41r<|D44(8y9ygZ%5Yd=cUl|?Xa6K@lLAI>Sq*6D@I*EQ%~^?4q(C7;77aIq zzkG&3h!(p?32L@rzt@ehd@PCn^yaO?cKyrVep%G9d0c+NvT^wdd&cFbhZCvwGI@&6 z6_T!bzrq-CzKXy%n^#P)Y?%gW=O=rYpZp1p#HW1kdRKhBZ%PVmLEz6TUbfyyau|zN3kd_NUlNa{TmrN^(XhOf`VlM1F%ErRi~}Kb%GdjL0o)MVrE_Kq27h@) z2%`>@a4mDl;pq|1it#1r$cP3-M>c#8iayW33;J!UmyLe#5||>Y?o3fVSn10z_{1e- z6SbY9*%z4b_2PK&otPdVTNG$fW2zF^VMK@ z75xfW0VJAg*PR%7c^h4OaD>cwxB_-w`?oMD3d@gz$}TMr>Oi2ZzX|+aTI4|~T)$w` zo04on`niD4)vc^6V8>5#&xw482qB>dLLf#7Svi%f0d={YVZ2&?nV)0x_usGf5dff^ z1)vxsB{_jtH)lsnA_FVRws(qBjHgrV3VWZS=LSFlw*_gUNhD=WE=02ka0}Sazg{TQ zQjn@G>E6N1{rw3UIe^5(o6g2xz&PHNr(iHq7W_CS6eXI5h8krP92AHo3@zCDS4VUq zqf9XCtQ-|JVayiraiK(zX>y6f@R*3}neS9hj1SEO3pbh4-3|HtYK7S;@=XhV@Z9<6 zSM7^-7O@B*tX?P?N?dZFxIA5_Et*|?RECEtBOJR5n(Hgb*`&T|gR-5Xjw|8>ss-9v8^iCf?~bgDWwP(+|`0 zFT#%)q@JWsvH`DUqwt=w>Rx@!m@g2x`hd^ku-{tFg07cOrS3Dg;-~ZXjEE={cH1i+ zbRVE%P@qv+Y}OwpUj*2`*vd?;@3ABAKri@M*2f-H8e}Exs33lNC=~{ZNqSfsMCt69 zBQ|1U0JD{jI5<((kdd~NESByRlekBqD`xZ0{t-f4A#07yI51biIWSYtpOV}%R^};z8X%|djW0$H44j1rl(TF4pXncEA%vk z=&DbS<(0)-t4Jev&$lv%6@FSjC;mO0J6Es)MMVO?tRzZLgyZQPW>U9cF^P~KDoX36 z4HFq5U&Gyz`ioDfmWB8OACpy2pGT0#hZf2OEm8`U+~}+ci0aEIlo|6P{B4cp>UBdO z+ZiOu15I0?D6&eLakO6IOEyLsT0i1{c93H|o6OS*j z)mhdiT7jk7mG8xHq*C>nHVSh{?k_hh5J(?W(m>l4chc zD&`*JK%`LD#4xgk$jE6TI6d_QJaB(|jKKp|u0``i%vSxzi|jH;G)w#0Y#?n3rc5CY znUuGm0?UvCZ~-F8Vt{aS8DtxlCJf4oxQ&M}{KRh`97f`O-<;30X@m(Y_)#<(X&?Sp zxDOp)?&-f5{D;~86(U(`mFLJ7>@A3fSc}OBD+%^Hyb_uz7C`v%M)AVrXa+f8%5LC%ODo~5arNDn&PU@wZgziXf1-ld7NN!xC<%!)Td5(=&vk` z60Ln#F!GKngK1*)AOcP%9uhrELl8xHXBYacWi}4oOElsLzM9eUH3@ZmlszNJirz3a z0!dJ}(uImZ;C)lh?UrYwA7$V$ND<%-B#TexlVHS;rqD8pWrIS=#q`aW?h%>{5OoEG z4`|zP87UMJ+<)QWEMd$)R8x5pM1-KP=$rc}gEPN}+89?9UK@BdUx#S>C z=S}GxG_ol}g0&-I?Qv6{Z+7DDx?u<(N|X%alEa&i!@f~nVz9=|LKm%9sn0U}bO2m@ z5?Ftr?0Dp*tt`LE;UK05gnyMR`gVE)-EW5czY7L=xjc|er)gD5HFdvYWM*E)2rieG zsv1yq+{ve6URUH&q~JNSi<|3!K>0Be%M{SF1~2_qAIuo@?DNI+xVh*MiTZCKWpawR z!B~GC<+><_Un!fuggTHaep)+vImL^nU4rDi)Lm5<^38?jtU#|C{DFAz{*-gY2-^Cj zN-7pe0XlC8rwrSS*w;eJ>zYO4}eJlkSB$oAgDBYajd_fI2Oti0|4 zQvN6g6Sh9Ni{=4Qi0Z60p>I;6zhi(q36+l>Z9h2!}Jpj{%2u9gQnSt>afwZmy6fDeDnhR8LBu3k); zvBkNQUHOVtqz^zOqnHlDQB&%dVg*21>;vCRypwzz`$b?6RVdiy=K%B+-8>=#R1aa0 zp4L?9lsE=S-3pt@PKxZqrb$6^TlqT|H0UFg6Fd&swWG4^N~cr{PDO(Nhm5K7%74{S z3b0-63#Aulzkde7q3}52i@&}QUHU#pN)yfIyGWi1^JES6li)3F~ZU7b~R2woYddF-HZE!voJoJJ7CJT3Wsp?{o}^ zy)pdT{#zg*Fd{@49F7@1S*m)gwP#|3`7x0upPjvmz1z_S?j}HpZy=CCXylSYH4(Su zJAgra3icE5>HgiAZWxDLqoUdl-?V&MEi?&Yo;MA%0FY#QfM}j`O4e~O`Wd7iatl;4 z)e^yCwIKY(fb-( z;PrHs!-}q!Uw*qdG(=xP&CsgCL8_RBIK>J$Su}J>1Tqjk2)UNMux%kk788YSSs-ar zeSaAH%7Tmcn;Id@G1^=^L<{KF`KNqDPXupt1Rw}*VcbDsQ)FW|Y6!P>n#Qv_2xf|a zG(?+a`q7jL!10o_lH{N@RY&4-oPw8D8bfH6QN1;~+B=mTdc$WDL%X9~U=d_QUkb)h zMw#C`E4RnjPT+5tEPY|VVd)}9S!QweAwP?6P#q7T0i@_VhwOOqupj#CW~y1rgJ*^SS0g-lSYg`kQ@W9pcQC79wb2tpO-`MHTjI=`B~f?eZWCQ$nd` zakzXjk0tY_b|0|&o)yBlw)-_l15g=oYg=cDH7GP)bo>;j;=A)-7DzqZdmw!n8TJ&b z7!rphMIm!+niK@@GiJ}A8VHv0qmmuH_b`vpc02%DHBRlPszewtE8SP zeB%h71oZw3)0|`gNqXozDKd*&v!V;~>fwxrT9TRs85^-YopYY11w;>TB86NXwE?PD#aen%*#@j9NpQ`tjVxr zLpL`$7Bc}M+e=ANpKN^{J*|C%dP{w-5b(}J2qVRnjKuBU~>fO(4Eww5ds`-cf;X_Y!1B53;|11v;o3cjf9NNxC|K@BQe`m;o&*dc{ z8{1l?I48T-4qV3A50P#2Bzkso^=(N+9T9dR$=#M3Sw!n{ z)zJ=KAc%AMpf00zbYZ}ezt?=E0N9fu5>$MR7-JD6W>;?r%HKO8tjg8PhK2ns2dks< zmd#?;P<8FG>qkk~A2A0s+y}}a#oCRVsOPIa9qm}SYVfPbtsa3D zyhMH3>iz6DuwcckBq2#;2{A2H(tv@`ij$}nfCwjEacHFt%+5Fac|Z}uez|cBzMF_5 zYyE1^HXf2ISF^%2OU&w;7a3}4`9icAS^f*nWUv>E+d*FxX`vl;Ka57^!&pR%6=?O+ z(!2$le^B`L?6)5}6|Pnp7N(HObVL`wLLOO+rG6KT*D{jutg=w$1ADOa>p4tIEde}t*hvA z&gIzT0lhvmsnv{2W;Fwyq=)x?j&Fyb;RF{RDr#Q_bt28kdzgj%DrNYP;wO0+_#G8M zLIp6E7k(&j7U^6!Mwa7m;9J;y)dnEb%Kh!2#7TZWBigbp-EZpDtX;)cnr4QOfiH?T zKjAZavIWLyf&t2<3ZP#sHRd(%r-E*l$JgMx zUX;id{YH$n5)o&T=-JV$%;y8?XAs@>r$Q~iSui$2RwU8CUx=uAK}7I1CIVqxrd7~K zgl%4kG5}(d<05VF2m7llkLw8%)=AT$8!eq_Sit15w;LrWqLETsu5!(ByZdo2u!M&* zrvuTkbHXQ>wqhk=3Y^)~eDP}?za%3KRMfWl@I9G{dhx53006@C6aM$t=Jh%$EIxC% z-1njN^lAAs$KCnYIbn2|V%wqh*HYy4CjC5*Q<{zT6SySj5JWPg&G7qC9qh&95Bl>hF{_HYV9PV*e zY;sIODcP3K{~_6Kr~V=}2?yYVC3B2x9tZf3uUpd4iT)#@OiWDS;!HI0RiSmQvaBVqE zL;Sk_8obv>LLk4@580(76zzpFXam|5Apiwnd%i(A=VF8$YFlzT6@c?hbhuP*RHZpR zGvM!^oA8!Qu|0f!MfiQ;4g7}jsmD$U@~B@Lw$?V*unbG3cuv4jqgl9mqa8Ucl@QL1 zD&lHNEIa_ti+~ZCT`O6N=B_{pL2x0I`h7Vs7f&c@c>rrn#%RfaSr!LL=`|@xge{b@~i>6ZqjtIe1*uW}f3R-A@I*=%LIaiJsX~BcNE3!ntRe@nl&>D+^09(?* z>FEK+94H{RHY46pAG+BeEZ<-^($2I^0eTPi4qwWaZ&2Qs z;+pxY1lnYL#`DCFR|^?RZO-M%I*5jQfOogrpr!FPu2yF%-XL%S*lkM^)O70rGptoZ z7GtNP{^zM~x-2U;c3h9p#RFm8Ndf+g{(r#70%U$ zgXT3Dj=I%kgCT`Bw|9D4q94WH_H;nW)+9)iR{*X{T;$o}N^yV!R*AQYA~&o4HR${b z1*kG+E5N3D;vuDmsGy!3EWwhK(K*I}z>)c@VvOpbKB$_;uAyLJCm=%gYOI-7Br2sX zRYJo|Cu&scb!HD&L4n1UtUkrc@#!zH_WJNnv4HX9L-H0tLQ8sWdp9Ck+1)7a413+X z3k5T|&zi|dt{EAJSrDO{C?dp?{YVb|6$DauWsMc#wNhp(7$spbc@)N6mm7OcmVP@w z64*gK(nM|`2eLC6!leSojL9U|#Q3a@_2k(EH|-rpx=?&m=8=4TF53q!x(7rU|J_Ax z_*7e^yQAw0Ycc{bUuDAbBop0&KNCW3b6u>p)FAo9*6th?MmTcEV&ue9 zoDqnnPw6Z+ex2)9Sd8W+8E9$a$+WvY`iQe0C1oLP=;uVoJb{#+IW#1NoI_I;R(+jD$U_5%C_c_et~r18KxVe6OG?cB zJ?OILQ|qCLRzzP(C%D2ej#-Oc4(`Se;3T*U3Vzs!ea#f&$<=30$IFPRw(qx}JCcZt zEUNJlL+R+fUSie2BI+ptJa*?C&oToEZMZnNKfXSs-95kQC>a|0i0o*5NJi0M&2;`hqfhtCu7@Qm^N+GdTha zgjzv3J7eXp#-C^lhh3C%h*%z)UEQ+=h&k7Gd6%=&fRN zM3{y6i;s(%SM3C;AQoKko-n}sfmNoULP17+q7@j5_p&-y3X(>Fd1~L7XwgaGqJ#pr z2h!ila$tPh>3)lhEWbd8*pZiooa~ezyOL|(C>UNcO>i17?Be5z=7u)B_!ts&*a8+G z9UNI6;uW@g+5V~Om*vq9A!>lwMGiN!pyg)v- zx&tS}=qib)!(-lWal=ts{C@Q`av1;PQgR0m|u%@;V6+xUC zlweejv}Ju9v;%e*dyN+ps13Y-wHDfb3Z5=K%6{AC@StTr>5sULy++KP| zY5xG6EyZ@E+Uw@ZJrU^3vu>O1R=+a1*=z!7TfyGQT`gi zPtXAUvao9T3??^IWD=r)PoRbU7uPiOCje3UdJ#TasTQPvQ}}TNSNN@B_`GgWrqTKl zG7;IHID(_Ve)0j4;-!TJT}*Ej=>s{@Q0Jb`aQcq<4Sgbgl)n%PKxS0z07_rUz!X8# zH+pn)!7e#NcJf|V@e*1*un2-aRRqimdge_b@)dd{ZJ?lZIRN5!@{ka7U1BNI*jf*E z1hUshAGt}lYaK{|e_$`d3I`_czzV1=fo*YG)`~+WT+rLd8RdGojRzllzhvEVXIJb; zd{7S-7j%zZtEgClFJ6brsIT3A3v=`%*a#{`BB()u?_?O3xQFt=Zf&ua4BkK3c>iGV z{^7>^hlBUN*J05AqrrP$^e}k;c<|o0Q4HQc@%suQO=8h*YAI>I(6UtiMt zH3w@mgw$3h$E9&)fWp&G*#0EvG6h{Ny9am)I_H;w{~}Em#f_}o%w>eRpe^|Fs_P+1jx1kUJ^DM=$MHRf_5lGey(=RG6j@x>Z(z1xKSj@WFxNGLmfV67OQh?|Dmv z4nYYEy~*hgJ_*hTiV1)skmlg}BH~P)BJh+bKez3h4s&G8TukGXq1TxgR&QjXbF_3# zjS)}QKJ|BVPM#sM$I&Y)Nj570peAJXw%%@*9|7lQ*Ord~Ti_59$p3xQ2pJXy=JRtO zF5O6zs5aj@K6CQPf$L?VqxszP8$Xq{EOL5qn(e&iZJw@PU?!Qs;jGgY z$1k;bWd|Y(sET2ZSgY?4uD-t3IbNa<+L6)7yy0!a!DE&r9l={7CDqgiu_CN$tV#%o zv9BO!Aq-J)^_A>58PF16a`LF`u#Y2^2l+OG^_dcuVsz1j2dx%);xI!iHk?@9>!Sf1 zjMGiSBGFVlC?34XZ2X!>ix?Z@hn!pLy!6zhRedOjS0O)o)|Duh(NGA{MxrEIrX+rp z7E6!O{tMI{4@KUbujD93c(rF;ji9mlk8++=8d)$;6Q3k_PA9)1PS) zn|%q^}%HO27#R7ru10` z!?0{g+!EZ7DFGH{)3w?GOQ5xAMgk9*=GWSc3^iqRNq*s~GTN~3lFX2|=Nymj3k4rj zS#^zncB8%do7rMjGI6|SsFwYU78q#eJT7DjDOgfq(C|}4>D)gL73hfS5}kT6HD+_q1Cz0nHquF7T(x)`UHzL z%u(mpx+Z6$srWOxq8LVieq?v>sU`;#L7a3H^nGa_G!R;&m{h_qU(xAHd0jcGPyPUI zhh4CPCTnswm4d&QScKZdJJcp)AEYe0Z%6LJOQS#`%pO9>w{erRLpfVw_6&m*b@(G! z5T}uTp?k_b?hxLHVOY#mUJwZRLB4lslm5_hX9-aV_^-b8d}QISFycg<>lJPNQZi7Y zV?|zRAW_J|_F(l8XAq^fhe_gR`WQlfh(?7ZU=g<KAntcA-9;1m)aDp%2Fky3%do9jy&QKwWb|QD@qCw0P(d3LG3>(m;TJL}R<>Xw z58R55r=KIvd)BYDg9Y9C0ZG*OBXae}GL=fPm11pjp2R1~QeH+#aKcj-zQd-k;NC3F zggXv$0h_HXLtPcMO^*)FG(ly1crCtkh><0^Tw&L(pv?mlDp;Wy7-e``h5yb0lLZJZ zyB7hFunoC>(k5)SVMLkNpBD6(b!27PsEMhVU`?WpWMe=cFuujDLXu{D&q7z`)sj>b z>+pMogVdV2Sn+Z%?|rEoQ~E%TM5J2$r?8CBe}eQAXXnp71v`2?pPu-I%n}0{CBmAou~x_ z3Uge0{nCVbqn&WTGPG8`9#P8k`T*!u=k_Zx)$d+PGkOh#GyQrVM^^=0IKxhygD}DQrMnQi*82cD10n@@$wxWl*pk0mUMFVK8=dN5#qt zL{tsmaInWKUo3Kd_%>Y~Sa|srMcNvRM6nrE4$W~;y?M5nvD}|n__{LY=AQK3xqWuh z<}_X59&DcoQiOZdHxdfLM~dtb(M^FXT1`G$fN#*bvQ!>L!4}SD2eNZs-{GcW+6pQ- z{gq=xl9_a_D9kV)A{ImLfsziytX|0_yfeQp-!YPKC=o&iy;1a++-fO&zFp|3W>7-5 zQT{;7q;EfXQ1gdKS?TycaYCyJ345CsLQ znB5kqo;PzFNI#u!=YS~t(+gkd4_C_O)U9W;+~YU>5R85%Jj4zE?HVkt!s%? z1RhB#B=@r7aHqKRa(z@9Gux+DK!{fzCOI4vcvDh`W-KUMzdR4vAVLbbROlP3F1Z22 zbSMv3a8?5uj2zr!Z9#wf` zWyu!F&eZ0mwExmLz-*<=fwR1%>u5CCQ4EF^YJyv`+vi4%`frWLQrPT_4iO#1hVsgHv3F zkG*bwyHu$Z1R+h(OP=CKT2E!$3(6XXn$nORJy%e4lSP~QBa|Siv+dn#k6}dmWT3H- z_2eT~uUl9((8-1x&_%qpulMC)zVDyDmG+z?6eTSOhrVJ6>=vLh(>4g znXde1P6}K4?!P+DZj12(=ajQHiQFA$piWk!-6#P+ku&g zR!(^qMK3=uopMbI{NlS3bFrm}v_8k+VYcNGpLHjed*7GTQW3%6=m^3OC0R(c+*fF# zR}$~4zH%I-j-ap*OESW(#8$B-sU3VGUBG2Cd9Ph(5G#y}dEhUtWpYuz2nRnK5EXWVx^` z1!Ij?j^scppl88aBez)XDU|I-Az<6I@KXNyX%L7JdpqK1SE@nQk7}pQb|QQ`qahG% zV6~A*Ucc23x)i_g?3mQMi|mhIdJP;H6;?++$7DgoE5^2iIM$M|W&lAS>WT>4a)o(rmlXCGG~#VizD_)_rI z-R$INy>>Iex2EZEM^|(NoQRQkiFaV7g1z5Y$CwrtGt*^`Q(rN3p+W(&Kz{A;SH+2P zN3O_#f7BF#tq!^uRacqmWVnpb)YEGM)RkCJZ4BR5qPNco63|8G>H`Rw20A2)iutor zSBYK2ey4k1F69|7t@x4I=OpyXQ*1R11vu42b;xQjuewF)i|eD)#R^X;UnexjN?lx& zW=r>K1bv>Mi@c`@d5g}VR@xJ-V0zw-LEv#Hku-*Ph9hno5D2G4FME1!QrD;hA$SxHNZlCCbXCN(59+EgwFtHVkmfd#_sBdW^!p6xE}G;%n`WF@jgX^b6xx zp-h3Tmp2#{64!i;5+;oj3w2{KTAgAzRCvEO!qy24rbQrk!yNWPYjKiePem>c$94Mc zM!QLVtZW??!G5C_;-&Vj>MIvmuJ>t zRkm`W$@x&IWc1?}o{7Cz>(5x@h=m+rnHbIcSQTG1O)MjxskVZnStx&TZ3l7FDOyNI zs0>^WA#t#v`jG8IP?CIFxYGPJy6s#cu9aP4o7N?bYj~iIpVsaq)i^*!dcl zxTgsk6qBq0B6{XQaOi!VmU=~%UX7&7M+@%4Qs%EuI;O<`_S9bsNaI>L9d1an?C*rC zDg*OU{|aC+MN$a=mY20yY9q3v!V>n9lSqiQ9c=IXM)iWUxvNh4@Uy${z`8fxGjPUJ z4lHB=vl9<6NT_RHm;?H!5x4z9u}jI>WhY-CuPcZ-3>Q#{P$&-;6p}8a0i)5LzxiVM zwUY>=JGq_GVi$|fHGLUe3n!mm`;blSSE^>J#w$BfhBRha^vj?nfl95NyVX5|AKlYM z8Pc!~=!?jEH@b6DD`UJ8{H(uqH(GzJ4<$?VPZ(p}-%0)kdzmYi7EJJB(( z0&pt!;@<m6Re0c1j z1Xk3r_8_HP0}uMktv~cIS*@_Bh&|F+M-;^aE2_UMLZoHjfGC4Vm3%c_npu~;UEcy6 zQ!sep6w~sAd66%S=2@uQngDAJi#paY7>3*MnbsI**#(X8oT~jZu}VR<7#;hOiN`|p zG#B6;Jy4%H8uLrhC=y_MTZms<u#@oD5g#8xZUtVpRu+#aA^r?NNfXID6{PlvWC!MEasCEW z=pT(#64hkx|9i8UTc?gC9vR`N%s6eC2R!{+PGYm-FIWzxSyDfN&D2BNAU{y&FsF$! zVmHB;5}Q&e;n&w`rIU06ZgeQ>f(}O_fdX_Bm{bU*V zUg=5Q1&`98;$QKBf6|0cH5U|hVQeIp8b9Hx{RQKKj3?HwR=*-ei$wM2BDN+-vo+ja zy?9-44#^A{8 zfkyh9izVEpL{w%!g#3QY0vThVK~IiEF(A~H_m@ywDcX^&BKd+yErdD_-053L`h#8l zKnQqC>J2Sc2n<5zAc7h}AWd?b&|`#cvHX~W7U$Qb;c185Gm(U zN?4z6KqpW@KFLlZXKd*&usTxEpdKHxH1X=_@5F{P$4rw`K1qUPEtZXpu)RGbOU@t# z1q=?%e%X8#tm~Hr+5F}6ahw)A5w@FDk}TJBZ%BZ0Bj; z^KHc}_!*misne!OpNe1W%v0AwqC6^X9P0H#Hm`0+fFd{ub3(&hT;SxfT3kJ!u;;Ea zh}cE>AznnJ>ndaNkau*7a`5Dt3BEE0aIO6y=dJsEuGI^8=5gh)R-D*{a6vFv_K?{A`T9bGfp8}*bq&|WKp^JOKi5SY_Ufo0C6d_l zKxG||AvdJD^h7F&5AYAAg&7wkVLyn~4M2O=jbVCy#kDd*A?DL>9+4u@C~V@shdZn? zCAE>lXgf+*gj}&?iEW?cGxlVqoYf>}`J zK^fP7d;!Yhgsr10`<6sj>{*jva8M_CN04?4QAr*Os)Cp2pRRRgMAC!$#~Vj{EX-eE zOIRRCnj?kZK%Gxc@LKT7ht&V)nUk{FUK~`bBj#}nY*zprx@H^ztq0t3zbpMf1yRcCs zY?0+0`L=Yg?rYX|FU+WthO-+Ij$l{q3OH3&gp>?mMq^zok+DUwNwvb@aaT+Nur^ei z6y-7`gOFxq$tqU4+qu}-_)g-!H#1d`;fV?#Zjxp)EZ*&0=5kHSQd8edWFW|i^f{>^qREl7YB4bDfZ>5cr7wX&*aRE;dPtIlP-glTl zaojBMgs*Ia(gjix?Y)o(s~58B7D&m-ehrb8Zkp0C+{Q#gqLhe3nz(Z75u?yE3uy9~ zp|_;Q_}e)`AYkYd{n#geUn{#nBfHuxJiYm}JYO$91ELq4W8P@QFWzr!Dc@{u?o%E} zmOC-cp6fkQ1$|F+{k9rJxnFXbDeJXu;;|0>AiN%jsF~rDD2Jkn5t0*@NB4(+eu=P( zjW(Aq*B2W`X!~&&4MJ|M=r(!s_xV+M^t;vsAM>Sju^8W{vpkg%P-MlSA8NMT3@!;1%#i-(g7P7OYuTs)avJe3Z3{071Lh^Ri)v@0?SC zUso;t#BgeBiMYXoOP#cHmdCnJWn^C!`-Cy1DuEq0g)61@(*&t`T>^!e$9#mCFak zspvMGfQYNgOJS@}F(8U_mBSe}=oW%hysdSqXnS!SHUq`;6Qxm_hn=wiW!^BSd|QxE z{I09O00b639&d9%U7PAgCD)bDXUk@%pn#cVTLn!pc}N@o7n_Gqqae~18ICZn%f%5M zm;xL9@guSl|GUD{;fr0fU&J%(><=J>`e>iarT95tz?#eQcxx`y@&Q%pPn2vQOJ1NPhg}HSDZ1XC&Bi1H3(~ZTOceBzs1Rkg(f$pa`7b;;cA(9pQ+h`6c0DB>t@RfJa!_Gre8?{tca!&3j{*`LIY@E&@JY0 zK85@#wSBSgW|I{ z&%=1z7DZa1Sn~{vWD;LdlufGtaTDv@b)hjRK znVxRcI$%jiIdvsD3q`WpN?RxUsWFoJ)2W?(oGHZ8Ng3JU;;K)EREjZ}luJlkd+lY5 z$!%{H*fl@@boIFv<%+#pObPcv7@4i^>6+y|f{=)~T215*#T>W#g@0JV+lQqm?ez4# zlbzd(iyOy?v~OO%JuqM>xpY^$_r&%SM22Y=7<^AlUQq(xFIgFzMS4np7Z+G<+dlts^EBntrxq4XerXpJpFFB2-E%Ax>Y?YD z^|TW8lyB^iX1c5PyDG@0C3f0FX8b4Ug0#+~#C}t-pN>C%d^|}sfU4%GSNF1|d;4v2 z&$F67{D}%kb2V_{`A@qaKjt}$G0h=x4V(J}WW0wCOKCXjc{=dm9aVr0= zmL!0CWz#0yY-|#}ZkEr- zjhXyr(U$d7H5CIWtJyjt2iiCce~|N$5sS%f%w*?@hnyJNbr8t6S^j8b$B(!4B^X}A z@!k8k^bgc9|IPl7ZYiI}xSoFeXrJV22Q1p!07nkTF5XE;ykcpbdGzCOgM+q|J!(YG zxzL{V}v7u6IvGW=KTnc*SN(M=L&= zD47psJ&SE(Ci!fgsw061P!6SHnclrBgr0Xy}XgNy;1Os(r=3XV2A>naPpJcA*sj>_O39<)G7pJSA{_p$u z@4tEU@X_vHcK2TG{N>@J7jORZ?CFyie|d2K;e-3TyKkO7dG_r8nSA^haA+}1UJk*4 zZms`69#8)5-_Fbo?tgzwWA`6E`pZrcjv_*JRURFCo?=~dm4s+#N$cGS_%&&68sDff z389hVPh@$@L=u2N=-JcLCcYIue{eOwfO{{mKXnSg2Au532!bypy=l*X(-Rqy1SL>t z1*IBb+E4fcF~qVZN|<`|A3I~D5@f~ahoPCTi&7(mF-cGLYwdiIX)GCqW)CPLC4IH& z<9Q|=`00_Pz2`qY`S?+3Cq&TBK7J&+0*Bwt(=p>7^jv%0Lqm?~A2I#DH!<4mO+2sl zhS;A#{Q8Vj^pjX`TPn+LhS_pINa#da1FjxJ{|QH2p4IK`gqNSO%?)1$liH@G8Yv?r zNzs1-+&`l)?B4c0io_Uw;{obzC77nQar6YFsG5V`E5^8?y?1(g{sAdC=;ZYLcV(0t zP?(-6+;_EXGJ0SWPCkCDYLGg){~t`};-`On{CEhdojk9nor8C@7Z*P*1T7@Ia=RCs zRR{0a+94<(>^w%QPo7i|^Tj2>Hrw>l`DJ}2LL+TpO=y}micKS57Bi9 zS(`jRbj%t`0Xfc^Wv$Y@)m}?Bn%1NQX=H}=g?qZT98C6~Y#zS4-gqh|RRTpw`X?I) zF#pLfMlh(A`|Ad`dV-O0yEDH!4cLTq`_-O6a3|Ddx`!I>_hr$va&q-W3f2?lTs z$}p}=^g|i`ngKDIxB!FrV8VAI3qh99Ms+FA%&PgUh`DK9VS7f`eJ~C;wxI4KILE!2 z@@8qApnQASA|XG9OScLn$KKeb$Gb`f-Y{rTe~Xa+Sn5LhpOVVR@vzzM22z1lZ791; ztvwB1jieh71|MZ_KQe7SU`DOmXKm{2YTo@bj%6Xpwsw-7{;+dUzkLJ-jbe_2Egoqx zcmOE0o=!&ggm}_EBDMOs@eSY+Qw7k3ZdC$q+A8jc|C+IbYG2x(}!Sc_tmqJeZh&luhRDMBd~lpK*gPrhO~zR^xGK;%?}6o zhcRXpY&;xb+s;UMemFokEJ{Pjw8S~C`vD5>j%B6;9NZlV&<_Vli2Y~W2nR^GI~ENF zD2J73Tweo}!w$r<+LJT?K7L6b4KQ$bBvw2cVBqdZtavoQz}=Bp@o0d7yCbpU(EtN? zM>2*-0}R|9i4~6q7`QtUD;^Cn@WDtb|7d`L7>GuJ%A)}WJ{XAtj|S+5scKwb19W>Z z5(OR&&~0brexZ1Gbat0CYa^N5g-sYBr@@BE3b7IUDZa1`dBXOjm*0A2$kRl0ie#K?lxl zV0c!oL4ljad~wM=?LH$raY@zvi=lB{i3WaLvFR!K{a;bv=2nG(-XB%jiQe+l(pP*X zcReR@no6S;8woK_CvQ2io95Zc^9ZSop|XNQ^MjIuP2MjrCYhFa5aQ);_GTaYso<~#m_PjufED{O5a6?M%waT*=RD75S=Szk zqp+$!*)S~8UldE$*52VtKduB5S_dcmq#NVe+QED>h5W7$eQQ-X$*6jWYH4ejJ4jJ` zC4`OurdGxfvEka_Mm7@MI5Mc;A7hr5IlaX45Y=}tAdy&}%lW;?th~DS8YKPWUJDNe zmt{+vU*2my{*$)&|C+9C-pvq*kxqdBnvRIN zEopAG{yias?|g;}Wxp7aADIkfN^C7l+G*pb&NmrS z*gcsA!OUZg)(yJ0O4zGt!nZQD|;;EOHAWA$!S-EE&sZ?>ga zOlsmAlPlZDT$_HMf>)43j&GHx2zdT=c~w2M%AQ*y&O_#j%YHO1)XB~DVP&fODa--KZj>=0rdH^Fa(ArLBS!q+u+O)R z>VJZMwAduC+kc4`Zu>eLN$Z2uw%Lf>IZha}o#m^=9Ewr}B6GHJm z4~o$)u$Yg)qK^J#Fa=TW_ky4)y5wI2o?Dvy=QsS82FoV(E2AZV^LJ~d5|(yYB7^c; z3Bul52{Oo93F7Qp3F6nVsAXeFe;8RCp|v0BGCl<)kf1BlYhK1 z`6nBbf5POk1`_yfPq`%bCrG=BZ8_xRjjc~AW8A};JV7Q~|8QfGp0G%2ig=DeYYa@q zj!5`AJ(Vt|o}YpxKIZmnO6u<4=kqW14QuN+DtveHf6b>{S(+a)r*&L>%HZlUBMmzS zGlKQB=ui7y*z)=*Uh?_ZaU1h=i#YmJ*R}uSgRV(XSixH|uaZu9?rhTTAM(L!>PU`H zng;rrojki=f(fHAqY3NUcLzsATPDxBwui%lUltc?_}PQW>9}D(12mNZ|B}N@YSVYr zxrvbm*=LU@uWmSexR`MYX36y;kt;(0vw}W-nP)s~Ok+6T&Q1rGJR2RZm-MY83dO(_ zr0WwjyO4$vw6K#XZf&wOr~T^mm;Dx#8rydCCy8(OeLbMUAyR8j%5PM(U#;i=$hjC9 z|1|>rFLc{4?(8{M=%WwN9FLjoe3zc-#TwmVcqYvgurZ{P=IvZ&LzKFWD=7wYpNapuros zfsE((Cwr>-8&~d~%(=k=#>S|dnZ(Pf?0%%2C-2+D%lU#EuIj8gK&3U? zn9^`Oa9M4{iyQc=mzebuf_0Mt!BjpIo3BiCDU=&B73Pus9Lpjy?O8M-wF1`Il7MymDm_2Rfy60zudl&wpZ4nD(1 zYb}|u2DO-vY9Vd3Izqy}C7?ld-Y!XvQYL6qR9}gis8VPTt(r`oeKn?{YCo4`TCJuC zUtg2?WX&_>`>GXXjp{36XcCi-L`w=V=b-G{=?xjk8+gUD&%I-gQ{LF%$gM{G<;-vO zX;Od1+3Hn2s)5k*?&O1R>}~+gfa9W84r}ze*aH1ub7*1NVx4QtleHJdV+#e<9h1?Y zVzgZuusw<^bb8HLt`Mfw!dyXvp|hnBx_dZk?}-e0)qeW_hX4MvV-t<3tc@GMMCeAH z;`k@H>OVWiI=*`)5Ee8Z?z)-A%z1`7`2x%IrE+t_(%K#;+u`tpMA<#vT@``EaB(uH z`-BjI*R(%4DG(-VeGDbI^Svp9FOh_OaU1PydRiPk*>{YpaarBo@q<@HT7HjPK5|Z* zUo)=T8fHk$hfg^5s$3Q2P?h+(X8C_qexUXfQ?~|$0Qq*q~;N{R={UB0L0doOWDXZkw<79 z+VSz!_6mHvAITVNn4!~f@V_k&zj`sqr$mF`Nn zSR-V6?7nxC5=7P}Nvw0he{s7G{b}AGu`+g%>9q>fuAFY=Sy$L7Z8;Y+LY@L|<2+rS zaE$8xYTuunTx2VKvB0#r^H`_)`_Y7nDBE4h?tuM+(|R$M{3YpiZE7swJ4XS4;PHcH z`UI=wG$sI9T;((~GKLTo-T2%H#tpiJMzMB!?E}+YbgjlIB3R$GfGEELp6V<1zAh^( z;HD(oxgyh8pQ6IeT#2RL3!Ae9@AV>NZx=SSHSlpxgY!$@sHql54xQ1gfBB4qo?ZT~jV(JyQw8)8)Z^T9MbaX9s(bE$WQ*M8`OAOy#@7dGaKPH*(>iFue8i4W!7($iS$0^OF3uu(O9B|Ce zj;_0ff)j6HhFYU00C*UfDFjh(f1+_kl#LziR$yo35z(ob!&vfeZF=5pd}a6 zKQk7o{Odag66==jxh@J8_a#df;P2dC%1z+QwK)`itP4DaTL%jgf)N50sa*~)h8Ic; zWF-fUsKre=-<|CAHHm#mJL!EJ_2tOpDzXlY7{|x}5s6O3z36uJU?CEJh6NGp_1oc_ zrx9VRyPaf$K`$ZyxyxRk&q&rt8Z$>5q6J@Gy;{yJpk;U~IsZz*yCc*N0@#`s{rs2t z<)^s>q@peFJ2^6%I0~?`plSmc7&*lDI`$~=hHLK&o>)<+~ca5H{6=^dGhninug3L^%W(H`$eisSdQ&qFr8vLdUdoFip&qfxO7X6$mCQag#MkVD`)wX zs5w!3zhRPrFlR|%hjw9d?u=M4p=Nb15$Ko!bQB)AYgv|y5C$yV^%}TnuLZT`yF8Vx zW7Np4HeZxiX37J)N{Ah~?EmT~;>Nx?g2Oi<72BMuTnx)YQ)8TL=2= zPep^lCKeoj{e3>W*1>^_2WmmN=^fNP>6PDx6wFn7@}y9s_>ew(~{p;Rt@e0|DQ zek9Q%iR>bhmBKkV{p}!{Y`1@8`T9r3cz~H@T4eV201~$c%Npeb0q`zUYDD{{@i-np zkp4}4*+C2r)0cHnx8fa8nSAcZu ztAMtxue8Rue5JL%<(1a_mRGF(U>J%%z*_Dhu8+Qd$8OyAowkK{vJ)Q_eJ4otplGD~ zT)u_%*4UUV%5*v`=-3mFoMYSa@yLUZ99rD+@km{mvy0DPpM&Rd+@V3}=qOqMV|xPt z^Y#}&naGm1Q<((nZ@{_!W`Xs)qSXT+dRV}c4GUr!#7yUxe~(+Q)P+ugvoV|H0nwY~ z0T%Xg`1{!F_MBW*iD3MG9a>cw(AKa;WvmC|7?#D@_K~5?<9xtNbpx0-%UL4Y*eqv^ zm?}s{rjJ>w_P{c=2bQQK1VZ=zkp<}=S%(jpYL0NJdieA)cxD|2&#c3`eDi>eKJtf# z8AZe|a0A`>iaUtio$}JvZQeBl(pqzO>L;_SH*$vIsI9i+CJ4BKE`VDrT7|1Ryu0;x z41`3mc{N)}@5GL%%mVo46dwOaF3Vt?p)8~?3$%jSq{Yij?|x=4wS$1T7%VDc@T(kt&-JO(CjS zAaD-%?gMOJVoSt$bv*B{5Ew+;*k`Th$a4}ffY0FQG9 zN`T##L0@6DXPs|-%{JZo4svkoJ4i$8pS8(>4s#(_%MWR77Hh^JPCY}#Fh8G`gm?8f zbF04}w-oQ8uZ7vVRe-|P%Gwe65zEadxoSeFuf#a^#q=Sfsa($77#vw{?@#s-w$A5< zcWbqkYSFR{r$rb2ZCn%|`GiLKlpf7T)*ERIAv4jaehG;kS8rr?fyX1AE95yE*YC(v z)sIKI03VOE7C#;t!}WNi4EA^=96TNg2Sg5!TE8bF;o!+gI8c0Y%YlR2ZQLk8w(hHu zd-?>b)_pZ{hZQf~eKm5w6;j=OHFEbAblrV5(%Jb0vf6z$QU!Pd!R@{p33mzt@4gxd zg->9@-B%-F@(JX;`)VwNBE7b+aD|S8D8$_EtFh3FCe(d3lBOx>J!~%X4dX+5wPsuZ zPx6~rN0JWKtO^|LCp^&?icN5f?wzidr2qRWDFk0#7p^Fa4X&iP-Lc8QvR>)-2nlZW zcSgE$7iuhG<-QCiEL)wI2RUJdNVmwq111tx_E(Y8kN1(^Ry-7(QUcS9tCyb_r^no} zr_=JIqQbkduU<&ogHU%7mrAAW2(F#pA%u79m(NozGEN{Ma> zcJ(5VlT^PXwSt^ANSdE5lzLRyc^BLDuMM>h)6UfNw}UEv46g_%u&%-pCwg>E)=9+8 z{yTKX>1?)||FKq#C^V=Ban}+x@v0aq@m;h+fzj^dfUAvuCrH;n-VtnUf$bMW-9=pR zmGUD1hak6E9!fL*bNlO1Hdmh)7eWAC5~mwMzRrK2-u##3awtw-hZlB;W5e;d5n5V0rhDD;#QM z-ky}ivB3wK!3jl(>~)@>&$l`;6fv=ph*`x50o#fJklI#$qS~<54d_nhP^lppP+bAO zJ87u8NC907PazS(l6xXA@PS=k-2F8?@UF&T$N75W%Bh5WMaccA3RsX;K=D}5nx}p^ z8O5rNt(qc5T_;^au>P&KV%US?PDa#X8%NX{$&r=bbbXIxW=tjrKRrI)SYKbbu173rC<9yOHoDLf=RZ`Hee&T8t#H>ii`zdwvn5QfbJ9segUStA+$$sF zWqPPE1tMYSQs+cuUTq0V2h6s=09m%bIFi`IB{_=|JY0CWeA6d=;nuDuy5BzR6W;T7 z`Av5z5x}aOu>3NwvEJtvE^Zdam`AnWWRGjr1{VtK?B0LOg#y3&uIq!V8`2<8fUm>F zjH^c9PmkjiAqOHM#AKb~-0$so72u*6wEbv0e@fe%WxHF-9^BC|yn3?{h`iS%WKXS` z3Sbmju)pdqb+~=d4-m@N8-K>AZ~x-amU%w=%jOWD{pHR%?L5JZvDx#(J9;MKX7htb zBtSu&ejVJL9r5E+lj_RlV7E``A+aRu?M}CB+>}Y)-pbR*Yj;(!{nNXbV9Nqb z|FUf?kG70&TW?S97~jtQXJiiDoafUmWeB{|U~uUN??!2nI6ozKleHKH!V&kr;(GYJ zFr(CuJPlE|#ic`md=uV(qSm;XgE@`qmOQopcrw*BdH;#g+}crz2(2Hv(H1E>_*hO2 zXapCnmxx2%c6EwmQUukzUPI*XdJQGL>owE5>owH&uGbLZyIw<-?|KcZyX!SP?ylF0 zgI(vbJCAYp96@t&xWx4eAEr1T?r!Jd1Oq;mY^3ER^bCVG5u7CA%jJ*T=a1`)8-bRy zDedF6Jg>V}k5OP8FFUujBJUU65R-oRkf*j*lust4#?$H9(ebpvg=LjHzX1FZXYQ;L zqTZcVjwVj~$RY8pW`{w6(lR>jMC)u1QdWYiOHIu|p1!_Tc~^aEt^~k^$gLmpR@ zG!>gr8|u#~kj1mSUyq#h=S)67-}>6_OK~ZDG z=d(Fvm{TgoIg8n``0oiB#61so2O)jX*5tMBO%i{opEZC${)$^`>$}!p$dWzwKG?Ed zN^_o*u!Ue{m;1^Z<i6=7DcJ(d4X^7nV!VxE@}xrW7d~A3mM@gX^KzKh%{`@u996(Z@=D z%{bKRmX|ET?Jt@CMz=?ksT_9e{hGF~b==DKoEyT&tn z3R@Nqf66DW*WxV8#r4&Cb9pqZt)TAd$a!wQgTdeWuC34Jcf<#11eLzVskK|10wQmH z$4cM&PMX)6IRYolii2b8(>7wg&@HYBI7%;*?QXooF?3PEQ^2yNn}%kN(k2_skV(iv zlc;b@1%NNujbd^M=+yW5MTGw0)fi>(SAvQkv^0_eD!0WCS{mt*QD%%Ev^3I7Ltc#^ zwKURmGp#m>TUUIfH)kpmibj1kzqO^29v;$l{GcUySnlrY=|~UH^oJ1lbfk@GDhcS$ z`9B@$>sFSLAG9B-ZP^yKKr_%xE99Q}}-fG zg;ZUmn9Gs)*qvbYZ0ziQNPeD;BtJ(#BtN7Q8#lWjq93Wo#~1I+Nv4i|NT!~RBvVH}Bva2ulBuH~lBs7S$<)yg$rLHZM(y29 zWGXbQ7xSxc^SR|iiTtyX_%?%@_%v`>^W&s3O~z$&iWIboi_`!S*TXqbLSoI{Ex%ke=(?IbSIsqA0>zQ4dg zKjSd)iB48SDbg`iaAb4N3d)YumKMVW#d-n9o@=2U!Aq< zm*-dg18)YmEmM{HR2i0DosryufBfC-V^@9Le#`Nb*7w;-`+e63gU;`$IC)NsgUV;H zuv_n2elqdv^_#18&gG8rKW$^a=$7vGZk`T@bVo%l%wAjR3oY<%_eCS5ZEWyE4IX=s z&qQ=aoO%!UrOAT8OL0WCc*`e)h1`5!0t-r0gX)7`GPOolOjs4%BB>Z|^_z{VzvTyM z51?*)V0P`Hz`efLogwWFu-_gYPcGqcw=N?RYORYDR(~sr;;kRaSho&1Pwobs-QBj_ zw>M0!!Ajm$^N#U3^WypdpZ;Kg5841{qdAzLcnO1-8(SffX6jqcc*N5fIvRr9V*+(yEWelWntZGiJ}1Zwy3 z=+Of9YILx~6x=n3$CIeAzLB#Z%%kHIcP!tN;aKjfdDkF?>T9-lT|v50#{4Cllr(=L zJUVo{UZ#Mtjk46bYSbMLn+xdDMm^yBRR^@7cuMYs{COlMKXX4bN~2gp`-D&MHD?r?!7u9>|>ig^H0J;uaCxD=#Og<|771A zKs0B0u5KFq#B%`!MM!r5qb%1^!N9a_OBJoMwx>>d-HvJKYPfEXm8`D>&MRA1|LV_P zkN2K(_v4`oR>;4Fr( zrZp!^J9A|NT!wdh<%iCLJF|R*Ii=q3PnH)S-x9rW z$V?{(r}Oy*1}^h-I?JsI+5aTW>&S<~`B5Q?Hr5DaG+$dhF(28y=77-?H2naC{-j5Mio zllm{RJ#~`wO6V`wRAZ`wL)u`wMBx zYluLE?&|vFWbys?DE^rOsqH9LB;y3Zu{3?Jtnx@f&3WRm-Cf& z5UZG60SDgFASViv{8^_5$VoCkjyELCP;FJ9Yo1#+*+7%WQI>P04$ za70B+X8p5AqA%<90Md1kJ5oJPDiAalT`~&xyf1;0DHo}oDwPb2Ev-TC&d!#$Fq??X z?hlfvaBSo92E$-?qSVhVlZqe1TCBnNY-wGRod@bjDTTZqphJH;L=1XkXirJ90_61> zSL<|TQ`vkWF=(pPEQ7Xz`8SKpvR102rFkBbB=9?^4A2fM?|Ow?S+)?rtl2i|^me^> zQA;~^-Ok*IQ{MKKIZAxR1`fVr)B@M;){WgZY#mAp)0jbtLHFNEt6BT@!LFvU|(`z$%P-n8G5l^Z6mU*>dF)a^EnoK_| z-Jh3u%58qSk%mouXaI})YtZ$OX^|GXRee&2{!kRX+bqRu4yqd0qE(?!UlrKoSZQnZ zq_!&h)>jo#^GT{&`H@Fkrz-Z~P857O_>vu1`_k*)zGT4h<=V18V%c@|$=cUm@b)$9 z9bd13km4UVzkX~es$Y}3Bfi$9c>So!)$#n7Mds;ZZytNWk*DQcvKmEJjpv;DxOV5H z&d7F{!{=!vRuo`zLtegETYG{zNv`s}F6U#fecu7mimd~3RYW^VM$vchq|88piTwviD|ZIn`Cw%{Hs6+Evw*dgd0lzueFF2i%`=|KNST5t;eq^IF*?W#bk%9;)lf zjC_lXh>VPkjP%Fp6pX>Tt@sL!GW5PthEB&a^w-O@15WTlUWa)%xXHB<#aNObTVtv2|=78)<|*`Wo_DR}b8j^RXVS`Fgc}#r`+?&(NJ~ zmZ0C)EW!A%Spr=2mUuEholJE}i-2g-?U||~IDeN9ZGcc~n~MK%u|scKWP#Pfqenp( z{4DGSk|1FWZg6~N=c=Y83wBAw-BYea%U08Qhk`RUE0BfaU<>Q87siWsl?mp!lk5W}|*$7XiQ zS)b%hn#Wv{q3s>v&5GFWXWv|2$k$7|(MOjGw1V-OmjV0)$i~c^3?DD;C=36M)(!QH z=0iiH`Ao-XK2(D+bEzdGG2Tl$(mGszddB*`p1!pB17NoR3bYqMv6Tg(@jNETmi&_$ zr<&#oo4{DNdei0G(4W!X_7jVwAM&Ky=;)eS6mNoHI5Vu`9}|~V4qf&JE@trS9V$GB zR_1*%F3rjx(5xtz=}aN|CAwSE7rcUA_Iw{t_+h9u_msDE3;b*K`E=wYOreaNCTlO8 zkYGy#!Yz8zt73D z>0D!kVkHuFs_5rC;%)z)g&5xntJ$$)jcnmoR-P;~o*^k}%?ry%I3;e;vo|V(K+4i| z7M02&i{PwCtJ!SHFw`@NcKRM>%3e>ZCsD@!IEk{`XOmc;f-`dCUHl2I$Ge?lr$)r4 zT3Ej0qrbsca{ee7N#-+KK9WRI?PXA>_MJ4iE{g0Vwwy~PsWGE9?X9}rJO&TZjAcV` zogRpDTMM?%{tq|xDcqwd$*oUqXA#|w9)?Cp#2%@%Er3MQX6@IftvKNmtIl=ThVHC5 z?s}Jlq)kS*z;_%!?OILelxWf=ck;Ch?GPU`gWL%WO{fb0o<{HJ;4+iJTxqd$D6Zc= zU7ztH#AIPR2MS{iVsLlFUp8R*aJi_%20CzA+a#bq{?D|p&Ah; zy-sB3MZB;3$K2?y6BTW9v-#>QJQ`4Euo=H3C_`3W7~N`f@p0 zUxgb13P)i!h=;2Qk*v5>Ao#=0ld}`f$e*w5g_zGKuXIOWrBvnN#;S3h&U;q*huW=l za%Dd}O~wREvmZPPXh%m6IG*4PT@Q1ZD{b{)vEuQq)dfwg6iCdVx)W$NYIjZen0pR{ z55o^X>NP=(`KCU_0r?7Ic5MBV^zb*;Cduuk$jS}~^VLZMXZ0bU zR;kPSe3bsHE5SaNdW2S!LutDU*9sDm!#R2zUeSyi1(4gFewZWJ<(hEB?6f(*_qPzW ziekZm$}sW7pfLWp-;??BbUZ#^JG9#D)?LE9=>ej(E)pFh)+_h93Ww?;vS0`ymjxB{ z8v}W~u(wG1%0aFYYhpMYV0l~w zjrw-UFt0t|Pq@p5$C-Eei^U zM$(~AR3N6CJ-$8a6NfLk!S3D@^?~Sf$mc7<++m|7jpfMGQVI*sCQiFgir^$7V;Lmm z)FhGctxVPg{3|t!`qCyaFovufwSAyy$A4`$`AcCvv0r_-grcm+bTFET)e!NoUSF_( zRj595p={+N@;iBPvO*oO@-7h5>9VCkKW%ebj@a102%%5SasmKxu*SSg^%f6|BrY_%Q0G(%TGM9>U zY*g#k12)6D)-=HgKG1veIlCj1dw1}hDX{QJ@;z6fHymIn+Zo(?MXYYyy`OE=FaHhL z;rThQBqQ{XE|0CV)kjO~GfW7tv#*jS;apzOe{o*uLqdf*!&2kBew*-OOjwyWMMWsw zzy&XDYb+4*>*$&zr7DOTbiGW}+$rg%4LG!vMjY+QbIY*#MkT5&_R##e_v_|jKGnHb?6s~MZ#9;~CC>> z7t!?fQBW;SLKIKj^Qe&8lX-Ds3TM4891F%vBHaaimOauFq~_XId3_)@!{w3gTRx`e z$L!|wKx8qIbv2TUm-S8=fhaqh_A-;@Oi?8?7qjXCk@z>#$LlB*cBjX;osVBb3~mo2 z7WQoRBFp1O{W&N6jiiht4YGPlP=4fY*u(}WA_Q#nO?Ov~Y`YWQh$L3X`rJHMZ09?W zl_jegUif@!4?KoPM{|O}(r&kaz^;DYH{%5ufQ{;J$03&U$&4dE@zo~s73iG%OW4^v z1I!k9wFj0T9cP_!)Mg2wowIF`Xd9t@K+VS`!v(@)9pf zFy@q(!PvuD!$=nIU#CzljxjLAlK15W_;D|i>Js(GzjK_nuRoy|=)KPQqx3jcAobd` z!x}k_2Oi4w#jx&xn^jT8jj7-I0Lfyw--x$X#1I>95{7Uz?|Avz(N@MaFfGbV3svEf zjC*gp0PW~TTW*=9F9?jc`crp*;`ZC|d%U2EKSFbKF{HDQnwX9D?L~7v>VN3k?V{YS_5)^ev zVmCw0MZu=BZEvk!)LRx7Hq%FQ`-ne%5#3Q-EMezpO!Wo!6yXiZk83kTpXnS$Hl26Z zxkv!&Hg^M!UjQY0!ZfYLb? z%1HT|BNME8HAM-i+LMJ+t3%2iaaHPkVt#_k%sx{l=sv?0+mD&j$44AQJ>3%BnVs{N zUi-3geqkNpG;F@60{3K<>T<0e(~wfI+m$>b=to+7i?^w9J zQ4fUJINfqF5g8(*!>{Wyg;*_&+plE5QJ-Ren50^hlhojq+zkpXvA0c#xY^qtlQAmF z5+#h7c(=bh9CAulQuEMr`@Gy?t4CY8)r1_Yp_$SoHPb{q5SB1!6qlu`lkK$nyR+sG zWYx*WHO)#>lB0Gb20NN#;R^0T_HB$)Y{ByrbPHT!K%&A)!8>(H-47Y0nmn zu!!8>gttOnNZ`bhkyPzFeM7(U>^)Te@o?KygxMqfVidcI5jr6In&gNggkwB`& z-*uGcfQ7e{PjA_@2A@QSJylqA+VIvoc^Z3a96HjBV?sz4wxKlN!;@O-RgqN;}vtOO8HB1q0=!K>A;z3Jn2^fnn806I1r0ibN-HI_n z?=$#N``by>&Sr10l?GYMuJxLcaWH549?R^x$uo5b+LnG1iQ6t>)F%|&s(4G~aIlLR zRpSrK8H?OfEzFxwq-I-`ETt-}l1i#c#xoaZWBDQceu||6>B>t8v&i(NOz*1EWI4ww zdF9n1y9BJ@TLJk(tcRCzluc4HxZ=i@Kp0nTfe+tkvF^-osO&~o@jIrV-WGD|dCTeV ztv^jY8hDz|u)?WrGk>xL)-|#8dZcMXpAu%mR3QlCrnUvtZ;MyU))Si5lBarofg6WG zSNlY(ZNp~Ns^=DgV^i3}qtH469Q(-p;e4^M2Ly~F?y7T7Po^ZocfBAGwv9g+zN1D7 zGxjC3*!$f`S204zG&t9XF_CQ16nTub#+x0g6inclAPWuE272{VFGXPi_?Bp~F~ZbT zPL%nbjjK3Ez1OnXhRJ45@CVJoV*X7)Pb?+*#}YA(#}E1F$kGX{7eBH!rl<5fyRXqd z>|S1p-O%*wo~UqBpP3nNbkm@q4jhajd1z-bJon1fy4~Jrm|ayXGdoodSkJ(r=j(to zGc9meue%ka%fR;vm*m99k!;DWcrr)L)v%%0hY7A2FJvErF(HgRi8*S4E} zT-l!J(Q1l|0%sd;x(lzaau>^T)8U05a@h2SQxF|^RA=z<+4L;z$ug3pcgWhPEI8&! zYfX+!+L!CNp}Gb%D7*$VM0O460~QvA>9|IbhV?+6AfrQNkw~`Qw2N&Rl;x`bgtxLC zZ@I=Hnq%oZ)qR!nIS z`PE0q2vM2ASSJ&Wm`}Um%PtFTtL3yV9AQ@<2zP$1H~PFa?pzauh=@ zZdLU5Z?+M?#X6X>V2(Ts>Q7k^ZJx!(zJ*!!36j4xsd$+QPa6rU==hVnVlZAg^r-*z zYPursqQ}o6fv(BB=l;ow?Q3j|`4K(+JGTd2%w>}9`K=c76Q_f&j_A-uCF!CA>jN5n z9o;;cCWm}#cVetG6LF@15O}P4%r?-jdACD6w|y$dx4A{H8fDrcdcwi}+i88F3Uw)| zHfK6utovpdEsBes8T&%LsZMjtK_?ErGWCrP%`K$T$Y(kl-#qyn2X~gczC~< zC`?4poTWoG=o|$@=b8QaOu%S9j4+x%$J6K(zj8dxZF{@}90C}cZ+NK>)rq==8mKRL z5a|ojYxon9#Bkb4jG&Q(2+@MkWC`i1ZJv-TWyS|G6d`JOx5{;4BZR~b8IjA6(kVYm z8|hhzFBJ3J>#-U-EP-QXbB&Qon7hnaDDdDwjV-8=Cku%X{CIZiZtz7;ju{g%wobSX zsEnoml9)@}^LfrmC-+wVA^d&IJ34RBT!T5&r56)b44(65U7|86SFpLvc=Qdr68ZVa z+)Pn%xO1TH5vS7B0<1EwnnpX!C$h+|k-CW)P1I?vU`4A%qbMYBvkeUDv_l3cQdPug z3|1}V^oPmf)hEPfd8t!jINp54;&q^?ZFus+uAn?!E)X0W-47S4;F_u5J7~%|Sf`0# zs7*&j9=*XCsSwG}TRu+eVra9}h({F>;p|!#h@5wG2=3=)H~d&WdH&r%>|IPwCs2qh za&Nb?3|h~2H`^e1;q7A04H5;<@+p6M|L}8m#j81tl z4QK}?1PF`V%GAYQ?7vC@m55?{h-K}!r9fzoBr$qK64=ZzVcr+v00KJ<8zEiqv~_{_ zQS14_7ox|1zC1$#k#@)`C9z4Mr~(vbib1iUa1=(3b+x{cTdnIp!m?6Q$@dizTuyKq z11oZG;t7$zki30&-EDABSlcwe1m7w^b*72@6;PcBy}h}&M>&s(SdHFcQdY7Y9_BM_ zwH3?6W&MM&<%YbjyLamjIb625K}Bm`Sa;+OnDrD+p3p7(+s2_K>K# zMowi00oIo6i)AHp@mrtEH@w<1^rU%|Sr`8?)L}$dm?`nS#0LX9_eCh0b`U^ACkPVQ zvD+rC>+@G_qs)A~QM?{l+g(Udq*JU%Fu+F3)1@Y$o#%%eGSaDrkcACgxKsq7ypo{N zPQBi-z9LCQn9aetie2QNQzGwLwZChU4BA1bl@3i}k_|vkjp4&24ij_UM1mz}E2=%# zS5Kva4aQlPt6sju6s;5`;;S>JnpzS2ERZb<@riq93RkQ4Z)xH>tu!X?qRRscy2xTb zaQvqjj3GBSnQB=%IJfZ;*kw;Drdemz6P($-m!T2^r{7nm+tw*l)?x zz$OdQYNbG3t(1f6c(q#i@`SePc6?^P1IW7CDtfabxZ%s~5nDrxdAKCZI=qlpAv;p? zohTj)rmIgD>YVhI1SM?-Vo8qrJ3!&2Qc$g%#jxP27-*Cqk+)ZtIG>hoEd#Y zzQ4Bgc)_j6IdURyU*Nqz`8mMDKl^#kNS30ruvzq0e zs2=|(8+5}@m36|k%=w=$CyNaezXOt%e5N1a9shc6N4*a?ax_b(o~!Z4F4K`$5GJ^? z{ONKN^jPnbd~$q8kPf0jLlGREK=<%!>?BfSU@3h}w3c-&B1MZ65sd-v0rfch&mXC-DKVZ48ZMdtX2W3UL3SESGZ^RQ# zyE*Hqf7jCS8Vz?Orc`$fX8I$o2&MKNt!yP|NYav9`Z|Hu1fvC`{xD0=v9vf_$BX!! z9C#=wn>pLu+hpP#Y0JCua-!4mN0fv3PK~eY%{RQB}`Q zX?4-#YW|C$46n{EzEF@86VR9wI1vb+hDUP`!7Ql?>~SVlAfayO9bxwf!euQX;2Bgo;~xWS+RpQpVt$!q;tl5x#gVG`h!6CA4nbrTD{o5(*S~D8*pQUU0BA% z0cJt`b}XT#jpq|xK&BrPd%9$A68)0w#2ha#ED z4Vj<&D`QNj-IG#0Dr3ECGTs}=e>Ekg4i}{ z645L!FzM{_{QQdDUy5CcOtueB`HfG}rx$@1>^s}u%dnE|-a^1z`D~b%l$;G|saOGc z{=zkyH{-=rx`X=l{A(^M;86ie!YPPGI#?@mvWvXAjhh;X8zkLDL)5A2O?p!GHk1-|@Vg({~Y}Ryy z#%5w5&hQXb_LlNZS*=132CLnznuyIq@X{E>O~shD){B$>2{D;?SSWoq*8;|A*M|6^!C>IFv$#>!J)g-%-~dlV>og7K z`I@J9rN0yjqieJNbM}mqF#i)#@h9@*bayK57Zk|LYZL7MghF#M z=Fj#r&WG}RQHzi5-~?w&mWIJn!Hj+E2MTUS#g?VmK3Ic;>3cpSqNt9!eY1_#4r9(v z81T6hh9M&dQZue*{bdzj9iaS`G+u8y=V`N8X!45=e#a!@Zf(wy?R`j0!fb?eKP{Qh zl7Xct82;GGR@|k$>A%+0H2csyN3vC%+g%ai$e8)9HLo|sQ9gg@*MHIzUK>3m{Rbld z&0R#8dLluE#)t%p$++o+-Mftd(N)Vhx$8$6Cr>`~Lc35M&Xjy>fm5AMj*LzYm+2mw z=|_?iyUVl=op@G$Ie&U$`vg1uf+)SIXJL0dpFOzBM}|Z~P;-h{0*Mqaghav@LV{L5 zgo|51P8)=0Gk+rp({BWxXeq=vyN(%ZXw%m`k)NG=EIe!AUGq-k5WLk=&LMB9nT(Do zr}Qs3bN1Z$fr!%6@o$>7_M)fbrkh-uU0uLs71!AGN9#|0pO_nFB&s^U7pdbO5>)b5 zr3ex}eerEUwTXTCc)sS?PZ#cdX{1WK)MZ_w@;`7r0q-wc*NRL}Zzo07?7N=&-Di&0 zXifz#Xu{B|kMxEvNC=wERN$<0@65Ai{9vJ010{|oYhH)sg5+dTO{0Tev`QF3DEhTa z9L=aJDa|yLGY=hpVe#9cx%?Axz-|qP5U*r&c=EZw0!D3!QS=?VT`_mT=RnU_COYe8 zIoPCAz5~q^BlK2D6ZeDAvzDkYAX0u#(M=kun`xtRT;#yDuP(Wk#|m`C>zST5L<1$L zEsS7G8*c=#B|cQ~>6&QWrky&O*E%QIs6VK){7G7`=Th!y4dp>aHHvfxYsX*B4) z(6?4}%7l=FC+@Ef7#8_N;S1cWZuuXyHQBIwf2o7rCSVP=C#9j!=HB>ept0LP` zXyr}F!mDd}g?Em;Sz;i(Pv;A96EmUpY~}K&PLvSrBtn*{PMf7L8Pt%{8Ai7tv(-)H zkiDA-(RLH*w(7U-iBMdVN8@9Uoy*D56rB3j1;wIz6>l{YsuxisqhnB2@ z<_l40f!v`iC?)O$Er3w!wdshuMeE95aPctM!z>AYHoxe4oz9{b1POipLYfGRVSAmH zAlT~{0^?T5^Z{ulczkj2H{B|Fvd`SgLUc2IyFjVy3m&z_J=DXyt4^!ja0&5_(ByaZ}5p}R> z{c*RN%;9byk$CiUu2qT~up!7fD~x;aY3(@*Z^fkjNf^sc7`nSRZ}c_76gp3j(pRukcVm|HJ%PaV*@~ z@upry{o?YNI63GDM(j$Vx2$OkToWn}B~S+}_iqF){tI0DeaI`$*(=rTm3U*?Uxcp9 zxO8u)ig?wN8ZK;a<3i^VTmobG&bOPjSDg@{1V)p)I+|j5EnKA_|N9pgiz_u0b)!0h zG$@IeV4dj}b>4>+c1n-nV2j9nQ!lEx7TM+76zScz zG@VJ9YX1b?KtLB^Un6Z-6jOAeu~?LMyOFw3vtQ!KC|}~Ly9;i%1c7Z_d zyFj4+T_9Q~((9}JgGQ&@1p-U$0%1S73j_^*7YLgCE)aHryFgficY(0n?gGK$u?s|- z&7Cj>6r;nWfbQ!jRqjoco0wpBnlvPA5xr+{>H_kU+S1;n#gKs|~K zw6m=O`cZ^|UG?bPcqdE&{SaPncRdC4qf_dg{V5PTI@8`+PXYbx7tqgs0sZKz=+6EW z(2uT;?yRSPe)bFKN7qevwWVvQ*!JQ&C)H%Xx{$h$3hdgT)ViP`gh;8>tLvX@E&!Sm z&5lMfU?_XDIzdB+-cWmL{TjURO@$M@7c4n{Pv`z}Hc;EVIssj8RFu9CR4QpYlm!#? zWwDFiyT+r|MQ3G(hHq2f3Jr9WtP{OwgjHp!_i&_j0g+8dO0)8&yL%`{Npu|j;#)gr zGKK-II{PSc7B1G)LieL`Mt}=~tRKy_^)Qk^n|}UsvORjax?Id2Sa@{>FOccm=ul)c z4g=-ygmFq9uLq)GKN@adrF%Xe^avE!(T@;C+>5k$o~X4Gi&w_2L2SMD)1KUui8*9& z_CeT%t;OWjEXHpG;jOH*b@X84n9w!{d;9D=3XVTBYfs;WCU9sR?Lp`M;pkhq)Ya33 zh8Snt=yG9i?1)0`y0LCtoMcXWMswiaG9xBJSf3)BS4N73SV-N2Zh}omz6Z(vgCvWa zRYc?tAT!O`K+oMgRCmI8a2nq$^v`*`iO%s)%!!62$cc5=59LS`YFJ~pY`MeN-Bw^j z@HX5%UT>bSH4qc&F1!zI1ON0Sv^X^E6RjQeRHdznl5!HSbVxI82V0I$ui`wI&KMEu zYb!dVb0-16^$fQ^{uk^)JGzNhc~V0&jzit+XiR$*`4fn46H+f1a;aPgcv*+Un_Rn47s|d{qM*{fKWm z;$~#Am~~}rQz@GxvX3#m=B87@2TM*Xz<=NvvsJF0wEF;k_3N!8uvK5FAUFE5*c|v` z%rX9CF|}}mvHJU**P$qEy;EACSqpDWL8X2(>*+W8UiuCFq~8!%`mKF+{eccre^9NP z)ndyDIqr_*&tj@kQD-5j2(}ayw3dQ`=0Z@h)+x&)f>{qx;aodA|H@yzbfaLAzh<`T zKU#4HFn>#d66#RLBC}kRMMDj-G!7sh&sb*9dNtH+X`3>V3o1u)q0Et77S7>ZZL@}R zwZR(B)mCpLmpL8IJvfj=c!=i*dU}0WApVJ8=5@w%MKO@|V4m|VOUycL-#A_2oA+U* z1*G$gbO;jLxb9umF#XgM0vX?koqan}>#Z=SyN`$!>X(n?KN^m5QrlW{uDN>jwixLY zoRRP6MH#B9^`1mFe@t~*?|sH@_srjPM>dUKw= z=33Ey&pfL&@@0r#TsxH1b}3|_$Tv+g^x2$b$g?%ctSQY&){Iim>R54{>Pd!Pc-0V> z&6z1|7noO`uX27>vS}QpfOO78OnuEJvK5=UfgG53AP3GR2Wm;Dx^63YYkG+)mc&8m?=;gzY(KgB8Xp`d72(h~nOUNo{63nf@BGpP%UzYJ+^@@6 zD#SqQUMuzO_as4)9zkIu?%qj6!f4w(H`~C&h3(oSiMF&T4G#6#2I~{$aS5QDEX_s> z$w2zPz!~YOtlI&gqxv}8mCvGEC%N+3W@UeXdviluHZF_cGO@XFShwK$D;cRPbR5AK)?>Ciplrb&8#sQvZoVSLHgz7oTbq*KM~YWaD`pQ_>({gc-n zhKOf`1>_Np*(3U+n2#IlE*t)4c7B?~lz`Jw5T@sF$!N~>aDbYzKsoh`s>ybu-pr~M z7GK?-Fm=o{!%pp~e=5P0waiSnQyrhpdG|WlVss9+qb6v6H&DxS=wR>O9M2&JvAEpe zp7nIy^enP`s7h?&WSgUp7W*@t;d)98R^{wtDo{@`7>S04a(xzua-F}1a^pdVx!s*j zS;ld+()PBI(DJxT&L|F^9Z&_Tru;aJBWN7PaWxKe5RPMpdV7k_fwQF?d?yRr7Q`TVxB#OU65jGO>95pfVLh#>C+P*zuqf3Xw%`;LW?dWjMuCEZO1*h-RWq=$H6B$a z|K>qB9zJm&WvVvek$pay9M2a4+J8U2cxVxL{BQMS#%pkR-9DK?lGOtQ5m6mp9EJ3o z_^xiN&nD|vUikC**KBC3uU2QX0KsZG*=(oM!-M2Y9j_h|vzN=M(K2C zl$A^QRRr{Ym18!Y*>6_v9Gg#Yyv*LorpqiaEVilFX-PCHYmO;^$o;s9j`u?H|ImY_vW+)M7>5$yVJlS@1C!9MKH`2S10-X`21q) zm`FCZG-;cF^{A_dPYJ5Zr8L(RSL@cqx$jPvuSo}6fnfRI|0DIDE)kGgPJ9oPnsyZ< z>>%Z|z*{pqNj4#A*z9W0welQp0Yx0B(Cmonox8!`Wny%tJv^ys)Q1k4{mExc5 zf^0V?0fTWCd5MK8E}pH z`t=zvo~i&FinSThRe}S{s0p!^KtkFxGvSm-=(x#U`1t(g{WU>J33j%6J-0)yl;LgWG)%22Jr&kXZ@f1Qzga^TFSFh$vqb&4nz-|g- z-zZHUqJe>#zm1+XW9I0HaE~J9h2ZFz9u}K;=I9r~=GE+YTG_G17mLXf2PQqG9%GAh zRYtdPS^t^Im&VU1Y7ee-Mj#Sqb2<(H`LzlsYLzoOcdeK9ZbZZuUDq9TO~F}{G5xdrTol1IP}DDB2zDrW)f zHg>_L9l~5(E?>O(+sW6HGgJ)hge?FDa>TVOm(Cj#7A)_=J^s-xSWHJfuxVg=&1Nv4 z&gz66yz7j(@j7+ecw%qZWS!=uIDu3 z)nNV&h5`53kO17I-fJ;5b_G+nz*HDiBN+^})s0&$@_nFSt1lUBb!wOkLG9GrT0NQ+ zb?byH(7tMLrSW35nRE01*(EQ;a7i*8M`8*@&6Cw^?T@3QR&=Vy+_urNm=*#M;K~xp zOs1^gMiBO<_u%z*JyxT&xQcDb1ITpyvyJRav-VpjD6Tc9Un5X`d&vcGAabY zL%9P*1x`(!v}o@`P*ha%LvUSS`tUQFrn`W~SeMR?id^ViV_NVqIP)8akB*I$!r@R| zSDwmZq6%wn=#U9R`a}l|?ymtXli5sQ3hRVKy-ZL~Dgv{e3MsN`@bY#%DG+tFF^k-j z^10S7X?^u*HCK!jEEXFqzqPT)4&fX@_^pHzScqB>szdAWdX5LfnF&@OC9YbSlIAl` zxEuscbBj?`CSq1yt|kZ73^KQ(2x?MrFb#etMvUsf9odzrL~m=x2XLivF<2-$Onp9i z52^nKZ?U8jxT{W1Wj*2UclLm8qI*B0tfSXlE(sJm!<|*e6s?8fr-D7%q{?Exk$=vA z#+-piH*r7ZPDMXGsGQ1J3LuZpZ1LnuNOjo!)b#Zm7jL4{A77r*XV9qNZ8DqHTYqo^H}FB@8%lGUJls4zaUQQDl&HX7wM7LQhk?+ZV?e^`-oj}3M!0Z68UaHVCL$a} zB38`F46W9jawK%V+#u-UiI?Kg&nL^bJjJSA05+_i_?DbaZ@kmaH3%*k34Ah4H>yUE z6d&Bm2<=<%ZlX&k3*sZnWEC+It>=&+jw{bE*UKkd1tS34eEq+!&X(F3uMRP}_*W2A zha0!u=*$rZz0G{7NSi9mYS}2E0xX!17X(mQLe(sYSh5x;s#|$bw1tIvswi1hHPdAy z)=IKqmAG2Tke!#b#~}rSRwsY!Si8BLATjArYyf2RBThf^B)laG<{|e})%g~We|BOlyixii z7)ZbnxJ4?TXi##>;Ng?aO6H+MdvIF(SR|~Z)D0;UF05pBQVY0!tZ!s3zulQ$M|0WL zSc6}L?k$Y(@%Hq!y7)b6N^Nc8d|`#9t18*^$3q`F1&nUB!ZBhp0_8r#UARbUU)4X#T(4q6^w`k!95)g zMkw~C(@Q%K^(K%Z4?nWeu&=UImk2ie9IX? zQFaShvkwXSNy#7t^sxhiQ9~YD1NbB7_NNzGHSEa+38dxROwLqP0#;ZX9WSX3o+<%@ z*$_z}1>m%HX_cbWO_^#_oFpf`FgZdqn+qcWuPH_mYgdQdp&eMNoq&TAn+^oTXC0iEQY87AYY>RhL`o9i^E0Z#V>9yOA>7@hmw z^2LjfC&%c*s8=CYnoe54r=1KNcIpyl=xodqQnD8%^rb!o8<(jL`pX1Z24MF{)RmYARw^6x;#YG2iR3eeMf2`B~yvN;t}ufqOZw+4(< zL+ONQPBWQGF1X9D9OcA>0GEuA8}?h&`7FS*z82pHijFerIO)ZYn(E`57)|BJji6@BZ}S z#dCNlOYBJk?hFAX&lOY4vI_Eo{V>+GPca9}EQXc-d}4D4_CZ89{Z7TZj*XEK0RH4; zwTN%ld+dJU6Hf4tC{vZlY;_YQySu573SIat!v^J9r9L|&*5&fF9hD&Y&RDT0*z<9R zQCue9$7yLV`QB)mkZ7M7$0zf+nQOutfXL2A59zV(`FTNEB)(X!~-jRmhs+M zlg*}Q75`6{Tr?ZwTNkr$hBnAKh^R(c8*)|_qG{xV`N6s**&4vmQ~F-LcyWY#4f>6a z%3#_3idQud{QsivU3jiG@9DSANZl31B22Y0*>a_6e7Cx;{e2^!t~b8(-l;x2bj;f0 z6;D&a{(!%lPT1_P-He3!*Jign$oiBKq-NnDtFE2Z>bcxuQqS6WG9QI})ZAh$ZQi_B$KmX3fFfzJstN6p;DfqaT_JBzm+dFXt#*ne72~LE)G^?>ph{U9QZ~EO52nrgT*o@}&m|f!=9j@^Wrh0f@ z4|_(i7Gou|&VCVGlc+E^>AO8jdHBVV9b}`Fe_u*(@p&$uOeSSrx9=98 z=Q7Lkv+?L#{&#~NYzQYQu2X1vb+Wy|^9Z;Sz&vNu>Z=E0%*2&{tPlQI7cZj0Aac;* zQ`>v6QQc?<{K@}zb`j39wIvD3+GAAmU{u$(M`tq7Q@@#?+?hW+w*o>%dBme1r0r%2 zzU<7YADUSh$z@*f)C-D&pY(5Z$}U9m)avT%h=t%P6uqXMfyL!S-4`%Slzr`0FJAEf zFRJI0&8z$FvWl7%Odk)~0gfCkW>vO(C04^OunfK zDRps4!jKqi%#v!jD3}NW8oMX62OUf~*5~@O29!feETr|ex5s87G2z>4!jWWWF*VNO zCv+W{KM!(45X#Gbt?kZ;w}#+5*fz5pfKZN_b=Y0xG# z;+?OgVc5Y18`NYhi1!BSqx5)$J#hS3w{pWqcq1jGM&8}=W2$>I(pbg}=}KGgzXz3_5o zH>@$DJg9Pph^x&-&1{yDNp4JPX3KWmOwdZxfY5T&NYI*dE-MVj z*^4VS^958ea6D5qF+uc1dsuwi<;sqA%&ka*QY&*%uEOIlIe-q!CnX&nAXjs}WA!*+ zEwwDk0oEOw9vxdZvb1+cw%2NOgnXr$Y|P*#qSV$YqdtYm`?F$ZS)Pc?M`WK6(=?72 z*FZC<>-K>a5CQ}xO(r7<(@ARj;EutY)5ok|THOs~vr>PCNP z+|Fe?8E`{S2E;M1bpA~gfC#pRKy-=L8W-iDwRHPD+RI6P8!w67gN%gGvwGjvS~uVB)eGl* zyPtpT)oZA51*qWn+o}7Na>%Is78J+3?gRW--Xj>QT<5Sa^Cgkbr7fu1ct{=T%Rk67UYQ0Tr_5Fn%}#%g2Hu~earfsi?17xV9pNzqrS5jNikJz2J7SBnSn;FFl&-{O>$>cSDGS=kvmlj}1)t9G z^F?A)uM5kIOxnyj4{C@L67bdlq>)MjT)L_Bw?~Lg)X1<_7fiXz+ zwT+8ptGHQYZP6s+>l*NDzFhbrLG&=x;{=-kG$QS?nb-)}{9K zVYzLkCQ*o$*hJxAK2m>p_UFeI(i2?z4<%f{lMIOf?*K(g2PpVWD;@Qp^8x$)++8j zzSFfTzuwU5*YJWhQs~=VwMH6#)82O0FLtB~(1ESEg%1f&_9=t;5FzR1a7V7QdxFgk_G6|_4iCG=9h>U|3{P_KWjg9&b| zwh-68mCnu77DNzn#%D5f-*3)H;x%2o6}#^Sl;&In7^Ktg8YSafL;a8!#JfH9md)~( zIQ5^*h~_L+wt}KpxXKmVeDa-QIX5h0yafK26A-D%>-VrD6wZ6LHZBf&rVSmy zIoD>x^xO}bbLZ474HE3BSB(83M3+@zNh}Uo4VJ``)P_Q9Zb97(F$eCwcwtwhbPxVDJ-Fw?p3Nl4Zvw|lT-RLAc@xOvufpXJ)2j=v+?Ov1<`uxm&*XkPRKAg$%VTwUMRTwF|(4% zh-0C?v(1~@rg+mZyPf1;bLBO5dP+gq3aXK=l*%&gS5ITJ@y+q^hxOK+dWv?(lxcKg zc*A#$WVKow@JazML;GV21&9vj<~s&+uO1BeC>zYZ;=w@BR%>H0N*No>y(&O-26JM& z{RSCK8Z*FGYr2&pWxQ>LRSNnSnfA-{tIr5HH{%?%^O~U9&X0p3beFuJLi6If9kqo3 zB0Fmfd(iRPreP<$11jj!JKKcwcaH$^U$p+s%KCXrGOUD+*e zu(Rp%y-go7!Vv;|jeg_%oiVTii&D7>3L~r0 zJlH74q4W~_pd6edm^+P!3nxMC8z1ROp$fKlQ_R^`fcNco+%QM)-8`t(`Ejs@Mm`EUB0*@cua|c5 zXspg#Wxc#ry3g3VIi~Mfu2e7Is19rRdp8RyXOCznrp)cGu~66C)0Nw@J_a7x-E^S_ zvKO6#cGp-aw)W&>S~i$M(Y2@hqh&QBz6Mvky_$wRlS#;}>$Niy7uDMOF0<(4%q1JTgdZtrH{j%SZcfQ9W9>IZweL0C3| z;yxnPhIC7r?A#Ha;6eq;Zt2#*XY?<+IT&s--yRfh@+&o8!@ z03w1%I-xDvpkUDrxw77rif_MJU()ST@qH_9vJ`1#6k|bD?M7{>_{N{I5Iv#!>+-C&jWFOBGA`IhNH}s#xmAbyT-8k)1``~u7{V^SZH3~ z(*^UPHP+WxoDU1up3?QzSne;nybiXQudZfQJI{_jvO7iL-fcWGJdaoOj{dx;vkFjD zx;zhdc<1Wu6PDlqKU^v%dyMJ*U^VlHYqkWIiOWFK33$|4sYdi+P(gS1v2=5Qr)yy!OP5mlAC?hC>4J*iY+;S1i<+|s<2~;tPi+mmT5ru;vPq5E_nrk=FJ-*PcOyzy@2sf18@tdl&*OdrKB-wiqpJ`Qof(WdG)=1Rt1icWiva8Guy3# zx$P`ylg1)!4Q4@zYA*s&_$03NwqWmoMLN`r`wrOBRRbr?LL|VYpAgZxj_GG=hyr4j zoY3ycC9grxSDkwOgZVU@tz#ph83^lrj4jmUDNc@$qoub)>@OPIt7Ac zGNRVg^)Wbc=>4Rc1eresQM$ez$HQc2%}z^AQ%xtkRFvV;*qtMJ*twqma1kE+`~@ooq2 zfndPpPFfb#*&MLOh>b)5}<^E73#gNDCVlYQDw9d4f62xuIAv1}a z;JLjw(~hgY`LQ=+g{U*N^U5w$3)UE{= zs4_7>kCLXZFY`Y67ag>M4$^5k$flv}Qlqw9u{6A)dP)~e++0TM(bTr(KF%yXiC{_= zpzIc&Pv;!I?av5nT}@?jTk8dtgIKp4N!iGwpeJc%>$$wQx&@-n*R815+rBauJZ5AqJjw3tmmS|xqV$ka&P}buKBV>V!YueUy7zDP zNPzvDP(@`?e7&`ToG6y#RED*-=5nNhx-=au9FxRjv$}&X~T)EMd5OS8Dy$`d&!~}^^K|m zarL!QXrC@R6zZ+}(aEW=jzYV@espWI6Mi*Bs) z;)`?CIND3)wwY5=hr5Yk5BGF^!3Lu#?d49RiSNrJG+~RK547M7d6ew$2cGS%3ycr7 zLnz52opoQa5CVqg~z zHK-xIm6VF&16f%*i=f3i8X>4#H*0Z_hm0C8(qQ#bP@>MZB!dN)8YFNzICV#1S9!iQMed z01nG%tq$uYgQ1$Ew%SuqDIvGq?;3q6rQ=&cl=cn2RHe}C4nxC)nTO>oE@@>ftM?>^ zTIk)r*#&XDZi{=Ira3hbg{b= z_CP&VlrFk*g3vIZPu4hsl`07YT>Tf-J7-_MT3IhdUZbx38)oK>D(R zAn(iSF#NrdCW401S5K*s!k5CBudj|$S=sW`XyCe3?BJ?Vrmzr!%FN@rPDYfe!opxo zw)IBgQp3kRgoGKyO{4QF8Yc7od!?d4ZWKGJDn(p$rw9|6j|?}7GPK||(IYtQzU}!* zrt0aV!N(*JuV&LAAvtC?4F@eKV%OtkXVmg}S-C|4>pv2jZRw{FQd&KS#}f7sg8*uH1gT9S(=#Wf zM6d3T_q3GeqwB-)kV+3GaJuN3KfA~_$z4eF(U=z!h?orJcUJU+9T&{@j~iypj4DQE zfijKeM?q!AY>|=0s~eu=WARnn=5k<;G-EAgX3UFBOpF&P9tSHpwKl*ngz&-Dm`Gp- z&}NaTl*8dtO`%gCX6B+)u0I*=_5+!}PN(svtQjcTWQ~5HZ`u?v z1AQyq-A%*pF0k%EZKd1IX;V2GsI62$$p>U7-gF+20qIR7oP>Chi5osS#puP!5+}O- z7}P6ZWVk|^-3F<6S~>x8VkzlAemsT!huXTb!%q40Ga4jPG8wfGS%lNJ#8QCG&SE!f zu4RL`l3P&GAhoX@#Hsv^ifSpnR$=M3ch=lw4CA9zpPBX9Ead;=E?xGbnt7=< z6<>KPjYG&2X$M5qiTxT*Pb;_@m62p=kfi-N^5e#I3hUa=kWf4)ulD#?syNF5DKB5T zW0J!W#;q6WQq-l!sbB$DN`j6HxDOxC@vQE68f__ud;1;RLrL8=z_$_f_INEdHLXK zIsF~(j?gx5qbvOxk9~TKS&;k5dUbj6z^-N9w5No>+)h7VeO>V?>l2<|ea;!|)3uqY z`edwmMfsXj%hsoBRi8v{$WB_+N1osM&K52tr-5WiFiAU!mC_z|hPE<5sJbT=3hqe- zSv{%qN&?rW(uv1nPF(N;o(G>WVmGRK7+*BE>yX!d(I_WBf0U>jPdl~n?k+(VG$rzi z*A3tNZeu}1v5_^cZQDL~-`0dfva&mq) zbiOUhXqM~C22!xCPXfQja zL$diPJ27WNU_eKg$I=~-=g(J1^EIO3>|f_kkN*T()miHj!J1#sm)ra6(@ngGZ6ZTrub;xt0)clZ+E>@>aXl&V=k1rRC#~-(Aa5M_XVNUEJ zJrlWMWlRRrNhNHpmj8mucBN&4+axnyNw67;rTHc(hm}W`WYuOF5Kn&wM+v5O#5r!j zQ6$!^C671bw?V4Vr)TpG?=qWwc$>@8b%i$`9oHX^*J~)`orMjpEADIMG?NPEHh(kzyoP{gVLh^OS0A;Lj1-}~^ZEJleC-ldUi9!&on$~o@)R2HTh7Nv62*>2PXl{?{`DJ&h=|nz_gN7wn@!jM2xHLi1K3{E7oa(HHc1L371ZvCc)5YwN zu30Ox^1Xv*4 zASF~cV$NQzWv6O_5uN6x(gD_E>hU?y=c_1Ml*wYNOdn1VGbDqQzGQUB_P*(ahrpA- zGl6jSuSO}38nuB=2`|~p#7HT7NK?rojox$y(r$$Zx`D1WQyZvNq8(z(F0yyG2iPU3 znsqT@axfE`iW5k0I?3oAeaVRKKM-W!*P+MX=#?X+g7t{uqQm){^pS#aVV#8sjAg%G z^4z&j3pP^%2CtK9O)2GEt_^{zY#-580>&JdfH8E~c=BvMU9D$f@nCeHPhOv$TAQvC z$6nv6E+%VM0ze?XIL-d0-a(m8hAwNB#B@l@Vjy7+Kje9O4a!h6mdUJ#6@|5mGWOiI zHNv)K%1X~dGe1RZmd4ypdcMBmu~v}D)9RD;t4QH>g)_ru-b92^23W2^V@6HDpiP6y z7hzW=!3xi1=jmYUZ0oNsd!fUnkreNVvp=v^pSkkVws%N{X#^EwGBuus81Y6|*B~^0 zJ=2XbeX<$u;{s-)m0Z*NLFKaW(OfFQ1(LP;>}<2qqwprH6ZM+p3NrK|tJ~#zet5b> z*?6dp%zy-ZEG6PoUd~=XA(PpRolg{>K}H$_#pOB(aMyq6wJ8*^AxP`Z%J`^}zh51O zZ@u8|stuB$V`nx8_hq8**o}G<(|U8L&gdzWb~dLhFx~vl+hk1xbE~Dk-tO>H&ceG+ z>$_@cKQ?S`Dh~JxBV;u<##^U{SxfV=VZ{lE4Jvip0gq^vKGP#*5VV8lGFZk4Wu!O@ z*)9;2@LeGA-7XN;z+E8lY!1T0kTwVP2*k}=bP6HqJaX@g%j3n_H0~^#NY_0BtBh^a zJgTZISB(`zb1*NmVP82`-NADEwhg$ySggK&e15UL@-2cZK&(a=i%C!+6W3|TCeJ=z zugJJ2I{Q+6jAK>u*#l_<4 ziv>$8TOvfDnF6IH))lKlP^l42wl0oOs*9i#OMMhL^7hX>YiNoaxMgajZprEs`je0O zPIYl%!)Ep`)zXZyxVCVwdJVO3@`?S4$LwFSS;N@VoYxpHy^X^pJbC#TDWvtZA1Q5_nfZbC<%dRGkCgnvW>ExHm@LeE0F%AF+ zK3rW~1#^M)o^(ngTe7PnYz=;20!ikagja`Q}%qtWNo=LT@MiJp4$w3SD_gEZ%7r_0~ZF}|hn9MGq(^hygD z%$H#Cm1%>jhS7b2-dID6#&uN`l8FzIV)YkCL@i{4{2j^#aYI?hl@7YKaI=2Z?bW^4 zcF9{(AGqCk4d8G}oo4WWQInoemgmAml*;+w$MQle0`s;!o+pYN?L`qn6@>aa;A!(x zR(o*7NW`I=X4h#>%cOf@^ed!LDny?zD4C!|27DuJ-lJ%rZ$-}VVthinXs2G;1XG5%=LCrf77mTXi zA5`R)Xu!;IUj%_pn%xe3hHH}u@dr`L^dc&_mcH8j4ZA;;eI z;<#p2o0&Z-xLyHY1$-x5)B;121vxAQ_cx!fmY;KwX^Y^==c~4wq^C3m40*=J}5!hjHKlj z{Jarlm93&f9+2^sj`120ce|SjGe2I_t!g$unQ*Eht3a|B#RW2sR1>Y23w+sZq^8BR zk;@xyfS^kiFC|yJlK~EA!j65JRx4DU`W@)kAC$ISW@{vug<&K&$4Iy4 z92+%T8Y&fgE7kkuavIS(d&GItYr=~|mJWCe0YMj!R_m?T5sR7o$L2vigNlxe3S1TK z=!a-v@?2iX6yqv2YT5b4V*X9t0P}t=_-VDdJXZ0Ci?#kpkWTPUI9=kyxFsR5vUi`O zoy)acQcMqzLif=n&UsVZL!Ms*$zssN779{%2mqFMu{{I;UdI6-v94lf_wFT#>jmDv z8cVVZ>Q3QXcBh^lXa=nF=Ix-h=r|9Io8O3z8lOIH;BvyI}HR^|r#4 zqdnKgB262Gx>I4d=a)79m$ekt6my83daF9xN)FVS;e)|vU*M{Zok{hwn+W5y;c}h9 zXF2IGjG}I%I|1EB>0+yT2GL4E26jT1 z7_xxqsBWmrdSqWn+~a*mJbxkd#6rJDNk^FBreJ57gaSvm3c zLx6;4k27&=RWRCd0El56po5fl6ZFB4Cv2_J)FCawK>ZIj6hX|MN7ebmMDW|fTIoy@&d^PA~ zBJ2(~VI)1SYSuL(sLs{pF8^4#hx3#3TJq|nAxKCd-i!Po;^v~Cnhx?MWdKAxJj8Yc zSKZZw-Xz}DiyV^!y?_;W)soAg{FOX&4HswgR0VF>zMaX5VJ9#w)13ypIX{e=TL<<0 zj6yXgZVYl{9?Ux2_Se3(BO3p$%mo_jUr~3Xo#6s5IJt?%5zS+(iN zc@;%&MiG6|R;K4fGQ9vf@%8~o{~xVE!70Z9+RobwQaQ*?+Aoe*Co}D?PU&ELv=%+K zJPyD@HQdQuWb|Q8&mWIh-%v+_FL0bxTW53T>}?_!(Y*k<(CGuv4t}(gijzAI&_}H~ zW;3au4^GzU4wcj0udpti$d}|H7t^P_XcRBm-d~&9W^OlFWUVfQWEu(~C-4|or#9T( zj(3+L&MFqWF=7pJeKe-D%P&1OGF0O@qA`sN6lnGC1Vm%f4R2u0sOXQQ$bvE4%Y z@W5;~n$KhEIa+jG|E*fX|*+y>$Jwm`v98MR2Qs1s(&{tY2bPQ zsE>H;*n4K4V))NLUS_ZCG*TP&=Q*6`%FWCR_qAZh339@U7<$R%5}nslFmcbTG>^%82bqOHfA@*McN_G`1Y)421#rp8mQHnUkp5up00 zw^ylHR%BLXA9eW-;%?hI<$@-8P%F+6PhfCf33jRVE2$y-!qspmNn8tTcTQh7^RPAro)#6)vf5ZV)ge zs8V(6jZ`P~zw0W$g_4(fp_&Ww4Ps+^V89y-eMAb0N zgcfoZ<4=gZw4PWfh<+FrY0SzxsMleB?hK~b1w&c;)%>E556t$Q$*q=PnN_bYkp35Q zUIADpFI!ovtf$HDU2EAI2D%2r=*uKB6m+f77O7H+s8&+MjM~}6ytJ-nf`xiIa-7vE z)g3E}aX^ga(8N?EN(C}3Ox8$KT!|mx zA&b_Ptn0f#oEsyidTVK-yBDO1?_Q85W%hzVn!CEoz8DafEApN)l!o=97KPEAx}h# zxkJJbfH!Dy9l|M#WHc-7r)Tr^WIcU(Mf4{k`fwi3lFa02Nj{g-sMXWlvue?7k5Mx_ zoeV9jV55`1uM9_qZwUPPbm9xVj`ldSTevhC0tsdZr{c~Y#E+fmx%-?xJ(2g3P~FS7 zZcEFS)XBWbNfYFfd|fA-Dd8#=3v0_G-CK)$!_bGaXly8pDHzJ4*F#x>!rkr6cr=Lg zECsZs_<01M6Gv=j3k%O?B^+b*{25vr3~1ZJfUKIKQYx#g@zCXYO7dPLqPHqtlxN$w zFa^2=N%<@zR--rz-JH#X`S$Di+yYg}wa-br*?+yo_-sz}j%o0*iEYsdhwo`lr*bsc z_BYg1i5zhr%@-%2&+Y~`9TN5U;KRjgX$}EIK#Tfs-KD_vs(vXx%5H@A^uxO0aJVbR z+G@`bHevCNcP7OIZZWj6*(kK%W`xb9o>)-1aOt=nj%TEvwKFEQK>>X@jlHSH>oStp zbGB(;fNV9~WoDMPaDE}t!CX(%J#ZyJ@h91pTa8G`rfm4w>nco9 z<2YgyLbcfL5A98`@RxIcX^ra*@wY0?2sK95?bpf!h$5$7*%O+rzWE!J{9^SrK^lkY#G7w71>$B;6b0a1YU-0aNK;a|feRLdwQ)yO1MXn@}mE#s2 z*WzrgmN%y8IRo@{t%`yGJ@5)E{_negtoEzw`;V(XSC`eKT2z~=`tc{#yxLZu^1Z=n z@?o{AW~5Z_Uy!mUXOD9KT>W!ZeTRQ3m3qE&gMa^2RX_i4)xT9YtN&j8UG<-;|4{wc z>IUC?eE&V)e_K`mUd1E_xrrBvqc>FQ1Xy{M}H?1`ddI)-|6BD7+W$rM zkNm6t{vY`7l!;hU=8S(6CS+cHW>fakrYb;w_ZQSw{diklQCbia{$5aKS)EqZFE5zN zmE~wkud1hfYpNFz!Z|S2`>!dXFHQYAu0Hsj9xV9Zq&numwD7?L zesB1dV7~vH-aWIvEB|8~*?E@ol$sw=Lgj_6>Vx~#rk<#;Q~p*z^RWv;-)GdetbT9U znlZlARxe!2Wu%&y>W6AgSl3s;!cU&@OXG;Oi@DB#s($>~dM5k{U#YhDAA_|EQmzbl zQ{d;MOkkk@>m|usGXF#MTmHA9(=l@c0i9Fv)X=bDAjFL!ZOX56U?+5G#ov86^k#LJ zUwi!iEmdohep_h>>Y|!G;=e2Ene(e|LGoeAKOxWas~>*Bmq=@BLlWUsAN&GR&Hq<@ z_czsVs(<&r-;m1R_fIGQVf`(Y%d4WrZKko*39;Li9$I=y#9%7QUfKN6WO z>EG7+;Zs)q`b(=(Jr{wC*pI9xjY;iA^itRAU19Mac)QuaVsGExch(VeRKJ`uUXh?? zr5F0&-c9fJsso$jy=;zmw*7(Tb5*?tXCh!&{MYRi36v%IC**4!V!~Jamgw+tiEhM> zm!#E9RsHZjb8&6x<+8L^+OY(E^vED{3#kxfC?RKj7KBF$- ztNNj^^9{?1@Nr7%mxw`6b6$~{Iim-GYTp-si8?9!&$*bqf#4F3CUCI&zqUCMSBTFY z0}{?lzI?^jh=f~V;6A_gb%waReXT!M^gPjRQ)kjFo9;E&Yyh=g!A758uq0-L4Q9VW%d47lnTrB zk0WP@p1#TI*CP3K{r%(nw4xP4w5Xm1YJ4v(ra$?N9*QfqP)P<0a%&6HeSW7BzZQ>3 z5{UAA{ZMbz4@o=GAYOu&Q+@CEz_6tKxQ$D%qYAR8#&Pv?uSZgA9a@-DL*lmgKc?<) zsFkJngEoCs@4YZ(3uWl1AJd~3@KMi<{Q5aPT!VMPI=L*OWGPs~`2Y+ZcD`m3r+} zEt*;3xB69HLl^c-8?hw5u>3jm9#Vc>r!?wowEdiRz5#Ddd?pp_XI{rZE-gd~Xvo|j zh=WA6K`#HgmiJ99MzrH|;WNh?^ueL=UabvPAEezbmm>rb7G&NHZ>2 zI|uM9O_7#xUuK=TJ7n?mT)ai}INektF23oBm9*pUw`R5w>-vw4?_x789CcSTyqn*$iRaVQr)QXCU?_=p4 zIudmC_q$;OVc+eCj99D}-d1mJU#DE^*THp4g&zK@zs#2qaojsX#see%0$geyrKo6o z0VE1jA0D3>m5CQvwg%cfqBgD-F(Wp=zwEE+IW=u<)~mgKh=b>pA2PibcH^kZih9j&N zQm`>Fs}U;0^o}tlm4j`X3+d`T&9&?R6`Pv$`6Qd-B`Ty%8{#n- z(`JL0tjLcl;W2pG&{|W$s(#S=MsdCX(zc1;d&su(sQP!m$z@XH#ag1ZYCw*-M3vGt zZ)|_NWvgF3wEmB`P=SYf*>I`YYV~h&h=|`7%m*<&Nq}FE$>LV&pT%)C#}s5VHU}v< z-PNF3i)<;vixh5GZ$w)gI9WmR2f5t@yRuYW4DGqH)ox*0eUPl=xcKc5}4?3SZ)^ zPA+P-6!r}pxfA~9D`8Ysnwwl-FQuF~_B%5>u#P(&RPRNrS@m6QauNC4nmhV16 zTd6+y#Ol8U?{3em-mg=%#nWs=?m@o&I!4V9C?!N0Qnaw?gZ6*Luh{^b?9*^cIrfLoxG6?DaSk9eI z+EJf0PMrj(1&LfKZPml;)ab%>&SE4AlKLpYR=xLM_^(D>y{`pSd?jnApxMT~_bF-O z{R(@Pa31WC90rN+1P?WS&u2kA`jB!qTVN{ve*7l=bZ!xk`|MPQ*QrGo1?O)ci74+6 z^m&eCs($}wHO2C(D`5>u%kRID$zVk(EzcLs(iJL)mPgqjgJS=iE{wQRbxOHuLI1i7?b{0} zGcDM?F05*nWm8+ZWw*rLZi(6+Int}!W90_>_aDbfUB9QAnYQ_&gOh*XZ8O5S(j~rv ziw1DloRvn2-*#(mkGuijgR}lIH%jfq*+>uXb$eLP?r2~C(^$zj>-E@dHAei)ZrgFj zK7o%=VL4phRE;v6Uv5~{$hsiCYKXdqIHzf*{@&-khHX=5f()Ej zL-tc-f)AWm!`ECe(w~ENf9g_$JqsK+)Y6C~?(}htU((2a)$U`&YJ)p^@iihh!U|Q7 zqCMV5?HxSz&qkxn4m^$YEv#5|--c(U(c(Y0F;$m)lm3p)PNUtQx7&>~6r>ef{hU{& z&0fNxG6o}ETDdxz(gs#~NLThmJzdzVTCz?3m41;nqOJU=rjM_YkkVVabxUhk-j=_W znPc=z(nR|n>ATYKO)7l%2?p#N^moS^IGzK*r7DkR*&L7Fqs2>*~FA& zn5aPehaffS*CyLDG~s1d&N1DTZ^BR1`S4Ghf|8~dPahgHiUKe3k4FzSQV&o!oKxR7D0S!ea58a5lld-uV%_6%*TYM-N> zmv*e$cUHet{YQ)-8n)W>+OFXNC55ROwfixWYWRw;1+~mrg{1-4{MlZyoD$WCZ!qP% z>sj^VKboH1rjhE$|D`|Oj8l>7bZY2&xwymjvp=h`@|36qPM^GzrUc?NP*7PnuQq_8PVx4fOIFz>b+<%tloEOkrb+a zIt6YC4zyzvJ~OWTvFE8i&3cq8)lbB!nn4-yv@(B6Y0W|Pfo4Nq8;c+nD~<(b{7

?;heNHtdRkC_e`-+T5mC2j$K{*b%3OM%sy>dtRNw#0-rI%veWiDv z=Z_GgwkSkV6hah2rBM`FElaXm?RML4wYw~p)fMZ_s*)YY?Pz4FEGyQVRkCHZ)7xc2 z2tx=>2qA0I!Y~ZWuq?we7jw1j)m|)fv6suR?A6}v_j8`}{LcBk{Qv)7 zy~&>4p{T0g@4P+FdCv28p7ZkSQF3-oCBc=yRlm;QkJ49mm*u@Ka2^!C7fUy=(;^-) ziQ9~;84laXV})|-jrO#_OnZ#%$7<0=3u$NP1Il*oJ8W_B z0ZKj)JTUe4tMNU&7ICzh7c>In2L0b~EWtJJS6k?4my#wOM)BDHQ=@slg|X&FHX3zV zs$1J$=qnP5qw%d*4g9C@SDTH`9?Yi-nEu|6 z^iE0sD&~1$RsBYKuwU*&UsNu<$lmYf9%6X~Gwswcv!)iL32L<9wy_2L(fve;S&+n&1v*v)p()@^R7fjHTR6K6s3^=pcgWX_JtcCZC+qG3#yosa|v}+g7}w^{qUfzJD3| z8ST{9eRxCnC1Lfxu~O5dKI3#PredFb<5!q72y798&pBmO!9T#*`C?`ZMyuv`bIn%X znGt#48CgYIgjF+4WO;6 z{Ry*dsyl1G!|$kttS!)I*qA5rz!n-t7GM%QJwCvE3Y;tH*>9R0y@@}BZt>a56Mw2{ zY#RY^Pug~`MJ7yFD0(x6PDb|Q9DNF{U$v>0&{AlfoMsYj`aZQjWBtrCIC@-`t7=bK z$!mh58R`B9YCCUg&Ff5fGjPIvS zhW#CyFUw`8ny|yo`q-$tG^@q^rul7r(9u=jr_F-6PE^?=&XXlqEDB<6o5_K$QdO&w zBYgW)Z3L#9n6wWHUJ@iQb!!uj)JMcD>D4$Ews+tOa&Zu@uo#_{@Z)c3g!UV^=Ni>` zq%Ax-Crlv&SdVDWG}E>S0+Im!DXur2)87_s;ShUgxt_8Xu`*gl-)*nUS1K_D?fooC zn1EW3*>*GAMd6_Bh~~+DAt}kvSG5LfHN6F;2okaa#&=}x>hIr`2Lx_FGoPKiOOII82#b;D6~{K|C);U*y>(FJ`qoHxa!Uj;I!^=7MGstIWUQMD~d+uZ%pk z`X5(+&{8%(ycgT|I8`GuwSPs}nQwz;Lqb!$Y~q>Tz}*hXqF>ql04Cx%ZId-l4dNq4 z+Bg;3!*k5zMMs_6aGklTc~Aqw0q^N=#qz5)Jj1b3b<6&<=`lm8@RvzAbX z{sie9?f4-j@9t3AUP}X8b}X^#Ntq(LH|w=>zf~@!E*Je*>cL#L9lNaO-%>AFWythX zewuNiGnnr;a^;B|O>-}8!(cO2QYT)s)yJa$vz}I?KwLj1vRTn!)<>!ir=42DDJUlY z$6zK1Z49B^)NSEpYYU?De&1Nxk|tRytQ{PUPLL!|66H?2 z$)>*02w-tm(R9U|D4`uqtkS5&2KzZlWP=9me;9 zlI$27QbsYpa`()LlBe#AE_RBKF&PW}L@v*adkh|Da%o!6tH>iTdV?r#xejwK*2JD< zUw1_PV^3RjDc3a%o;Wj#-b3n~9!~usHC`Dv7DMWtt+M-@=Q#D8As_q%%I%bk)H?ddfaWtVvN*~Dj^M=1Fk8K(qhhK=j zwWt!UFdzN0^d%DHa@;az;VAR{u33`N-1Mkof%~arv2~l9S91eh8qzVxI!(J5R0H4Z zQ6C7}8R?~m!qU|yHgCSJo)c+Q+-vWm`dpmgK3KoUz-v^eSPxx`dJ9U{XF*;v?4yKR zEKijMibo~c)ozr)>-OBRzd75ga&&;C+oIa6i@97iw>dqm?4`v9vzdH2Ow7KH zQ?m^yWKq!+b2!#4;qySpxf1&R3Pf(9G939tR3Rsy z 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
f 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

;k!+2}xv<7Si- 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

  • #62ZQFeE)lQve+_9=(?eWV$^EQmg z4Bx&+`tJ0|dQA>mKPbwvYDeZ+wKjI39Vf@CF+?@QBs=|I6A>(LSC|m&AhM|uYHLm% zL%^N|*-*#L5#Y}J82NQJ*b0)2- zH)mVw1Mxp@v6H6}r?oFi2TGgoEpVCAwVTfuecpW0BkCSMF>1u+wRL-cS^UexM!%lS zy`A_&z5APX2f9Y|pQK!R;p-*OQ+C}ic_Dt0)2iT&`+p)&uU|d&tnH3i-NyM2?$$@Y YA3f;axOeK+!{^pY+;wByUu%i~2i^&*;s5{u literal 0 HcmV?d00001 diff --git a/HomeCinema.Data/bin/Debug/EntityFramework.xml b/HomeCinema.Data/bin/Debug/EntityFramework.xml new file mode 100644 index 00000000..b231108f --- /dev/null +++ b/HomeCinema.Data/bin/Debug/EntityFramework.xml @@ -0,0 +1,52816 @@ + + + + EntityFramework + + + + + Represents a result mapping for a function import. + + + + + Base class for items in the mapping space (DataSpace.CSSpace) + + + + + Adds a type mapping. + + The type mapping to add. + + + + Removes a type mapping. + + The type mapping to remove. + + + + Gets the type mappings. + + + + + Specifies a mapping condition evaluated by checking whether the value + of the a property/column is null or not null. + + + + + Mapping metadata for Conditional property mapping on a type. + Condition Property Mapping specifies a Condition either on the C side property or S side property. + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ConditionProperyMap ( constant value-->SMemberMetadata ) + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ComplexPropertyMap + --ComplexTypeMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --ConditionProperyMap ( constant value-->SMemberMetadata ) + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + --EndPropertyMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --EndPropertyMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + This class represents the metadata for all the condition property map elements in the + above example. + + + + + Mapping metadata for all types of property mappings. + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap + --ScalarPropertyMap + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap + --ComplexPropertyMap + --ScalarPropertyMap + --ScalarProperyMap + --ScalarPropertyMap + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + --EndPropertyMap + --ScalarPropertyMap + --ScalarProperyMap + --EndPropertyMap + --ScalarPropertyMap + This class represents the metadata for all property map elements in the + above example. This includes the scalar property maps, complex property maps + and end property maps. + + + + + Gets an EdmProperty that specifies the mapped property. + + + + + Gets an EdmProperty that specifies the mapped property. + + + + + Gets an EdmProperty that specifies the mapped column. + + + + + Creates an IsNullConditionMapping instance. + + An EdmProperty that specifies a property or column. + A boolean that indicates whether to perform a null or a not-null check. + + + + Gets a bool that specifies whether the condition is evaluated by performing a null check + or a not-null check. + + + + + Specifies a mapping condition evaluated by comparing the value of + a property or column with a given value. + + + + + Creates a ValueConditionMapping instance. + + An EdmProperty that specifies a property or column. + An object that specifies the value to compare with. + + + + Gets an object that specifies the value to check against. + + + + + Serializes an that conforms to the restrictions of a single + CSDL schema file to an XML writer. The model to be serialized must contain a single + . + + + + + Serialize the to the XmlWriter. + + + The EdmModel to serialize. + + The XmlWriter to serialize to. + The serialized model's namespace. + true if the model is valid; otherwise, false. + + + + Occurs when an error is encountered serializing the model. + + + + + Information about an error that occurred processing an Entity Framework model. + + + + + Gets an optional value indicating which property of the source item caused the event to be raised. + + + + + Gets an optional descriptive message the describes the error that is being raised. + + + + + Gets a value indicating the that caused the event to be raised. + + + + + Contains additional attributes and properties of the + + + Note that objects are short lived and exist only to + make initialization easier. Instance of this type are not + compared to each other and arrays returned by array properties are copied to internal + collections in the ctor. Therefore it is fine to suppress the + Code Analysis messages. + + + + Gets or sets the function schema. + The function schema. + + + Gets or sets the store function name. + The store function name. + + + Gets or sets the command text associated with the function. + The command text associated with the function. + + + Gets or sets the entity sets for the function. + The entity sets for the function. + + + Gets a value that indicates whether this is an aggregate function. + true if this is an aggregate function; otherwise, false. + + + Gets or sets whether this function is a built-in function. + true if this function is a built-in function; otherwise, false. + + + Gets or sets whether the function contains no arguments. + true if the function contains no arguments; otherwise, false. + + + Gets or sets whether this function can be composed. + true if this function can be composed; otherwise, false. + + + Gets or sets whether this function is from a provider manifest. + true if this function is from a provider manifest; otherwise, false. + + + Gets or sets whether this function is a cached store function. + true if this function is a cached store function; otherwise, false. + + + Gets or sets whether this function is a function import. + true if this function is a function import; otherwise, false. + + + Gets or sets the return parameters. + The return parameters. + + + Gets or sets the parameter type semantics. + The parameter type semantics. + + + Gets or sets the function parameters. + The function parameters. + + + + Serializes the storage (database) section of an to XML. + + + + + Serialize the to the + + The EdmModel to serialize + Provider information on the Schema element + ProviderManifestToken information on the Schema element + The XmlWriter to serialize to + A value indicating whether to serialize Nullable attributes when they are set to the default value. + true if model can be serialized, otherwise false + + + + Serialize the to the + + The EdmModel to serialize + Namespace name on the Schema element + Provider information on the Schema element + ProviderManifestToken information on the Schema element + The XmlWriter to serialize to + A value indicating whether to serialize Nullable attributes when they are set to the default value. + true if model can be serialized, otherwise false + + + + Occurs when an error is encountered serializing the model. + + + + Visits each element of an expression tree from a given root expression. If any element changes, the tree is rebuilt back to the root and the new root expression is returned; otherwise the original root expression is returned. + + + Defines the basic functionality that should be implemented by visitors that return a result value of a specific type. + The type of the result produced by the visitor. + + + When overridden in a derived class, handles any expression of an unrecognized type. + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern method for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + A result value of a specific type. + + The that is being visited. + + + + + Typed visitor pattern method for DbInExpression. + + The DbInExpression that is being visited. + An instance of TResultType. + + + + Initializes a new instance of the + + class. + + + + Replaces an old expression with a new one for the expression visitor. + The old expression. + The new expression. + + + Represents an event when the variable is rebound for the expression visitor. + The location of the variable. + The reference of the variable where it is rebounded. + + + Represents an event when entering the scope for the expression visitor with specified scope variables. + The collection of scope variables. + + + Exits the scope for the expression visitor. + + + Implements the visitor pattern for the expression. + The implemented visitor pattern. + The expression. + + + Implements the visitor pattern for the expression list. + The implemented visitor pattern. + The expression list. + + + Implements the visitor pattern for expression binding. + The implemented visitor pattern. + The expression binding. + + + Implements the visitor pattern for the expression binding list. + The implemented visitor pattern. + The expression binding list. + + + Implements the visitor pattern for the group expression binding. + The implemented visitor pattern. + The binding. + + + Implements the visitor pattern for the sort clause. + The implemented visitor pattern. + The sort clause. + + + Implements the visitor pattern for the sort order. + The implemented visitor pattern. + The sort order. + + + Implements the visitor pattern for the aggregate. + The implemented visitor pattern. + The aggregate. + + + Implements the visitor pattern for the function aggregate. + The implemented visitor pattern. + The aggregate. + + + Implements the visitor pattern for the group aggregate. + The implemented visitor pattern. + The aggregate. + + + Implements the visitor pattern for the Lambda function. + The implemented visitor pattern. + The lambda function. + + + Implements the visitor pattern for the type. + The implemented visitor pattern. + The type. + + + Implements the visitor pattern for the type usage. + The implemented visitor pattern. + The type. + + + Implements the visitor pattern for the entity set. + The implemented visitor pattern. + The entity set. + + + Implements the visitor pattern for the function. + The implemented visitor pattern. + The function metadata. + + + Implements the visitor pattern for the basic functionality required by expression types. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the different kinds of constants. + The implemented visitor. + The constant expression. + + + Implements the visitor pattern for a reference to a typed null literal. + The implemented visitor. + The expression. + + + Implements the visitor pattern for a reference to a variable that is currently in scope. + The implemented visitor. + The expression. + + + Implements the visitor pattern for a reference to a parameter declared on the command tree that contains this expression. + The implemented visitor. + The expression. + + + Implements the visitor pattern for an invocation of a function. + The implemented visitor. + The function expression. + + + Implements the visitor pattern for the application of a lambda function to arguments represented by DbExpression objects. + The implemented visitor. + The expression. + + + Implements the visitor pattern for retrieving an instance property. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the comparison operation applied to two arguments. + The implemented visitor. + The cast expression. + + + Implements the visitor pattern for a string comparison against the specified pattern with an optional escape string. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the restriction of the number of elements in the argument collection to the specified limit value. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the null determination applied to a single argument. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the arithmetic operation applied to numeric arguments. + The implemented visitor. + The arithmetic expression. + + + Implements the visitor pattern for the logical AND expression. + The implemented visitor. + The logical AND expression. + + + Implements the visitor pattern for the logical OR of two Boolean arguments. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the DbInExpression. + The implemented visitor. + The DbInExpression that is being visited. + + + Implements the visitor pattern for the logical NOT of a single Boolean argument. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the removed duplicate elements from the specified set argument. + The implemented visitor. + The distinct expression. + + + Implements the visitor pattern for the conversion of the specified set argument to a singleton the conversion of the specified set argument to a singleton. + The implemented visitor. + The element expression. + + + Implements the visitor pattern for an empty set determination applied to a single set argument. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the set union operation between the left and right operands. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the set intersection operation between the left and right operands. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the set subtraction operation between the left and right operands. + The implemented visitor. + The expression. + + + Implements the visitor pattern for a type conversion operation applied to a polymorphic argument. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the type comparison of a single argument against the specified type. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the type conversion of a single argument to the specified type. + The implemented visitor. + The cast expression. + + + Implements the visitor pattern for the When, Then, and Else clauses. + The implemented visitor. + The case expression. + + + Implements the visitor pattern for the retrieval of elements of the specified type from the given set argument. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the construction of a new instance of a given type, including set and record types. + The implemented visitor. + The expression. + + + Implements the visitor pattern for a strongly typed reference to a specific instance within an entity set. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the navigation of a relationship. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the expression that retrieves an entity based on the specified reference. + The implemented visitor. + The DEREF expression. + + + Implements the visitor pattern for the retrieval of the key value from the underlying reference value. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the expression that extracts a reference from the underlying entity instance. + The implemented visitor. + The entity reference expression. + + + Implements the visitor pattern for a scan over an entity set or relationship set, as indicated by the Target property. + The implemented visitor. + The expression. + + + Implements the visitor pattern for a predicate applied to filter an input set. + The implemented visitor. + The filter expression. + + + Implements the visitor pattern for the projection of a given input set over the specified expression. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the unconditional join operation between the given collection arguments. + The implemented visitor. + The join expression. + + + Implements the visitor pattern for an inner, left outer, or full outer join operation between the given collection arguments on the specified join condition. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the invocation of the specified function for each element in the specified input set. + The implemented visitor. + The APPLY expression. + + + Implements the visitor pattern for a group by operation. + The implemented visitor. + The expression. + + + Implements the visitor pattern for the skip expression. + The implemented visitor. + The expression. + + + Implements the visitor pattern for a sort key that can be used as part of the sort order. + The implemented visitor. + The expression. + + + Implements the visitor pattern for a quantifier operation of the specified kind over the elements of the specified input set. + The implemented visitor. + The expression. + + + + When this attribute is placed on a property it indicates that the database column to which the + property is mapped has an index. + + + This attribute is used by Entity Framework Migrations to create indexes on mapped database columns. + Multi-column indexes are created by using the same index name in multiple attributes. The information + in these attributes is then merged together to specify the actual database index. + + + + + Creates a instance for an index that will be named by convention and + has no column order, clustering, or uniqueness specified. + + + + + Creates a instance for an index with the given name and + has no column order, clustering, or uniqueness specified. + + The index name. + + + + Creates a instance for an index with the given name and column order, + but with no clustering or uniqueness specified. + + + Multi-column indexes are created by using the same index name in multiple attributes. The information + in these attributes is then merged together to specify the actual database index. + + The index name. + A number which will be used to determine column ordering for multi-column indexes. + + + + Returns true if this attribute specifies the same name and configuration as the given attribute. + + The attribute to compare. + True if the other object is equal to this object; otherwise false. + + + + + + + Returns true if this attribute specifies the same name and configuration as the given attribute. + + The attribute to compare. + True if the other object is equal to this object; otherwise false. + + + + + + + The index name. + + + Multi-column indexes are created by using the same index name in multiple attributes. The information + in these attributes is then merged together to specify the actual database index. + + + + + A number which will be used to determine column ordering for multi-column indexes. This will be -1 if no + column order has been specified. + + + Multi-column indexes are created by using the same index name in multiple attributes. The information + in these attributes is then merged together to specify the actual database index. + + + + + Set this property to true to define a clustered index. Set this property to false to define a + non-clustered index. + + + The value of this property is only relevant if returns true. + If returns false, then the value of this property is meaningless. + + + + + Returns true if has been set to a value. + + + + + Set this property to true to define a unique index. Set this property to false to define a + non-unique index. + + + The value of this property is only relevant if returns true. + If returns false, then the value of this property is meaningless. + + + + + Returns true if has been set to a value. + + + + + Returns a different ID for each object instance such that type descriptors won't + attempt to combine all IndexAttribute instances into a single instance. + + + + + A class derived from this class can be placed in the same assembly as a class derived from + to define Entity Framework configuration for an application. + Configuration is set by calling protected methods and setting protected properties of this + class in the constructor of your derived type. + The type to use can also be registered in the config file of the application. + See http://go.microsoft.com/fwlink/?LinkId=260883 for more information about Entity Framework configuration. + + + + + Any class derived from must have a public parameterless constructor + and that constructor should call this constructor. + + + + + The Singleton instance of for this app domain. This can be + set at application start before any Entity Framework features have been used and afterwards + should be treated as read-only. + + The instance of . + + + + Attempts to discover and load the associated with the given + type. This method is intended to be used by tooling to ensure that + the correct configuration is loaded into the app domain. Tooling should use this method + before accessing the property. + + A type to use for configuration discovery. + + + + Attempts to discover and load the from the given assembly. + This method is intended to be used by tooling to ensure that the correct configuration is loaded into + the app domain. Tooling should use this method before accessing the + property. If the tooling knows the type being used, then the + method should be used since it gives a greater chance that + the correct configuration will be found. + + An to use for configuration discovery. + + + + Call this method from the constructor of a class derived from to + add a instance to the Chain of Responsibility of resolvers that + are used to resolve dependencies needed by the Entity Framework. + + + Resolvers are asked to resolve dependencies in reverse order from which they are added. This means + that a resolver can be added to override resolution of a dependency that would already have been + resolved in a different way. + The exceptions to this is that any dependency registered in the application's config file + will always be used in preference to using a dependency resolver added here. + + The resolver to add. + + + + Call this method from the constructor of a class derived from to + add a instance to the Chain of Responsibility of resolvers that + are used to resolve dependencies needed by the Entity Framework. Unlike the AddDependencyResolver + method, this method puts the resolver at the bottom of the Chain of Responsibility such that it will only + be used to resolve a dependency that could not be resolved by any of the other resolvers. + + + A implementation is automatically registered as a default resolver + when it is added with a call to . This allows EF providers to act as + resolvers for other services that may need to be overridden by the provider. + + The resolver to add. + + + + Call this method from the constructor of a class derived from to register + an Entity Framework provider. + + + Note that the provider is both registered as a service itself and also registered as a default resolver with + a call to AddDefaultResolver. This allows EF providers to act as resolvers for other services that + may need to be overridden by the provider. + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + and also using AddDefaultResolver to add the provider as a default + resolver. This means that, if desired, the same functionality can be achieved using a custom resolver or a + resolver backed by an Inversion-of-Control container. + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which this provider will be used. + The provider instance. + + + + Call this method from the constructor of a class derived from to register + an ADO.NET provider. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolvers for + and . This means that, if desired, + the same functionality can be achieved using a custom resolver or a resolver backed by an + Inversion-of-Control container. + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which this provider will be used. + The provider instance. + + + + Call this method from the constructor of a class derived from to register an + for use with the provider represented by the given invariant name. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which this execution strategy will be used. + A function that returns a new instance of an execution strategy. + + + + Call this method from the constructor of a class derived from to register an + for use with the provider represented by the given invariant name and + for a given server name. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which this execution strategy will be used. + + A function that returns a new instance of an execution strategy. + A string that will be matched against the server name in the connection string. + + + + Call this method from the constructor of a class derived from to register a + . + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + A function that returns a new instance of a transaction handler. + + + + Call this method from the constructor of a class derived from to register a + for use with the provider represented by the given invariant name. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which this transaction handler will be used. + + A function that returns a new instance of a transaction handler. + + + + Call this method from the constructor of a class derived from to register a + for use with the provider represented by the given invariant name and + for a given server name. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which this transaction handler will be used. + + A function that returns a new instance of a transaction handler. + A string that will be matched against the server name in the connection string. + + + + Sets the that is used to create connections by convention if no other + connection string or connection is given to or can be discovered by . + Note that a default connection factory is set in the app.config or web.config file whenever the + EntityFramework NuGet package is installed. As for all config file settings, the default connection factory + set in the config file will take precedence over any setting made with this method. Therefore the setting + must be removed from the config file before calling this method will have any effect. + Call this method from the constructor of a class derived from to change + the default connection factory being used. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + The connection factory. + + + + Call this method from the constructor of a class derived from to + set the pluralization service. + + The pluralization service to use. + + + + Call this method from the constructor of a class derived from to + set the database initializer to use for the given context type. The database initializer is called when a + the given type is used to access a database for the first time. + The default strategy for Code First contexts is an instance of . + + + Calling this method is equivalent to calling . + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + The type of the context. + The initializer to use, or null to disable initialization for the given context type. + + + + Call this method from the constructor of a class derived from to register a + for use with the provider represented by the given invariant name. + + + This method is typically used by providers to register an associated SQL generator for Code First Migrations. + It is different from setting the generator in the because it allows + EF to use the Migrations pipeline to create a database even when there is no Migrations configuration in the project + and/or Migrations are not being explicitly used. + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + The invariant name of the ADO.NET provider for which this generator should be used. + A delegate that returns a new instance of the SQL generator each time it is called. + + + + Call this method from the constructor of a class derived from to set + an implementation of which allows provider manifest tokens to + be obtained from connections without necessarily opening the connection. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + The manifest token resolver. + + + + Call this method from the constructor of a class derived from to set + a factory for implementations of which allows custom annotations + represented by instances to be serialized to and from the EDMX XML. + + + Note that an is not needed if the annotation uses a simple string value. + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + The name of custom annotation that will be handled by this serializer. + A delegate that will be used to create serializer instances. + + + + Call this method from the constructor of a class derived from to set + an implementation of which allows a + to be obtained from a in cases where the default implementation is not + sufficient. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + The provider factory service. + + + + Call this method from the constructor of a class derived from to set + a as the model cache key factory which allows the key + used to cache the model behind a to be changed. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can + be achieved using a custom resolver or a resolver backed by an Inversion-of-Control container. + + The key factory. + + + + Call this method from the constructor of a class derived from to set + a delegate which which be used for + creation of the default for a any + . This default factory will only be used if no factory is + set explicitly in the and if no factory has been registered + for the provider in use using the + + method. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality + can be achieved using a custom resolver or a resolver backed by an Inversion-of-Control container. + + + A factory for creating instances for a given and + representing the default schema. + + + + + Call this method from the constructor of a class derived from to set + a delegate which allows for creation of a customized + for the given provider for any + that does not have an explicit factory set. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality + can be achieved using a custom resolver or a resolver backed by an Inversion-of-Control container. + + The invariant name of the ADO.NET provider for which this generator should be used. + + A factory for creating instances for a given and + representing the default schema. + + + + + Call this method from the constructor of a class derived from to set + the global instance of which will be used whenever a spatial provider is + required and a provider-specific spatial provider cannot be found. Normally, a provider-specific spatial provider + is obtained from the a implementation which is in turn returned by resolving + a service for passing the provider invariant name as a key. However, this + cannot work for stand-alone instances of and since + it is impossible to know the spatial provider to use. Therefore, when creating stand-alone instances + of and the global spatial provider is always used. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + The spatial provider. + + + + Call this method from the constructor of a class derived from to set + an implementation of to use for a specific provider and provider + manifest token. + + + Use + to register spatial services for use only when a specific manifest token is returned by the provider. + Use to register global + spatial services to be used when provider information is not available or no provider-specific + spatial services are found. + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + + The indicating the type of ADO.NET connection for which this spatial provider will be used. + + The spatial provider. + + + + Call this method from the constructor of a class derived from to set + an implementation of to use for a specific provider with any + manifest token. + + + Use + to register spatial services for use when any manifest token is returned by the provider. + Use to register global + spatial services to be used when provider information is not available or no provider-specific + spatial services are found. + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which this spatial provider will be used. + The spatial provider. + + + + Call this method from the constructor of a class derived from to set + a factory for the type of to use with . + + + Note that setting the type of formatter to use with this method does change the way command are + logged when is used. It is still necessary to set a + instance onto before any commands will be logged. + For more low-level control over logging/interception see and + . + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + A delegate that will create formatter instances. + + + + Call this method from the constructor of a class derived from to + register an at application startup. Note that interceptors can also + be added and removed at any time using . + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + . This means that, if desired, the same functionality can be achieved using + a custom resolver or a resolver backed by an Inversion-of-Control container. + + The interceptor to register. + + + + Call this method from the constructor of a class derived from to set + a factory to allow to create instances of a context that does not have a public, + parameterless constructor. + + + This is typically needed to allow design-time tools like Migrations or scaffolding code to use contexts that + do not have public, parameterless constructors. + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + with the context as the key. This means that, if desired, + the same functionality can be achieved using a custom resolver or a resolver backed by an + Inversion-of-Control container. + + The context type for which the factory should be used. + The delegate to use to create context instances. + + + + Call this method from the constructor of a class derived from to set + a factory to allow to create instances of a context that does not have a public, + parameterless constructor. + + + This is typically needed to allow design-time tools like Migrations or scaffolding code to use contexts that + do not have public, parameterless constructors. + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + with the context as the key. This means that, if desired, + the same functionality can be achieved using a custom resolver or a resolver backed by an + Inversion-of-Control container. + + The context type for which the factory should be used. + The delegate to use to create context instances. + + + + Call this method from the constructor of a class derived from to register + a database table existence checker for a given provider. + + + This method is provided as a convenient and discoverable way to add configuration to the Entity Framework. + Internally it works in the same way as using AddDependencyResolver to add an appropriate resolver for + and also using AddDefaultResolver to add the provider as a default + resolver. This means that, if desired, the same functionality can be achieved using a custom resolver or a + resolver backed by an Inversion-of-Control container. + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which this provider will be used. + The table existence checker to use. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Creates a shallow copy of the current . + + A shallow copy of the current . + + + + Occurs during EF initialization after the DbConfiguration has been constructed but just before + it is locked ready for use. Use this event to inspect and/or override services that have been + registered before the configuration is locked. Note that this event should be used carefully + since it may prevent tooling from discovering the same configuration that is used at runtime. + + + Handlers can only be added before EF starts to use the configuration and so handlers should + generally be added as part of application initialization. Do not access the DbConfiguration + static methods inside the handler; instead use the the members of + to get current services and/or add overrides. + + + + + Gets the that is being used to resolve service + dependencies in the Entity Framework. + + + + + This attribute can be placed on a subclass of to indicate that the subclass of + representing the code-based configuration for the application is in a different + assembly than the context type. + + + Normally a subclass of should be placed in the same assembly as + the subclass of used by the application. It will then be discovered automatically. + However, if this is not possible or if the application contains multiple context types in different + assemblies, then this attribute can be used to direct DbConfiguration discovery to the appropriate type. + An alternative to using this attribute is to specify the DbConfiguration type to use in the application's + config file. See http://go.microsoft.com/fwlink/?LinkId=260883 for more information. + + + + + Indicates that the given subclass of should be used for code-based configuration + for this application. + + + The type to use. + + + + + Indicates that the subclass of represented by the given assembly-qualified + name should be used for code-based configuration for this application. + + + The type to use. + + + + + Gets the subclass of that should be used for code-based configuration + for this application. + + + + Implements the basic functionality required by aggregates in a GroupBy clause. + + + + Gets the result type of this . + + + The result type of this . + + + + + Gets the list of expressions that define the arguments to this + + . + + + The list of expressions that define the arguments to this + + . + + + + Represents the logical AND of two Boolean arguments. This class cannot be inherited. + + + Implements the basic functionality required by expressions that accept two expression operands. + + + Represents the base type for all expressions. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + The type of the result produced by . + + + An instance of . + + The type of the result produced by visitor. + + + + Determines whether the specified is equal to the current DbExpression instance. + + + True if the specified is equal to the current DbExpression instance; otherwise, false. + + + The object to compare to the current . + + + + Serves as a hash function for the type. + A hash code for the current expression. + + + + Creates a that represents the specified binary value, which may be null + + + A that represents the specified binary value. + + The binary value on which the returned expression should be based. + + + + Enables implicit casting from a byte array. + + The value to be converted. + The converted value. + + + + Creates a that represents the specified (nullable) Boolean value. + + + A that represents the specified Boolean value. + + The Boolean value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified (nullable) byte value. + + + A that represents the specified byte value. + + The byte value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified (nullable) + + value. + + + A that represents the specified DateTime value. + + The DateTime value on which the returned expression should be based. + + + + Enables implicit casting from . + + The expression to be converted. + The converted value. + + + + Creates a that represents the specified (nullable) + + value. + + + A that represents the specified DateTimeOffset value. + + The DateTimeOffset value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified (nullable) decimal value. + + + A that represents the specified decimal value. + + The decimal value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified (nullable) double value. + + + A that represents the specified double value. + + The double value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified + + value, which may be null. + + + A that represents the specified DbGeography value. + + The DbGeography value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified + + value, which may be null. + + + A that represents the specified DbGeometry value. + + The DbGeometry value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified (nullable) + + value. + + + A that represents the specified Guid value. + + The Guid value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified (nullable) Int16 value. + + + A that represents the specified Int16 value. + + The Int16 value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified (nullable) Int32 value. + + + A that represents the specified Int32 value. + + The Int32 value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified (nullable) Int64 value. + + + A that represents the specified Int64 value. + + The Int64 value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified (nullable) Single value. + + + A that represents the specified Single value. + + The Single value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + + Creates a that represents the specified string value. + + + A that represents the specified string value. + + The string value on which the returned expression should be based. + + + + Enables implicit casting from . + + The value to be converted. + The converted value. + + + Gets the type metadata for the result type of the expression. + The type metadata for the result type of the expression. + + + Gets the kind of the expression, which indicates the operation of this expression. + The kind of the expression, which indicates the operation of this expression. + + + + Gets the that defines the left argument. + + + The that defines the left argument. + + The expression is null. + + The expression is not associated with the command tree of the + + ,or its result type is not equal or promotable to the required type for the left argument. + + + + + Gets the that defines the right argument. + + + The that defines the right argument. + + The expression is null. + + The expression is not associated with the command tree of the + + ,or its result type is not equal or promotable to the required type for the right argument. + + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by the visitor . + visitor is null. + + + Represents an apply operation, which is the invocation of the specified function for each element in the specified input set. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by the visitor . + visitor is null. + + + + Gets the that specifies the function that is invoked for each element in the input set. + + + The that specifies the function that is invoked for each element in the input set. + + + + + Gets the that specifies the input set. + + + The that specifies the input set. + + + + + Represents an arithmetic operation applied to numeric arguments. + Addition, subtraction, multiplication, division, modulo, and negation are arithmetic operations. + This class cannot be inherited. + + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + + Gets the list of elements that define the current arguments. + + + A fixed-size list of elements. + + + + + Represents the When, Then, and Else clauses of the + + . This class cannot be inherited. + + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor. + visitor is null. + + + + Gets the When clauses of this . + + + The When clauses of this . + + + + + Gets the Then clauses of this . + + + The Then clauses of this . + + + + + Gets the Else clause of this . + + + The Else clause of this . + + The expression is null. + + The expression is not associated with the command tree of the + + ,or its result type is not equal or promotable to the result type of the + + . + + + + Represents the type conversion of a single argument to the specified type. This class cannot be inherited. + + + Implements the basic functionality required by expressions that accept a single expression argument. + + + + Gets the that defines the argument. + + + The that defines the argument. + + The expression is null. + + The expression is not associated with the command tree of a + + , or its result type is not equal or promotable to the required type for the argument. + + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor. + visitor is null. + + + + Describes the different "kinds" (classes) of command trees. + + + + + A query to retrieve data + + + + + Update existing data + + + + + Insert new data + + + + + Deleted existing data + + + + + Call a function + + + + Represents a comparison operation applied to two arguments. Equality, greater than, greater than or equal, less than, less than or equal, and inequality are comparison operations. This class cannot be inherited. + + DbComparisonExpression requires that its arguments have a common result type + that is equality comparable (for .Equals and .NotEquals), + order comparable (for .GreaterThan and .LessThan), + or both (for .GreaterThanOrEquals and .LessThanOrEquals). + + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor. + visitor is null. + + + Represents different kinds of constants (literals). This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor. + visitor is null. + + + Gets the constant value. + The constant value. + + + Represents an unconditional join operation between the given collection arguments. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor. + visitor is null. + + + + Gets a list that provides the input sets to the join. + + + A list that provides the input sets to the join. + + + + Represents the an expression that retrieves an entity based on the specified reference. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor. + visitor is null. + + + Removes duplicate elements from the specified set argument. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor. + visitor is null. + + + Represents the conversion of the specified set argument to a singleton. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor. + visitor is null. + + + Represents an expression that extracts a reference from the underlying entity instance. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor. + visitor is null. + + + Represents the set subtraction operation between the left and right operands. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor. + visitor is null. + + + + Describes a binding for an expression. Conceptually similar to a foreach loop + in C#. The DbExpression property defines the collection being iterated over, + while the Var property provides a means to reference the current element + of the collection during the iteration. DbExpressionBinding is used to describe the set arguments + to relational expressions such as , + and . + + + + + + + Gets the that defines the input set. + + + The that defines the input set. + + The expression is null. + The expression is not associated with the command tree of the binding, or its result type is not equal or promotable to the result type of the current value of the property. + + + Gets the name assigned to the element variable. + The name assigned to the element variable. + + + Gets the type metadata of the element variable. + The type metadata of the element variable. + + + + Gets the that references the element variable. + + The variable reference. + + + Represents a predicate applied to filter an input set. This produces the set of elements that satisfy the predicate. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + + Gets the that specifies the input set. + + + The that specifies the input set. + + + + + Gets the that specifies the predicate used to filter the input set. + + + The that specifies the predicate used to filter the input set. + + The expression is null. + + The expression is not associated with the command tree of the + + , or its result type is not a Boolean type. + + + + Represents an invocation of a function. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Gets the metadata for the function to invoke. + The metadata for the function to invoke. + + + + Gets an list that provides the arguments to the function. + + + An list that provides the arguments to the function. + + + + Represents a collection of elements that compose a group. + + + Represents a group by operation. A group by operation is a grouping of the elements in the input set based on the specified key expressions followed by the application of the specified aggregates. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + + Gets the that specifies the input set and provides access to the set element and group element variables. + + + The that specifies the input set and provides access to the set element and group element variables. + + + + + Gets a list that provides grouping keys. + + + A list that provides grouping keys. + + + + + Gets a list that provides the aggregates to apply. + + + A list that provides the aggregates to apply. + + + + Represents the set intersection operation between the left and right operands. This class cannot be inherited. + + DbIntersectExpression requires that its arguments have a common collection result type + + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Represents an empty set determination applied to a single set argument. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Represents null determination applied to a single argument. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Represents the type comparison of a single argument against the specified type. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Gets the type metadata that the type metadata of the argument should be compared to. + The type metadata that the type metadata of the argument should be compared to. + + + Represents an inner, left outer, or full outer join operation between the given collection arguments on the specified join condition. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + + Gets the that provides the left input. + + + The that provides the left input. + + + + + Gets the that provides the right input. + + + The that provides the right input. + + + + Gets the join condition to apply. + The join condition to apply. + The expression is null. + + The expression is not associated with the command tree of the + + , or its result type is not a Boolean type. + + + + + Allows the application of a lambda function to arguments represented by + + objects. + + + + The visitor pattern method for expression visitors that do not produce a result value. + + An instance of . + + visitor is null + + + The visitor pattern method for expression visitors that produce a result value of a specific type. + The type of the result produced by the expression visitor. + + An instance of a typed that produces a result value of type TResultType. + + The type of the result produced by visitor + visitor is null + + + + Gets the representing the Lambda function applied by this expression. + + + The representing the Lambda function applied by this expression. + + + + + Gets a list that provides the arguments to which the Lambda function should be applied. + + + The list. + + + + Represents a string comparison against the specified pattern with an optional escape string. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Gets an expression that specifies the string to compare against the given pattern. + An expression that specifies the string to compare against the given pattern. + The expression is null. + + The expression is not associated with the command tree of + + , or its result type is not a string type. + + + + Gets an expression that specifies the pattern against which the given string should be compared. + An expression that specifies the pattern against which the given string should be compared. + The expression is null. + + The expression is not associated with the command tree of + + , or its result type is not a string type. + + + + Gets an expression that provides an optional escape string to use for the comparison. + An expression that provides an optional escape string to use for the comparison. + The expression is null. + + The expression is not associated with the command tree of + + , or its result type is not a string type. + + + + Represents the restriction of the number of elements in the argument collection to the specified limit value. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Gets an expression that specifies the input collection. + An expression that specifies the input collection. + The expression is null. + + The expression is not associated with the command tree of the + + , or its result type is not a collection type. + + + + Gets an expression that specifies the limit on the number of elements returned from the input collection. + An expression that specifies the limit on the number of elements returned from the input collection. + The expression is null. + + The expression is not associated with the command tree of the + + , or is not one of + + or + + , or its result type is not equal or promotable to a 64-bit integer type. + + + + + Gets whether the limit operation will include tied results. Including tied results might produce more results than specified by the + + value. + + true if the limit operation will include tied results; otherwise, false. The default is false. + + + Represents the construction of a new instance of a given type, including set and record types. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + + Gets an list that provides the property/column values or set elements for the new instance. + + + An list that provides the property/column values or set elements for the new instance. + + + + Represents the logical NOT of a single Boolean argument. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Represents a reference to a typed null literal. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Represents the retrieval of elements of the specified type from the given set argument. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Gets the metadata of the type of elements that should be retrieved from the set argument. + The metadata of the type of elements that should be retrieved from the set argument. + + + Represents the logical OR of two Boolean arguments. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Represents a reference to a parameter declared on the command tree that contains this expression. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Gets the name of the referenced parameter. + The name of the referenced parameter. + + + Represents the projection of a given input set over the specified expression. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + + Gets the that specifies the input set. + + + The that specifies the input set. + + + + + Gets the that defines the projection. + + + The that defines the projection. + + The expression is null. + + The expression is not associated with the command tree of the + + , or its result type is not equal or promotable to the reference type of the current projection. + + + + Provides methods and properties for retrieving an instance property. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Creates a new key/value pair based on this property expression. + + A new key/value pair with the key and value derived from the + + . + + + + + Enables implicit casting to . + + The expression to be converted. + The converted value. + + + Gets the property metadata for the property to retrieve. + The property metadata for the property to retrieve. + + + + Gets a that defines the instance from which the property should be retrieved. + + + A that defines the instance from which the property should be retrieved. + + The expression is null. + + The expression is not associated with the command tree of the + + , or its result type is not equal or promotable to the type that defines the property. + + + + Represents a quantifier operation of the specified kind over the elements of the specified input set. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + + Gets the that specifies the input set. + + + The that specifies the input set. + + + + Gets the Boolean predicate that should be evaluated for each element in the input set. + The Boolean predicate that should be evaluated for each element in the input set. + The expression is null. + + The expression is not associated with the command tree for the + + ,or its result type is not a Boolean type. + + + + Represents a strongly typed reference to a specific instance within an entity set. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Gets the metadata for the entity set that contains the instance. + The metadata for the entity set that contains the instance. + + + Represents the navigation of a relationship. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Gets the metadata for the relationship over which navigation occurs. + The metadata for the relationship over which navigation occurs. + + + Gets the metadata for the relationship end to navigate from. + The metadata for the relationship end to navigate from. + + + Gets the metadata for the relationship end to navigate to. + The metadata for the relationship end to navigate to. + + + + Gets an that specifies the starting point of the navigation and must be a reference to an entity instance. + + + An that specifies the instance of the source relationship end from which navigation should occur. + + The expression is null. + + The expression is not associated with the command tree of the + + , or its result type is not equal or promotable to the reference type of the + + property. + + + + + Skips a specified number of elements in the input set. + + can only be used after the input collection has been sorted as specified by the sort keys. + + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + + Gets the that specifies the input set. + + + The that specifies the input set. + + + + + Gets a list that defines the sort order. + + + A list that defines the sort order. + + + + Gets an expression that specifies the number of elements to skip from the input collection. + An expression that specifies the number of elements to skip from the input collection. + The expression is null. + + The expression is not associated with the command tree of the + + ; the expression is not either a + + or a + + ; or the result type of the expression is not equal or promotable to a 64-bit integer type. + + + + + Specifies a sort key that can be used as part of the sort order in a + + . This class cannot be inherited. + + + + Gets a Boolean value indicating whether or not this sort key uses an ascending sort order. + true if this sort key uses an ascending sort order; otherwise, false. + + + Gets a string value that specifies the collation for this sort key. + A string value that specifies the collation for this sort key. + + + + Gets the that provides the value for this sort key. + + + The that provides the value for this sort key. + + + + Represents a sort operation applied to the elements of the specified input set based on the given sort keys. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by + visitor + + + visitor + is null. + + + + Gets the that specifies the input set. + + + The that specifies the input set. + + + + + Gets a list that defines the sort order. + + + A list that defines the sort order. + + + + Represents a type conversion operation applied to a polymorphic argument. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Supports standard aggregate functions, such as MIN, MAX, AVG, SUM, and so on. This class cannot be inherited. + + + Gets a value indicating whether this aggregate is a distinct aggregate. + true if the aggregate is a distinct aggregate; otherwise, false. + + + Gets the method metadata that specifies the aggregate function to invoke. + The method metadata that specifies the aggregate function to invoke. + + + + An abstract base type for types that implement the IExpressionVisitor interface to derive from. + + + + + An abstract base type for types that implement the IExpressionVisitor interface to derive from. + + + + Defines the basic functionality that should be implemented by visitors that do not return a result value. + + + When overridden in a derived class, handles any expression of an unrecognized type. + The expression to be handled. + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + When overridden in a derived class, implements the visitor pattern for + + . + + + The that is visited. + + + + + Visitor pattern method for DbInExpression. + + The DbInExpression that is being visited. + + + + Convenience method to visit the specified . + + The DbUnaryExpression to visit. + + + is null + + + + + Convenience method to visit the specified . + + The DbBinaryExpression to visit. + + + is null + + + + + Convenience method to visit the specified . + + The DbExpressionBinding to visit. + + + is null + + + + + Convenience method for post-processing after a DbExpressionBinding has been visited. + + The previously visited DbExpressionBinding. + + + + Convenience method to visit the specified . + + The DbGroupExpressionBinding to visit. + + + is null + + + + + Convenience method indicating that the grouping keys of a have been visited and the aggregates are now about to be visited. + + The DbGroupExpressionBinding of the DbGroupByExpression + + + + Convenience method for post-processing after a DbGroupExpressionBinding has been visited. + + The previously visited DbGroupExpressionBinding. + + + + Convenience method indicating that the body of a Lambda is now about to be visited. + + The DbLambda that is about to be visited + + + is null + + + + + Convenience method for post-processing after a DbLambda has been visited. + + The previously visited DbLambda. + + + + Convenience method to visit the specified , if non-null. + + The expression to visit. + + + is null + + + + + Convenience method to visit each in the given list, if the list is non-null. + + The list of expressions to visit. + + + is null + + + + + Convenience method to visit each in the list, if the list is non-null. + + The list of aggregates to visit. + + + is null + + + + + Convenience method to visit the specified . + + The aggregate to visit. + + + is null + + + + + Called when an of an otherwise unrecognized type is encountered. + + The expression + + + is null + + + Always thrown if this method is called, since it indicates that + + is of an unsupported type + + + + + Visitor pattern method for . + + The DbConstantExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbNullExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbVariableReferenceExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbParameterReferenceExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbFunctionExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbLambdaExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbPropertyExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbComparisonExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbLikeExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbLimitExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbIsNullExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbArithmeticExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbAndExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbOrExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbInExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbNotExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbDistinctExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbElementExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbIsEmptyExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbUnionAllExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbIntersectExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbExceptExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbOfTypeExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbTreatExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbCastExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbIsOfExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbCaseExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbNewInstanceExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbRefExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbRelationshipNavigationExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DeRefExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbRefKeyExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbEntityRefExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbScanExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbFilterExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbProjectExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbCrossJoinExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbJoinExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbApplyExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbSkipExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbSortExpression that is being visited. + + + is null + + + + + Visitor pattern method for . + + The DbQuantifierExpression that is being visited. + + + is null + + + + Implements the visitor pattern for the set clause. + The set clause. + + + Implements the visitor pattern for the modification clause. + The modification clause. + + + Implements the visitor pattern for the collection of modification clauses. + The modification clauses. + + + Implements the visitor pattern for the command tree. + The command tree. + + + Implements the visitor pattern for the delete command tree. + The delete command tree. + + + Implements the visitor pattern for the function command tree. + The function command tree. + + + Implements the visitor pattern for the insert command tree. + The insert command tree. + + + Implements the visitor pattern for the query command tree. + The query command tree. + + + Implements the visitor pattern for the update command tree. + The update command tree. + + + An immutable class that implements the basic functionality for the Query, Insert, Update, Delete, and function invocation command tree types. + + + + Returns a that represents this command. + + + A that represents this command. + + + + + Gets a value indicating whether database null semantics are exhibited when comparing + two operands, both of which are potentially nullable. The default value is true. + + For example (operand1 == operand2) will be translated as: + + (operand1 = operand2) + + if UseDatabaseNullSemantics is true, respectively + + (((operand1 = operand2) AND (NOT (operand1 IS NULL OR operand2 IS NULL))) OR ((operand1 IS NULL) AND (operand2 IS NULL))) + + if UseDatabaseNullSemantics is false. + + + true if database null comparison behavior is enabled, otherwise false . + + + + + Gets the name and corresponding type of each parameter that can be referenced within this + + . + + + The name and corresponding type of each parameter that can be referenced within this + + . + + + + + Gets the kind of this command tree. + + + + + Gets the metadata workspace used by this command tree. + + + + + Gets the data space in which metadata used by this command tree must reside. + + + + Represents a single row delete operation expressed as a command tree. This class cannot be inherited. + + + Represents a data manipulation language (DML) operation expressed as a command tree. + + + + Gets the that specifies the target table for the data manipulation language (DML) operation. + + + The that specifies the target table for the DML operation. + + + + + Initializes a new instance of the class. + + The model this command will operate on. + The data space. + The target table for the data manipulation language (DML) operation. + A predicate used to determine which members of the target collection should be deleted. + + + + Gets an that specifies the predicate used to determine which members of the target collection should be deleted. + + + The predicate can include only the following elements: + + Equality expression + Constant expression + IsNull expression + Property expression + Reference expression to the target + And expression + Or expression + Not expression + + + + An that specifies the predicate used to determine which members of the target collection should be deleted. + + + + Gets the kind of this command tree. + The kind of this command tree. + + + + Contains values that each expression class uses to denote the operation it represents. The + + property of an + + can be retrieved to determine which operation that expression represents. + + + + + True for all. + + + + + Logical And. + + + + + True for any. + + + + + Conditional case statement. + + + + + Polymorphic type cast. + + + + + A constant value. + + + + + Cross apply + + + + + Cross join + + + + + Dereference. + + + + + Duplicate removal. + + + + + Division. + + + + + Set to singleton conversion. + + + + + Entity ref value retrieval. + + + + + Equality + + + + + Set subtraction + + + + + Restriction. + + + + + Full outer join + + + + + Invocation of a stand-alone function + + + + + Greater than. + + + + + Greater than or equal. + + + + + Grouping. + + + + + Inner join + + + + + Set intersection. + + + + + Empty set determination. + + + + + Null determination. + + + + + Type comparison (specified Type or Subtype). + + + + + Type comparison (specified Type only). + + + + + Left outer join + + + + + Less than. + + + + + Less than or equal. + + + + + String comparison. + + + + + Result count restriction (TOP n). + + + + + Subtraction. + + + + + Modulo. + + + + + Multiplication. + + + + + Instance, row, and set construction. + + + + + Logical Not. + + + + + Inequality. + + + + + Null. + + + + + Set members by type (or subtype). + + + + + Set members by (exact) type. + + + + + Logical Or. + + + + + Outer apply. + + + + + A reference to a parameter. + + + + + Addition. + + + + + Projection. + + + + + Retrieval of a static or instance property. + + + + + Reference. + + + + + Ref key value retrieval. + + + + + Navigation of a (composition or association) relationship. + + + + + Entity or relationship set scan. + + + + + Skip elements of an ordered collection. + + + + + Sorting. + + + + + Type conversion. + + + + + Negation. + + + + + Set union (with duplicates). + + + + + A reference to a variable. + + + + + Application of a lambda function + + + + + In. + + + + Represents the invocation of a database function. + + + + Constructs a new DbFunctionCommandTree that uses the specified metadata workspace, data space and function metadata + + The metadata workspace that the command tree should use. + The logical 'space' that metadata in the expressions used in this command tree must belong to. + The that represents the function that is being invoked. + The expected result type for the function’s first result set. + The function's parameters. + + , or is null + + + does not represent a valid data space or + is a composable function + + + + + Gets the that represents the function that is being invoked. + + + The that represents the function that is being invoked. + + + + Gets the expected result type for the function’s first result set. + The expected result type for the function’s first result set. + + + Gets or sets the command tree kind. + The command tree kind. + + + Represents a single row insert operation expressed as a command tree. This class cannot be inherited. + + Represents a single row insert operation expressed as a canonical command tree. + When the property is set, the command returns a reader; otherwise, + it returns a scalar value indicating the number of rows affected. + + + + + Initializes a new instance of the class. + + The model this command will operate on. + The data space. + The target table for the data manipulation language (DML) operation. + The list of insert set clauses that define the insert operation. . + A that specifies a projection of results to be returned, based on the modified rows. + + + Gets the list of insert set clauses that define the insert operation. + The list of insert set clauses that define the insert operation. + + + + Gets an that specifies a projection of results to be returned based on the modified rows. + + + An that specifies a projection of results to be returned based on the modified rows. null indicates that no results should be returned from this command. + + + + Gets the command tree kind. + The command tree kind. + + + + Represents a Lambda function that can be invoked to produce a + + . + + + + + Creates a with the specified inline Lambda function implementation and formal parameters. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters + An expression that defines the logic of the Lambda function + + A collection that represents the formal parameters to the Lambda function. These variables are valid for use in the body expression. + + + + is null or contains null, or + + is null + + + + contains more than one element with the same variable name. + + + + + Creates a with the specified inline Lambda function implementation and formal parameters. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters + An expression that defines the logic of the Lambda function + + A collection that represents the formal parameters to the Lambda function. These variables are valid for use in the body expression. + + + + is null or contains null, or + + is null. + + + + contains more than one element with the same variable name. + + + + + Creates a new with a single argument of the specified type, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and single formal parameter. + + A that defines the EDM type of the argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A that defines the EDM type of the sixth argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A that defines the EDM type of the sixth argument to the Lambda function + + + A that defines the EDM type of the seventh argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A that defines the EDM type of the sixth argument to the Lambda function + + + A that defines the EDM type of the seventh argument to the Lambda function + + + A that defines the EDM type of the eighth argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A that defines the EDM type of the sixth argument to the Lambda function + + + A that defines the EDM type of the seventh argument to the Lambda function + + + A that defines the EDM type of the eighth argument to the Lambda function + + + A that defines the EDM type of the ninth argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A that defines the EDM type of the sixth argument to the Lambda function + + + A that defines the EDM type of the seventh argument to the Lambda function + + + A that defines the EDM type of the eighth argument to the Lambda function + + + A that defines the EDM type of the ninth argument to the Lambda function + + + A that defines the EDM type of the tenth argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A that defines the EDM type of the sixth argument to the Lambda function + + + A that defines the EDM type of the seventh argument to the Lambda function + + + A that defines the EDM type of the eighth argument to the Lambda function + + + A that defines the EDM type of the ninth argument to the Lambda function + + + A that defines the EDM type of the tenth argument to the Lambda function + + + A that defines the EDM type of the eleventh argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A that defines the EDM type of the sixth argument to the Lambda function + + + A that defines the EDM type of the seventh argument to the Lambda function + + + A that defines the EDM type of the eighth argument to the Lambda function + + + A that defines the EDM type of the ninth argument to the Lambda function + + + A that defines the EDM type of the tenth argument to the Lambda function + + + A that defines the EDM type of the eleventh argument to the Lambda function + + + A that defines the EDM type of the twelfth argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A that defines the EDM type of the sixth argument to the Lambda function + + + A that defines the EDM type of the seventh argument to the Lambda function + + + A that defines the EDM type of the eighth argument to the Lambda function + + + A that defines the EDM type of the ninth argument to the Lambda function + + + A that defines the EDM type of the tenth argument to the Lambda function + + + A that defines the EDM type of the eleventh argument to the Lambda function + + + A that defines the EDM type of the twelfth argument to the Lambda function + + + A that defines the EDM type of the thirteenth argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A that defines the EDM type of the sixth argument to the Lambda function + + + A that defines the EDM type of the seventh argument to the Lambda function + + + A that defines the EDM type of the eighth argument to the Lambda function + + + A that defines the EDM type of the ninth argument to the Lambda function + + + A that defines the EDM type of the tenth argument to the Lambda function + + + A that defines the EDM type of the eleventh argument to the Lambda function + + + A that defines the EDM type of the twelfth argument to the Lambda function + + + A that defines the EDM type of the thirteenth argument to the Lambda function + + + A that defines the EDM type of the fourteenth argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A that defines the EDM type of the sixth argument to the Lambda function + + + A that defines the EDM type of the seventh argument to the Lambda function + + + A that defines the EDM type of the eighth argument to the Lambda function + + + A that defines the EDM type of the ninth argument to the Lambda function + + + A that defines the EDM type of the tenth argument to the Lambda function + + + A that defines the EDM type of the eleventh argument to the Lambda function + + + A that defines the EDM type of the twelfth argument to the Lambda function + + + A that defines the EDM type of the thirteenth argument to the Lambda function + + + A that defines the EDM type of the fourteenth argument to the Lambda function + + + A that defines the EDM type of the fifteenth argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + or + + is null or produces a result of null. + + + + + Creates a new with arguments of the specified types, as defined by the specified function. + + A new DbLambda that describes an inline Lambda function with the specified body and formal parameters. + + A that defines the EDM type of the first argument to the Lambda function + + + A that defines the EDM type of the second argument to the Lambda function + + + A that defines the EDM type of the third argument to the Lambda function + + + A that defines the EDM type of the fourth argument to the Lambda function + + + A that defines the EDM type of the fifth argument to the Lambda function + + + A that defines the EDM type of the sixth argument to the Lambda function + + + A that defines the EDM type of the seventh argument to the Lambda function + + + A that defines the EDM type of the eighth argument to the Lambda function + + + A that defines the EDM type of the ninth argument to the Lambda function + + + A that defines the EDM type of the tenth argument to the Lambda function + + + A that defines the EDM type of the eleventh argument to the Lambda function + + + A that defines the EDM type of the twelfth argument to the Lambda function + + + A that defines the EDM type of the thirteenth argument to the Lambda function + + + A that defines the EDM type of the fourteenth argument to the Lambda function + + + A that defines the EDM type of the fifteenth argument to the Lambda function + + + A that defines the EDM type of the sixteenth argument to the Lambda function + + + A function that defines the logic of the Lambda function as a + + + + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, + + is null, or + + is null or produces a result of null. + + + + Gets the body of the lambda expression. + + A that represents the body of the lambda function. + + + + Gets the parameters of the lambda expression. + The list of lambda function parameters represented as DbVariableReferenceExpression objects. + + + + Specifies a single clause in an insert or update modification operation, see + and + + + An abstract base class allows the possibility of patterns other than + Property = Value in future versions, e.g., + update SomeTable + set ComplexTypeColumn.SomeProperty() + where Id = 2 + + + + Represents a query operation expressed as a command tree. This class cannot be inherited. + + + + Constructs a new DbQueryCommandTree that uses the specified metadata workspace. + + The metadata workspace that the command tree should use. + The logical 'space' that metadata in the expressions used in this command tree must belong to. + + A that defines the logic of the query. + + When set to false the validation of the tree is turned off. + A boolean that indicates whether database null semantics are exhibited when comparing + two operands, both of which are potentially nullable. + + + or + + is null + + + + does not represent a valid data space + + + + + Constructs a new DbQueryCommandTree that uses the specified metadata workspace, using database null semantics. + + The metadata workspace that the command tree should use. + The logical 'space' that metadata in the expressions used in this command tree must belong to. + + A that defines the logic of the query. + + When set to false the validation of the tree is turned off. + + + or + + is null + + + + does not represent a valid data space + + + + + Constructs a new DbQueryCommandTree that uses the specified metadata workspace, using database null semantics. + + The metadata workspace that the command tree should use. + The logical 'space' that metadata in the expressions used in this command tree must belong to. + + A that defines the logic of the query. + + + + or + + is null + + + + does not represent a valid data space + + + + + Gets an that defines the logic of the query operation. + + + An that defines the logic of the query operation. + + The expression is null. + The expression is associated with a different command tree. + + + Gets the kind of this command tree. + The kind of this command tree. + + + Specifies the clause in a modification operation that sets the value of a property. This class cannot be inherited. + + + + Gets an that specifies the property that should be updated. + + + An that specifies the property that should be updated. + + + + + Gets an that specifies the new value with which to update the property. + + + An that specifies the new value with which to update the property. + + + + Represents a single-row update operation expressed as a command tree. This class cannot be inherited. + + Represents a single-row update operation expressed as a canonical command tree. + When the property is set, the command returns a reader; otherwise, + it returns a scalar indicating the number of rows affected. + + + + + Initializes a new instance of the class. + + The model this command will operate on. + The data space. + The target table for the data manipulation language (DML) operation. + A predicate used to determine which members of the target collection should be updated. + The list of update set clauses that define the update operation. + A that specifies a projection of results to be returned, based on the modified rows. + + + Gets the list of update set clauses that define the update operation. + The list of update set clauses that define the update operation. + + + + Gets an that specifies a projection of results to be returned, based on the modified rows. + + + An that specifies a projection of results to be returned based, on the modified rows. null indicates that no results should be returned from this command. + + + + + Gets an that specifies the predicate used to determine which members of the target collection should be updated. + + + An that specifies the predicate used to determine which members of the target collection should be updated. + + + + Gets the kind of this command tree. + The kind of this command tree. + + + Represents a reference to a variable that is currently in scope. This class cannot be inherited. + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Gets the name of the referenced variable. + The name of the referenced variable. + + + + Defines the binding for the input set to a . + In addition to the properties of , DbGroupExpressionBinding + also provides access to the group element via the variable reference + and to the group aggregate via the property. + + + + + Gets the that defines the input set. + + + The that defines the input set. + + The expression is null. + + The expression is not associated with the command tree of the + + , or its result type is not equal or promotable to the result type of the current value of the property. + + + + Gets the name assigned to the element variable. + The name assigned to the element variable. + + + Gets the type metadata of the element variable. + The type metadata of the element variable. + + + + Gets the that references the element variable. + + A reference to the element variable. + + + Gets the name assigned to the group element variable. + The name assigned to the group element variable. + + + Gets the type metadata of the group element variable. + The type metadata of the group element variable. + + + + Gets the that references the group element variable. + + A reference to the group element variable. + + + + Gets the that represents the collection of elements in the group. + + The elements in the group. + + + + Provides an API to construct s and allows that API to be accessed as extension methods on the expression type itself. + + + + Returns the specified arguments as a key/value pair object. + A key/value pair object. + The value in the key/value pair. + The key in the key/value pair. + + + Returns the specified arguments as a key/value pair object. + A key/value pair object. + The value in the key/value pair. + The key in the key/value pair. + + + + Creates a new that uses a generated variable name to bind the given expression. + + A new expression binding with the specified expression and a generated variable name. + The expression to bind. + input is null. + input does not have a collection result. + + + + Creates a new that uses the specified variable name to bind the given expression + + A new expression binding with the specified expression and variable name. + The expression to bind. + The variable name that should be used for the binding. + input or varName is null. + input does not have a collection result. + + + Creates a new group expression binding that uses generated variable and group variable names to bind the given expression. + A new group expression binding with the specified expression and a generated variable name and group variable name. + The expression to bind. + input is null. + input does not have a collection result type. + + + + Creates a new that uses the specified variable name and group variable names to bind the given expression. + + A new group expression binding with the specified expression, variable name and group variable name. + The expression to bind. + The variable name that should be used for the binding. + The variable name that should be used to refer to the group when the new group expression binding is used in a group-by expression. + input, varName or groupVarName is null. + input does not have a collection result type. + + + + Creates a new . + + A new function aggregate with a reference to the given function and argument. The function aggregate's Distinct property will have the value false. + The function that defines the aggregate operation. + The argument over which the aggregate function should be calculated. + function or argument null. + function is not an aggregate function or has more than one argument, or the result type of argument is not equal or promotable to the parameter type of function. + + + + Creates a new that is applied in a distinct fashion. + + A new function aggregate with a reference to the given function and argument. The function aggregate's Distinct property will have the value true. + The function that defines the aggregate operation. + The argument over which the aggregate function should be calculated. + function or argument is null. + function is not an aggregate function or has more than one argument, or the result type of argument is not equal or promotable to the parameter type of function. + + + + Creates a new over the specified argument + + The argument over which to perform the nest operation + A new group aggregate representing the elements of the group referenced by the given argument. + + + is null + + + + + Creates a with the specified inline Lambda function implementation and formal parameters. + + A new expression that describes an inline Lambda function with the specified body and formal parameters. + An expression that defines the logic of the Lambda function. + + A collection that represents the formal parameters to the Lambda function. These variables are valid for use in the body expression. + + variables is null or contains null, or body is null. + variables contains more than one element with the same variable name. + + + + Creates a with the specified inline Lambda function implementation and formal parameters. + + A new expression that describes an inline Lambda function with the specified body and formal parameters. + An expression that defines the logic of the Lambda function. + + A collection that represents the formal parameters to the Lambda function. These variables are valid for use in the body expression. + + variables is null or contains null, or body is null. + variables contains more than one element with the same variable name. + + + + Creates a new with an ascending sort order and default collation. + + A new sort clause with the given sort key and ascending sort order. + The expression that defines the sort key. + key is null. + key does not have an order-comparable result type. + + + + Creates a new with a descending sort order and default collation. + + A new sort clause with the given sort key and descending sort order. + The expression that defines the sort key. + key is null. + key does not have an order-comparable result type. + + + + Creates a new with an ascending sort order and the specified collation. + + A new sort clause with the given sort key and collation, and ascending sort order. + The expression that defines the sort key. + The collation to sort under. + key is null. + collation is empty or contains only space characters. + key does not have an order-comparable result type. + + + + Creates a new with a descending sort order and the specified collation. + + A new sort clause with the given sort key and collation, and descending sort order. + The expression that defines the sort key. + The collation to sort under. + key is null. + collation is empty or contains only space characters. + key does not have an order-comparable result type. + + + + Creates a new that determines whether the given predicate holds for all elements of the input set. + + A new DbQuantifierExpression that represents the All operation. + An expression binding that specifies the input set. + An expression representing a predicate to evaluate for each member of the input set. + input or predicate is null. + predicate does not have a Boolean result type. + + + + Creates a new that determines whether the given predicate holds for any element of the input set. + + A new DbQuantifierExpression that represents the Any operation. + An expression binding that specifies the input set. + An expression representing a predicate to evaluate for each member of the input set. + input or predicate is null. + The expression produced by predicate does not have a Boolean result type. + + + + Creates a new that evaluates the given apply expression once for each element of a given input set, producing a collection of rows with corresponding input and apply columns. Rows for which apply evaluates to an empty set are not included. + + + An new DbApplyExpression with the specified input and apply bindings and an + + of CrossApply. + + + An that specifies the input set. + + + An that specifies logic to evaluate once for each member of the input set. + + input or apply is null. + + + + Creates a new that evaluates the given apply expression once for each element of a given input set, producing a collection of rows with corresponding input and apply columns. Rows for which apply evaluates to an empty set have an apply column value of null. + + + An new DbApplyExpression with the specified input and apply bindings and an + + of OuterApply. + + + An that specifies the input set. + + + An that specifies logic to evaluate once for each member of the input set. + + input or apply is null. + + + + Creates a new that unconditionally joins the sets specified by the list of input expression bindings. + + + A new DbCrossJoinExpression, with an of CrossJoin, that represents the unconditional join of the input sets. + + A list of expression bindings that specifies the input sets. + inputs is null or contains null element. + inputs contains fewer than 2 expression bindings. + + + + Creates a new that joins the sets specified by the left and right expression bindings, on the specified join condition, using InnerJoin as the + + . + + + A new DbJoinExpression, with an of InnerJoin, that represents the inner join operation applied to the left and right input sets under the given join condition. + + + An that specifies the left set argument. + + + An that specifies the right set argument. + + An expression that specifies the condition on which to join. + left, right or joinCondition is null. + joinCondition does not have a Boolean result type. + + + + Creates a new that joins the sets specified by the left and right expression bindings, on the specified join condition, using LeftOuterJoin as the + + . + + + A new DbJoinExpression, with an of LeftOuterJoin, that represents the left outer join operation applied to the left and right input sets under the given join condition. + + + An that specifies the left set argument. + + + An that specifies the right set argument. + + An expression that specifies the condition on which to join. + left, right or joinCondition is null. + joinCondition does not have a Boolean result type. + + + + Creates a new that joins the sets specified by the left and right expression bindings, on the specified join condition, using FullOuterJoin as the + + . + + + A new DbJoinExpression, with an of FullOuterJoin, that represents the full outer join operation applied to the left and right input sets under the given join condition. + + + An that specifies the left set argument. + + + An that specifies the right set argument. + + An expression that specifies the condition on which to join. + left, right or joinCondition is null. + The expression produced by joinCondition does not have a Boolean result type. + + + + Creates a new that filters the elements in the given input set using the specified predicate. + + A new DbFilterExpression that produces the filtered set. + An expression binding that specifies the input set. + An expression representing a predicate to evaluate for each member of the input set. + input or predicate is null. + predicate does not have a Boolean result type. + + + + Creates a new that groups the elements of the input set according to the specified group keys and applies the given aggregates. + + A new DbGroupByExpression with the specified input set, grouping keys and aggregates. + + A that specifies the input set. + + A list of string-expression pairs that define the grouping columns. + A list of expressions that specify aggregates to apply. + input, keys or aggregates is null, keys contains a null column key or expression, or aggregates contains a null aggregate column name or aggregate. + Both keys and aggregates are empty, or an invalid or duplicate column name was specified. + + + + Creates a new that projects the specified expression over the given input set. + + A new DbProjectExpression that represents the projection operation. + An expression binding that specifies the input set. + An expression to project over the set. + input or projection is null. + + + + Creates a new that sorts the given input set by the given sort specifications before skipping the specified number of elements. + + A new DbSkipExpression that represents the skip operation. + An expression binding that specifies the input set. + A list of sort specifications that determine how the elements of the input set should be sorted. + An expression the specifies how many elements of the ordered set to skip. + input, sortOrder or count is null, or sortOrder contains null. + + sortOrder is empty, or count is not or + + or has a result type that is not equal or promotable to a 64-bit integer type. + + + + + Creates a new that sorts the given input set by the specified sort specifications. + + A new DbSortExpression that represents the sort operation. + An expression binding that specifies the input set. + A list of sort specifications that determine how the elements of the input set should be sorted. + input or sortOrder is null, or sortOrder contains null. + sortOrder is empty. + + + + Creates a new , which represents a typed null value. + + An instance of DbNullExpression. + The type of the null value. + nullType is null. + + + + Creates a new with the given constant value. + + A new DbConstantExpression with the given value. + The constant value to represent. + value is null. + value is not an instance of a valid constant type. + + + + Creates a new of the specified primitive type with the given constant value. + + A new DbConstantExpression with the given value and a result type of constantType. + The type of the constant value. + The constant value to represent. + value or constantType is null. + value is not an instance of a valid constant type, constantType does not represent a primitive type, or value is of a different primitive type than that represented by constantType. + + + + Creates a new that references a parameter with the specified name and type. + + A DbParameterReferenceExpression that represents a reference to a parameter with the specified name and type. The result type of the expression will be the same as type. + The type of the referenced parameter. + The name of the referenced parameter. + + + + Creates a new that references a variable with the specified name and type. + + A DbVariableReferenceExpression that represents a reference to a variable with the specified name and type. The result type of the expression will be the same as type. + The type of the referenced variable. + The name of the referenced variable. + + + + Creates a new that references the specified entity or relationship set. + + A new DbScanExpression based on the specified entity or relationship set. + Metadata for the entity or relationship set to reference. + targetSet is null. + + + + Creates an that performs the logical And of the left and right arguments. + + A new DbAndExpression with the specified arguments. + A Boolean expression that specifies the left argument. + A Boolean expression that specifies the right argument. + left or right is null. + left and right does not have a Boolean result type. + + + + Creates an that performs the logical Or of the left and right arguments. + + A new DbOrExpression with the specified arguments. + A Boolean expression that specifies the left argument. + A Boolean expression that specifies the right argument. + left or right is null. + left or right does not have a Boolean result type. + + + + Creates a that matches the result of the specified + expression with the results of the constant expressions in the specified list. + + A DbExpression to be matched. + A list of DbConstantExpression to test for a match. + + A new DbInExpression with the specified arguments. + + + + or + + is null. + + + The result type of + + is different than the result type of an expression from + . + + + + + Creates a that performs the logical negation of the given argument. + + A new DbNotExpression with the specified argument. + A Boolean expression that specifies the argument. + argument is null. + argument does not have a Boolean result type. + + + + Creates a new that divides the left argument by the right argument. + + A new DbArithmeticExpression representing the division operation. + An expression that specifies the left argument. + An expression that specifies the right argument. + left or right is null. + No common numeric result type exists between left or right. + + + + Creates a new that subtracts the right argument from the left argument. + + A new DbArithmeticExpression representing the subtraction operation. + An expression that specifies the left argument. + An expression that specifies the right argument. + left or right is null. + No common numeric result type exists between left and right. + + + + Creates a new that computes the remainder of the left argument divided by the right argument. + + A new DbArithmeticExpression representing the modulo operation. + An expression that specifies the left argument. + An expression that specifies the right argument. + left or right is null. + No common numeric result type exists between left and right. + + + + Creates a new that multiplies the left argument by the right argument. + + A new DbArithmeticExpression representing the multiplication operation. + An expression that specifies the left argument. + An expression that specifies the right argument. + left or right is null. + No common numeric result type exists between left and right. + + + + Creates a new that adds the left argument to the right argument. + + A new DbArithmeticExpression representing the addition operation. + An expression that specifies the left argument. + An expression that specifies the right argument. + left or right is null. + No common numeric result type exists between left and right. + + + + Creates a new that negates the value of the argument. + + A new DbArithmeticExpression representing the negation operation. + An expression that specifies the argument. + argument is null. + No numeric result type exists for argument. + + + + Creates a new that negates the value of the argument. + + A new DbArithmeticExpression representing the negation operation. + An expression that specifies the argument. + argument is null. + No numeric result type exists for argument. + + + + Creates a new that compares the left and right arguments for equality. + + A new DbComparisonExpression representing the equality comparison. + An expression that specifies the left argument. + An expression that specifies the right argument. + left or right is null. + No common equality-comparable result type exists between left and right. + + + + Creates a new that compares the left and right arguments for inequality. + + A new DbComparisonExpression representing the inequality comparison. + An expression that specifies the left argument. + An expression that specifies the right argument. + left or right is null. + No common equality-comparable result type exists between left and right. + + + + Creates a new that determines whether the left argument is greater than the right argument. + + A new DbComparisonExpression representing the greater-than comparison. + An expression that specifies the left argument. + An expression that specifies the right argument. + left or right is null. + No common order-comparable result type exists between left and right. + + + + Creates a new that determines whether the left argument is less than the right argument. + + A new DbComparisonExpression representing the less-than comparison. + An expression that specifies the left argument. + An expression that specifies the right argument. + left or right is null. + No common order-comparable result type exists between left and right. + + + + Creates a new that determines whether the left argument is greater than or equal to the right argument. + + A new DbComparisonExpression representing the greater-than-or-equal-to comparison. + An expression that specifies the left argument. + An expression that specifies the right argument. + left or right is null. + No common order-comparable result type exists between left and right. + + + + Creates a new that determines whether the left argument is less than or equal to the right argument. + + A new DbComparisonExpression representing the less-than-or-equal-to comparison. + An expression that specifies the left argument. + An expression that specifies the right argument. + left or right is null. + No common result type that is both equality- and order-comparable exists between left and right. + + + + Creates a new that determines whether the specified argument is null. + + A new DbIsNullExpression with the specified argument. + An expression that specifies the argument. + argument is null. + argument has a collection result type. + + + + Creates a new that compares the specified input string to the given pattern. + + A new DbLikeExpression with the specified input, pattern and a null escape. + An expression that specifies the input string. + An expression that specifies the pattern string. + Argument or pattern is null. + Argument or pattern does not have a string result type. + + + + Creates a new that compares the specified input string to the given pattern using the optional escape. + + A new DbLikeExpression with the specified input, pattern and escape. + An expression that specifies the input string. + An expression that specifies the pattern string. + An optional expression that specifies the escape string. + argument, pattern or escape is null. + argument, pattern or escape does not have a string result type. + + + + Creates a new that applies a cast operation to a polymorphic argument. + + A new DbCastExpression with the specified argument and target type. + The argument to which the cast should be applied. + Type metadata that specifies the type to cast to. + Argument or toType is null. + The specified cast is not valid. + + + + Creates a new . + + A new DbTreatExpression with the specified argument and type. + An expression that specifies the instance. + Type metadata for the treat-as type. + argument or treatType is null. + treatType is not in the same type hierarchy as the result type of argument. + + + + Creates a new that produces a set consisting of the elements of the given input set that are of the specified type. + + + A new DbOfTypeExpression with the specified set argument and type, and an ExpressionKind of + + . + + + A that specifies the input set. + + Type metadata for the type that elements of the input set must have to be included in the resulting set. + argument or type is null. + argument does not have a collection result type, or type is not a type in the same type hierarchy as the element type of the collection result type of argument. + + + + Creates a new that produces a set consisting of the elements of the given input set that are of exactly the specified type. + + + A new DbOfTypeExpression with the specified set argument and type, and an ExpressionKind of + + . + + + An that specifies the input set. + + Type metadata for the type that elements of the input set must match exactly to be included in the resulting set. + argument or type is null. + argument does not have a collection result type, or type is not a type in the same type hierarchy as the element type of the collection result type of argument. + + + + Creates a new that determines whether the given argument is of the specified type or a subtype. + + A new DbIsOfExpression with the specified instance and type and DbExpressionKind IsOf. + An expression that specifies the instance. + Type metadata that specifies the type that the instance's result type should be compared to. + argument or type is null. + type is not in the same type hierarchy as the result type of argument. + + + + Creates a new expression that determines whether the given argument is of the specified type, and only that type (not a subtype). + + A new DbIsOfExpression with the specified instance and type and DbExpressionKind IsOfOnly. + An expression that specifies the instance. + Type metadata that specifies the type that the instance's result type should be compared to. + argument or type is null. + type is not in the same type hierarchy as the result type of argument. + + + + Creates a new that retrieves a specific Entity given a reference expression. + + A new DbDerefExpression that retrieves the specified Entity. + + An that provides the reference. This expression must have a reference Type. + + argument is null. + argument does not have a reference result type. + + + + Creates a new that retrieves the ref of the specifed entity in structural form. + + A new DbEntityRefExpression that retrieves a reference to the specified entity. + The expression that provides the entity. This expression must have an entity result type. + argument is null. + argument does not have an entity result type. + + + + Creates a new that encodes a reference to a specific entity based on key values. + + A new DbRefExpression that references the element with the specified key values in the given entity set. + The entity set in which the referenced element resides. + + A collection of s that provide the key values. These expressions must match (in number, type, and order) the key properties of the referenced entity type. + + entitySet is null, or keyValues is null or contains null. + The count of keyValues does not match the count of key members declared by the entitySet’s element type, or keyValues contains an expression with a result type that is not compatible with the type of the corresponding key member. + + + + Creates a new that encodes a reference to a specific entity based on key values. + + A new DbRefExpression that references the element with the specified key values in the given entity set. + The entity set in which the referenced element resides. + + A collection of s that provide the key values. These expressions must match (in number, type, and order) the key properties of the referenced entity type. + + entitySet is null, or keyValues is null or contains null. + The count of keyValues does not match the count of key members declared by the entitySet’s element type, or keyValues contains an expression with a result type that is not compatible with the type of the corresponding key member. + + + + Creates a new that encodes a reference to a specific entity of a given type based on key values. + + A new DbRefExpression that references the element with the specified key values in the given entity set. + The entity set in which the referenced element resides. + The specific type of the referenced entity. This must be an entity type from the same hierarchy as the entity set's element type. + + A collection of s that provide the key values. These expressions must match (in number, type, and order) the key properties of the referenced entity type. + + entitySet or entityType is null, or keyValues is null or contains null. + entityType is not from the same type hierarchy (a subtype, supertype, or the same type) as entitySet's element type. + The count of keyValues does not match the count of key members declared by the entitySet’s element type, or keyValues contains an expression with a result type that is not compatible with the type of the corresponding key member. + + + + Creates a new that encodes a reference to a specific entity of a given type based on key values. + + A new DbRefExpression that references the element with the specified key values in the given entity set. + The entity set in which the referenced element resides. + The specific type of the referenced entity. This must be an entity type from the same hierarchy as the entity set's element type. + + A collection of s that provide the key values. These expressions must match (in number, type, and order) the key properties of the referenced entity type. + + entitySet or entityType is null, or keyValues is null or contains null. + entityType is not from the same type hierarchy (a subtype, supertype, or the same type) as entitySet's element type. + The count of keyValues does not match the count of key members declared by the entitySet’s element type, or keyValues contains an expression with a result type that is not compatible with the type of the corresponding key member. + + + + Creates a new that encodes a reference to a specific Entity based on key values. + + A new DbRefExpression that references the element with the specified key values in the given Entity set. + The Entity set in which the referenced element resides. + + A that constructs a record with columns that match (in number, type, and order) the Key properties of the referenced Entity type. + + entitySet or keyRow is null. + keyRow does not have a record result type that matches the key properties of the referenced entity set's entity type. + + + + Creates a new that encodes a reference to a specific Entity based on key values. + + A new DbRefExpression that references the element with the specified key values in the given Entity set. + The Entity set in which the referenced element resides. + + A that constructs a record with columns that match (in number, type, and order) the Key properties of the referenced Entity type. + + The type of the Entity that the reference should refer to. + entitySet, keyRow or entityType is null. + entityType is not in the same type hierarchy as the entity set's entity type, or keyRow does not have a record result type that matches the key properties of the referenced entity set's entity type. + + + + Creates a new that retrieves the key values of the specifed reference in structural form. + + A new DbRefKeyExpression that retrieves the key values of the specified reference. + The expression that provides the reference. This expression must have a reference Type with an Entity element type. + argument is null. + argument does not have a reference result type. + + + + Creates a new representing the navigation of a composition or association relationship. + + A new DbRelationshipNavigationExpression representing the navigation of the specified from and to relation ends of the specified relation type from the specified navigation source instance. + An expression that specifies the instance from which navigation should occur. + Metadata for the property that represents the end of the relationship from which navigation should occur. + Metadata for the property that represents the end of the relationship to which navigation should occur. + fromEnd, toEnd or navigateFrom is null. + fromEnd and toEnd are not declared by the same relationship type, or navigateFrom has a result type that is not compatible with the property type of fromEnd. + + + + Creates a new representing the navigation of a composition or association relationship. + + A new DbRelationshipNavigationExpression representing the navigation of the specified from and to relation ends of the specified relation type from the specified navigation source instance. + Metadata for the relation type that represents the relationship. + The name of the property of the relation type that represents the end of the relationship from which navigation should occur. + The name of the property of the relation type that represents the end of the relationship to which navigation should occur. + An expression the specifies the instance from which naviagtion should occur. + type, fromEndName, toEndName or navigateFrom is null. + type is not associated with this command tree's metadata workspace or navigateFrom is associated with a different command tree, or type does not declare a relation end property with name toEndName or fromEndName, or navigateFrom has a result type that is not compatible with the property type of the relation end property with name fromEndName. + + + + Creates a new that removes duplicates from the given set argument. + + A new DbDistinctExpression that represents the distinct operation applied to the specified set argument. + An expression that defines the set over which to perfom the distinct operation. + argument is null. + argument does not have a collection result type. + + + + Creates a new that converts a set into a singleton. + + A DbElementExpression that represents the conversion of the set argument to a singleton. + An expression that specifies the input set. + argument is null. + argument does not have a collection result type. + + + + Creates a new that determines whether the specified set argument is an empty set. + + A new DbIsEmptyExpression with the specified argument. + An expression that specifies the input set. + argument is null. + argument does not have a collection result type. + + + + Creates a new that computes the subtraction of the right set argument from the left set argument. + + A new DbExceptExpression that represents the difference of the left argument from the right argument. + An expression that defines the left set argument. + An expression that defines the right set argument. + left or right is null. + No common collection result type exists between left and right. + + + + Creates a new that computes the intersection of the left and right set arguments. + + A new DbIntersectExpression that represents the intersection of the left and right arguments. + An expression that defines the left set argument. + An expression that defines the right set argument. + left or right is null. + No common collection result type exists between left or right. + + + + Creates a new that computes the union of the left and right set arguments and does not remove duplicates. + + A new DbUnionAllExpression that union, including duplicates, of the the left and right arguments. + An expression that defines the left set argument. + An expression that defines the right set argument. + left or right is null. + No common collection result type with an equality-comparable element type exists between left and right. + + + + Creates a new that restricts the number of elements in the Argument collection to the specified count Limit value. Tied results are not included in the output. + + A new DbLimitExpression with the specified argument and count limit values that does not include tied results. + An expression that specifies the input collection. + An expression that specifies the limit value. + argument or count is null. + argument does not have a collection result type, or count does not have a result type that is equal or promotable to a 64-bit integer type. + + + + Creates a new . + + A new DbCaseExpression with the specified cases and default result. + A list of expressions that provide the conditional for of each case. + A list of expressions that provide the result of each case. + An expression that defines the result when no case is matched. + whenExpressions or thenExpressions is null or contains null, or elseExpression is null. + whenExpressions or thenExpressions is empty or whenExpressions contains an expression with a non-Boolean result type, or no common result type exists for all expressions in thenExpressions and elseExpression. + + + + Creates a new representing the invocation of the specified function with the given arguments. + + A new DbFunctionExpression representing the function invocation. + Metadata for the function to invoke. + A list of expressions that provide the arguments to the function. + function is null, or arguments is null or contains null. + The count of arguments does not equal the number of parameters declared by function, or arguments contains an expression that has a result type that is not equal or promotable to the corresponding function parameter type. + + + + Creates a new representing the invocation of the specified function with the given arguments. + + A new DbFunctionExpression representing the function invocation. + Metadata for the function to invoke. + Expressions that provide the arguments to the function. + function is null, or arguments is null or contains null. + The count of arguments does not equal the number of parameters declared by function, or arguments contains an expression that has a result type that is not equal or promotable to the corresponding function parameter type. + + + + Creates a new representing the application of the specified Lambda function to the given arguments. + + A new Expression representing the Lambda function application. + + A instance representing the Lambda function to apply. + + A list of expressions that provide the arguments. + lambda or arguments is null. + The count of arguments does not equal the number of variables declared by lambda, or arguments contains an expression that has a result type that is not equal or promotable to the corresponding variable type. + + + + Creates a new representing the application of the specified Lambda function to the given arguments. + + A new expression representing the Lambda function application. + + A instance representing the Lambda function to apply. + + Expressions that provide the arguments. + lambda or arguments is null. + The count of arguments does not equal the number of variables declared by lambda, or arguments contains an expression that has a result type that is not equal or promotable to the corresponding variable type. + + + + Creates a new . If the type argument is a collection type, the arguments specify the elements of the collection. Otherwise the arguments are used as property or column values in the new instance. + + A new DbNewInstanceExpression with the specified type and arguments. + The type of the new instance. + Expressions that specify values of the new instances, interpreted according to the instance's type. + instanceType or arguments is null, or arguments contains null. + arguments is empty or the result types of the contained expressions do not match the requirements of instanceType (as explained in the remarks section). + + + + Creates a new . If the type argument is a collection type, the arguments specify the elements of the collection. Otherwise the arguments are used as property or column values in the new instance. + + A new DbNewInstanceExpression with the specified type and arguments. + The type of the new instance. + Expressions that specify values of the new instances, interpreted according to the instance's type. + instanceType or arguments is null, or arguments contains null. + arguments is empty or the result types of the contained expressions do not match the requirements of instanceType (as explained in the remarks section). + + + + Creates a new that constructs a collection containing the specified elements. The type of the collection is based on the common type of the elements. If no common element type exists an exception is thrown. + + A new DbNewInstanceExpression with the specified collection type and arguments. + A list of expressions that provide the elements of the collection. + elements is null, or contains null. + elements is empty or contains expressions for which no common result type exists. + + + + Creates a new that constructs a collection containing the specified elements. The type of the collection is based on the common type of the elements. If no common element type exists an exception is thrown. + + A new DbNewInstanceExpression with the specified collection type and arguments. + A list of expressions that provide the elements of the collection. + elements is null, or contains null.. + elements is empty or contains expressions for which no common result type exists. + + + + Creates a new that constructs an empty collection of the specified collection type. + + A new DbNewInstanceExpression with the specified collection type and an empty Arguments list. + The type metadata for the collection to create + collectionType is null. + collectionType is not a collection type. + + + + Creates a new that produces a row with the specified named columns and the given values, specified as expressions. + + A new DbNewInstanceExpression that represents the construction of the row. + A list of string-DbExpression key-value pairs that defines the structure and values of the row. + columnValues is null or contains an element with a null column name or expression. + columnValues is empty, or contains a duplicate or invalid column name. + + + + Creates a new representing the retrieval of the specified property. + + A new DbPropertyExpression representing the property retrieval. + The instance from which to retrieve the property. May be null if the property is static. + Metadata for the property to retrieve. + propertyMetadata is null or instance is null and the property is not static. + + + + Creates a new representing the retrieval of the specified navigation property. + + A new DbPropertyExpression representing the navigation property retrieval. + The instance from which to retrieve the navigation property. + Metadata for the navigation property to retrieve. + navigationProperty or instance is null. + + + + Creates a new representing the retrieval of the specified relationship end member. + + A new DbPropertyExpression representing the relationship end member retrieval. + The instance from which to retrieve the relationship end member. + Metadata for the relationship end member to retrieve. + relationshipEnd is null or instance is null and the property is not static. + + + + Creates a new representing the retrieval of the instance property with the specified name from the given instance. + + A new DbPropertyExpression that represents the property retrieval. + The instance from which to retrieve the property. + The name of the property to retrieve. + propertyName is null or instance is null and the property is not static. + No property with the specified name is declared by the type of instance. + + + + Creates a new representing setting a property to a value. + + The property to be set. + The value to set the property to. + The newly created set clause. + + + + Creates a new that determines whether the given predicate holds for all elements of the input set. + + A new DbQuantifierExpression that represents the All operation. + An expression that specifies the input set. + A method representing a predicate to evaluate for each member of the input set. This method must produce an expression with a Boolean result type that provides the predicate logic. + source or predicate is null. + The expression produced by predicate is null. + source does not have a collection result type. + The expression produced by Predicate does not have a Boolean result type. + + + + Creates a new that determines whether the specified set argument is non-empty. + + + A new applied to a new + + with the specified argument. + + An expression that specifies the input set. + source is null. + source does not have a collection result type. + + + + Creates a new that determines whether the specified set argument is non-empty. + + + A new applied to a new + + with the specified argument. + + An expression that specifies the input set. + argument is null. + argument does not have a collection result type. + + + + Creates a new that determines whether the given predicate holds for any element of the input set. + + A new DbQuantifierExpression that represents the Any operation. + An expression that specifies the input set. + A method representing the predicate to evaluate for each member of the input set. This method must produce an expression with a Boolean result type that provides the predicate logic. + source or predicate is null. + The expression produced by predicate is null. + source does not have a collection result type. + The expression produced by predicate does not have a Boolean result type. + + + + Creates a new that evaluates the given apply expression once for each element of a given input set, producing a collection of rows with corresponding input and apply columns. Rows for which apply evaluates to an empty set are not included. + + + An new DbApplyExpression with the specified input and apply bindings and an + + of CrossApply. + + + A that specifies the input set. + + A method that specifies the logic to evaluate once for each member of the input set. + source or apply is null. + source does not have a collection result type. + The result of apply contains a name or expression that is null. + The result of apply contains a name or expression that is not valid in an expression binding. + + + + Creates a new that evaluates the given apply expression once for each element of a given input set, producing a collection of rows with corresponding input and apply columns. Rows for which apply evaluates to an empty set have an apply column value of null. + + + An new DbApplyExpression with the specified input and apply bindings and an + + of OuterApply. + + + A that specifies the input set. + + A method that specifies the logic to evaluate once for each member of the input set. + source or apply is null. + Source does not have a collection result type. + The result of apply contains a name or expression that is null. + The result of apply contains a name or expression that is not valid in an expression binding. + + + + Creates a new that joins the sets specified by the left and right expressions, on the specified join condition, using FullOuterJoin as the + + . + + + A new DbJoinExpression, with an of FullOuterJoin, that represents the full outer join operation applied to the left and right input sets under the given join condition. + + + A that specifies the left set argument. + + + A that specifies the right set argument. + + A method representing the condition on which to join. This method must produce an expression with a Boolean result type that provides the logic of the join condition. + left, right or joinCondition is null. + left or right does not have a collection result type. + The expression produced by joinCondition is null. + The expression produced by joinCondition does not have a Boolean result type. + + + + Creates a new that joins the sets specified by the left and right expressions, on the specified join condition, using InnerJoin as the + + . + + + A new DbJoinExpression, with an of InnerJoin, that represents the inner join operation applied to the left and right input sets under the given join condition. + + + A that specifies the left set argument. + + + A that specifies the right set argument. + + A method representing the condition on which to join. This method must produce an expression with a Boolean result type that provides the logic of the join condition. + left, right or joinCondition is null. + left or right does not have a collection result type. + The expression produced by joinCondition is null. + The expression produced by joinCondition does not have a Boolean result type. + + + + Creates a new that joins the sets specified by the left and right expressions, on the specified join condition, using LeftOuterJoin as the + + . + + + A new DbJoinExpression, with an of LeftOuterJoin, that represents the left outer join operation applied to the left and right input sets under the given join condition. + + + A that specifies the left set argument. + + + A that specifies the right set argument. + + A method representing the condition on which to join. This method must produce an expression with a Boolean result type that provides the logic of the join condition. + left, right or joinCondition is null. + left or right does not have a collection result type. + The expression produced by joinCondition is null. + The expression produced by joinCondition does not have a Boolean result type. + + + + Creates a new that joins the sets specified by the outer and inner expressions, on an equality condition between the specified outer and inner keys, using InnerJoin as the + + . + + + A new DbJoinExpression, with an of InnerJoin, that represents the inner join operation applied to the left and right input sets under a join condition that compares the outer and inner key values for equality. + + + A that specifies the outer set argument. + + + A that specifies the inner set argument. + + A method that specifies how the outer key value should be derived from an element of the outer set. + A method that specifies how the inner key value should be derived from an element of the inner set. + outer, inner, outerKey or innerKey is null. + outer or inner does not have a collection result type. + The expression produced by outerKey or innerKey is null. + The expressions produced by outerKey and innerKey are not comparable for equality. + + + + Creates a new that projects the specified selector over the sets specified by the outer and inner expressions, joined on an equality condition between the specified outer and inner keys, using InnerJoin as the + + . + + + A new DbProjectExpression with the specified selector as its projection, and a new DbJoinExpression as its input. The input DbJoinExpression is created with an + + of InnerJoin, that represents the inner join operation applied to the left and right input sets under a join condition that compares the outer and inner key values for equality. + + + A that specifies the outer set argument. + + + A that specifies the inner set argument. + + A method that specifies how the outer key value should be derived from an element of the outer set. + A method that specifies how the inner key value should be derived from an element of the inner set. + + A method that specifies how an element of the result set should be derived from elements of the inner and outer sets. This method must produce an instance of a type that is compatible with Join and can be resolved into a + + . Compatibility requirements for TSelector are described in remarks. + + The type of the selector . + outer, inner, outerKey, innerKey or selector is null. + outer or inner does not have a collection result type. + The expression produced by outerKey or innerKey is null. + The result of selector is null after conversion to DbExpression. + The expressions produced by outerKey and innerKey is not comparable for equality. + The result of Selector is not compatible with SelectMany. + + + + Creates a new that sorts the given input set by the specified sort key, with ascending sort order and default collation. + + A new DbSortExpression that represents the order-by operation. + An expression that specifies the input set. + A method that specifies how to derive the sort key expression given a member of the input set. This method must produce an expression with an order-comparable result type that provides the sort key definition. + source or sortKey is null. + The expression produced by sortKey is null. + source does not have a collection result type. + The expression produced by sortKey does not have an order-comparable result type. + + + + Creates a new that sorts the given input set by the specified sort key, with ascending sort order and the specified collation. + + A new DbSortExpression that represents the order-by operation. + An expression that specifies the input set. + A method that specifies how to derive the sort key expression given a member of the input set. This method must produce an expression with an order-comparable result type that provides the sort key definition. + The collation to sort under. + source, sortKey or collation is null. + The expression produced by sortKey is null. + source does not have a collection result type. + The expression produced by sortKey does not have an order-comparable string result type. + collation is empty or contains only space characters. + + + + Creates a new that sorts the given input set by the specified sort key, with descending sort order and default collation. + + A new DbSortExpression that represents the order-by operation. + An expression that specifies the input set. + A method that specifies how to derive the sort key expression given a member of the input set. This method must produce an expression with an order-comparable result type that provides the sort key definition. + source or sortKey is null. + The expression produced by sortKey is null. + source does not have a collection result type. + The expression produced by sortKey does not have an order-comparable result type. + + + + Creates a new that sorts the given input set by the specified sort key, with descending sort order and the specified collation. + + A new DbSortExpression that represents the order-by operation. + An expression that specifies the input set. + A method that specifies how to derive the sort key expression given a member of the input set. This method must produce an expression with an order-comparable result type that provides the sort key definition. + The collation to sort under. + source, sortKey or collation is null. + The expression produced by sortKey is null. + source does not have a collection result type. + The expression produced by sortKey does not have an order-comparable string result type. + collation is empty or contains only space characters. + + + + Creates a new that selects the specified expression over the given input set. + + A new DbProjectExpression that represents the select operation. + An expression that specifies the input set. + + A method that specifies how to derive the projected expression given a member of the input set. This method must produce an instance of a type that is compatible with Select and can be resolved into a + + . Compatibility requirements for TProjection are described in remarks. + + The method result type of projection. + source or projection is null. + The result of projection is null. + + + + Creates a new that evaluates the given apply expression once for each element of a given input set, producing a collection of rows with corresponding input and apply columns. Rows for which apply evaluates to an empty set are not included. A + + is then created that selects the apply column from each row, producing the overall collection of apply results. + + + An new DbProjectExpression that selects the apply column from a new DbApplyExpression with the specified input and apply bindings and an + + of CrossApply. + + + A that specifies the input set. + + A method that represents the logic to evaluate once for each member of the input set. + source or apply is null. + The expression produced by apply is null. + source does not have a collection result type. + The expression produced by apply does not have a collection type. + + + + Creates a new that evaluates the given apply expression once for each element of a given input set, producing a collection of rows with corresponding input and apply columns. Rows for which apply evaluates to an empty set are not included. A + + is then created that selects the specified selector over each row, producing the overall collection of results. + + + An new DbProjectExpression that selects the result of the given selector from a new DbApplyExpression with the specified input and apply bindings and an + + of CrossApply. + + + A that specifies the input set. + + A method that represents the logic to evaluate once for each member of the input set. + + A method that specifies how an element of the result set should be derived given an element of the input and apply sets. This method must produce an instance of a type that is compatible with SelectMany and can be resolved into a + + . Compatibility requirements for TSelector are described in remarks. + + The method result type of selector. + source, apply or selector is null. + The expression produced by apply is null. + The result of selector is null on conversion to DbExpression. + source does not have a collection result type. + The expression produced by apply does not have a collection type. does not have a collection type. + + + + Creates a new that skips the specified number of elements from the given sorted input set. + + A new DbSkipExpression that represents the skip operation. + + A that specifies the sorted input set. + + An expression the specifies how many elements of the ordered set to skip. + argument or count is null. + + count is not or + + or has a result type that is not equal or promotable to a 64-bit integer type. + + + + + Creates a new that restricts the number of elements in the Argument collection to the specified count Limit value. Tied results are not included in the output. + + A new DbLimitExpression with the specified argument and count limit values that does not include tied results. + An expression that specifies the input collection. + An expression that specifies the limit value. + argument or count is null. + argument does not have a collection result type, count does not have a result type that is equal or promotable to a 64-bit integer type. + + + + Creates a new that with a sort order that includes the sort order of the given order input set together with the specified sort key in ascending sort order and with default collation. + + A new DbSortExpression that represents the new overall order-by operation. + A DbSortExpression that specifies the ordered input set. + A method that specifies how to derive the additional sort key expression given a member of the input set. This method must produce an expression with an order-comparable result type that provides the sort key definition. + source or sortKey is null. + The expression produced by sortKey is null. + source does not have a collection result type. + sortKey does not have an order-comparable result type. + + + + Creates a new that with a sort order that includes the sort order of the given order input set together with the specified sort key in ascending sort order and with the specified collation. + + A new DbSortExpression that represents the new overall order-by operation. + A DbSortExpression that specifies the ordered input set. + A method that specifies how to derive the additional sort key expression given a member of the input set. This method must produce an expression with an order-comparable result type that provides the sort key definition. + The collation to sort under. + source, sortKey or collation is null. + The expression produced by sortKey is null. + source does not have a collection result type. + The expression produced by sortKey does not have an order-comparable string result type. + collation is empty or contains only space characters. + + + + Creates a new that with a sort order that includes the sort order of the given order input set together with the specified sort key in descending sort order and with default collation. + + A new DbSortExpression that represents the new overall order-by operation. + A DbSortExpression that specifies the ordered input set. + A method that specifies how to derive the additional sort key expression given a member of the input set. This method must produce an expression with an order-comparable result type that provides the sort key definition. + source or sortKey is null. + The expression produced by sortKey is null. + source does not have a collection result type. + The expression produced by sortKey does not have an order-comparable result type. + + + + Creates a new that with a sort order that includes the sort order of the given order input set together with the specified sort key in descending sort order and with the specified collation. + + A new DbSortExpression that represents the new overall order-by operation. + A DbSortExpression that specifies the ordered input set. + A method that specifies how to derive the additional sort key expression given a member of the input set. This method must produce an expression with an order-comparable result type that provides the sort key definition. + The collation to sort under. + source, sortKey or collation is null. + The expression produced by sortKey is null. + source does not have a collection result type. + The expression produced by sortKey does not have an order-comparable string result type. + collation is empty or contains only space characters. + + + + Creates a new that filters the elements in the given input set using the specified predicate. + + A new DbQuantifierExpression that represents the Any operation. + An expression that specifies the input set. + A method representing the predicate to evaluate for each member of the input set. This method must produce an expression with a Boolean result type that provides the predicate logic. + source or predicate is null. + The expression produced by predicate is null. + The expression produced by predicate does not have a Boolean result type. + + + + Creates a new that computes the union of the left and right set arguments with duplicates removed. + + A new DbExpression that computes the union, without duplicates, of the the left and right arguments. + An expression that defines the left set argument. + An expression that defines the right set argument. + left or right is null. + No common collection result type with an equality-comparable element type exists between left and right. + + + + Gets a with the Boolean value true. + + + A with the Boolean value true. + + + + + Gets a with the Boolean value false. + + + A with the Boolean value false. + + + + + Provides an API to construct s that invoke canonical EDM functions, and allows that API to be accessed as extension methods on the expression type itself. + + + + + Creates a that invokes the canonical 'Avg' function over the specified collection. The result type of the expression is the same as the element type of the collection. + + A new DbFunctionExpression that produces the average value. + An expression that specifies the collection from which the average value should be computed. + + + + Creates a that invokes the canonical 'Count' function over the specified collection. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that produces the count value. + An expression that specifies the collection over which the count value should be computed. + + + + Creates a that invokes the canonical 'BigCount' function over the specified collection. The result type of the expression is Edm.Int64. + + A new DbFunctionExpression that produces the count value. + An expression that specifies the collection over which the count value should be computed. + + + + Creates a that invokes the canonical 'Max' function over the specified collection. The result type of the expression is the same as the element type of the collection. + + A new DbFunctionExpression that produces the maximum value. + An expression that specifies the collection from which the maximum value should be retrieved + + + + Creates a that invokes the canonical 'Min' function over the specified collection. The result type of the expression is the same as the element type of the collection. + + A new DbFunctionExpression that produces the minimum value. + An expression that specifies the collection from which the minimum value should be retrieved. + + + + Creates a that invokes the canonical 'Sum' function over the specified collection. The result type of the expression is the same as the element type of the collection. + + A new DbFunctionExpression that produces the sum. + An expression that specifies the collection from which the sum should be computed. + + + + Creates a that invokes the canonical 'StDev' function over the non-null members of the specified collection. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that produces the standard deviation value over non-null members of the collection. + An expression that specifies the collection for which the standard deviation should be computed. + + + + Creates a that invokes the canonical 'StDevP' function over the population of the specified collection. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that produces the standard deviation value. + An expression that specifies the collection for which the standard deviation should be computed. + + + + Creates a that invokes the canonical 'Var' function over the non-null members of the specified collection. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that produces the statistical variance value for the non-null members of the collection. + An expression that specifies the collection for which the statistical variance should be computed. + + + + Creates a that invokes the canonical 'VarP' function over the population of the specified collection. The result type of the expression Edm.Double. + + A new DbFunctionExpression that produces the statistical variance value. + An expression that specifies the collection for which the statistical variance should be computed. + + + + Creates a that invokes the canonical 'Concat' function with the specified arguments, which must each have a string result type. The result type of the expression is string. + + A new DbFunctionExpression that produces the concatenated string. + An expression that specifies the string that should appear first in the concatenated result string. + An expression that specifies the string that should appear second in the concatenated result string. + + + + Creates a that invokes the canonical 'Contains' function with the specified arguments, which must each have a string result type. The result type of the expression is Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether or not searchedForString occurs within searchedString. + An expression that specifies the string to search for any occurence of searchedForString. + An expression that specifies the string to search for in searchedString. + + + + Creates a that invokes the canonical 'EndsWith' function with the specified arguments, which must each have a string result type. The result type of the expression is Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether or not stringArgument ends with suffix. + An expression that specifies the string that is searched at the end for string suffix. + An expression that specifies the target string that is searched for at the end of stringArgument. + + + + Creates a that invokes the canonical 'IndexOf' function with the specified arguments, which must each have a string result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the first index of stringToFind in searchString. + An expression that specifies the string to search for stringToFind. + An expression that specifies the string to locate within searchString should be checked. + + + + Creates a that invokes the canonical 'Left' function with the specified arguments, which must have a string and integer numeric result type. The result type of the expression is string. + + A new DbFunctionExpression that returns the the leftmost substring of length length from stringArgument. + An expression that specifies the string from which to extract the leftmost substring. + An expression that specifies the length of the leftmost substring to extract from stringArgument. + + + + Creates a that invokes the canonical 'Length' function with the specified argument, which must have a string result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the length of stringArgument. + An expression that specifies the string for which the length should be computed. + + + + Creates a that invokes the canonical 'Replace' function with the specified arguments, which must each have a string result type. The result type of the expression is also string. + + A new DbFunctionExpression than returns a new string based on stringArgument where every occurence of toReplace is replaced by replacement. + An expression that specifies the string in which to perform the replacement operation. + An expression that specifies the string that is replaced. + An expression that specifies the replacement string. + + + + Creates a that invokes the canonical 'Reverse' function with the specified argument, which must have a string result type. The result type of the expression is also string. + + A new DbFunctionExpression that produces the reversed value of stringArgument. + An expression that specifies the string to reverse. + + + + Creates a that invokes the canonical 'Right' function with the specified arguments, which must have a string and integer numeric result type. The result type of the expression is string. + + A new DbFunctionExpression that returns the the rightmost substring of length length from stringArgument. + An expression that specifies the string from which to extract the rightmost substring. + An expression that specifies the length of the rightmost substring to extract from stringArgument. + + + + Creates a that invokes the canonical 'StartsWith' function with the specified arguments, which must each have a string result type. The result type of the expression is Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether or not stringArgument starts with prefix. + An expression that specifies the string that is searched at the start for string prefix. + An expression that specifies the target string that is searched for at the start of stringArgument. + + + + Creates a that invokes the canonical 'Substring' function with the specified arguments, which must have a string and integer numeric result types. The result type of the expression is string. + + A new DbFunctionExpression that returns the substring of length length from stringArgument starting at start. + An expression that specifies the string from which to extract the substring. + An expression that specifies the starting index from which the substring should be taken. + An expression that specifies the length of the substring. + + + + Creates a that invokes the canonical 'ToLower' function with the specified argument, which must have a string result type. The result type of the expression is also string. + + A new DbFunctionExpression that returns value of stringArgument converted to lower case. + An expression that specifies the string that should be converted to lower case. + + + + Creates a that invokes the canonical 'ToUpper' function with the specified argument, which must have a string result type. The result type of the expression is also string. + + A new DbFunctionExpression that returns value of stringArgument converted to upper case. + An expression that specifies the string that should be converted to upper case. + + + + Creates a that invokes the canonical 'Trim' function with the specified argument, which must have a string result type. The result type of the expression is also string. + + A new DbFunctionExpression that returns value of stringArgument with leading and trailing space removed. + An expression that specifies the string from which leading and trailing space should be removed. + + + + Creates a that invokes the canonical 'RTrim' function with the specified argument, which must have a string result type. The result type of the expression is also string. + + A new DbFunctionExpression that returns value of stringArgument with trailing space removed. + An expression that specifies the string from which trailing space should be removed. + + + + Creates a that invokes the canonical 'LTrim' function with the specified argument, which must have a string result type. The result type of the expression is also string. + + A new DbFunctionExpression that returns value of stringArgument with leading space removed. + An expression that specifies the string from which leading space should be removed. + + + + Creates a that invokes the canonical 'Year' function with the specified argument, which must have a DateTime or DateTimeOffset result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the integer year value from dateValue. + An expression that specifies the value from which the year should be retrieved. + + + + Creates a that invokes the canonical 'Month' function with the specified argument, which must have a DateTime or DateTimeOffset result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the integer month value from dateValue. + An expression that specifies the value from which the month should be retrieved. + + + + Creates a that invokes the canonical 'Day' function with the specified argument, which must have a DateTime or DateTimeOffset result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the integer day value from dateValue. + An expression that specifies the value from which the day should be retrieved. + + + + Creates a that invokes the canonical 'DayOfYear' function with the specified argument, which must have a DateTime or DateTimeOffset result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the integer day of year value from dateValue. + An expression that specifies the value from which the day within the year should be retrieved. + + + + Creates a that invokes the canonical 'Hour' function with the specified argument, which must have a DateTime, DateTimeOffset or Time result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the integer hour value from timeValue. + An expression that specifies the value from which the hour should be retrieved. + + + + Creates a that invokes the canonical 'Minute' function with the specified argument, which must have a DateTime, DateTimeOffset or Time result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the integer minute value from timeValue. + An expression that specifies the value from which the minute should be retrieved. + + + + Creates a that invokes the canonical 'Second' function with the specified argument, which must have a DateTime, DateTimeOffset or Time result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the integer second value from timeValue. + An expression that specifies the value from which the second should be retrieved. + + + + Creates a that invokes the canonical 'Millisecond' function with the specified argument, which must have a DateTime, DateTimeOffset or Time result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the integer millisecond value from timeValue. + An expression that specifies the value from which the millisecond should be retrieved. + + + + Creates a that invokes the canonical 'GetTotalOffsetMinutes' function with the specified argument, which must have a DateTimeOffset result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the number of minutes dateTimeOffsetArgument is offset from GMT. + An expression that specifies the DateTimeOffset value from which the minute offset from GMT should be retrieved. + + + + Creates a that invokes the canonical 'CurrentDateTime' function. + + A new DbFunctionExpression that returns the current date and time as an Edm.DateTime instance. + + + + Creates a that invokes the canonical 'CurrentDateTimeOffset' function. + + A new DbFunctionExpression that returns the current date and time as an Edm.DateTimeOffset instance. + + + + Creates a that invokes the canonical 'CurrentUtcDateTime' function. + + A new DbFunctionExpression that returns the current UTC date and time as an Edm.DateTime instance. + + + + Creates a that invokes the canonical 'TruncateTime' function with the specified argument, which must have a DateTime or DateTimeOffset result type. The result type of the expression is the same as the result type of dateValue. + + A new DbFunctionExpression that returns the value of dateValue with time set to zero. + An expression that specifies the value for which the time portion should be truncated. + + + + Creates a that invokes the canonical 'CreateDateTime' function with the specified arguments. second must have a result type of Edm.Double, while all other arguments must have a result type of Edm.Int32. The result type of the expression is Edm.DateTime. + + A new DbFunctionExpression that returns a new DateTime based on the specified values. + An expression that provides the year value for the new DateTime instance. + An expression that provides the month value for the new DateTime instance. + An expression that provides the day value for the new DateTime instance. + An expression that provides the hour value for the new DateTime instance. + An expression that provides the minute value for the new DateTime instance. + An expression that provides the second value for the new DateTime instance. + + + + Creates a that invokes the canonical 'CreateDateTimeOffset' function with the specified arguments. second must have a result type of Edm.Double, while all other arguments must have a result type of Edm.Int32. The result type of the expression is Edm.DateTimeOffset. + + A new DbFunctionExpression that returns a new DateTimeOffset based on the specified values. + An expression that provides the year value for the new DateTimeOffset instance. + An expression that provides the month value for the new DateTimeOffset instance. + An expression that provides the day value for the new DateTimeOffset instance. + An expression that provides the hour value for the new DateTimeOffset instance. + An expression that provides the minute value for the new DateTimeOffset instance. + An expression that provides the second value for the new DateTimeOffset instance. + An expression that provides the number of minutes in the time zone offset value for the new DateTimeOffset instance. + + + + Creates a that invokes the canonical 'CreateTime' function with the specified arguments. second must have a result type of Edm.Double, while all other arguments must have a result type of Edm.Int32. The result type of the expression is Edm.Time. + + A new DbFunctionExpression that returns a new Time based on the specified values. + An expression that provides the hour value for the new DateTime instance. + An expression that provides the minute value for the new DateTime instance. + An expression that provides the second value for the new DateTime instance. + + + + Creates a that invokes the canonical 'AddYears' function with the specified arguments, which must have DateTime or DateTimeOffset and integer result types. The result type of the expression is the same as the result type of dateValue. + + A new DbFunctionExpression that adds the number of years specified by addValue to the value specified by dateValue. + An expression that specifies the value to which addValueshould be added. + An expression that specifies the number of years to add to dateValue. + + + + Creates a that invokes the canonical 'AddMonths' function with the specified arguments, which must have DateTime or DateTimeOffset and integer result types. The result type of the expression is the same as the result type of dateValue. + + A new DbFunctionExpression that adds the number of months specified by addValue to the value specified by dateValue. + An expression that specifies the value to which addValueshould be added. + An expression that specifies the number of months to add to dateValue. + + + + Creates a that invokes the canonical 'AddDays' function with the specified arguments, which must have DateTime or DateTimeOffset and integer result types. The result type of the expression is the same as the result type of dateValue. + + A new DbFunctionExpression that adds the number of days specified by addValue to the value specified by dateValue. + An expression that specifies the value to which addValueshould be added. + An expression that specifies the number of days to add to dateValue. + + + + Creates a that invokes the canonical 'AddHours' function with the specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result type of the expression is the same as the result type of timeValue. + + A new DbFunctionExpression that adds the number of hours specified by addValue to the value specified by timeValue. + An expression that specifies the value to which addValueshould be added. + An expression that specifies the number of hours to add to timeValue. + + + + Creates a that invokes the canonical 'AddMinutes' function with the specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result type of the expression is the same as the result type of timeValue. + + A new DbFunctionExpression that adds the number of minutes specified by addValue to the value specified by timeValue. + An expression that specifies the value to which addValueshould be added. + An expression that specifies the number of minutes to add to timeValue. + + + + Creates a that invokes the canonical 'AddSeconds' function with the specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result type of the expression is the same as the result type of timeValue. + + A new DbFunctionExpression that adds the number of seconds specified by addValue to the value specified by timeValue. + An expression that specifies the value to which addValueshould be added. + An expression that specifies the number of seconds to add to timeValue. + + + + Creates a that invokes the canonical 'AddMilliseconds' function with the specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result type of the expression is the same as the result type of timeValue. + + A new DbFunctionExpression that adds the number of milliseconds specified by addValue to the value specified by timeValue. + An expression that specifies the value to which addValueshould be added. + An expression that specifies the number of milliseconds to add to timeValue. + + + + Creates a that invokes the canonical 'AddMicroseconds' function with the specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result type of the expression is the same as the result type of timeValue. + + A new DbFunctionExpression that adds the number of microseconds specified by addValue to the value specified by timeValue. + An expression that specifies the value to which addValueshould be added. + An expression that specifies the number of microseconds to add to timeValue. + + + + Creates a that invokes the canonical 'AddNanoseconds' function with the specified arguments, which must have DateTime, DateTimeOffset or Time, and integer result types. The result type of the expression is the same as the result type of timeValue. + + A new DbFunctionExpression that adds the number of nanoseconds specified by addValue to the value specified by timeValue. + An expression that specifies the value to which addValueshould be added. + An expression that specifies the number of nanoseconds to add to timeValue. + + + + Creates a that invokes the canonical 'DiffYears' function with the specified arguments, which must each have DateTime or DateTimeOffset result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the number of years that is the difference between dateValue1 and dateValue2. + An expression that specifies the first date value argument. + An expression that specifies the second date value argument. + + + + Creates a that invokes the canonical 'DiffMonths' function with the specified arguments, which must each have DateTime or DateTimeOffset result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the number of months that is the difference between dateValue1 and dateValue2. + An expression that specifies the first date value argument. + An expression that specifies the second date value argument. + + + + Creates a that invokes the canonical 'DiffDays' function with the specified arguments, which must each have DateTime or DateTimeOffset result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the number of days that is the difference between dateValue1 and dateValue2. + An expression that specifies the first date value argument. + An expression that specifies the second date value argument. + + + + Creates a that invokes the canonical 'DiffHours' function with the specified arguments, which must each have DateTime, DateTimeOffset or Time result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the number of hours that is the difference between timeValue1 and timeValue2. + An expression that specifies the first time value argument. + An expression that specifies the second time value argument. + + + + Creates a that invokes the canonical 'DiffMinutes' function with the specified arguments, which must each have DateTime, DateTimeOffset or Time result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the number of minutes that is the difference between timeValue1 and timeValue2. + An expression that specifies the first time value argument. + An expression that specifies the second time value argument. + + + + Creates a that invokes the canonical 'DiffSeconds' function with the specified arguments, which must each have DateTime, DateTimeOffset or Time result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the number of seconds that is the difference between timeValue1 and timeValue2. + An expression that specifies the first time value argument. + An expression that specifies the second time value argument. + + + + Creates a that invokes the canonical 'DiffMilliseconds' function with the specified arguments, which must each have DateTime, DateTimeOffset or Time result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the number of milliseconds that is the difference between timeValue1 and timeValue2. + An expression that specifies the first time value argument. + An expression that specifies the second time value argument. + + + + Creates a that invokes the canonical 'DiffMicroseconds' function with the specified arguments, which must each have DateTime, DateTimeOffset or Time result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the number of microseconds that is the difference between timeValue1 and timeValue2. + An expression that specifies the first time value argument. + An expression that specifies the second time value argument. + + + + Creates a that invokes the canonical 'DiffNanoseconds' function with the specified arguments, which must each have DateTime, DateTimeOffset or Time result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the number of nanoseconds that is the difference between timeValue1 and timeValue2. + An expression that specifies the first time value argument. + An expression that specifies the second time value argument. + + + + Creates a that invokes the canonical 'Round' function with the specified argument, which must each have a single, double or decimal result type. The result type of the expression is the same as the result type of value. + + A new DbFunctionExpression that rounds the specified argument to the nearest integer value. + An expression that specifies the numeric value to round. + + + + Creates a that invokes the canonical 'Round' function with the specified arguments, which must have a single, double or decimal, and integer result types. The result type of the expression is the same as the result type of value. + + A new DbFunctionExpression that rounds the specified argument to the nearest integer value, with precision as specified by digits. + An expression that specifies the numeric value to round. + An expression that specifies the number of digits of precision to use when rounding. + + + + Creates a that invokes the canonical 'Floor' function with the specified argument, which must each have a single, double or decimal result type. The result type of the expression is the same as the result type of value. + + A new DbFunctionExpression that returns the largest integer value not greater than value. + An expression that specifies the numeric value. + + + + Creates a that invokes the canonical 'Ceiling' function with the specified argument, which must each have a single, double or decimal result type. The result type of the expression is the same as the result type of value. + + A new DbFunctionExpression that returns the smallest integer value not less than than value. + An expression that specifies the numeric value. + + + + Creates a that invokes the canonical 'Abs' function with the specified argument, which must each have a numeric result type. The result type of the expression is the same as the result type of value. + + A new DbFunctionExpression that returns the absolute value of value. + An expression that specifies the numeric value. + + + + Creates a that invokes the canonical 'Truncate' function with the specified arguments, which must have a single, double or decimal, and integer result types. The result type of the expression is the same as the result type of value. + + A new DbFunctionExpression that truncates the specified argument to the nearest integer value, with precision as specified by digits. + An expression that specifies the numeric value to truncate. + An expression that specifies the number of digits of precision to use when truncating. + + + + Creates a that invokes the canonical 'Power' function with the specified arguments, which must have numeric result types. The result type of the expression is the same as the result type of baseArgument. + + A new DbFunctionExpression that returns the value of baseArgument raised to the power specified by exponent. + An expression that specifies the numeric value to raise to the given power. + An expression that specifies the power to which baseArgument should be raised. + + + + Creates a that invokes the canonical 'BitwiseAnd' function with the specified arguments, which must have the same integer numeric result type. The result type of the expression is the same as the type of the arguments. + + A new DbFunctionExpression that returns the value produced by performing the bitwise AND of value1 and value2. + An expression that specifies the first operand. + An expression that specifies the second operand. + + + + Creates a that invokes the canonical 'BitwiseOr' function with the specified arguments, which must have the same integer numeric result type. The result type of the expression is the same as the type of the arguments. + + A new DbFunctionExpression that returns the value produced by performing the bitwise OR of value1 and value2. + An expression that specifies the first operand. + An expression that specifies the second operand. + + + + Creates a that invokes the canonical 'BitwiseNot' function with the specified argument, which must have an integer numeric result type. The result type of the expression is the same as the type of the arguments. + + A new DbFunctionExpression that returns the value produced by performing the bitwise NOT of value. + An expression that specifies the first operand. + + + + Creates a that invokes the canonical 'BitwiseXor' function with the specified arguments, which must have the same integer numeric result type. The result type of the expression is the same as the type of the arguments. + + A new DbFunctionExpression that returns the value produced by performing the bitwise XOR (exclusive OR) of value1 and value2. + An expression that specifies the first operand. + An expression that specifies the second operand. + + + + Creates a that invokes the canonical 'NewGuid' function. + + A new DbFunctionExpression that returns a new GUID value. + + + + Provides a constructor-like means of calling + + . + + + + + Initializes a new instance of the class with the specified first column value and optional successive column values. + + A key-value pair that provides the first column in the new row instance. (required) + A key-value pairs that provide any subsequent columns in the new row instance. (optional) + + + + Creates a new that constructs a new row based on the columns contained in this Row instance. + + A new DbNewInstanceExpression that constructs a row with the same column names and DbExpression values as this Row instance. + + + + Converts the given Row instance into an instance of + + The Row instance. + A DbExpression based on the Row instance + + + is null. + + + + + + Provides an API to construct s that invoke spatial realted canonical EDM functions, and, where appropriate, allows that API to be accessed as extension methods on the expression type itself. + + + + + Creates a that invokes the canonical 'GeometryFromText' function with the specified argument, which must have a string result type. The result type of the expression is Edm.Geometry. Its value has the default coordinate system id (SRID) of the underlying provider. + + A new DbFunctionExpression that returns a new geometry value based on the specified value. + An expression that provides the well known text representation of the geometry value. + + + + Creates a that invokes the canonical 'GeometryFromText' function with the specified arguments. wellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry value based on the specified values. + An expression that provides the well known text representation of the geometry value. + An expression that provides the coordinate system id (SRID) of the geometry value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryPointFromText' function with the specified arguments. pointWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry point value based on the specified values. + An expression that provides the well known text representation of the geometry point value. + An expression that provides the coordinate system id (SRID) of the geometry point value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryLineFromText' function with the specified arguments. lineWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry line value based on the specified values. + An expression that provides the well known text representation of the geometry line value. + An expression that provides the coordinate system id (SRID) of the geometry line value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryPolygonFromText' function with the specified arguments. polygonWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry polygon value based on the specified values. + An expression that provides the well known text representation of the geometry polygon value. + An expression that provides the coordinate system id (SRID) of the geometry polygon value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryMultiPointFromText' function with the specified arguments. multiPointWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry multi-point value based on the specified values. + An expression that provides the well known text representation of the geometry multi-point value. + An expression that provides the coordinate system id (SRID) of the geometry multi-point value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryMultiLineFromText' function with the specified arguments. multiLineWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry multi-line value based on the specified values. + An expression that provides the well known text representation of the geometry multi-line value. + An expression that provides the coordinate system id (SRID) of the geometry multi-line value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryMultiPolygonFromText' function with the specified arguments. multiPolygonWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry multi-polygon value based on the specified values. + An expression that provides the well known text representation of the geometry multi-polygon value. + An expression that provides the coordinate system id (SRID) of the geometry multi-polygon value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryCollectionFromText' function with the specified arguments. geometryCollectionWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry collection value based on the specified values. + An expression that provides the well known text representation of the geometry collection value. + An expression that provides the coordinate system id (SRID) of the geometry collection value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryFromBinary' function with the specified argument, which must have a binary result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry value based on the specified binary value. + An expression that provides the well known binary representation of the geometry value. + + + + Creates a that invokes the canonical 'GeometryFromBinary' function with the specified arguments. wellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry value based on the specified values. + An expression that provides the well known binary representation of the geometry value. + An expression that provides the coordinate system id (SRID) of the geometry value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryPointFromBinary' function with the specified arguments. pointWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry point value based on the specified values. + An expression that provides the well known binary representation of the geometry point value. + An expression that provides the coordinate system id (SRID) of the geometry point value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryLineFromBinary' function with the specified arguments. lineWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry line value based on the specified values. + An expression that provides the well known binary representation of the geometry line value. + An expression that provides the coordinate system id (SRID) of the geometry line value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryPolygonFromBinary' function with the specified arguments. polygonWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry polygon value based on the specified values. + An expression that provides the well known binary representation of the geometry polygon value. + An expression that provides the coordinate system id (SRID) of the geometry polygon value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryMultiPointFromBinary' function with the specified arguments. multiPointWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry multi-point value based on the specified values. + An expression that provides the well known binary representation of the geometry multi-point value. + An expression that provides the coordinate system id (SRID) of the geometry multi-point value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryMultiLineFromBinary' function with the specified arguments. multiLineWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry multi-line value based on the specified values. + An expression that provides the well known binary representation of the geometry multi-line value. + An expression that provides the coordinate system id (SRID) of the geometry multi-line value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryMultiPolygonFromBinary' function with the specified arguments. multiPolygonWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry multi-polygon value based on the specified values. + An expression that provides the well known binary representation of the geometry multi-polygon value. + An expression that provides the coordinate system id (SRID) of the geometry multi-polygon value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryCollectionFromBinary' function with the specified arguments. geometryCollectionWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry collection value based on the specified values. + An expression that provides the well known binary representation of the geometry collection value. + An expression that provides the coordinate system id (SRID) of the geometry collection value's coordinate system. + + + + Creates a that invokes the canonical 'GeometryFromGml' function with the specified argument, which must have a string result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry value based on the specified value with the default coordinate system id (SRID) of the underlying provider. + An expression that provides the Geography Markup Language (GML) representation of the geometry value. + + + + Creates a that invokes the canonical 'GeometryFromGml' function with the specified arguments. geometryMarkup must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a new geometry value based on the specified values. + An expression that provides the Geography Markup Language (GML) representation of the geometry value. + An expression that provides the coordinate system id (SRID) of the geometry value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyFromText' function with the specified argument, which must have a string result type. The result type of the expression is Edm.Geography. Its value has the default coordinate system id (SRID) of the underlying provider. + + A new DbFunctionExpression that returns a new geography value based on the specified value. + An expression that provides the well known text representation of the geography value. + + + + Creates a that invokes the canonical 'GeographyFromText' function with the specified arguments. wellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography value based on the specified values. + An expression that provides the well known text representation of the geography value. + An expression that provides the coordinate system id (SRID) of the geography value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyPointFromText' function with the specified arguments. + + The canonical 'GeographyPointFromText' function. + An expression that provides the well-known text representation of the geography point value. + An expression that provides the coordinate system id (SRID) of the geography point value's coordinate systempointWellKnownTextValue. + + + + Creates a that invokes the canonical 'GeographyLineFromText' function with the specified arguments. lineWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography line value based on the specified values. + An expression that provides the well known text representation of the geography line value. + An expression that provides the coordinate system id (SRID) of the geography line value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyPolygonFromText' function with the specified arguments. polygonWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography polygon value based on the specified values. + An expression that provides the well known text representation of the geography polygon value. + An expression that provides the coordinate system id (SRID) of the geography polygon value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyMultiPointFromText' function with the specified arguments. multiPointWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography multi-point value based on the specified values. + An expression that provides the well known text representation of the geography multi-point value. + An expression that provides the coordinate system id (SRID) of the geography multi-point value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyMultiLineFromText' function with the specified arguments. multiLineWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography multi-line value based on the specified values. + An expression that provides the well known text representation of the geography multi-line value. + An expression that provides the coordinate system id (SRID) of the geography multi-line value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyMultiPolygonFromText' function with the specified arguments. multiPolygonWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography multi-polygon value based on the specified values. + An expression that provides the well known text representation of the geography multi-polygon value. + An expression that provides the coordinate system id (SRID) of the geography multi-polygon value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyCollectionFromText' function with the specified arguments. geographyCollectionWellKnownText must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography collection value based on the specified values. + An expression that provides the well known text representation of the geography collection value. + An expression that provides the coordinate system id (SRID) of the geography collection value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyFromBinary' function with the specified argument, which must have a binary result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography value based on the specified binary value. + An expression that provides the well known binary representation of the geography value. + + + + Creates a that invokes the canonical 'GeographyFromBinary' function with the specified arguments. wellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography value based on the specified values. + An expression that provides the well known binary representation of the geography value. + An expression that provides the coordinate system id (SRID) of the geography value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyPointFromBinary' function with the specified arguments. pointWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography point value based on the specified values. + An expression that provides the well known binary representation of the geography point value. + An expression that provides the coordinate system id (SRID) of the geography point value's coordinate systempointWellKnownBinaryValue. + + + + Creates a that invokes the canonical 'GeographyLineFromBinary' function with the specified arguments. lineWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography line value based on the specified values. + An expression that provides the well known binary representation of the geography line value. + An expression that provides the coordinate system id (SRID) of the geography line value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyPolygonFromBinary' function with the specified arguments. polygonWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography polygon value based on the specified values. + An expression that provides the well known binary representation of the geography polygon value. + An expression that provides the coordinate system id (SRID) of the geography polygon value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyMultiPointFromBinary' function with the specified arguments. multiPointWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography multi-point value based on the specified values. + An expression that provides the well known binary representation of the geography multi-point value. + An expression that provides the coordinate system id (SRID) of the geography multi-point value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyMultiLineFromBinary' function with the specified arguments. multiLineWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography multi-line value based on the specified values. + An expression that provides the well known binary representation of the geography multi-line value. + An expression that provides the coordinate system id (SRID) of the geography multi-line value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyMultiPolygonFromBinary' function with the specified arguments. multiPolygonWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography multi-polygon value based on the specified values. + An expression that provides the well known binary representation of the geography multi-polygon value. + An expression that provides the coordinate system id (SRID) of the geography multi-polygon value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyCollectionFromBinary' function with the specified arguments. geographyCollectionWellKnownBinaryValue must have a binary result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography collection value based on the specified values. + An expression that provides the well known binary representation of the geography collection value. + An expression that provides the coordinate system id (SRID) of the geography collection value's coordinate system. + + + + Creates a that invokes the canonical 'GeographyFromGml' function with the specified argument, which must have a string result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography value based on the specified value with the default coordinate system id (SRID) of the underlying provider. + An expression that provides the Geography Markup Language (GML) representation of the geography value. + + + + Creates a that invokes the canonical 'GeographyFromGml' function with the specified arguments. geographyMarkup must have a string result type, while coordinateSystemId must have an integer numeric result type. The result type of the expression is Edm.Geography. + + A new DbFunctionExpression that returns a new geography value based on the specified values. + An expression that provides the Geography Markup Language (GML) representation of the geography value. + An expression that provides the coordinate system id (SRID) of the geography value's coordinate system. + + + + Creates a that invokes the canonical 'CoordinateSystemId' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the integer SRID value from spatialValue. + An expression that specifies the value from which the coordinate system id (SRID) should be retrieved. + + + + Creates a that invokes the canonical 'SpatialTypeName' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.String. + + A new DbFunctionExpression that returns the string Geometry Type name from spatialValue. + An expression that specifies the value from which the Geometry Type name should be retrieved. + + + + Creates a that invokes the canonical 'SpatialDimension' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns the Dimension value from spatialValue. + An expression that specifies the value from which the Dimension value should be retrieved. + + + + Creates a that invokes the canonical 'SpatialEnvelope' function with the specified argument, which must have an Edm.Geometry result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns the the minimum bounding box for geometryValue. + An expression that specifies the value from which the Envelope value should be retrieved. + + + + Creates a that invokes the canonical 'AsBinary' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.Binary. + + A new DbFunctionExpression that returns the well known binary representation of spatialValue. + An expression that specifies the spatial value from which the well known binary representation should be produced. + + + + Creates a that invokes the canonical 'AsGml' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.String. + + A new DbFunctionExpression that returns the Geography Markup Language (GML) representation of spatialValue. + An expression that specifies the spatial value from which the Geography Markup Language (GML) representation should be produced. + + + + Creates a that invokes the canonical 'AsText' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.String. + + A new DbFunctionExpression that returns the well known text representation of spatialValue. + An expression that specifies the spatial value from which the well known text representation should be produced. + + + + Creates a that invokes the canonical 'IsEmptySpatial' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether spatialValue is empty. + An expression that specifies the spatial value from which the IsEmptySptiaal value should be retrieved. + + + + Creates a that invokes the canonical 'IsSimpleGeometry' function with the specified argument, which must have an Edm.Geometry result type. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether geometryValue is a simple geometry. + The geometry value. + + + + Creates a that invokes the canonical 'SpatialBoundary' function with the specified argument, which must have an Edm.Geometry result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns the the boundary for geometryValue. + An expression that specifies the geometry value from which the SpatialBoundary value should be retrieved. + + + + Creates a that invokes the canonical 'IsValidGeometry' function with the specified argument, which must have an Edm.Geometry result type. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether geometryValue is valid. + An expression that specifies the geometry value which should be tested for spatial validity. + + + + Creates a that invokes the canonical 'SpatialEquals' function with the specified arguments, which must each have an Edm.Geography or Edm.Geometry result type. The result type of spatialValue1 must match the result type of spatialValue2. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether spatialValue1 and spatialValue2 are equal. + An expression that specifies the first spatial value. + An expression that specifies the spatial value that should be compared with spatialValue1 for equality. + + + + Creates a that invokes the canonical 'SpatialDisjoint' function with the specified arguments, which must each have an Edm.Geography or Edm.Geometry result type. The result type of spatialValue1 must match the result type of spatialValue2. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether spatialValue1 and spatialValue2 are spatially disjoint. + An expression that specifies the first spatial value. + An expression that specifies the spatial value that should be compared with spatialValue1 for disjointness. + + + + Creates a that invokes the canonical 'SpatialIntersects' function with the specified arguments, which must each have an Edm.Geography or Edm.Geometry result type. The result type of spatialValue1 must match the result type of spatialValue2. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether spatialValue1 and spatialValue2 intersect. + An expression that specifies the first spatial value. + An expression that specifies the spatial value that should be compared with spatialValue1 for intersection. + + + + Creates a that invokes the canonical 'SpatialTouches' function with the specified arguments, which must each have an Edm.Geometry result type. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether geometryValue1 touches geometryValue2. + An expression that specifies the first geometry value. + An expression that specifies the geometry value that should be compared with geometryValue1. + + + + Creates a that invokes the canonical 'SpatialCrosses' function with the specified arguments, which must each have an Edm.Geometry result type. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether geometryValue1 crosses geometryValue2 intersect. + An expression that specifies the first geometry value. + An expression that specifies the geometry value that should be compared with geometryValue1. + + + + Creates a that invokes the canonical 'SpatialWithin' function with the specified arguments, which must each have an Edm.Geometry result type. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether geometryValue1 is spatially within geometryValue2. + An expression that specifies the first geometry value. + An expression that specifies the geometry value that should be compared with geometryValue1. + + + + Creates a that invokes the canonical 'SpatialContains' function with the specified arguments, which must each have an Edm.Geometry result type. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether geometryValue1 spatially contains geometryValue2. + An expression that specifies the first geometry value. + An expression that specifies the geometry value that should be compared with geometryValue1. + + + + Creates a that invokes the canonical 'SpatialOverlaps' function with the specified arguments, which must each have an Edm.Geometry result type. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether geometryValue1 spatially overlaps geometryValue2. + An expression that specifies the first geometry value. + An expression that specifies the geometry value that should be compared with geometryValue1. + + + + Creates a that invokes the canonical 'SpatialRelate' function with the specified arguments, which must have Edm.Geometry and string result types. The result type of the expression is Edm.Boolean. + + A new DbFunctionExpression that returns a Boolean value indicating whether geometryValue1 is spatially related to geometryValue2 according to the spatial relationship designated by intersectionPatternMatrix. + An expression that specifies the first geometry value. + An expression that specifies the geometry value that should be compared with geometryValue1. + An expression that specifies the text representation of the Dimensionally Extended Nine-Intersection Model (DE-9IM) intersection pattern used to compare geometryValue1 and geometryValue2. + + + + Creates a that invokes the canonical 'SpatialBuffer' function with the specified arguments, which must have a Edm.Geography or Edm.Geometry and Edm.Double result types. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns a geometry value representing all points less than or equal to distance from spatialValue. + An expression that specifies the spatial value. + An expression that specifies the buffer distance. + + + + Creates a that invokes the canonical 'Distance' function with the specified arguments, which must each have an Edm.Geography or Edm.Geometry result type. The result type of spatialValue1 must match the result type of spatialValue2. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that returns the distance between the closest points in spatialValue1 and spatialValue1. + An expression that specifies the first spatial value. + An expression that specifies the spatial value from which the distance from spatialValue1 should be measured. + + + + Creates a that invokes the canonical 'SpatialConvexHull' function with the specified argument, which must have an Edm.Geometry result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns the the convex hull for geometryValue. + An expression that specifies the geometry value from which the convex hull value should be retrieved. + + + + Creates a that invokes the canonical 'SpatialIntersection' function with the specified arguments, which must each have an Edm.Geography or Edm.Geometry result type. The result type of spatialValue1 must match the result type of spatialValue2. The result type of the expression is the same as the type of spatialValue1 and spatialValue2. + + A new DbFunctionExpression that returns the spatial value representing the intersection of spatialValue1 and spatialValue2. + An expression that specifies the first spatial value. + An expression that specifies the spatial value for which the intersection with spatialValue1 should be computed. + + + + Creates a that invokes the canonical 'SpatialUnion' function with the specified arguments, which must each have an Edm.Geography or Edm.Geometry result type. The result type of spatialValue1 must match the result type of spatialValue2. The result type of the expression is the same as the type of spatialValue1 and spatialValue2. + + A new DbFunctionExpression that returns the spatial value representing the union of spatialValue1 and spatialValue2. + An expression that specifies the first spatial value. + An expression that specifies the spatial value for which the union with spatialValue1 should be computed. + + + + Creates a that invokes the canonical 'SpatialDifference' function with the specified arguments, which must each have an Edm.Geography or Edm.Geometry result type. The result type of spatialValue1 must match the result type of spatialValue2. The result type of the expression is the same as the type of spatialValue1 and spatialValue2. + + A new DbFunctionExpression that returns the geometry value representing the difference of spatialValue2 with spatialValue1. + An expression that specifies the first spatial value. + An expression that specifies the spatial value for which the difference with spatialValue1 should be computed. + + + + Creates a that invokes the canonical 'SpatialSymmetricDifference' function with the specified arguments, which must each have an Edm.Geography or Edm.Geometry result type. The result type of spatialValue1 must match the result type of spatialValue2. The result type of the expression is the same as the type of spatialValue1 and spatialValue2. + + A new DbFunctionExpression that returns the geometry value representing the symmetric difference of spatialValue2 with spatialValue1. + An expression that specifies the first spatial value. + An expression that specifies the spatial value for which the symmetric difference with spatialValue1 should be computed. + + + + Creates a that invokes the canonical 'SpatialElementCount' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns either the number of elements in spatialValue or null if spatialValue is not a collection. + An expression that specifies the geography or geometry collection value from which the number of elements should be retrieved. + + + + Creates a that invokes the canonical 'SpatialElementAt' function with the specified arguments. The first argument must have an Edm.Geography or Edm.Geometry result type. The second argument must have an integer numeric result type. The result type of the expression is the same as that of spatialValue. + + A new DbFunctionExpression that returns either the collection element at position indexValue in spatialValue or null if spatialValue is not a collection. + An expression that specifies the geography or geometry collection value. + An expression that specifies the position of the element to be retrieved from within the geometry or geography collection. + + + + Creates a that invokes the canonical 'XCoordinate' function with the specified argument, which must have an Edm.Geometry result type. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that returns either the X co-ordinate value of geometryValue or null if geometryValue is not a point. + An expression that specifies the geometry point value from which the X co-ordinate value should be retrieved. + + + + Creates a that invokes the canonical 'YCoordinate' function with the specified argument, which must have an Edm.Geometry result type. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that returns either the Y co-ordinate value of geometryValue or null if geometryValue is not a point. + An expression that specifies the geometry point value from which the Y co-ordinate value should be retrieved. + + + + Creates a that invokes the canonical 'Elevation' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that returns either the elevation value of spatialValue or null if spatialValue is not a point. + An expression that specifies the spatial point value from which the elevation (Z co-ordinate) value should be retrieved. + + + + Creates a that invokes the canonical 'Measure' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that returns either the Measure of spatialValue or null if spatialValue is not a point. + An expression that specifies the spatial point value from which the Measure (M) co-ordinate value should be retrieved. + + + + Creates a that invokes the canonical 'Latitude' function with the specified argument, which must have an Edm.Geography result type. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that returns either the Latitude value of geographyValue or null if geographyValue is not a point. + An expression that specifies the geography point value from which the Latitude value should be retrieved. + + + + Creates a that invokes the canonical 'Longitude' function with the specified argument, which must have an Edm.Geography result type. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that returns either the Longitude value of geographyValue or null if geographyValue is not a point. + An expression that specifies the geography point value from which the Longitude value should be retrieved. + + + + Creates a that invokes the canonical 'SpatialLength' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that returns either the length of spatialValue or null if spatialValue is not a curve. + An expression that specifies the spatial curve value from which the length should be retrieved. + + + + Creates a that invokes the canonical 'StartPoint' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type is the same as that of spatialValue. + + A new DbFunctionExpression that returns either the start point of spatialValue or null if spatialValue is not a curve. + An expression that specifies the spatial curve value from which the start point should be retrieved. + + + + Creates a that invokes the canonical 'EndPoint' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type is the same as that of spatialValue. + + A new DbFunctionExpression that returns either the end point of spatialValue or null if spatialValue is not a curve. + An expression that specifies the spatial curve value from which the end point should be retrieved. + + + + Creates a that invokes the canonical 'IsClosedSpatial' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type is Edm.Boolean. + + A new DbFunctionExpression that returns either a Boolean value indicating whether spatialValue is closed, or null if spatialValue is not a curve. + An expression that specifies the spatial curve value from which the IsClosedSpatial value should be retrieved. + + + + Creates a that invokes the canonical 'IsRing' function with the specified argument, which must have an Edm.Geometry result type. The result type is Edm.Boolean. + + A new DbFunctionExpression that returns either a Boolean value indicating whether geometryValue is a ring (both closed and simple), or null if geometryValue is not a curve. + An expression that specifies the geometry curve value from which the IsRing value should be retrieved. + + + + Creates a that invokes the canonical 'PointCount' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns either the number of points in spatialValue or null if spatialValue is not a line string. + An expression that specifies the spatial line string value from which the number of points should be retrieved. + + + + Creates a that invokes the canonical 'PointAt' function with the specified arguments. The first argument must have an Edm.Geography or Edm.Geometry result type. The second argument must have an integer numeric result type. The result type of the expression is the same as that of spatialValue. + + A new DbFunctionExpression that returns either the point at position indexValue in spatialValue or null if spatialValue is not a line string. + An expression that specifies the spatial line string value. + An expression that specifies the position of the point to be retrieved from within the line string. + + + + Creates a that invokes the canonical 'Area' function with the specified argument, which must have an Edm.Geography or Edm.Geometry result type. The result type of the expression is Edm.Double. + + A new DbFunctionExpression that returns either the area of spatialValue or null if spatialValue is not a surface. + An expression that specifies the spatial surface value for which the area should be calculated. + + + + Creates a that invokes the canonical 'Centroid' function with the specified argument, which must have an Edm.Geometry result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns either the centroid point of geometryValue (which may not be on the surface itself) or null if geometryValue is not a surface. + An expression that specifies the geometry surface value from which the centroid should be retrieved. + + + + Creates a that invokes the canonical 'PointOnSurface' function with the specified argument, which must have an Edm.Geometry result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns either a point guaranteed to be on the surface geometryValue or null if geometryValue is not a surface. + An expression that specifies the geometry surface value from which the point should be retrieved. + + + + Creates a that invokes the canonical 'ExteriorRing' function with the specified argument, which must have an Edm.Geometry result type. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns either the exterior ring of the polygon geometryValue or null if geometryValue is not a polygon. + The geometry value. + + + + Creates a that invokes the canonical 'InteriorRingCount' function with the specified argument, which must have an Edm.Geometry result type. The result type of the expression is Edm.Int32. + + A new DbFunctionExpression that returns either the number of interior rings in the polygon geometryValue or null if geometryValue is not a polygon. + The geometry value. + + + + Creates a that invokes the canonical 'InteriorRingAt' function with the specified arguments. The first argument must have an Edm.Geometry result type. The second argument must have an integer numeric result types. The result type of the expression is Edm.Geometry. + + A new DbFunctionExpression that returns either the interior ring at position indexValue in geometryValue or null if geometryValue is not a polygon. + The geometry value. + An expression that specifies the position of the interior ring to be retrieved from within the polygon. + + + + Ensures that all metadata in a given expression tree is from the specified metadata workspace, + potentially rebinding and rebuilding the expressions to appropriate replacement metadata where necessary. + + + + Initializes a new instance of the class. + The target workspace. + + + Implements the visitor pattern for the entity set. + The implemented visitor pattern. + The entity set. + + + Implements the visitor pattern for the function. + The implemented visitor pattern. + The function metadata. + + + Implements the visitor pattern for the type. + The implemented visitor pattern. + The type. + + + Implements the visitor pattern for the type usage. + The implemented visitor pattern. + The type. + + + Implements the visitor pattern for retrieving an instance property. + The implemented visitor. + The expression. + + + + Represents a boolean expression that tests whether a specified item matches any element in a list. + + + + + The visitor pattern method for expression visitors that do not produce a result value. + + An instance of DbExpressionVisitor. + + + is null + + + + + The visitor pattern method for expression visitors that produce a result value of a specific type. + + An instance of a typed DbExpressionVisitor that produces a result value of type TResultType. + + The type of the result produced by + + + + is null + + + An instance of . + + + + + Gets a DbExpression that specifies the item to be matched. + + + + + Gets the list of DbExpression to test for a match. + + + + + Represents the retrieval of the key value of the specified Reference as a row. + + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + + Represents the set union (without duplicate removal) operation between the left and right operands. + + + DbUnionAllExpression requires that its arguments have a common collection result type + + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + + Represents a 'scan' of all elements of a given entity set. + + + + Implements the visitor pattern for expressions that do not produce a result value. + + An instance of . + + visitor is null. + + + Implements the visitor pattern for expressions that produce a result value of a specific type. + + A result value of a specific type produced by + + . + + + An instance of a typed that produces a result value of a specific type. + + The type of the result produced by visitor . + visitor is null. + + + Gets the metadata for the referenced entity or relationship set. + The metadata for the referenced entity or relationship set. + + + + Extension methods for . + + + + + Gets the conceptual model from the specified DbModel. + + An instance of a class that implements IEdmModelAdapter (ex. DbModel). + An instance of EdmModel that represents the conceptual model. + + + + Gets the store model from the specified DbModel. + + An instance of a class that implements IEdmModelAdapter (ex. DbModel). + An instance of EdmModel that represents the store model. + + + + An interface to get the underlying store and conceptual model for a . + + + + + Gets the conceptual model. + + + + + Gets the store model. + + + + + Inherit from this class to create a service that allows for code generation of custom annotations as part of + scaffolding Migrations. The derived class should be set onto the . + + + Note that an is not needed if the annotation uses a simple string value, + or if calling ToString on the annotation object is sufficient for use in the scaffolded Migration. + + + + + Override this method to return additional namespaces that should be included in the code generated for the + scaffolded migration. The default implementation returns an empty enumeration. + + The names of the annotations that are being included in the generated code. + A list of additional namespaces to include. + + + + Implement this method to generate code for the given annotation value. + + The name of the annotation for which a value is being generated. + The annotation value. + The writer to which generated code should be written. + + + + Represents a pair of annotation values in a scaffolded or hand-coded . + + + Code First allows for custom annotations to be associated with columns and tables in the + generated model. This class represents a pair of annotation values in a migration such + that when the Code First model changes the old annotation value and the new annotation + value can be provided to the migration and used in SQL generation. + + + + + Creates a new pair of annotation values. + + The old value of the annotation, which may be null if the annotation has just been created. + The new value of the annotation, which may be null if the annotation has been deleted. + + + + + + + + + + Returns true if both annotation pairs contain the same values, otherwise false. + + A pair of annotation values. + A pair of annotation values. + True if both pairs contain the same values. + + + + Returns true if the two annotation pairs contain different values, otherwise false. + + A pair of annotation values. + A pair of annotation values. + True if the pairs contain different values. + + + + Gets the old value of the annotation, which may be null if the annotation has just been created. + + + + + Gets the new value of the annotation, which may be null if the annotation has been deleted. + + + + + Returned by and related methods to indicate whether or + not one object does not conflict with another such that the two can be combined into one. + + + If the two objects are not compatible then information about why they are not compatible is contained + in the property. + + + + + Creates a new instance. + + Indicates whether or not the two tested objects are compatible. + + An error message indicating how the objects are not compatible. Expected to be null if isCompatible is true. + + + + + Implicit conversion to a bool to allow the result object to be used directly in checks. + + The object to convert. + True if the result is compatible; false otherwise. + + + + True if the two tested objects are compatible; otherwise false. + + + + + If is true, then returns an error message indicating how the two tested objects + are incompatible. + + + + + Types used as custom annotations can implement this interface to indicate that an attempt to use + multiple annotations with the same name on a given table or column may be possible by merging + the multiple annotations into one. + + + Normally there can only be one custom annotation with a given name on a given table or + column. If a table or column ends up with multiple annotations, for example, because + multiple CLR properties map to the same column, then an exception will be thrown. + However, if the annotation type implements this interface, then the two annotations will be + checked for compatibility using the method and, if compatible, + will be merged into one using the method. + + + + + Returns true if this annotation does not conflict with the given annotation such that + the two can be combined together using the method. + + The annotation to compare. + A CompatibilityResult indicating whether or not this annotation is compatible with the other. + + + + Merges this annotation with the given annotation and returns a new merged annotation. This method is + only expected to succeed if returns true. + + The annotation to merge with this one. + A new merged annotation. + + + + Instances of this class are used as custom annotations for representing database indexes in an + Entity Framework model. + + + An index annotation is added to a Code First model when an is placed on + a mapped property of that model. This is used by Entity Framework Migrations to create indexes on + mapped database columns. Note that multiple index attributes on a property will be merged into a + single annotation for the column. Similarly, index attributes on multiple properties that map to the + same column will be merged into a single annotation for the column. This means that one index + annotation can represent multiple indexes. Within an annotation there can be only one index with any + given name. + + + + + The name used when this annotation is stored in Entity Framework metadata or serialized into + an SSDL/EDMX file. + + + + + Creates a new annotation for the given index. + + An index attributes representing an index. + + + + Creates a new annotation for the given collection of indexes. + + Index attributes representing one or more indexes. + + + + Returns true if this annotation does not conflict with the given annotation such that + the two can be combined together using the method. + + + Each index annotation contains at most one with a given name. + Two annotations are considered compatible if each IndexAttribute with a given name is only + contained in one annotation or the other, or if both annotations contain an IndexAttribute + with the given name. + + The annotation to compare. + A CompatibilityResult indicating whether or not this annotation is compatible with the other. + + + + Merges this annotation with the given annotation and returns a new annotation containing the merged indexes. + + + Each index annotation contains at most one with a given name. + The merged annotation will contain IndexAttributes from both this and the other annotation. + If both annotations contain an IndexAttribute with the same name, then the merged annotation + will contain one IndexAttribute with that name. + + The annotation to merge with this one. + A new annotation with indexes from both annotations merged. + + The other annotation contains indexes that are not compatible with indexes in this annotation. + + + + + + + + Gets the indexes represented by this annotation. + + + + + This class is used to serialize and deserialize objects so that they + can be stored in the EDMX form of the Entity Framework model. + + + An example of the serialized format is: + { Name: 'MyIndex', Order: 7, IsClustered: True, IsUnique: False } { } { Name: 'MyOtherIndex' }. + Note that properties that have not been explicitly set in an index attribute will be excluded from + the serialized output. So, in the example above, the first index has all properties specified, + the second has none, and the third has just the name set. + + + + + Implement this interface to allow custom annotations represented by instances to be + serialized to and from the EDMX XML. Usually a serializer instance is set using the + method. + + + + + Serializes the given annotation value into a string for storage in the EDMX XML. + + The name of the annotation that is being serialized. + The value to serialize. + The serialized value. + + + + Deserializes the given string back into the expected annotation value. + + The name of the annotation that is being deserialized. + The string to deserialize. + The deserialized annotation value. + + + + Serializes the given into a string for storage in the EDMX XML. + + The name of the annotation that is being serialized. + The value to serialize which must be an IndexAnnotation object. + The serialized value. + + + + Deserializes the given string back into an object. + + The name of the annotation that is being deserialized. + The string to deserialize. + The deserialized annotation value. + If there is an error reading the serialized value. + + + + This interface is implemented by any object that can resolve a dependency, either directly + or through use of an external container. + + + The public services currently resolved using IDbDependencyResolver are documented here: + http://msdn.microsoft.com/en-us/data/jj680697 + + + + + Attempts to resolve a dependency for a given contract type and optionally a given key. + If the resolver cannot resolve the dependency then it must return null and not throw. This + allows resolvers to be used in a Chain of Responsibility pattern such that multiple resolvers + can be asked to resolve a dependency until one finally does. + + The interface or abstract base class that defines the dependency to be resolved. The returned object is expected to be an instance of this type. + Optionally, the key of the dependency to be resolved. This may be null for dependencies that are not differentiated by key. + The resolved dependency, which must be an instance of the given contract type, or null if the dependency could not be resolved. + + + + Attempts to resolve a dependencies for a given contract type and optionally a given key. + If the resolver cannot resolve the dependency then it must return an empty enumeration and + not throw. This method differs from in that it returns all registered + services for the given type and key combination. + + The interface or abstract base class that defines the dependency to be resolved. Every returned object is expected to be an instance of this type. + Optionally, the key of the dependency to be resolved. This may be null for dependencies that are not differentiated by key. + All services that resolve the dependency, which must be instances of the given contract type, or an empty enumeration if the dependency could not be resolved. + + + + An implementation used for resolving + factories. + + + + + Initializes a new instance of + + A function that returns a new instance of a transaction handler. + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which the transaction handler will be used. + null will match anything. + + + A string that will be matched against the server name in the connection string. null will match anything. + + + + + If the given type is , then this method will attempt + to return the service to use, otherwise it will return null. When the given type is + , then the key is expected to be a . + + The service type to resolve. + A key used to make a determination of the service to return. + + An , or null. + + + + + If the given type is , then this resolver will attempt + to return the service to use, otherwise it will return an empty enumeration. When the given type is + , then the key is expected to be an . + + The service type to resolve. + A key used to make a determination of the service to return. + + An enumerable of , or an empty enumeration. + + + + + + + + + + + Provides utility methods for reading from an App.config or Web.config file. + + + + + Initializes a new instance of . + + The configuration to read from. + + + + Gets the specified provider services from the configuration. + + The invariant name of the provider services. + The provider services type name, or null if not found. + + + + A simple logger for logging SQL and other database operations to the console or a file. + A logger can be registered in code or in the application's web.config /app.config file. + + + + + An object that implements this interface can be registered with to + receive notifications when Entity Framework loads the application's . + + + Interceptors can also be registered in the config file of the application. + See http://go.microsoft.com/fwlink/?LinkId=260883 for more information about Entity Framework configuration. + + + + + This is the base interface for all interfaces that provide interception points for various + different types and operations. For example, see . + Interceptors are registered on the class. + + + + + Occurs during EF initialization after the has been constructed but just before + it is locked ready for use. Use this event to inspect and/or override services that have been + registered before the configuration is locked. Note that an interceptor of this type should be used carefully + since it may prevent tooling from discovering the same configuration that is used at runtime. + + + Handlers can only be added before EF starts to use the configuration and so handlers should + generally be added as part of application initialization. Do not access the DbConfiguration + static methods inside the handler; instead use the the members of + to get current services and/or add overrides. + + Arguments to the event that this interceptor mirrors. + Contextual information about the event. + + + + Creates a new logger that will send log output to the console. + + + + + Creates a new logger that will send log output to a file. If the file already exists then + it is overwritten. + + A path to the file to which log output will be written. + + + + Creates a new logger that will send log output to a file. + + A path to the file to which log output will be written. + True to append data to the file if it exists; false to overwrite the file. + + + + Stops logging and closes the underlying file if output is being written to a file. + + + + + Stops logging and closes the underlying file if output is being written to a file. + + + True to release both managed and unmanaged resources; False to release only unmanaged resources. + + + + + Starts logging. This method is a no-op if logging is already started. + + + + + Stops logging. This method is a no-op if logging is not started. + + + + + Called to start logging during Entity Framework initialization when this logger is registered. + as an . + + Arguments to the event that this interceptor mirrors. + Contextual information about the event. + + + + Represents contextual information associated with calls into + implementations. + + + Instances of this class are publicly immutable for contextual information. To add + contextual information use one of the With... or As... methods to create a new + interception context containing the new information. + + + + + Represents contextual information associated with calls into + implementations. + + + Note that specific types/operations that can be intercepted may use a more specific + interception context derived from this class. For example, if SQL is being executed by + a , then the DbContext will be contained in the + instance that is passed to the methods + of . + Instances of this class are publicly immutable for contextual information. To add + contextual information use one of the With... or As... methods to create a new + interception context containing the new information. + + + + + Constructs a new with no state. + + + + + Creates a new by copying state from the given + interception context. See + + The context from which to copy state. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context the flag set to true. + + A new interception context associated with the async flag set. + + + + Call this method when creating a copy of an interception context in order to add new state + to it. Using this method instead of calling the constructor directly ensures virtual dispatch + so that the new type will have the same type (and any specialized state) as the context that + is being cloned. + + A new context with all state copied. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Gets all the instances associated with this interception context. + + + This list usually contains zero or one items. However, it can contain more than one item if + a single has been used to construct multiple + instances. + + + + + Gets all the instances associated with this interception context. + + + This list usually contains zero or one items. However, it can contain more than one item when + EF has created a new for use in database creation and initialization, or + if a single is used with multiple . + + + + + True if the operation is being executed asynchronously, otherwise false. + + + + + Constructs a new with no state. + + + + + Creates a new by copying state from the given + interception context. Also see + + The context from which to copy state. + + + + + + + Creates a new that contains all the contextual information in + this interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in + this interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in + this interception context the flag set to true. + + A new interception context associated with the async flag set. + + + + + + + + + + + + + + + + Implemented by Entity Framework providers and used to check whether or not tables exist + in a given database. This is used by database initializers when determining whether or not to + treat an existing database as empty such that tables should be created. + + + + + When overridden in a derived class checks where the given tables exist in the database + for the given connection. + + + The context for which table checking is being performed, usually used to obtain an appropriate + . + + + A connection to the database. May be open or closed; should be closed again if opened. Do not + dispose. + + The tables to check for existence. + The name of the EdmMetadata table to check for existence. + True if any of the model tables or EdmMetadata table exists. + + + + Helper method to get the table name for the given s-space . + + The s-space entity set for the table. + The table name. + + + + Thrown when an error occurs committing a . + + + + + Initializes a new instance of + + + + + Initializes a new instance of + + The exception message. + + + + Initializes a new instance of + + The exception message. + The inner exception. + + + + Initializes a new instance of the class. + + The data necessary to serialize or deserialize an object. + Description of the source and destination of the specified serialized stream. + + + + Event arguments passed to event handlers. + + + + + Call this method to add a instance to the Chain of + Responsibility of resolvers that are used to resolve dependencies needed by the Entity Framework. + + + Resolvers are asked to resolve dependencies in reverse order from which they are added. This means + that a resolver can be added to override resolution of a dependency that would already have been + resolved in a different way. + The only exception to this is that any dependency registered in the application's config file + will always be used in preference to using a dependency resolver added here, unless the + overrideConfigFile is set to true in which case the resolver added here will also override config + file settings. + + The resolver to add. + If true, then the resolver added will take precedence over settings in the config file. + + + + Call this method to add a instance to the Chain of Responsibility + of resolvers that are used to resolve dependencies needed by the Entity Framework. Unlike the AddDependencyResolver + method, this method puts the resolver at the bottom of the Chain of Responsibility such that it will only + be used to resolve a dependency that could not be resolved by any of the other resolvers. + + The resolver to add. + + + + Adds a wrapping resolver to the configuration that is about to be locked. A wrapping + resolver is a resolver that incepts a service would have been returned by the resolver + chain and wraps or replaces it with another service of the same type. + + The type of service to wrap or replace. + A delegate that takes the unwrapped service and key and returns the wrapped or replaced service. + + + + + + + + + + + + + + + + Returns a snapshot of the that is about to be locked. + Use the GetService methods on this object to get services that have been registered. + + + + + An implementation used for resolving + factories. + + + This class can be used by to aid in the resolving + of factories as a default service for the provider. + + The type of execution strategy that is resolved. + + + + Initializes a new instance of + + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which this execution strategy will be used. + + + A string that will be matched against the server name in the connection string. null will match anything. + + A function that returns a new instance of an execution strategy. + + + + If the given type is , then this resolver will attempt + to return the service to use, otherwise it will return null. When the given type is + Func{IExecutionStrategy}, then the key is expected to be an . + + The service type to resolve. + A key used to make a determination of the service to return. + + An , or null. + + + + + If the given type is , then this resolver will attempt + to return the service to use, otherwise it will return an empty enumeration. When the given type is + Func{IExecutionStrategy}, then the key is expected to be an . + + The service type to resolve. + A key used to make a determination of the service to return. + + An enumerable of , or an empty enumeration. + + + + + Extension methods to call the method using + a generic type parameter and/or no name. + + + + + Calls passing the generic type of the method and the given + name as arguments. + + The contract type to resolve. + The resolver to use. + The key of the dependency to resolve. + The resolved dependency, or null if the resolver could not resolve it. + + + + Calls passing the generic type of the method as + the type argument and null for the name argument. + + The contract type to resolve. + The resolver to use. + The resolved dependency, or null if the resolver could not resolve it. + + + + Calls passing the given type argument and using + null for the name argument. + + The resolver to use. + The contract type to resolve. + The resolved dependency, or null if the resolver could not resolve it. + + + + Calls passing the generic type of the method and the given + name as arguments. + + The contract type to resolve. + The resolver to use. + The key of the dependency to resolve. + All resolved dependencies, or an if no services are resolved. + + + + Calls passing the generic type of the method as + the type argument and null for the name argument. + + The contract type to resolve. + The resolver to use. + All resolved dependencies, or an if no services are resolved. + + + + Calls passing the given type argument and using + null for the name argument. + + The resolver to use. + The contract type to resolve. + All resolved dependencies, or an if no services are resolved. + + + + Implements to resolve a dependency such that it always returns + the same instance. + + The type that defines the contract for the dependency that will be resolved. + + This class is immutable such that instances can be accessed by multiple threads at the same time. + + + + + Constructs a new resolver that will return the given instance for the contract type + regardless of the key passed to the Get method. + + The instance to return. + + + + Constructs a new resolver that will return the given instance for the contract type + if the given key matches exactly the key passed to the Get method. + + The instance to return. + Optionally, the key of the dependency to be resolved. This may be null for dependencies that are not differentiated by key. + + + + Constructs a new resolver that will return the given instance for the contract type + if the given key matches the key passed to the Get method based on the given predicate. + + The instance to return. + A predicate that takes the key object and returns true if and only if it matches. + + + + + + + + + + Represents contextual information associated with calls to + implementations. + + + Instances of this class are publicly immutable for contextual information. To add + contextual information use one of the With... or As... methods to create a new + interception context containing the new information. + + + + + Represents contextual information associated with calls to with return type . + + The return type of the target method. + + + + Represents contextual information associated with calls with return type . + + The return type of the target method. + + + + Constructs a new with no state. + + + + + Creates a new by copying immutable state from the given + interception context. Also see + + The context from which to copy state. + + + + Prevents the operation from being executed if called before the operation has executed. + + + Thrown if this method is called after the operation has already executed. + + + + + Creates a new that contains all the contextual information in this + interception context together with the flag set to true. + + A new interception context associated with the async flag set. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + + + + + + + + + + + + + If execution of the operation completes without throwing, then this property will contain + the result of the operation. If the operation was suppressed or did not fail, then this property + will always contain the default value for the generic type. + + + When an operation operation completes without throwing both this property and the + property are set. However, the property can be set or changed by interceptors, + while this property will always represent the actual result returned by the operation, if any. + + + + + If this property is set before the operation has executed, then execution of the operation will + be suppressed and the set result will be returned instead. Otherwise, if the operation succeeds, then + this property will be set to the returned result. In either case, interceptors that run + after the operation can change this property to change the result that will be returned. + + + When an operation operation completes without throwing both this property and the + property are set. However, this property can be set or changed by interceptors, while the + property will always represent the actual result returned by the + operation, if any. + + + + + When true, this flag indicates that that execution of the operation has been suppressed by + one of the interceptors. This can be done before the operation has executed by calling + , by setting an to be thrown, or + by setting the operation result using . + + + + + Gets or sets a value containing arbitrary user-specified state information associated with the operation. + + + + + If execution of the operation fails, then this property will contain the exception that was + thrown. If the operation was suppressed or did not fail, then this property will always be null. + + + When an operation fails both this property and the property are set + to the exception that was thrown. However, the property can be set or + changed by interceptors, while this property will always represent the original exception thrown. + + + + + If this property is set before the operation has executed, then execution of the operation will + be suppressed and the set exception will be thrown instead. Otherwise, if the operation fails, then + this property will be set to the exception that was thrown. In either case, interceptors that run + after the operation can change this property to change the exception that will be thrown, or set this + property to null to cause no exception to be thrown at all. + + + When an operation fails both this property and the property are set + to the exception that was thrown. However, the this property can be set or changed by + interceptors, while the property will always represent + the original exception thrown. + + + + + Set to the status of the after an async operation has finished. Not used for + synchronous operations. + + + + + Constructs a new with no state. + + + + + Creates a new by copying immutable state from the given + interception context. Also see + + The context from which to copy state. + + + + Creates a new that contains all the contextual information in this + interception context together with the flag set to true. + + A new interception context associated with the async flag set. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + + + + + + + + + + + + + + + + Constructs a new with no state. + + + + + Creates a new by copying immutable state from the given + interception context. Also see + + The context from which to copy state. + + + + Creates a new that contains all the contextual information in this + interception context together with the flag set to true. + + A new interception context associated with the async flag set. + + + + Creates a new that contains all the contextual information in this + interception context together with the given . + + The isolation level to associate. + A new interception context associated with the given isolation level. + + + + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + + + + + + + + + + + + + The that will be used or has been used to start a transaction. + + + + + This is the default log formatter used when some is set onto the + property. A different formatter can be used by creating a class that inherits from this class and overrides + some or all methods to change behavior. + + + To set the new formatter create a code-based configuration for EF using and then + set the formatter class to use with . + Note that setting the type of formatter to use with this method does change the way command are + logged when is used. It is still necessary to set a + onto before any commands will be logged. + For more low-level control over logging/interception see and + . + Interceptors can also be registered in the config file of the application. + See http://go.microsoft.com/fwlink/?LinkId=260883 for more information about Entity Framework configuration. + + + + + An object that implements this interface can be registered with to + receive notifications when Entity Framework executes commands. + + + Interceptors can also be registered in the config file of the application. + See http://go.microsoft.com/fwlink/?LinkId=260883 for more information about Entity Framework configuration. + + + + + This method is called before a call to or + one of its async counterparts is made. + + The command being executed. + Contextual information associated with the call. + + + + This method is called after a call to or + one of its async counterparts is made. The result used by Entity Framework can be changed by setting + . + + + For async operations this method is not called until after the async task has completed + or failed. + + The command being executed. + Contextual information associated with the call. + + + + This method is called before a call to or + one of its async counterparts is made. + + The command being executed. + Contextual information associated with the call. + + + + This method is called after a call to or + one of its async counterparts is made. The result used by Entity Framework can be changed by setting + . + + + For async operations this method is not called until after the async task has completed + or failed. + + The command being executed. + Contextual information associated with the call. + + + + This method is called before a call to or + one of its async counterparts is made. + + The command being executed. + Contextual information associated with the call. + + + + This method is called after a call to or + one of its async counterparts is made. The result used by Entity Framework can be changed by setting + . + + + For async operations this method is not called until after the async task has completed + or failed. + + The command being executed. + Contextual information associated with the call. + + + + An object that implements this interface can be registered with to + receive notifications when Entity Framework performs operations on a . + + + Interceptors can also be registered in the config file of the application. + See http://go.microsoft.com/fwlink/?LinkId=260883 for more information about Entity Framework configuration. + + + + + Called before is invoked. + + The connection beginning the transaction. + Contextual information associated with the call. + + + + Called after is invoked. + The transaction used by Entity Framework can be changed by setting + . + + The connection that began the transaction. + Contextual information associated with the call. + + + + Called before is invoked. + + The connection being closed. + Contextual information associated with the call. + + + + Called after is invoked. + + The connection that was closed. + Contextual information associated with the call. + + + + Called before is retrieved. + + The connection. + Contextual information associated with the call. + + + + Called after is retrieved. + + The connection. + Contextual information associated with the call. + + + + Called before is set. + + The connection. + Contextual information associated with the call. + + + + Called after is set. + + The connection. + Contextual information associated with the call. + + + + Called before is retrieved. + + The connection. + Contextual information associated with the call. + + + + Called after is retrieved. + + The connection. + Contextual information associated with the call. + + + + Called before is retrieved. + + The connection. + Contextual information associated with the call. + + + + Called after is retrieved. + + The connection. + Contextual information associated with the call. + + + + Called before is retrieved. + + The connection. + Contextual information associated with the call. + + + + Called after is retrieved. + + The connection. + Contextual information associated with the call. + + + + Called before is invoked. + + The connection being disposed. + Contextual information associated with the call. + + + + Called after is invoked. + + The connection that was disposed. + Contextual information associated with the call. + + + + Called before is invoked. + + The connection. + Contextual information associated with the call. + + + + Called after is invoked. + + The connection. + Contextual information associated with the call. + + + + Called before or its async counterpart is invoked. + + The connection being opened. + Contextual information associated with the call. + + + + Called after or its async counterpart is invoked. + + The connection that was opened. + Contextual information associated with the call. + + + + Called before is retrieved. + + The connection. + Contextual information associated with the call. + + + + Called after is retrieved. + + The connection. + Contextual information associated with the call. + + + + Called before is retrieved. + + The connection. + Contextual information associated with the call. + + + + Called after is retrieved. + + The connection. + Contextual information associated with the call. + + + + An object that implements this interface can be registered with to + receive notifications when Entity Framework commits or rollbacks a transaction. + + + Interceptors can also be registered in the config file of the application. + See http://go.microsoft.com/fwlink/?LinkId=260883 for more information about Entity Framework configuration. + + + + + Called before is retrieved. + + The transaction. + Contextual information associated with the call. + + + + Called after is retrieved. + + The transaction. + Contextual information associated with the call. + + + + Called before is retrieved. + + The transaction. + Contextual information associated with the call. + + + + Called after is retrieved. + + The transaction. + Contextual information associated with the call. + + + + This method is called before is invoked. + + The transaction being commited. + Contextual information associated with the call. + + + + This method is called after is invoked. + + The transaction that was commited. + Contextual information associated with the call. + + + + This method is called before is invoked. + + The transaction being disposed. + Contextual information associated with the call. + + + + This method is called after is invoked. + + The transaction that was disposed. + Contextual information associated with the call. + + + + This method is called before is invoked. + + The transaction being rolled back. + Contextual information associated with the call. + + + + This method is called after is invoked. + + The transaction that was rolled back. + Contextual information associated with the call. + + + + Creates a formatter that will not filter by any and will instead log every command + from any context and also commands that do not originate from a context. + + + This constructor is not used when a delegate is set on . Instead it can be + used by setting the formatter directly using . + + The delegate to which output will be sent. + + + + Creates a formatter that will only log commands the come from the given instance. + + + This constructor must be called by a class that inherits from this class to override the behavior + of . + + + The context for which commands should be logged. Pass null to log every command + from any context and also commands that do not originate from a context. + + The delegate to which output will be sent. + + + + Writes the given string to the underlying write delegate. + + The string to write. + + + + This method is called before a call to or + one of its async counterparts is made. + The default implementation calls and starts . + + The command being executed. + Contextual information associated with the call. + + + + This method is called after a call to or + one of its async counterparts is made. + The default implementation stops and calls . + + The command being executed. + Contextual information associated with the call. + + + + This method is called before a call to or + one of its async counterparts is made. + The default implementation calls and starts . + + The command being executed. + Contextual information associated with the call. + + + + This method is called after a call to or + one of its async counterparts is made. + The default implementation stops and calls . + + The command being executed. + Contextual information associated with the call. + + + + This method is called before a call to or + one of its async counterparts is made. + The default implementation calls and starts . + + The command being executed. + Contextual information associated with the call. + + + + This method is called after a call to or + one of its async counterparts is made. + The default implementation stops and calls . + + The command being executed. + Contextual information associated with the call. + + + + Called whenever a command is about to be executed. The default implementation of this method + filters by set into , if any, and then calls + . This method would typically only be overridden to change the + context filtering behavior. + + The type of the operation's results. + The command that will be executed. + Contextual information associated with the command. + + + + Called whenever a command has completed executing. The default implementation of this method + filters by set into , if any, and then calls + . This method would typically only be overridden to change the context + filtering behavior. + + The type of the operation's results. + The command that was executed. + Contextual information associated with the command. + + + + Called to log a command that is about to be executed. Override this method to change how the + command is logged to . + + The type of the operation's results. + The command to be logged. + Contextual information associated with the command. + + + + Called by to log each parameter. This method can be called from an overridden + implementation of to log parameters, and/or can be overridden to + change the way that parameters are logged to . + + The type of the operation's results. + The command being logged. + Contextual information associated with the command. + The parameter to log. + + + + Called to log the result of executing a command. Override this method to change how results are + logged to . + + The type of the operation's results. + The command being logged. + Contextual information associated with the command. + + + + Does not write to log unless overridden. + + The connection beginning the transaction. + Contextual information associated with the call. + + + + Called after is invoked. + The default implementation of this method filters by set into + , if any, and then logs the event. + + The connection that began the transaction. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection being opened. + Contextual information associated with the call. + + + + Called after or its async counterpart is invoked. + The default implementation of this method filters by set into + , if any, and then logs the event. + + The connection that was opened. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection being closed. + Contextual information associated with the call. + + + + Called after is invoked. + The default implementation of this method filters by set into + , if any, and then logs the event. + + The connection that was closed. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Called before is invoked. + The default implementation of this method filters by set into + , if any, and then logs the event. + + The connection being disposed. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection that was disposed. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The connection. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The transaction. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The transaction. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + The transaction. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The transaction. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The transaction being commited. + Contextual information associated with the call. + + + + This method is called after is invoked. + The default implementation of this method filters by set into + , if any, and then logs the event. + + The transaction that was commited. + Contextual information associated with the call. + + + + This method is called before is invoked. + The default implementation of this method filters by set into + , if any, and then logs the event. + + The transaction being disposed. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The transaction that was disposed. + Contextual information associated with the call. + + + + Does not write to log unless overridden. + + The transaction being rolled back. + Contextual information associated with the call. + + + + This method is called after is invoked. + The default implementation of this method filters by set into + , if any, and then logs the event. + + The transaction that was rolled back. + Contextual information associated with the call. + + + + + + + + + + + + + + + + The context for which commands are being logged, or null if commands from all contexts are + being logged. + + + + + The stop watch used to time executions. This stop watch is started at the end of + , , and + methods and is stopped at the beginning of the , , + and methods. If these methods are overridden and the stop watch is being used + then the overrides should either call the base method or start/stop the watch themselves. + + + + + Represents contextual information associated with calls to that don't return any results. + + + + + Represents contextual information associated with calls that don't return any results. + + + + + Constructs a new with no state. + + + + + Creates a new by copying immutable state from the given + interception context. Also see + + The context from which to copy state. + + + + Prevents the operation from being executed if called before the operation has executed. + + + Thrown if this method is called after the operation has already executed. + + + + + Creates a new that contains all the contextual information in this + interception context together with the flag set to true. + + A new interception context associated with the async flag set. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + + + + + + + + + + + + + When true, this flag indicates that that execution of the operation has been suppressed by + one of the interceptors. This can be done before the operation has executed by calling + or by setting an to be thrown + + + + + If execution of the operation fails, then this property will contain the exception that was + thrown. If the operation was suppressed or did not fail, then this property will always be null. + + + When an operation fails both this property and the property are set + to the exception that was thrown. However, the property can be set or + changed by interceptors, while this property will always represent the original exception thrown. + + + + + If this property is set before the operation has executed, then execution of the operation will + be suppressed and the set exception will be thrown instead. Otherwise, if the operation fails, then + this property will be set to the exception that was thrown. In either case, interceptors that run + after the operation can change this property to change the exception that will be thrown, or set this + property to null to cause no exception to be thrown at all. + + + When an operation fails both this property and the property are set + to the exception that was thrown. However, the this property can be set or changed by + interceptors, while the property will always represent + the original exception thrown. + + + + + Set to the status of the after an async operation has finished. Not used for + synchronous operations. + + + + + Gets or sets a value containing arbitrary user-specified state information associated with the operation. + + + + + Constructs a new with no state. + + + + + Creates a new by copying immutable state from the given + interception context. Also see + + The context from which to copy state. + + + + Creates a new that contains all the contextual information in this + interception context together with the flag set to true. + + A new interception context associated with the async flag set. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + + + + + + + + + + + + + + + + Represents contextual information associated with calls to property setters of type on a . + + The type of the target property. + + + + Represents contextual information associated with calls to property setters of type . + + + An instance of this class is passed to the dispatch methods and does not contain mutable information such as + the result of the operation. This mutable information is obtained from the + that is passed to the interceptors. Instances of this class are publicly immutable. To add contextual information + use one of the With... or As... methods to create a new interception context containing the new information. + + The type of the target property. + + + + Constructs a new with no state. + + + + + Creates a new by copying immutable state from the given + interception context. Also see + + The context from which to copy state. + + + + Creates a new that contains all the contextual information in this + interception context together with the given property value. + + The value that will be assigned to the target property. + A new interception context associated with the given property value. + + + + + + + Prevents the operation from being executed if called before the operation has executed. + + + Thrown if this method is called after the operation has already executed. + + + + + Creates a new that contains all the contextual information in this + interception context together with the flag set to true. + + A new interception context associated with the async flag set. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + + + + + + + + + + + + + The value that will be assigned to the target property. + + + + + Gets or sets a value containing arbitrary user-specified state information associated with the operation. + + + + + When true, this flag indicates that that execution of the operation has been suppressed by + one of the interceptors. This can be done before the operation has executed by calling + or by setting an to be thrown + + + + + If execution of the operation fails, then this property will contain the exception that was + thrown. If the operation was suppressed or did not fail, then this property will always be null. + + + When an operation fails both this property and the property are set + to the exception that was thrown. However, the property can be set or + changed by interceptors, while this property will always represent the original exception thrown. + + + + + If this property is set before the operation has executed, then execution of the operation will + be suppressed and the set exception will be thrown instead. Otherwise, if the operation fails, then + this property will be set to the exception that was thrown. In either case, interceptors that run + after the operation can change this property to change the exception that will be thrown, or set this + property to null to cause no exception to be thrown at all. + + + When an operation fails both this property and the property are set + to the exception that was thrown. However, the this property can be set or changed by + interceptors, while the property will always represent + the original exception thrown. + + + + + Set to the status of the after an async operation has finished. Not used for + synchronous operations. + + + + + Constructs a new with no state. + + + + + Creates a new by copying immutable state from the given + interception context. Also see + + The context from which to copy state. + + + + Creates a new that contains all the contextual information in this + interception context together with the given property value. + + The value that will be assigned to the target property. + A new interception context associated with the given property value. + + + + + + + Creates a new that contains all the contextual information in this + interception context together with the flag set to true. + + A new interception context associated with the async flag set. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + + + + + + + + + + + + + Used for dispatching operations to a such that any + registered on will be notified before and after the + operation executes. + Instances of this class are obtained through the the fluent API. + + + This class is used internally by Entity Framework when executing commands. It is provided publicly so that + code that runs outside of the core EF assemblies can opt-in to command interception/tracing. This is + typically done by EF providers that are executing commands on behalf of EF. + + + + + Sends and + to any + registered on before/after making a + call to . + + + Note that the result of executing the command is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The command on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after making a + call to . + + + Note that the result of executing the command is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The command on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after making a + call to . + + + Note that the result of executing the command is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The command on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after making a + call to . + + + Note that the result of executing the command is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The command on which the operation will be executed. + Optional information about the context of the call being made. + The cancellation token for the asynchronous operation. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after making a + call to . + + + Note that the result of executing the command is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The command on which the operation will be executed. + Optional information about the context of the call being made. + The cancellation token for the asynchronous operation. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after making a + call to . + + + Note that the result of executing the command is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The command on which the operation will be executed. + Optional information about the context of the call being made. + The cancellation token for the asynchronous operation. + The result of the operation, which may have been modified by interceptors. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Represents contextual information associated with calls into + implementations. + + + An instance of this class is passed to the dispatch methods of + and does not contain mutable information such as the result of the operation. This mutable information + is obtained from the that is passed to the interceptors. + Instances of this class are publicly immutable. To add contextual information use one of the + With... or As... methods to create a new interception context containing the new information. + + + + + Constructs a new with no state. + + + + + Creates a new by copying state from the given + interception context. Also see + + The context from which to copy state. + + + + Creates a new that contains all the contextual information in this + interception context together with the given . + + The command behavior to associate. + A new interception context associated with the given command behavior. + + + + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context the flag set to true. + + A new interception context associated with the async flag set. + + + + + + + + + + + + + + + + The that will be used or has been used to execute the command with a + . This property is only used for + and its async counterparts. + + + + + Represents contextual information associated with calls into + implementations including the result of the operation. + + The type of the operation's results. + + Instances of this class are publicly immutable for contextual information. To add + contextual information use one of the With... or As... methods to create a new + interception context containing the new information. + + + + + Constructs a new with no state. + + + + + Creates a new by copying immutable state from the given + interception context. Also see + + The context from which to copy state. + + + + Prevents the operation from being executed if called before the operation has executed. + + + Thrown if this method is called after the operation has already executed. + + + + + Creates a new that contains all the contextual information in this + interception context together with the flag set to true. + + A new interception context associated with the async flag set. + + + + Creates a new that contains all the contextual information in this + interception context together with the given . + + The command behavior to associate. + A new interception context associated with the given command behavior. + + + + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + + + + + + + + + + + + + If execution of the operation completes without throwing, then this property will contain + the result of the operation. If the operation was suppressed or did not fail, then this property + will always contain the default value for the generic type. + + + When an operation operation completes without throwing both this property and the + property are set. However, the property can be set or changed by interceptors, + while this property will always represent the actual result returned by the operation, if any. + + + + + If this property is set before the operation has executed, then execution of the operation will + be suppressed and the set result will be returned instead. Otherwise, if the operation succeeds, then + this property will be set to the returned result. In either case, interceptors that run + after the operation can change this property to change the result that will be returned. + + + When an operation operation completes without throwing both this property and the + property are set. However, this property can be set or changed by interceptors, while the + property will always represent the actual result returned by the + operation, if any. + + + + + When true, this flag indicates that that execution of the operation has been suppressed by + one of the interceptors. This can be done before the operation has executed by calling + , by setting an to be thrown, or + by setting the operation result using . + + + + + Gets or sets a value containing arbitrary user-specified state information associated with the operation. + + + + + If execution of the operation fails, then this property will contain the exception that was + thrown. If the operation was suppressed or did not fail, then this property will always be null. + + + When an operation fails both this property and the property are set + to the exception that was thrown. However, the property can be set or + changed by interceptors, while this property will always represent the original exception thrown. + + + + + If this property is set before the operation has executed, then execution of the operation will + be suppressed and the set exception will be thrown instead. Otherwise, if the operation fails, then + this property will be set to the exception that was thrown. In either case, interceptors that run + after the operation can change this property to change the exception that will be thrown, or set this + property to null to cause no exception to be thrown at all. + + + When an operation fails both this property and the property are set + to the exception that was thrown. However, the this property can be set or changed by + interceptors, while the property will always represent + the original exception thrown. + + + + + Set to the status of the after an async operation has finished. Not used for + synchronous operations. + + + + + Base class that implements . This class is a convenience for + use when only one or two methods of the interface actually need to have any implementation. + + + + + + + + + + + + + + + + + + + + + + + Represents contextual information associated with calls into + implementations. + + + Instances of this class are publicly immutable for contextual information. To add + contextual information use one of the With... or As... methods to create a new + interception context containing the new information. + + + + + Constructs a new with no state. + + + + + Creates a new by copying state from the given + interception context. Also see + + The context from which to copy state. + + + + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context the flag set to true. + + A new interception context associated with the async flag set. + + + + + + + + + + + + + + + + The original tree created by Entity Framework. Interceptors can change the + property to change the tree that will be used, but the + will always be the tree created by Entity Framework. + + + + + The command tree that will be used by Entity Framework. This starts as the tree contained in the + the property but can be set by interceptors to change + the tree that will be used by Entity Framework. + + + + + Gets or sets a value containing arbitrary user-specified state information associated with the operation. + + + + + Used for dispatching operations to a such that any + registered on will be notified before and after the + operation executes. + Instances of this class are obtained through the the fluent API. + + + This class is used internally by Entity Framework when interacting with . + It is provided publicly so that code that runs outside of the core EF assemblies can opt-in to command + interception/tracing. This is typically done by EF providers that are executing commands on behalf of EF. + + + + + Sends and + to any + registered on before/after making a + call to . + + + Note that the result of executing the command is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after making a + call to . + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + + + + Sends and + to any + registered on before/after making a + call to . + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + + + + Sends and + to any + registered on before/after + getting . + + + Note that the value of the property is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after + setting . + + The connection on which the operation will be executed. + Information about the context of the call being made, including the value to be set. + + + + Sends and + to any + registered on before/after + getting . + + + Note that the value of the property is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after + getting . + + + Note that the value of the property is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after + getting . + + + Note that the value of the property is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after making a + call to . + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + + + + Sends and + to any + registered on before/after making a + call to . + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + + + + Sends and + to any + registered on before/after making a + call to . + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + The cancellation token. + A task that represents the asynchronous operation. + + + + Sends and + to any + registered on before/after + getting . + + + Note that the value of the property is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after + getting . + + + Note that the value of the property is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The connection on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Provides access to all dispatchers through the the fluent API. + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Provides methods for dispatching to interceptors for + interception of methods on . + + + + + Provides methods for dispatching to interceptors for + interception of methods on . + + + + + Provides methods for dispatching to interceptors for + interception of methods on . + + + + + This is the registration point for interceptors. Interceptors + receive notifications when EF performs certain operations such as executing commands against + the database. For example, see . + + + + + Registers a new to receive notifications. Note that the interceptor + must implement some interface that extends from to be useful. + + The interceptor to add. + + + + Removes a registered so that it will no longer receive notifications. + If the given interceptor is not registered, then this is a no-op. + + The interceptor to remove. + + + + This is the entry point for dispatching to interceptors. This is usually only used internally by + Entity Framework but it is provided publicly so that other code can make sure that registered + interceptors are called when operations are performed on behalf of EF. For example, EF providers + a may make use of this when executing commands. + + + + + Used for dispatching operations to a such that any + registered on will be notified before and after the + operation executes. + Instances of this class are obtained through the the fluent API. + + + This class is used internally by Entity Framework when interacting with . + It is provided publicly so that code that runs outside of the core EF assemblies can opt-in to command + interception/tracing. This is typically done by EF providers that are executing commands on behalf of EF. + + + + + Sends and + to any + registered on before/after + getting . + + + Note that the value of the property is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The transaction on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after + getting . + + + Note that the value of the property is returned by this method. The result is not available + in the interception context passed into this method since the interception context is cloned before + being passed to interceptors. + + The transaction on which the operation will be executed. + Optional information about the context of the call being made. + The result of the operation, which may have been modified by interceptors. + + + + Sends and + to any + registered on before/after making a + call to . + + The transaction on which the operation will be executed. + Optional information about the context of the call being made. + + + + Sends and + to any + registered on before/after making a + call to . + + The transaction on which the operation will be executed. + Optional information about the context of the call being made. + + + + Sends and + to any + registered on before/after making a + call to . + + The transaction on which the operation will be executed. + Optional information about the context of the call being made. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Represents contextual information associated with calls to that don't return any results. + + + + + Constructs a new with no state. + + + + + Creates a new by copying immutable state from the given + interception context. Also see + + The context from which to copy state. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The connection on which the transaction was started. + A new interception context that also contains the connection on which the transaction was started. + + + + Creates a new that contains all the contextual information in this + interception context together with the flag set to true. + + A new interception context associated with the async flag set. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + + + + + + + + + + + + + + + + The connection on which the transaction was started + + + + + Represents contextual information associated with calls to with return type . + + The return type of the target method. + + + + Constructs a new with no state. + + + + + Creates a new by copying immutable state from the given + interception context. Also see + + The context from which to copy state. + + + + Creates a new that contains all the contextual information in this + interception context together with the flag set to true. + + A new interception context associated with the async flag set. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + + + + + + + + + + + + + + + + Represents contextual information associated with calls to + implementations. + + + Instances of this class are publicly immutable for contextual information. To add + contextual information use one of the With... or As... methods to create a new + interception context containing the new information. + + + + + Constructs a new with no state. + + + + + Creates a new by copying immutable state from the given + interception context. Also see + + The context from which to copy state. + + + + Creates a new that contains all the contextual information in this + interception context together with the flag set to true. + + A new interception context associated with the async flag set. + + + + Creates a new that contains all the contextual information in this + interception context together with the given . + + The transaction to be used in the invocation. + A new interception context associated with the given isolation level. + + + + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + Creates a new that contains all the contextual information in this + interception context with the addition of the given . + + The context to associate. + A new interception context associated with the given context. + + + + + + + + + + + + + + + + The that will be used or has been used to enlist a connection. + + + + + An object that implements this interface can be registered with to + receive notifications when Entity Framework creates command trees. + + + Interceptors can also be registered in the config file of the application. + See http://go.microsoft.com/fwlink/?LinkId=260883 for more information about Entity Framework configuration. + + + + + This method is called after a new has been created. + The tree that is used after interception can be changed by setting + while intercepting. + + + Command trees are created for both queries and insert/update/delete commands. However, query + command trees are cached by model which means that command tree creation only happens the + first time a query is executed and this notification will only happen at that time + + Contextual information associated with the call. + + + + Represents a mapping view. + + + + + Creates a instance having the specified entity SQL. + + A string that specifies the entity SQL. + + + + Gets the entity SQL. + + + + + Base abstract class for mapping view cache implementations. + Derived classes must have a parameterless constructor if used with . + + + + + Gets a view corresponding to the specified extent. + + An that specifies the extent. + A that specifies the mapping view, + or null if the extent is not associated with a mapping view. + + + + Gets a hash value computed over the mapping closure. + + + + + Specifies the means to create concrete instances. + + + + + Creates a generated view cache instance for the container mapping specified by + the names of the mapped containers. + + The name of a container in the conceptual model. + The name of a container in the store model. + + A that specifies the generated view cache. + + + + + Defines a custom attribute that specifies the mapping view cache type (subclass of ) + associated with a context type (subclass of or ). + The cache type is instantiated at runtime and used to retrieve pre-generated views in the + corresponding context. + + + + + Creates a instance that associates a context type + with a mapping view cache type. + + + A subclass of or . + + + A subclass of . + + + + + Creates a instance that associates a context type + with a mapping view cache type. + + + A subclass of or . + + The assembly qualified full name of the cache type. + + + + The base class for interceptors that handle the transaction operations. Derived classes can be registered using + or + . + + + + + Initializes a new instance of the class. + + + One of the Initialize methods needs to be called before this instance can be used. + + + + + Initializes this instance using the specified context. + + The context for which transaction operations will be handled. + + + + Initializes this instance using the specified context. + + The context for which transaction operations will be handled. + The connection to use for the initialization. + + This method is called by migrations. It is important that no action is performed on the + specified context that causes it to be initialized. + + + + + + + + Releases the resources used by this transaction handler. + + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + + Checks whether the supplied interception context contains the target context + or the supplied connection is the same as the one used by the target context. + + A connection. + An interception context. + + true if the supplied interception context contains the target context or + the supplied connection is the same as the one used by the target context if + the supplied interception context doesn't contain any contexts; false otherwise. + + + Note that calling this method will trigger initialization of any DbContext referenced from the + + + + + When implemented in a derived class returns the script to prepare the database + for this transaction handler. + + A script to change the database schema for this transaction handler. + + + + Can be implemented in a derived class. + + The connection beginning the transaction. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection that began the transaction. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection being closed. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection that was closed. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection being disposed. + Contextual information associated with the call. + + + + Can be implemented in a derived class. + + The connection that was disposed. + Contextual information associated with the call. + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection being opened. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection that was opened. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The connection. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The transaction. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The transaction. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The transaction. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The transaction. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The transaction being commited. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The transaction that was commited. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The transaction being disposed. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The transaction that was disposed. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The transaction being rolled back. + Contextual information associated with the call. + + + + + Can be implemented in a derived class. + + The transaction that was rolled back. + Contextual information associated with the call. + + + + + Gets the context. + + + The for which the transaction operations will be handled. + + + + + Gets the context. + + + The for which the transaction operations will be handled, could be null. + + + + + Gets the connection. + + + The for which the transaction operations will be handled. + + + This connection object is only used to determine whether a particular operation needs to be handled + in cases where a context is not available. + + + + + Gets or sets a value indicating whether this transaction handler is disposed. + + + true if disposed; otherwise, false. + + + + + This class is used by to write and read transaction tracing information + from the database. + To customize the definition of the transaction table you can derive from + this class and override . Derived classes can be registered + using . + + + By default EF will poll the resolved to check wether the database schema is compatible and + will try to modify it accordingly if it's not. To disable this check call + Database.SetInitializer<TTransactionContext>(null) where TTransactionContext is the type of the resolved context. + + + + + A DbContext instance represents a combination of the Unit Of Work and Repository patterns such that + it can be used to query from a database and group together changes that will then be written + back to the store as a unit. + DbContext is conceptually similar to ObjectContext. + + + DbContext is usually used with a derived type that contains properties for + the root entities of the model. These sets are automatically initialized when the + instance of the derived class is created. This behavior can be modified by applying the + attribute to either the entire derived context + class, or to individual properties on the class. + The Entity Data Model backing the context can be specified in several ways. When using the Code First + approach, the properties on the derived context are used to build a model + by convention. The protected OnModelCreating method can be overridden to tweak this model. More + control over the model used for the Model First approach can be obtained by creating a + explicitly from a and passing this model to one of the DbContext constructors. + When using the Database First or Model First approach the Entity Data Model can be created using the + Entity Designer (or manually through creation of an EDMX file) and then this model can be specified using + entity connection string or an object. + The connection to the database (including the name of the database) can be specified in several ways. + If the parameterless DbContext constructor is called from a derived context, then the name of the derived context + is used to find a connection string in the app.config or web.config file. If no connection string is found, then + the name is passed to the DefaultConnectionFactory registered on the class. The connection + factory then uses the context name as the database name in a default connection string. (This default connection + string points to .\SQLEXPRESS on the local machine unless a different DefaultConnectionFactory is registered.) + Instead of using the derived context name, the connection/database name can also be specified explicitly by + passing the name to one of the DbContext constructors that takes a string. The name can also be passed in + the form "name=myname", in which case the name must be found in the config file or an exception will be thrown. + Note that the connection found in the app.config or web.config file can be a normal database connection + string (not a special Entity Framework connection string) in which case the DbContext will use Code First. + However, if the connection found in the config file is a special Entity Framework connection string, then the + DbContext will use Database/Model First and the model specified in the connection string will be used. + An existing or explicitly created DbConnection can also be used instead of the database/connection name. + A can be applied to a class derived from DbContext to set the + version of conventions used by the context when it creates a model. If no attribute is applied then the + latest version of conventions will be used. + + + + + Interface implemented by objects that can provide an instance. + The class implements this interface to provide access to the underlying + ObjectContext. + + + + + Gets the object context. + + The object context. + + + + Constructs a new context instance using conventions to create the name of the database to + which a connection will be made. The by-convention name is the full name (namespace + class name) + of the derived context class. + See the class remarks for how this is used to create a connection. + + + + + Constructs a new context instance using conventions to create the name of the database to + which a connection will be made, and initializes it from the given model. + The by-convention name is the full name (namespace + class name) of the derived context class. + See the class remarks for how this is used to create a connection. + + The model that will back this context. + + + + Constructs a new context instance using the given string as the name or connection string for the + database to which a connection will be made. + See the class remarks for how this is used to create a connection. + + Either the database name or a connection string. + + + + Constructs a new context instance using the given string as the name or connection string for the + database to which a connection will be made, and initializes it from the given model. + See the class remarks for how this is used to create a connection. + + Either the database name or a connection string. + The model that will back this context. + + + + Constructs a new context instance using the existing connection to connect to a database. + The connection will not be disposed when the context is disposed if + is false. + + An existing connection to use for the new context. + + If set to true the connection is disposed when the context is disposed, otherwise the caller must dispose the connection. + + + + + Constructs a new context instance using the existing connection to connect to a database, + and initializes it from the given model. + The connection will not be disposed when the context is disposed if + is false. + + An existing connection to use for the new context. + The model that will back this context. + + If set to true the connection is disposed when the context is disposed, otherwise the caller must dispose the connection. + + + + + Constructs a new context instance around an existing ObjectContext. + + An existing ObjectContext to wrap with the new context. + + If set to true the ObjectContext is disposed when the DbContext is disposed, otherwise the caller must dispose the connection. + + + + + This method is called when the model for a derived context has been initialized, but + before the model has been locked down and used to initialize the context. The default + implementation of this method does nothing, but it can be overridden in a derived class + such that the model can be further configured before it is locked down. + + + Typically, this method is called only once when the first instance of a derived context + is created. The model for that context is then cached and is for all further instances of + the context in the app domain. This caching can be disabled by setting the ModelCaching + property on the given ModelBuidler, but note that this can seriously degrade performance. + More control over caching is provided through use of the DbModelBuilder and DbContextFactory + classes directly. + + The builder that defines the model for the context being created. + + + + Returns a instance for access to entities of the given type in the context + and the underlying store. + + + Note that Entity Framework requires that this method return the same instance each time that it is called + for a given context instance and entity type. Also, the non-generic returned by the + method must wrap the same underlying query and set of entities. These invariants must + be maintained if this method is overridden for anything other than creating test doubles for unit testing. + See the class for more details. + + The type entity for which a set should be returned. + A set for the given entity type. + + + + Returns a non-generic instance for access to entities of the given type in the context + and the underlying store. + + The type of entity for which a set should be returned. + A set for the given entity type. + + Note that Entity Framework requires that this method return the same instance each time that it is called + for a given context instance and entity type. Also, the generic returned by the + method must wrap the same underlying query and set of entities. These invariants must + be maintained if this method is overridden for anything other than creating test doubles for unit testing. + See the class for more details. + + + + + Saves all changes made in this context to the underlying database. + + + The number of state entries written to the underlying database. This can include + state entries for entities and/or relationships. Relationship state entries are created for + many-to-many relationships and relationships where there is no foreign key property + included in the entity class (often referred to as independent associations). + + An error occurred sending updates to the database. + + A database command did not affect the expected number of rows. This usually indicates an optimistic + concurrency violation; that is, a row has been changed in the database since it was queried. + + + The save was aborted because validation of entity property values failed. + + + An attempt was made to use unsupported behavior such as executing multiple asynchronous commands concurrently + on the same context instance. + The context or connection have been disposed. + + Some error occurred attempting to process entities in the context either before or after sending commands + to the database. + + + + + Asynchronously saves all changes made in this context to the underlying database. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous save operation. + The task result contains the number of state entries written to the underlying database. This can include + state entries for entities and/or relationships. Relationship state entries are created for + many-to-many relationships and relationships where there is no foreign key property + included in the entity class (often referred to as independent associations). + + An error occurred sending updates to the database. + + A database command did not affect the expected number of rows. This usually indicates an optimistic + concurrency violation; that is, a row has been changed in the database since it was queried. + + + The save was aborted because validation of entity property values failed. + + + An attempt was made to use unsupported behavior such as executing multiple asynchronous commands concurrently + on the same context instance. + The context or connection have been disposed. + + Some error occurred attempting to process entities in the context either before or after sending commands + to the database. + + + + + Asynchronously saves all changes made in this context to the underlying database. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous save operation. + The task result contains the number of state entries written to the underlying database. This can include + state entries for entities and/or relationships. Relationship state entries are created for + many-to-many relationships and relationships where there is no foreign key property + included in the entity class (often referred to as independent associations). + + Thrown if the context has been disposed. + + + + Validates tracked entities and returns a Collection of containing validation results. + + Collection of validation results for invalid entities. The collection is never null and must not contain null values or results for valid entities. + + 1. This method calls DetectChanges() to determine states of the tracked entities unless + DbContextConfiguration.AutoDetectChangesEnabled is set to false. + 2. By default only Added on Modified entities are validated. The user is able to change this behavior + by overriding ShouldValidateEntity method. + + + + + Extension point allowing the user to override the default behavior of validating only + added and modified entities. + + DbEntityEntry instance that is supposed to be validated. + true to proceed with validation; false otherwise. + + + + Extension point allowing the user to customize validation of an entity or filter out validation results. + Called by . + + DbEntityEntry instance to be validated. + + User-defined dictionary containing additional info for custom validation. It will be passed to + + and will be exposed as + + . This parameter is optional and can be null. + + Entity validation result. Possibly null when overridden. + + + + Gets a object for the given entity providing access to + information about the entity and the ability to perform actions on the entity. + + The type of the entity. + The entity. + An entry for the entity. + + + + Gets a object for the given entity providing access to + information about the entity and the ability to perform actions on the entity. + + The entity. + An entry for the entity. + + + + Calls the protected Dispose method. + + + + + Disposes the context. The underlying is also disposed if it was created + is by this context or ownership was passed to this context when this context was created. + The connection to the database ( object) is also disposed if it was created + is by this context or ownership was passed to this context when this context was created. + + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + + + + + + + + + + + + + + Creates a Database instance for this context that allows for creation/deletion/existence checks + for the underlying database. + + + + + Returns the Entity Framework ObjectContext that is underlying this context. + + Thrown if the context has been disposed. + + + + Provides access to features of the context that deal with change tracking of entities. + + An object used to access features that deal with change tracking. + + + + Provides access to configuration options for the context. + + An object used to access configuration options. + + + + Initializes a new instance of the class. + + The connection used by the context for which the transactions will be recorded. + + + + + + + Gets or sets a that can be used to read and write instances. + + + + + A transaction handler that allows to gracefully recover from connection failures + during transaction commit by storing transaction tracing information in the database. + It needs to be registered by using . + + + This transaction handler uses to store the transaction information + the schema used can be configured by creating a class derived from + that overrides DbContext.OnModelCreating(DbModelBuilder) and passing it to the constructor of this class. + + + + + Initializes a new instance of the class using the default . + + + One of the Initialize methods needs to be called before this instance can be used. + + + + + Initializes a new instance of the class. + + The transaction context factory. + + One of the Initialize methods needs to be called before this instance can be used. + + + + + + + + + + + + + + + + + Stores the tracking information for the new transaction to the database in the same transaction. + + The connection that began the transaction. + Contextual information associated with the call. + + + + + If there was an exception thrown checks the database for this transaction and rethrows it if not found. + Otherwise marks the commit as succeeded and queues the transaction information to be deleted. + + The transaction that was commited. + Contextual information associated with the call. + + + + + Stops tracking the transaction that was rolled back. + + The transaction that was rolled back. + Contextual information associated with the call. + + + + + Stops tracking the transaction that was disposed. + + The transaction that was disposed. + Contextual information associated with the call. + + + + + Removes all the transaction history. + + + This method should only be invoked when there are no active transactions to remove any leftover history + that was not deleted due to catastrophic failures + + + + + Asynchronously removes all the transaction history. + + + This method should only be invoked when there are no active transactions to remove any leftover history + that was not deleted due to catastrophic failures + + A task that represents the asynchronous operation. + + + + Asynchronously removes all the transaction history. + + + This method should only be invoked when there are no active transactions to remove any leftover history + that was not deleted due to catastrophic failures + + The cancellation token. + A task that represents the asynchronous operation. + + + + Adds the specified transaction to the list of transactions that can be removed from the database + + The transaction to be removed from the database. + + + + Removes the transactions marked for deletion. + + + + + Asynchronously removes the transactions marked for deletion. + + A task that represents the asynchronous operation. + + + + Asynchronously removes the transactions marked for deletion. + + The cancellation token. + A task that represents the asynchronous operation. + + + + Removes the transactions marked for deletion if their number exceeds . + + + if set to true will remove all the old transactions even if their number does not exceed . + + + if set to true the operation will be executed using the associated execution strategy + + + + + Removes the transactions marked for deletion if their number exceeds . + + + if set to true will remove all the old transactions even if their number does not exceed . + + + if set to true the operation will be executed using the associated execution strategy + + The cancellation token. + A task that represents the asynchronous operation. + + + + Gets the associated with the if there is one; + otherwise returns null. + + The context + The associated . + + + + Gets the associated with the if there is one; + otherwise returns null. + + The context + The associated . + + + + Gets the transaction context. + + + The transaction context. + + + + + Gets the number of transactions to be executed on the context before the transaction log will be cleaned. + The default value is 20. + + + + + An implementation of this interface is used to initialize the underlying database when + an instance of a derived class is used for the first time. + This initialization can conditionally create the database and/or seed it with data. + The strategy used is set using the static InitializationStrategy property of the + class. + The following implementations are provided: , + , . + + The type of the context. + + + + Executes the strategy to initialize the database for the given context. + + The context. + + + + Rrepresents a transaction + + + + + + + + + + + A unique id assigned to a transaction object. + + + + + The local time when the transaction was started. + + + + + Helper class that is used to configure a parameter. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Creates a new parameter definition to pass Binary data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The maximum allowable length of the array data. + Value indicating whether or not all data should be padded to the maximum length. + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass Boolean data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass Byte data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass DateTime data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The precision of the parameter. + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass Decimal data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The numeric precision of the parameter. + The numeric scale of the parameter. + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass Double data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass GUID data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass Single data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass Short data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass Integer data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass Long data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass String data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The maximum allowable length of the string data. + Value indicating whether or not all data should be padded to the maximum length. + Value indicating whether or not the parameter supports Unicode content. + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass Time data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The precision of the parameter. + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass DateTimeOffset data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The precision of the parameter. + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass geography data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + Creates a new parameter definition to pass geometry data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Constant value to use as the default value for this parameter. + SQL expression used as the default value for this parameter. + The name of the parameter. + Provider specific data type to use for this parameter. + A value indicating whether the parameter is an output parameter. + The newly constructed parameter definition. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Creates a shallow copy of the current . + + A shallow copy of the current . + + + + Represents altering an existing stored procedure. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + A migration operation that affects stored procedures. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Represents an operation to modify a database schema. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the MigrationOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" + }'. + + + + + Gets additional arguments that may be processed by providers. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets an operation that will revert this operation. + + + + + Gets a value indicating if this operation may result in data loss. + + + + + Initializes a new instance of the class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the stored procedure. + The body of the stored procedure expressed in SQL. + Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the stored procedure. + + + The name of the stored procedure. + + + + + Gets the body of the stored procedure expressed in SQL. + + + The body of the stored procedure expressed in SQL. + + + + + Gets the parameters of the stored procedure. + + + The parameters of the stored procedure. + + + + + Gets a value indicating if this operation may result in data loss. Always returns false. + + + + + Initializes a new instance of the class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the stored procedure. + The body of the stored procedure expressed in SQL. + Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets an operation that will revert this operation. + Always returns a . + + + + + Represents changes made to custom annotations on a table. + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the AlterTableOperation class. + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Name of the table on which annotations have changed. + The custom annotations on the table that have changed. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Gets the name of the table on which annotations have changed. + + + + + Gets the columns to be included in the table for which annotations have changed. + + + + + Gets the custom annotations that have changed on the table. + + + + + Gets an operation that is the inverse of this one such that annotations will be changed back to how + they were before this operation was applied. + + + + + + + + Represents renaming an existing index. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the RenameIndexOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Name of the table the index belongs to. + Name of the index to be renamed. + New name for the index. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the table the index belongs to. + + + + + Gets the name of the index to be renamed. + + + + + Gets the new name for the index. + + + + + Gets an operation that reverts the rename. + + + + + + + + Used when scripting an update database operation to store the operations that would have been performed against the database. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The queries used to determine if this migration needs to be applied to the database. + This is used to generate an idempotent SQL script that can be run against a database at any version. + + + + + Adds a migration to this update database operation. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The id of the migration. + The individual operations applied by the migration. + + + + The queries used to determine if this migration needs to be applied to the database. + This is used to generate an idempotent SQL script that can be run against a database at any version. + + + + + Gets the migrations applied during the update database operation. + + + The migrations applied during the update database operation. + + + + + Gets a value indicating if any of the operations may result in data loss. + + + + + Represents a migration to be applied to the database. + + + + + Gets the id of the migration. + + + The id of the migration. + + + + + Gets the individual operations applied by this migration. + + + The individual operations applied by this migration. + + + + + Represents moving a stored procedure to a new schema in the database. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the stored procedure to move. + The new schema for the stored procedure. + Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the stored procedure to move. + + + The name of the stored procedure to move. + + + + + Gets the new schema for the stored procedure. + + + The new schema for the stored procedure. + + + + + Gets an operation that will revert this operation. + + + + + Gets a value indicating if this operation may result in data loss. Always returns false. + + + + + Represents renaming a stored procedure in the database. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the stored procedure to rename. + The new name for the stored procedure. + Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the stored procedure to rename. + + + The name of the stored procedure to rename. + + + + + Gets the new name for the stored procedure. + + + The new name for the stored procedure. + + + + + Gets an operation that will revert this operation. + + + + + Gets a value indicating if this operation may result in data loss. Always returns false. + + + + + Represents a migration operation that can not be performed, possibly because it is not supported by the targeted database provider. + + + + + Gets a value indicating if this operation may result in data loss. Always returns false. + + + + + Represents information about a parameter. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Represents information about a property of an entity. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the PropertyModel class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The data type for this property model. + Additional details about the data type. This includes details such as maximum length, nullability etc. + + + + Gets the data type for this property model. + + + + + Gets additional details about the data type of this property model. + This includes details such as maximum length, nullability etc. + + + + + Gets or sets the name of the property model. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets or sets a provider specific data type to use for this property model. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets or sets the maximum length for this property model. + Only valid for array data types. + + + + + Gets or sets the precision for this property model. + Only valid for decimal data types. + + + + + Gets or sets the scale for this property model. + Only valid for decimal data types. + + + + + Gets or sets a constant value to use as the default value for this property model. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets or sets a SQL expression used as the default value for this property model. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets or sets a value indicating if this property model is fixed length. + Only valid for array data types. + + + + + Gets or sets a value indicating if this property model supports Unicode characters. + Only valid for textual data types. + + + + + Initializes a new instance of the ParameterModel class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The data type for this parameter. + + + + Initializes a new instance of the ParameterModel class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The data type for this parameter. + Additional details about the data type. This includes details such as maximum length, nullability etc. + + + + Gets or sets a value indicating whether this instance is out parameter. + + + true if this instance is out parameter; otherwise, false. + + + + + Drops a stored procedure from the database. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the stored procedure to drop. + Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the stored procedure to drop. + + + The name of the stored procedure to drop. + + + + + Gets an operation that will revert this operation. + Always returns a . + + + + + Gets a value indicating if this operation may result in data loss. Always returns false. + + + + + Allows configuration to be performed for a lightweight convention based on + the entity types in a model. + + + + + Filters the entity types that this convention applies to based on a + predicate. + + A function to test each entity type for a condition. + + An instance so that multiple calls can be chained. + + + + + Filters the entity types that this convention applies to based on a predicate + while capturing a value to use later during configuration. + + Type of the captured value. + + A function to capture a value for each entity type. If the value is null, the + entity type will be filtered out. + + + An instance so that multiple calls can be chained. + + + + + Allows configuration of the entity types that this convention applies to. + + + An action that performs configuration against a + + . + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Allows configuration to be performed for a lightweight convention based on + the entity types in a model that inherit from a common, specified type. + + The common type of the entity types that this convention applies to. + + + + Filters the entity types that this convention applies to based on a + predicate. + + A function to test each entity type for a condition. + + An instance so that multiple calls can be chained. + + + + + Filters the entity types that this convention applies to based on a predicate + while capturing a value to use later during configuration. + + Type of the captured value. + + A function to capture a value for each entity type. If the value is null, the + entity type will be filtered out. + + + An instance so that multiple calls can be chained. + + + + + Allows configuration of the entity types that this convention applies to. + + + An action that performs configuration against a + + . + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Allows configuration to be performed for a lightweight convention based on + the entity types in a model that inherit from a common, specified type and a + captured value. + + The common type of the entity types that this convention applies to. + Type of the captured value. + + + + Allows configuration of the entity types that this convention applies to. + + + An action that performs configuration against a + using a captured value. + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Allows configuration to be performed for a lightweight convention based on + the entity types in a model and a captured value. + + Type of the captured value. + + + + Allows configuration of the entity types that this convention applies to. + + + An action that performs configuration against a + using a captured value. + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Allows configuration to be performed for an entity type in a model. + This configuration functionality is available via lightweight conventions. + + + + + Configures the entity set name to be used for this entity type. + The entity set name can only be configured for the base type in each set. + + The name of the entity set. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Excludes this entity type from the model so that it will not be mapped to the database. + + + The same instance so that multiple calls can be chained. + + + + + Changes this entity type to a complex type. + + + The same instance so that multiple calls can be chained. + + + + + Excludes a property from the model so that it will not be mapped to the database. + + The name of the property to be configured. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect if the property does not exist. + + + + + Excludes a property from the model so that it will not be mapped to the database. + + The property to be configured. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect if the property does not exist. + + + + + Configures a property that is defined on this type. + + The name of the property being configured. + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + The property being configured. + A configuration object that can be used to configure the property. + + + + Configures the primary key property for this entity type. + + The name of the property to be used as the primary key. + + The same instance so that multiple calls can be chained. + + + + + Configures the primary key property for this entity type. + + The property to be used as the primary key. + + The same instance so that multiple calls can be chained. + + + + + Configures the primary key property(s) for this entity type. + + The names of the properties to be used as the primary key. + + The same instance so that multiple calls can be chained. + + + + + Configures the primary key property(s) for this entity type. + + The properties to be used as the primary key. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured or if any + property does not exist. + + + + + Configures the table name that this entity type is mapped to. + + The name of the table. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Configures the table name that this entity type is mapped to. + + The name of the table. + The database schema of the table. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Sets an annotation in the model for the table to which this entity is mapped. The annotation + value can later be used when processing the table such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Calling this method will have no effect if the + annotation with the given name has already been configured. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same configuration instance so that multiple calls can be chained. + + + + Configures this type to use stored procedures for insert, update and delete. + The default conventions for procedure and parameter names will be used. + + The same configuration instance so that multiple calls can be chained. + + + + Configures this type to use stored procedures for insert, update and delete. + + + Configuration to override the default conventions for procedure and parameter names. + + The same configuration instance so that multiple calls can be chained. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Gets the of this entity type. + + + + + Allows configuration to be performed for an entity type in a model. + This configuration functionality is available via lightweight conventions. + + A type inherited by the entity type. + + + + Configures the entity set name to be used for this entity type. + The entity set name can only be configured for the base type in each set. + + The name of the entity set. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Excludes this entity type from the model so that it will not be mapped to the database. + + + The same instance so that multiple calls can be chained. + + + + + Changes this entity type to a complex type. + + + The same instance so that multiple calls can be chained. + + + + + Excludes a property from the model so that it will not be mapped to the database. + + The type of the property to be ignored. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + + The same instance so that multiple calls can be chained. + + + + + Configures a property that is defined on this type. + + The type of the property being configured. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures the primary key property(s) for this entity type. + + The type of the key. + A lambda expression representing the property to be used as the primary key. C#: t => t.Id VB.Net: Function(t) t.Id If the primary key is made up of multiple properties then specify an anonymous type including the properties. C#: t => new { t.Id1, t.Id2 } VB.Net: Function(t) New With { t.Id1, t.Id2 } + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Configures the table name that this entity type is mapped to. + + The name of the table. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Configures the table name that this entity type is mapped to. + + The name of the table. + The database schema of the table. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Sets an annotation in the model for the table to which this entity is mapped. The annotation + value can later be used when processing the table such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Calling this method will have no effect if the + annotation with the given name has already been configured. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same configuration instance so that multiple calls can be chained. + + + + Configures this type to use stored procedures for insert, update and delete. + The default conventions for procedure and parameter names will be used. + + The same configuration instance so that multiple calls can be chained. + + + + Configures this type to use stored procedures for insert, update and delete. + + + Configuration to override the default conventions for procedure and parameter names. + + The same configuration instance so that multiple calls can be chained. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Gets the of this entity type. + + + + + Identifies conventions that can be added to or removed from a instance. + + + Note that implementations of this interface must be immutable. + + + + + A general purpose class for Code First conventions that read attributes from .NET properties + and generate column annotations based on those attributes. + + The type of attribute to discover. + The type of annotation that will be created. + + + + A convention that doesn't override configuration. + + + + + The derived class can use the default constructor to apply a set rule of that change the model configuration. + + + + + Begins configuration of a lightweight convention that applies to all mapped types in + the model. + + A configuration object for the convention. + + + + Begins configuration of a lightweight convention that applies to all mapped types in + the model that derive from or implement the specified type. + + The type of the entities that this convention will apply to. + A configuration object for the convention. + This method does not add new types to the model. + + + + Begins configuration of a lightweight convention that applies to all properties + in the model. + + A configuration object for the convention. + + + + Begins configuration of a lightweight convention that applies to all primitive + properties of the specified type in the model. + + The type of the properties that the convention will apply to. + A configuration object for the convention. + + The convention will apply to both nullable and non-nullable properties of the + specified type. + + + + + Constructs a convention that will create column annotations with the given name and + using the given factory delegate. + + The name of the annotations to create. + A factory for creating the annotation on each column. + + + + A general purpose class for Code First conventions that read attributes from .NET types + and generate table annotations based on those attributes. + + The type of attribute to discover. + The type of annotation that will be created. + + + + Constructs a convention that will create table annotations with the given name and + using the given factory delegate. + + The name of the annotations to create. + A factory for creating the annotation on each table. + + + + A convention for discovering attributes on properties and generating + column annotations in the model. + + + + + Constructs a new instance of the convention. + + + + + Base class for conventions that process CLR attributes found on primitive properties in the model. + + The type of the attribute to look for. + + + + Initializes a new instance of the class. + + + + + Applies this convention to a property that has an attribute of type TAttribute applied. + + The configuration for the property that has the attribute. + The attribute. + + + + Base class for conventions that process CLR attributes found on properties of types in the model. + + + Note that the derived convention will be applied for any non-static property on the mapped type that has + the specified attribute, even if it wasn't included in the model. + + The type of the attribute to look for. + + + + Initializes a new instance of the class. + + + + + Applies this convention to a property that has an attribute of type TAttribute applied. + + The member info for the property that has the attribute. + The configuration for the class that contains the property. + The attribute. + + + + Base class for conventions that process CLR attributes found in the model. + + The type of the attribute to look for. + + + + Initializes a new instance of the class. + + + + + Applies this convention to a class that has an attribute of type TAttribute applied. + + The configuration for the class that contains the property. + The attribute. + + + + Used to configure a property in a mapping fragment. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures the name of the database column used to store the property, in a mapping fragment. + + The name of the column. + The same PropertyMappingConfiguration instance so that multiple calls can be chained. + + + + Sets an annotation in the model for the database column used to store the property. The annotation + value can later be used when processing the column such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Passing a null value clears any annotation with + the given name on the column that had been previously set. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same PropertyMappingConfiguration instance so that multiple calls can be chained. + + + + Convention to introduce indexes for foreign keys. + + + + + A convention that operates on the database section of the model after the model is created. + + The type of metadata item that this convention operates on. + + + + Applies this convention to an item in the model. + + The item to apply the convention to. + The model. + + + + + + + A convention that operates on the conceptual section of the model after the model is created. + + The type of metadata item that this convention operates on. + + + + Applies this convention to an item in the model. + + The item to apply the convention to. + The model. + + + + Useful extension methods for use with Entity Framework LINQ queries. + + + + + Specifies the related objects to include in the query results. + + + This extension method calls the Include(String) method of the source object, + if such a method exists. If the source does not have a matching method, + then this method does nothing. The , , + and types all have an appropriate Include method to call. + Paths are all-inclusive. For example, if an include call indicates Include("Orders.OrderLines"), not only will + OrderLines be included, but also Orders. When you call the Include method, the query path is only valid on + the returned instance of the . Other instances of + and the object context itself are not affected. Because the Include method returns the query object, + you can call this method multiple times on an to specify multiple paths for the query. + + The type of entity being queried. + + The source on which to call Include. + + The dot-separated list of related objects to return in the query results. + + A new with the defined query path. + + + + + Specifies the related objects to include in the query results. + + + This extension method calls the Include(String) method of the source object, + if such a method exists. If the source does not have a matching method, + then this method does nothing. The , , + and types all have an appropriate Include method to call. + Paths are all-inclusive. For example, if an include call indicates Include("Orders.OrderLines"), not only will + OrderLines be included, but also Orders. When you call the Include method, the query path is only valid on + the returned instance of the . Other instances of + and the object context itself are not affected. Because the Include method returns the query object, + you can call this method multiple times on an to specify multiple paths for the query. + + + The source on which to call Include. + + The dot-separated list of related objects to return in the query results. + + A new with the defined query path. + + + + + Specifies the related objects to include in the query results. + + + The path expression must be composed of simple property access expressions together with calls to Select for + composing additional includes after including a collection proprty. Examples of possible include paths are: + To include a single reference: query.Include(e => e.Level1Reference) + To include a single collection: query.Include(e => e.Level1Collection) + To include a reference and then a reference one level down: query.Include(e => e.Level1Reference.Level2Reference) + To include a reference and then a collection one level down: query.Include(e => e.Level1Reference.Level2Collection) + To include a collection and then a reference one level down: query.Include(e => e.Level1Collection.Select(l1 => l1.Level2Reference)) + To include a collection and then a collection one level down: query.Include(e => e.Level1Collection.Select(l1 => l1.Level2Collection)) + To include a collection and then a reference one level down: query.Include(e => e.Level1Collection.Select(l1 => l1.Level2Reference)) + To include a collection and then a collection one level down: query.Include(e => e.Level1Collection.Select(l1 => l1.Level2Collection)) + To include a collection, a reference, and a reference two levels down: query.Include(e => e.Level1Collection.Select(l1 => l1.Level2Reference.Level3Reference)) + To include a collection, a collection, and a reference two levels down: query.Include(e => e.Level1Collection.Select(l1 => l1.Level2Collection.Select(l2 => l2.Level3Reference))) + This extension method calls the Include(String) method of the source IQueryable object, if such a method exists. + If the source IQueryable does not have a matching method, then this method does nothing. + The Entity Framework ObjectQuery, ObjectSet, DbQuery, and DbSet types all have an appropriate Include method to call. + When you call the Include method, the query path is only valid on the returned instance of the IQueryable<T>. Other + instances of IQueryable<T> and the object context itself are not affected. Because the Include method returns the + query object, you can call this method multiple times on an IQueryable<T> to specify multiple paths for the query. + + The type of entity being queried. + The type of navigation property being included. + The source IQueryable on which to call Include. + A lambda expression representing the path to include. + + A new IQueryable<T> with the defined query path. + + + + + Returns a new query where the entities returned will not be cached in the + or . This method works by calling the AsNoTracking method of the + underlying query object. If the underlying query object does not have an AsNoTracking method, + then calling this method will have no affect. + + The element type. + The source query. + A new query with NoTracking applied, or the source query if NoTracking is not supported. + + + + Returns a new query where the entities returned will not be cached in the + or . This method works by calling the AsNoTracking method of the + underlying query object. If the underlying query object does not have an AsNoTracking method, + then calling this method will have no affect. + + The source query. + A new query with NoTracking applied, or the source query if NoTracking is not supported. + + + + Returns a new query that will stream the results instead of buffering. This method works by calling + the AsStreaming method of the underlying query object. If the underlying query object does not have + an AsStreaming method, then calling this method will have no affect. + + + The type of the elements of . + + + An to apply AsStreaming to. + + A new query with AsStreaming applied, or the source query if AsStreaming is not supported. + + + + Returns a new query that will stream the results instead of buffering. This method works by calling + the AsStreaming method of the underlying query object. If the underlying query object does not have + an AsStreaming method, then calling this method will have no affect. + + + An to apply AsStreaming to. + + A new query with AsStreaming applied, or the source query if AsStreaming is not supported. + + + + Enumerates the query such that for server queries such as those of , + + , + , and others the results of the query will be loaded into the associated + + , + or other cache on the client. + This is equivalent to calling ToList and then throwing away the list without the overhead of actually creating the list. + + The source query. + + + + Asynchronously enumerates the query such that for server queries such as those of , + + , + , and others the results of the query will be loaded into the associated + + , + or other cache on the client. + This is equivalent to calling ToList and then throwing away the list without the overhead of actually creating the list. + + The source query. + + A task that represents the asynchronous operation. + + + + + Asynchronously enumerates the query such that for server queries such as those of , + + , + , and others the results of the query will be loaded into the associated + + , + or other cache on the client. + This is equivalent to calling ToList and then throwing away the list without the overhead of actually creating the list. + + The source query. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + + + + Asynchronously enumerates the query results and performs the specified action on each element. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + An to enumerate. + + The action to perform on each element. + A task that represents the asynchronous operation. + + + + Asynchronously enumerates the query results and performs the specified action on each element. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + An to enumerate. + + The action to perform on each element. + + A to observe while waiting for the task to complete. + + A task that represents the asynchronous operation. + + + + Asynchronously enumerates the query results and performs the specified action on each element. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to enumerate. + + The action to perform on each element. + A task that represents the asynchronous operation. + + + + Asynchronously enumerates the query results and performs the specified action on each element. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to enumerate. + + The action to perform on each element. + + A to observe while waiting for the task to complete. + + A task that represents the asynchronous operation. + + + + Creates a from an by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + An to create a from. + + + A task that represents the asynchronous operation. + The task result contains a that contains elements from the input sequence. + + + + + Creates a from an by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + An to create a from. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains elements from the input sequence. + + + + + Creates a from an by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to create a from. + + + A task that represents the asynchronous operation. + The task result contains a that contains elements from the input sequence. + + + + + Creates a from an by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to create a list from. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains elements from the input sequence. + + + + + Creates an array from an by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to create an array from. + + + A task that represents the asynchronous operation. + The task result contains an array that contains elements from the input sequence. + + + + + Creates an array from an by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to create an array from. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains an array that contains elements from the input sequence. + + + + + Creates a from an by enumerating it asynchronously + according to a specified key selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the key returned by . + + + An to create a from. + + A function to extract a key from each element. + + A task that represents the asynchronous operation. + The task result contains a that contains selected keys and values. + + + + + Creates a from an by enumerating it asynchronously + according to a specified key selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the key returned by . + + + An to create a from. + + A function to extract a key from each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains selected keys and values. + + + + + Creates a from an by enumerating it asynchronously + according to a specified key selector function and a comparer. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the key returned by . + + + An to create a from. + + A function to extract a key from each element. + + An to compare keys. + + + A task that represents the asynchronous operation. + The task result contains a that contains selected keys and values. + + + + + Creates a from an by enumerating it asynchronously + according to a specified key selector function and a comparer. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the key returned by . + + + An to create a from. + + A function to extract a key from each element. + + An to compare keys. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains selected keys and values. + + + + + Creates a from an by enumerating it asynchronously + according to a specified key selector and an element selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the key returned by . + + + The type of the value returned by . + + + An to create a from. + + A function to extract a key from each element. + A transform function to produce a result element value from each element. + + A task that represents the asynchronous operation. + The task result contains a that contains values of type + selected from the input sequence. + + + + + Creates a from an by enumerating it asynchronously + according to a specified key selector and an element selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the key returned by . + + + The type of the value returned by . + + + An to create a from. + + A function to extract a key from each element. + A transform function to produce a result element value from each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains values of type + selected from the input sequence. + + + + + Creates a from an by enumerating it asynchronously + according to a specified key selector function, a comparer, and an element selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the key returned by . + + + The type of the value returned by . + + + An to create a from. + + A function to extract a key from each element. + A transform function to produce a result element value from each element. + + An to compare keys. + + + A task that represents the asynchronous operation. + The task result contains a that contains values of type + selected from the input sequence. + + + + + Creates a from an by enumerating it asynchronously + according to a specified key selector function, a comparer, and an element selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the key returned by . + + + The type of the value returned by . + + + An to create a from. + + A function to extract a key from each element. + A transform function to produce a result element value from each element. + + An to compare keys. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains values of type + selected from the input sequence. + + + + + Asynchronously returns the first element of a sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the first element of. + + + A task that represents the asynchronous operation. + The task result contains the first element in . + + + is null. + + + doesn't implement . + + The source sequence is empty. + + + + Asynchronously returns the first element of a sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the first element of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the first element in . + + + + is + null + . + + + + doesn't implement + + . + + The source sequence is empty. + + + + Asynchronously returns the first element of a sequence that satisfies a specified condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the first element of. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains the first element in that passes the test in + . + + + + or + + is + null + . + + + + doesn't implement + + . + + + No element satisfies the condition in + + . + + + + + Asynchronously returns the first element of a sequence that satisfies a specified condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the first element of. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the first element in that passes the test in + . + + + + or + + is + null + . + + + + doesn't implement + + . + + + No element satisfies the condition in + + . + + + + + Asynchronously returns the first element of a sequence, or a default value if the sequence contains no elements. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the first element of. + + + A task that represents the asynchronous operation. + The task result contains default ( ) if + is empty; otherwise, the first element in . + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously returns the first element of a sequence, or a default value if the sequence contains no elements. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the first element of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains default ( ) if + is empty; otherwise, the first element in . + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously returns the first element of a sequence that satisfies a specified condition + or a default value if no such element is found. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the first element of. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains default ( ) if + is empty or if no element passes the test specified by ; otherwise, the first + element in that passes the test specified by . + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously returns the first element of a sequence that satisfies a specified condition + or a default value if no such element is found. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the first element of. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains default ( ) if + is empty or if no element passes the test specified by ; otherwise, the first + element in that passes the test specified by . + + + + or + + is + null + . + + + + doesn't implement + + . + + + + has more than one element. + + + + + Asynchronously returns the only element of a sequence, and throws an exception + if there is not exactly one element in the sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the single element of. + + + A task that represents the asynchronous operation. + The task result contains the single element of the input sequence. + + + + is + null + . + + + + doesn't implement + + . + + The source sequence is empty. + + + + Asynchronously returns the only element of a sequence, and throws an exception + if there is not exactly one element in the sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the single element of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the single element of the input sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + has more than one element. + + The source sequence is empty. + + + + Asynchronously returns the only element of a sequence that satisfies a specified condition, + and throws an exception if more than one such element exists. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the the single element of. + + A function to test an element for a condition. + + A task that represents the asynchronous operation. + The task result contains the single element of the input sequence that satisfies the condition in + . + + + + or + + is + null + . + + + + doesn't implement + + . + + + No element satisfies the condition in + + . + + + More than one element satisfies the condition in + + . + + + + + Asynchronously returns the only element of a sequence that satisfies a specified condition, + and throws an exception if more than one such element exists. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the single element of. + + A function to test an element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the single element of the input sequence that satisfies the condition in + . + + + + or + + is + null + . + + + + doesn't implement + + . + + + No element satisfies the condition in + + . + + + More than one element satisfies the condition in + + . + + + + + Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; + this method throws an exception if there is more than one element in the sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the single element of. + + + A task that represents the asynchronous operation. + The task result contains the single element of the input sequence, or default () + if the sequence contains no elements. + + + + is + null + . + + + + doesn't implement + + . + + + + has more than one element. + + + + + Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; + this method throws an exception if there is more than one element in the sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the single element of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the single element of the input sequence, or default () + if the sequence contains no elements. + + + + is + null + . + + + + doesn't implement + + . + + + + has more than one element. + + + + + Asynchronously returns the only element of a sequence that satisfies a specified condition or + a default value if no such element exists; this method throws an exception if more than one element + satisfies the condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the single element of. + + A function to test an element for a condition. + + A task that represents the asynchronous operation. + The task result contains the single element of the input sequence that satisfies the condition in + , or default ( ) if no such element is found. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously returns the only element of a sequence that satisfies a specified condition or + a default value if no such element exists; this method throws an exception if more than one element + satisfies the condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the single element of. + + A function to test an element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the single element of the input sequence that satisfies the condition in + , or default ( ) if no such element is found. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously determines whether a sequence contains a specified element by using the default equality comparer. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the single element of. + + The object to locate in the sequence. + + A task that represents the asynchronous operation. + The task result contains true if the input sequence contains the specified value; otherwise, false. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously determines whether a sequence contains a specified element by using the default equality comparer. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to return the single element of. + + The object to locate in the sequence. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains true if the input sequence contains the specified value; otherwise, false. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously determines whether a sequence contains any elements. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to check for being empty. + + + A task that represents the asynchronous operation. + The task result contains true if the source sequence contains any elements; otherwise, false. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously determines whether a sequence contains any elements. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An to check for being empty. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains true if the source sequence contains any elements; otherwise, false. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously determines whether any element of a sequence satisfies a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An whose elements to test for a condition. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains true if any elements in the source sequence pass the test in the specified predicate; otherwise, false. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously determines whether any element of a sequence satisfies a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An whose elements to test for a condition. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains true if any elements in the source sequence pass the test in the specified predicate; otherwise, false. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously determines whether all the elements of a sequence satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An whose elements to test for a condition. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains true if every element of the source sequence passes the test in the specified predicate; otherwise, false. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously determines whether all the elements of a sequence satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An whose elements to test for a condition. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains true if every element of the source sequence passes the test in the specified predicate; otherwise, false. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously returns the number of elements in a sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to be counted. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the input sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously returns the number of elements in a sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to be counted. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the input sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously returns the number of elements in a sequence that satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to be counted. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains the number of elements in the sequence that satisfy the condition in the predicate function. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + that satisfy the condition in the predicate function + is larger than + + . + + + + + Asynchronously returns the number of elements in a sequence that satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to be counted. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the sequence that satisfy the condition in the predicate function. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + that satisfy the condition in the predicate function + is larger than + + . + + + + + Asynchronously returns an that represents the total number of elements in a sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to be counted. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the input sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously returns an that represents the total number of elements in a sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to be counted. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the input sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously returns an that represents the number of elements in a sequence + that satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to be counted. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains the number of elements in the sequence that satisfy the condition in the predicate function. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + that satisfy the condition in the predicate function + is larger than + + . + + + + + Asynchronously returns an that represents the number of elements in a sequence + that satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to be counted. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the sequence that satisfy the condition in the predicate function. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + that satisfy the condition in the predicate function + is larger than + + . + + + + + Asynchronously returns the minimum value of a sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to determine the minimum of. + + + A task that represents the asynchronous operation. + The task result contains the minimum value in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously returns the minimum value of a sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to determine the minimum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the minimum value in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously invokes a projection function on each element of a sequence and returns the minimum resulting value. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the value returned by the function represented by . + + + An that contains the elements to determine the minimum of. + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the minimum value in the sequence. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously invokes a projection function on each element of a sequence and returns the minimum resulting value. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the value returned by the function represented by . + + + An that contains the elements to determine the minimum of. + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the minimum value in the sequence. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously returns the maximum value of a sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to determine the maximum of. + + + A task that represents the asynchronous operation. + The task result contains the maximum value in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously returns the maximum value of a sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + An that contains the elements to determine the maximum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the maximum value in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously invokes a projection function on each element of a sequence and returns the maximum resulting value. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the value returned by the function represented by . + + + An that contains the elements to determine the maximum of. + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the maximum value in the sequence. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously invokes a projection function on each element of a sequence and returns the maximum resulting value. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + The type of the value returned by the function represented by . + + + An that contains the elements to determine the maximum of. + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the maximum value in the sequence. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the sum of. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the sum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the sum of. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the sum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the sum of. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the sum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the sum of. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the sum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the sum of. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the sum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the sum of. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the sum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the sum of. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the sum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the sum of. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the sum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the sum of. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the sum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the sum of. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the sum of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the values in the sequence. + + + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of the sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of the sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of the sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of the sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of the sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of the sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of the sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the sum of the sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the sum of the sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + + A sequence of values of type . + + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the sum of the projected values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + The number of elements in + + is larger than + + . + + + + + Asynchronously computes the average of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the average of. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the average of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the average of. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the average of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the average of. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the average of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the average of. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the average of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the average of. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the average of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the average of. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the average of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the average of. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the average of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the average of. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the average of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the average of. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of values to calculate the average of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the average of. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of nullable values. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A sequence of nullable values to calculate the average of. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + contains no elements. + + + + + Asynchronously computes the average of a sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Asynchronously computes the average of a sequence of nullable values that is obtained + by invoking a projection function on each element of the input sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the elements of . + + A sequence of values to calculate the average of. + A projection function to apply to each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the average of the sequence of values. + + + + or + + is + null + . + + + + doesn't implement + + . + + + + + Bypasses a specified number of elements in a sequence and then returns the remaining elements. + + The type of the elements of source. + A sequence to return elements from. + An expression that evaluates to the number of elements to skip. + A sequence that contains elements that occur after the specified index in the + input sequence. + + + + Returns a specified number of contiguous elements from the start of a sequence. + + The type of the elements of source. + The sequence to return elements from. + An expression that evaluates to the number of elements + to return. + A sequence that contains the specified number of elements from the + start of the input sequence. + + + + Controls the transaction creation behavior while executing a database command or query. + + + + + If no transaction is present then a new transaction will be used for the operation. + + + + + If an existing transaction is present then use it, otherwise execute the command or query without a transaction. + + + + + Specifies a structural type mapping. + + + + + Adds a property mapping. + + The property mapping to be added. + + + + Removes a property mapping. + + The property mapping to be removed. + + + + Adds a property mapping condition. + + The property mapping condition to be added. + + + + Removes a property mapping condition. + + The property mapping condition to be removed. + + + + Gets a read-only collection of property mappings. + + + + + Gets a read-only collection of property mapping conditions. + + + + + Represents the base item class for all the metadata + + + Represents the base item class for all the metadata + + + + + Adds or updates an annotation with the specified name and value. + + + If an annotation with the given name already exists then the value of that annotation + is updated to the given value. If the given value is null then the annotation will be + removed. + + The name of the annotation property. + The value of the annotation property. + + + + Removes an annotation with the specified name. + + The name of the annotation property. + true if an annotation was removed; otherwise, false. + + + + Returns a conceptual model built-in type that matches one of the + + values. + + + An object that represents the built-in type in the EDM. + + + One of the values. + + + + Returns the list of the general facet descriptions for a specified type. + + A object that represents the list of the general facet descriptions for a specified type. + + + + Gets the built-in type kind for this type. + + A object that represents the built-in type kind for this type. + + + + Gets the list of properties of the current type. + + A collection of type that contains the list of properties of the current type. + + + + Gets or sets the documentation associated with this type. + + A object that represents the documentation on this type. + + + + + Indicates that the given method is a proxy for an EDM function. + + + Note that this attribute has been replaced by the starting with EF6. + + + + + Indicates that the given method is a proxy for an EDM function. + + + Note that this class was called EdmFunctionAttribute in some previous versions of Entity Framework. + + + + + Initializes a new instance of the class. + + The namespace of the mapped-to function. + The name of the mapped-to function. + + + The namespace of the mapped-to function. + The namespace of the mapped-to function. + + + The name of the mapped-to function. + The name of the mapped-to function. + + + + Creates a new DbFunctionAttribute instance. + + The namespace name of the EDM function represented by the attributed method. + The function name of the EDM function represented by the attributed method. + + + + Provides common language runtime (CLR) methods that expose EDM canonical functions + for use in or LINQ to Entities queries. + + + Note that these functions have been moved to the class starting with EF6. + The functions are retained here only to help in the migration of older EF apps to EF6. + + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Left EDM function to return a given + number of the leftmost characters in a string. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input string. + The number of characters to return + A string containing the number of characters asked for from the left of the input string. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Right EDM function to return a given + number of the rightmost characters in a string. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input string. + The number of characters to return + A string containing the number of characters asked for from the right of the input string. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Reverse EDM function to return a given + string with the order of the characters reversed. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input string. + The input string with the order of the characters reversed. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical GetTotalOffsetMinutes EDM function to + return the number of minutes that the given date/time is offset from UTC. This is generally between +780 + and -780 (+ or - 13 hrs). + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The date/time value to use. + The offset of the input from UTC. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical TruncateTime EDM function to return + the given date with the time portion cleared. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The date/time value to use. + The input date with the time portion cleared. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical TruncateTime EDM function to return + the given date with the time portion cleared. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The date/time value to use. + The input date with the time portion cleared. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical CreateDateTime EDM function to + create a new object. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The year. + The month (1-based). + The day (1-based). + The hours. + The minutes. + The seconds, including fractional parts of the seconds if desired. + The new date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical CreateDateTimeOffset EDM function to + create a new object. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The year. + The month (1-based). + The day (1-based). + The hours. + The minutes. + The seconds, including fractional parts of the seconds if desired. + The time zone offset part of the new date. + The new date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical CreateTime EDM function to + create a new object. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The hours. + The minutes. + The seconds, including fractional parts of the seconds if desired. + The new time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddYears EDM function to + add the given number of years to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of years to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddYears EDM function to + add the given number of years to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of years to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMonths EDM function to + add the given number of months to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of months to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMonths EDM function to + add the given number of months to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of months to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddDays EDM function to + add the given number of days to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of days to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddDays EDM function to + add the given number of days to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of days to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddHours EDM function to + add the given number of hours to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of hours to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddHours EDM function to + add the given number of hours to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of hours to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddHours EDM function to + add the given number of hours to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of hours to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMinutes EDM function to + add the given number of minutes to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of minutes to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMinutes EDM function to + add the given number of minutes to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of minutes to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMinutes EDM function to + add the given number of minutes to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of minutes to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddSeconds EDM function to + add the given number of seconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of seconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddSeconds EDM function to + add the given number of seconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of seconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddSeconds EDM function to + add the given number of seconds to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of seconds to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMilliseconds EDM function to + add the given number of milliseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of milliseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMilliseconds EDM function to + add the given number of milliseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of milliseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMilliseconds EDM function to + add the given number of milliseconds to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of milliseconds to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMicroseconds EDM function to + add the given number of microseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of microseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMicroseconds EDM function to + add the given number of microseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of microseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMicroseconds EDM function to + add the given number of microseconds to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of microseconds to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddNanoseconds EDM function to + add the given number of nanoseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of nanoseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddNanoseconds EDM function to + add the given number of nanoseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of nanoseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddNanoseconds EDM function to + add the given number of nanoseconds to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of nanoseconds to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffYears EDM function to + calculate the number of years between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of years between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffYears EDM function to + calculate the number of years between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of years between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMonths EDM function to + calculate the number of months between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of months between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMonths EDM function to + calculate the number of months between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of months between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffDays EDM function to + calculate the number of days between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of days between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffDays EDM function to + calculate the number of days between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of days between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffHours EDM function to + calculate the number of hours between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of hours between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffHours EDM function to + calculate the number of hours between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of hours between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffHours EDM function to + calculate the number of hours between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of hours between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMinutes EDM function to + calculate the number of minutes between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of minutes between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMinutes EDM function to + calculate the number of minutes between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of minutes between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMinutes EDM function to + calculate the number of minutes between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of minutes between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffSeconds EDM function to + calculate the number of seconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of seconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffSeconds EDM function to + calculate the number of seconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of seconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffSeconds EDM function to + calculate the number of seconds between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of seconds between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMilliseconds EDM function to + calculate the number of milliseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of milliseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMilliseconds EDM function to + calculate the number of milliseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of milliseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMilliseconds EDM function to + calculate the number of milliseconds between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of milliseconds between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMicroseconds EDM function to + calculate the number of microseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of microseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMicroseconds EDM function to + calculate the number of microseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of microseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMicroseconds EDM function to + calculate the number of microseconds between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of microseconds between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffNanoseconds EDM function to + calculate the number of nanoseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of nanoseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffNanoseconds EDM function to + calculate the number of nanoseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of nanoseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffNanoseconds EDM function to + calculate the number of nanoseconds between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of nanoseconds between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Truncate EDM function to + truncate the given value to the number of specified digits. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The value to truncate. + The number of digits to preserve. + The truncated value. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Truncate EDM function to + truncate the given value to the number of specified digits. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The value to truncate. + The number of digits to preserve. + The truncated value. + + + + When used as part of a LINQ to Entities query, this method acts as an operator that ensures the input + is treated as a Unicode string. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function impacts the way the LINQ query is translated to a query that can be run in the database. + + The input string. + The input string treated as a Unicode string. + + + + When used as part of a LINQ to Entities query, this method acts as an operator that ensures the input + is treated as a non-Unicode string. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function impacts the way the LINQ query is translated to a query that can be run in the database. + + The input string. + The input string treated as a non-Unicode string. + + + + Options for query execution. + + + + + Creates a new instance of . + + Merge option to use for entity results. + + + + Creates a new instance of . + + Merge option to use for entity results. + Whether the query is streaming or buffering. + + + Determines whether the specified objects are equal. + true if the two objects are equal; otherwise, false. + The left object to compare. + The right object to compare. + + + + Determines whether the specified objects are not equal. + + The left object to compare. + The right object to compare. + true if the two objects are not equal; otherwise, false. + + + + + + + + + + Merge option to use for entity results. + + + + + Whether the query is streaming or buffering. + + + + + DataRecord interface supporting structured types and rich metadata information. + + + + + Gets a object with the specified index. + + + A object. + + The index of the row. + + + + Returns nested readers as objects. + + + Nested readers as objects. + + The ordinal of the column. + + + + Gets for this + + . + + + A object. + + + + + DataRecordInfo class providing a simple way to access both the type information and the column information. + + + + + Initializes a new object for a specific type with an enumerable collection of data fields. + + + The metadata for the type represented by this object, supplied by + + . + + + An enumerable collection of objects that represent column information. + + + + + Gets for this + + object. + + + A object. + + + + + Gets type info for this object as a object. + + + A value. + + + + + A prepared command definition, can be cached and reused to avoid + repreparing a command. + + + + + Initializes a new instance of the class using the supplied + + . + + + The supplied . + + method used to clone the + + + + Initializes a new instance of the class. + + + + + Creates and returns a object that can be executed. + + The command for database. + + + + Metadata Interface for all CLR types types + + + + + Value to pass to GetInformation to get the StoreSchemaDefinition + + + + + Value to pass to GetInformation to get the StoreSchemaMapping + + + + + Value to pass to GetInformation to get the ConceptualSchemaDefinition + + + + + Value to pass to GetInformation to get the StoreSchemaDefinitionVersion3 + + + + + Value to pass to GetInformation to get the StoreSchemaMappingVersion3 + + + + + Value to pass to GetInformation to get the ConceptualSchemaDefinitionVersion3 + + + + + Name of the MaxLength Facet + + + + + Name of the Unicode Facet + + + + + Name of the FixedLength Facet + + + + + Name of the Precision Facet + + + + + Name of the Scale Facet + + + + + Name of the Nullable Facet + + + + + Name of the DefaultValue Facet + + + + + Name of the Collation Facet + + + + + Name of the SRID Facet + + + + + Name of the IsStrict Facet + + + + When overridden in a derived class, returns the set of primitive types supported by the data source. + The set of types supported by the data source. + + + When overridden in a derived class, returns a collection of EDM functions supported by the provider manifest. + A collection of EDM functions. + + + Returns the FacetDescription objects for a particular type. + The FacetDescription objects for the specified EDM type. + The EDM type to return the facet description for. + + + When overridden in a derived class, this method maps the specified storage type and a set of facets for that type to an EDM type. + + The instance that describes an EDM type and a set of facets for that type. + + The TypeUsage instance that describes a storage type and a set of facets for that type to be mapped to the EDM type. + + + When overridden in a derived class, this method maps the specified EDM type and a set of facets for that type to a storage type. + The TypeUsage instance that describes a storage type and a set of facets for that type. + The TypeUsage instance that describes the EDM type and a set of facets for that type to be mapped to a storage type. + + + When overridden in a derived class, this method returns provider-specific information. + The XmlReader object that represents the mapping to the underlying data store catalog. + The type of the information to return. + + + Gets the provider-specific information. + The provider-specific information. + The type of the information to return. + + + Indicates if the provider supports escaping strings to be used as patterns in a Like expression. + True if this provider supports escaping strings to be used as patterns in a Like expression; otherwise, false. + If the provider supports escaping, the character that would be used as the escape character. + + + Provider writers should override this method to return the argument with the wildcards and the escape character escaped. This method is only used if SupportsEscapingLikeArgument returns true. + The argument with the wildcards and the escape character escaped. + The argument to be escaped. + + + + Returns a boolean that specifies whether the provider can handle expression trees + containing instances of DbInExpression. + The default implementation returns false for backwards compatibility. Derived classes can override this method. + + + false + + + + + Returns a boolean that specifies whether the provider can process expression trees not having DbProjectExpression + nodes directly under both Left and Right sides of DbUnionAllExpression and DbIntersectExpression + + + false + + + + Gets the namespace used by this provider manifest. + The namespace used by this provider manifest. + + + + The factory for building command definitions; use the type of this object + as the argument to the IServiceProvider.GetService method on the provider + factory; + + + + + Constructs an EF provider that will use the obtained from + the app domain Singleton for resolving EF dependencies such + as the instance to use. + + + + + Registers a handler to process non-error messages coming from the database provider. + + The connection to receive information for. + The handler to process messages. + + + + Create a Command Definition object given a command tree. + + command tree for the statement + an executable command definition object + + This method simply delegates to the provider's implementation of CreateDbCommandDefinition. + + + + Creates command definition from specified manifest and command tree. + The created command definition. + The manifest. + The command tree. + + + Creates a command definition object for the specified provider manifest and command tree. + An executable command definition object. + Provider manifest previously retrieved from the store provider. + Command tree for the statement. + + + + Create the default DbCommandDefinition object based on the prototype command + This method is intended for provider writers to build a default command definition + from a command. + Note: This will clone the prototype + + the prototype command + an executable command definition object + + + + See issue 2390 - cloning the DesignTimeVisible property on the + DbCommand can cause deadlocks. So here allow sub-classes to override. + + the object to clone + a clone of the + + + Returns provider manifest token given a connection. + The provider manifest token. + Connection to provider. + + + + Returns provider manifest token for a given connection. + + Connection to find manifest token from. + The provider manifest token for the specified connection. + + + Returns the provider manifest by using the specified version information. + The provider manifest by using the specified version information. + The token information associated with the provider manifest. + + + When overridden in a derived class, returns an instance of a class that derives from the DbProviderManifest. + A DbProviderManifest object that represents the provider manifest. + The token information associated with the provider manifest. + + + + Gets the that will be used to execute methods that use the specified connection. + + The database connection + + A new instance of + + + + + Gets the that will be used to execute methods that use the specified connection. + This overload should be used by the derived classes for compatability with wrapping providers. + + The database connection + The provider invariant name + + A new instance of + + + + + Gets the spatial data reader for the . + + The spatial data reader. + The reader where the spatial data came from. + The manifest token associated with the provider manifest. + + + + Gets the spatial services for the . + + The spatial services. + The token information associated with the provider manifest. + + + Gets the spatial services for the . + The spatial services. + Information about the database that the spatial services will be used for. + + + + Gets the spatial data reader for the . + + The spatial data reader. + The reader where the spatial data came from. + The token information associated with the provider manifest. + + + + Gets the spatial services for the . + + The spatial services. + The token information associated with the provider manifest. + + + + Sets the parameter value and appropriate facets for the given . + + The parameter. + The type of the parameter. + The value of the parameter. + + + + Sets the parameter value and appropriate facets for the given . + + The parameter. + The type of the parameter. + The value of the parameter. + + + Returns providers given a connection. + + The instanced based on the specified connection. + + Connection to provider. + + + Retrieves the DbProviderFactory based on the specified DbConnection. + The retrieved DbProviderFactory. + The connection to use. + + + + Return an XML reader which represents the CSDL description + + The name of the CSDL description. + An XmlReader that represents the CSDL description + + + Generates a data definition language (DDL script that creates schema objects (tables, primary keys, foreign keys) based on the contents of the StoreItemCollection parameter and targeted for the version of the database corresponding to the provider manifest token. + + Individual statements should be separated using database-specific DDL command separator. + It is expected that the generated script would be executed in the context of existing database with + sufficient permissions, and it should not include commands to create the database, but it may include + commands to create schemas and other auxiliary objects such as sequences, etc. + + A DDL script that creates schema objects based on the contents of the StoreItemCollection parameter and targeted for the version of the database corresponding to the provider manifest token. + The provider manifest token identifying the target version. + The structure of the database. + + + + Generates a data definition language (DDL) script that creates schema objects + (tables, primary keys, foreign keys) based on the contents of the StoreItemCollection + parameter and targeted for the version of the database corresponding to the provider manifest token. + + + Individual statements should be separated using database-specific DDL command separator. + It is expected that the generated script would be executed in the context of existing database with + sufficient permissions, and it should not include commands to create the database, but it may include + commands to create schemas and other auxiliary objects such as sequences, etc. + + The provider manifest token identifying the target version. + The structure of the database. + + A DDL script that creates schema objects based on the contents of the StoreItemCollection parameter + and targeted for the version of the database corresponding to the provider manifest token. + + + + + Creates a database indicated by connection and creates schema objects + (tables, primary keys, foreign keys) based on the contents of storeItemCollection. + + Connection to a non-existent database that needs to be created and populated with the store objects indicated with the storeItemCollection parameter. + Execution timeout for any commands needed to create the database. + The collection of all store items based on which the script should be created. + + + Creates a database indicated by connection and creates schema objects (tables, primary keys, foreign keys) based on the contents of a StoreItemCollection. + Connection to a non-existent database that needs to be created and populated with the store objects indicated with the storeItemCollection parameter. + Execution timeout for any commands needed to create the database. + The collection of all store items based on which the script should be created. + + + Returns a value indicating whether a given database exists on the server. + True if the provider can deduce the database only based on the connection. + Connection to a database whose existence is checked by this method. + Execution timeout for any commands needed to determine the existence of the database. + The collection of all store items from the model. This parameter is no longer used for determining database existence. + + + Returns a value indicating whether a given database exists on the server. + True if the provider can deduce the database only based on the connection. + Connection to a database whose existence is checked by this method. + Execution timeout for any commands needed to determine the existence of the database. + The collection of all store items from the model. This parameter is no longer used for determining database existence. + + + Returns a value indicating whether a given database exists on the server. + True if the provider can deduce the database only based on the connection. + Connection to a database whose existence is checked by this method. + Execution timeout for any commands needed to determine the existence of the database. + The collection of all store items from the model. This parameter is no longer used for determining database existence. + + + Returns a value indicating whether a given database exists on the server. + True if the provider can deduce the database only based on the connection. + Connection to a database whose existence is checked by this method. + Execution timeout for any commands needed to determine the existence of the database. + The collection of all store items from the model. This parameter is no longer used for determining database existence. + Override this method to avoid creating the store item collection if it is not needed. The default implementation evaluates the Lazy and calls the other overload of this method. + + + Deletes the specified database. + Connection to an existing database that needs to be deleted. + Execution timeout for any commands needed to delete the database. + The collection of all store items from the model. This parameter is no longer used for database deletion. + + + Deletes the specified database. + Connection to an existing database that needs to be deleted. + Execution timeout for any commands needed to delete the database. + The collection of all store items from the model. This parameter is no longer used for database deletion. + + + + Expands |DataDirectory| in the given path if it begins with |DataDirectory| and returns the expanded path, + or returns the given string if it does not start with |DataDirectory|. + + The path to expand. + The expanded path. + + + + Adds an that will be used to resolve additional default provider + services when a derived type is registered as an EF provider either using an entry in the application's + config file or through code-based registration in . + + The resolver to add. + + + + Called to resolve additional default provider services when a derived type is registered as an + EF provider either using an entry in the application's config file or through code-based + registration in . The implementation of this method in this + class uses the resolvers added with the AddDependencyResolver method to resolve + dependencies. + + + Use this method to set, add, or change other provider-related services. Note that this method + will only be called for such services if they are not already explicitly configured in some + other way by the application. This allows providers to set default services while the + application is still able to override and explicitly configure each service if required. + See and for more details. + + The type of the service to be resolved. + An optional key providing additional information for resolving the service. + An instance of the given type, or null if the service could not be resolved. + + + + Called to resolve additional default provider services when a derived type is registered as an + EF provider either using an entry in the application's config file or through code-based + registration in . The implementation of this method in this + class uses the resolvers added with the AddDependencyResolver method to resolve + dependencies. + + The type of the service to be resolved. + An optional key providing additional information for resolving the service. + All registered services that satisfy the given type and key, or an empty enumeration if there are none. + + + + A specialization of the ProviderManifest that accepts an XmlReader + + + + + Initializes a new instance of the class. + + + An object that provides access to the XML data in the provider manifest file. + + + + Returns the list of facet descriptions for the specified Entity Data Model (EDM) type. + + A collection of type that contains the list of facet descriptions for the specified EDM type. + + + An for which the facet descriptions are to be retrieved. + + + + Returns the list of primitive types supported by the storage provider. + + A collection of type that contains the list of primitive types supported by the storage provider. + + + + Returns the list of provider-supported functions. + + A collection of type that contains the list of provider-supported functions. + + + + Gets the namespace name supported by this provider manifest. + The namespace name supported by this provider manifest. + + + Gets the best mapped equivalent Entity Data Model (EDM) type for a specified storage type name. + The best mapped equivalent EDM type for a specified storage type name. + + + Gets the best mapped equivalent storage primitive type for a specified storage type name. + The best mapped equivalent storage primitive type for a specified storage type name. + + + + Class for representing a collection of items. + Most of the implementation for actual maintenance of the collection is + done by MetadataCollection + + + + + Class representing a read-only wrapper around MetadataCollection + + The type of items in this collection + + + Retrieves an item from this collection by using the specified identity. + An item from this collection. + The identity of the item to be searched for. + true to perform the case-insensitive search; otherwise, false. + + + Determines whether the collection contains an item with the specified identity. + true if the collection contains the item to be searched for; otherwise, false. The default is false. + The identity of the item. + + + Retrieves an item from this collection by using the specified identity. + true if there is an item that matches the search criteria; otherwise, false. + The identity of the item to be searched for. + true to perform the case-insensitive search; otherwise, false. + When this method returns, this output parameter contains an item from the collection. If there is no matched item, this output parameter contains null. + + + Returns an enumerator that can iterate through this collection. + + A that can be used to iterate through this + + . + + + + Returns the index of the specified value in this collection. + The index of the specified value in this collection. + A value to seek. + + + Gets a value indicating whether this collection is read-only. + true if this collection is read-only; otherwise, false. + + + Gets an item from this collection by using the specified identity. + An item from this collection. + The identity of the item to be searched for. + + + + The enumerator for MetadataCollection + + + + Disposes of this enumerator. + + + + Moves to the next member in the collection of type + + . + + + true if the enumerator is moved in the collection of type + + ; otherwise, false. + + + + + Positions the enumerator before the first position in the collection of type + + . + + + + Gets the member at the current position. + The member at the current position. + + + + Gets the member at the current position + + + + + Returns a strongly typed object by using the specified identity. + + The item that is specified by the identity. + The identity of the item. + The type returned by the method. + + + + Returns a strongly typed object by using the specified identity from this item collection. + + true if there is an item that matches the search criteria; otherwise, false. + The identity of the item. + + When this method returns, the output parameter contains a + + object. If there is no global item with the specified identity in the item collection, this output parameter contains null. + + The type returned by the method. + + + + Returns a strongly typed object by using the specified identity from this item collection. + + true if there is an item that matches the search criteria; otherwise, false. + The identity of the item. + true to perform the case-insensitive search; otherwise, false. + + When this method returns, the output parameter contains a + + object. If there is no global item with the specified identity in the item collection, this output parameter contains null. + + The type returned by the method. + + + + Returns a strongly typed object by using the specified identity with either case-sensitive or case-insensitive search. + + The item that is specified by the identity. + The identity of the item. + true to perform the case-insensitive search; otherwise, false. + The type returned by the method. + + + Returns all the items of the specified type from this item collection. + + A collection of type that contains all the items of the specified type. + + The type returned by the method. + + + + Returns an object by using the specified type name and the namespace name in this item collection. + + + An object that represents the type that matches the specified type name and the namespace name in this item collection. If there is no matched type, this method returns null. + + The name of the type. + The namespace of the type. + + + + Returns an object by using the specified type name and the namespace name from this item collection. + + true if there is a type that matches the search criteria; otherwise, false. + The name of the type. + The namespace of the type. + + When this method returns, this output parameter contains an + + object. If there is no type with the specified name and namespace name in this item collection, this output parameter contains null. + + + + + Returns an object by using the specified type name and the namespace name from this item collection. + + + An object that represents the type that matches the specified type name and the namespace name in this item collection. If there is no matched type, this method returns null. + + The name of the type. + The namespace of the type. + true to perform the case-insensitive search; otherwise, false. + + + + Returns an object by using the specified type name and the namespace name from this item collection. + + true if there is a type that matches the search criteria; otherwise, false. + The name of the type. + The namespace of the type. + true to perform the case-insensitive search; otherwise, false. + + When this method returns, this output parameter contains an + + object. If there is no type with the specified name and namespace name in this item collection, this output parameter contains null. + + + + Returns all the overloads of the functions by using the specified name from this item collection. + + A collection of type that contains all the functions that have the specified name. + + The full name of the function. + + + Returns all the overloads of the functions by using the specified name from this item collection. + + A collection of type that contains all the functions that have the specified name. + + The full name of the function. + true to perform the case-insensitive search; otherwise, false. + + + Returns all the overloads of the functions by using the specified name from this item collection. + A collection of type ReadOnlyCollection that contains all the functions that have the specified name. + A dictionary of functions. + The full name of the function. + true to perform the case-insensitive search; otherwise, false. + + + + Returns an object by using the specified entity container name. + + If there is no entity container, this method returns null; otherwise, it returns the first one. + The name of the entity container. + + + + Returns an object by using the specified entity container name. If there is no entity container, the output parameter contains null; otherwise, it contains the first entity container. + + true if there is an entity container that matches the search criteria; otherwise, false. + The name of the entity container. + + When this method returns, it contains an object. If there is no entity container, this output parameter contains null; otherwise, it contains the first entity container. + + + + + Returns an object by using the specified entity container name. + + If there is no entity container, this method returns null; otherwise, it returns the first entity container. + The name of the entity container. + true to perform the case-insensitive search; otherwise, false. + + + + Returns an object by using the specified entity container name. If there is no entity container, this output parameter contains null; otherwise, it contains the first entity container. + + true if there is an entity container that matches the search criteria; otherwise, false. + The name of the entity container. + true to perform the case-insensitive search; otherwise, false. + + When this method returns, it contains an object. If there is no entity container, this output parameter contains null; otherwise, it contains the first entity container. + + + + Gets the data model associated with this item collection. + The data model associated with this item collection. + + + + EntityRecordInfo class providing a simple way to access both the type information and the column information. + + + + + Initializes a new instance of the class of a specific entity type with an enumerable collection of data fields and with specific key and entity set information. + + + The of the entity represented by the + + described by this + + object. + + + An enumerable collection of objects that represent column information. + + The key for the entity. + The entity set to which the entity belongs. + + + + Gets the for the entity. + + The key for the entity. + + + + Public Entity SQL Parser class. + + + + Parse the specified query with the specified parameters. + + The containing + + and information describing inline function definitions if any. + + The EntitySQL query to be parsed. + The optional query parameters. + + + + Parse a specific query with a specific set variables and produce a + + . + + + The containing + + and information describing inline function definitions if any. + + The query to be parsed. + The optional query variables. + + + + Entity SQL query inline function definition, returned as a part of . + + + + Function name. + + + Function body and parameters. + + + Start position of the function definition in the eSQL query text. + + + End position of the function definition in the eSQL query text. + + + + Entity SQL Parser result information. + + + + A command tree produced during parsing. + + + + List of objects describing query inline function definitions. + + + + + Compares objects using reference equality. + + + + + Gets the default instance. + + + + + Wraps access to the transaction object on the underlying store connection and ensures that the + Entity Framework executes commands on the database within the context of that transaction. + An instance of this class is retrieved by calling BeginTransaction() on the + + object. + + + + + Commits the underlying store transaction + + + + + Rolls back the underlying store transaction + + + + + Cleans up this transaction object and ensures the Entity Framework + is no longer using that transaction. + + + + + Releases the resources used by this transaction object + + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + + + + + + + + + + + + + + Gets the database (store) transaction that is underlying this context transaction. + + + + + A service for obtaining the correct from a given + . + + + On .NET 4.5 the provider is publicly accessible from the connection. On .NET 4 the + default implementation of this service uses some heuristics to find the matching + provider. If these fail then a new implementation of this service can be registered + on to provide an appropriate resolution. + + + + + Returns the for the given connection. + + The connection. + The provider factory for the connection. + + + + Explicitly implemented by to prevent certain members from showing up + in the IntelliSense of scaffolded migrations. + + + + + Adds a custom to the migration. + Custom operation implementors are encouraged to create extension methods on + that provide a fluent-style API for adding new operations. + + The operation to add. + + + + A default implementation of that uses the + underlying provider to get the manifest token. + Note that to avoid multiple queries, this implementation using caching based on the actual type of + instance, the property, + and the property. + + + + + A service for getting a provider manifest token given a connection. + The class is used by default and makes use of the + underlying provider to get the token which often involves opening the connection. + A different implementation can be used instead by adding an + to that may use any information in the connection to return + the token. For example, if the connection is known to point to a SQL Server 2008 database then + "2008" can be returned without opening the connection. + + + + + Returns the manifest token to use for the given connection. + + The connection for which a manifest token is required. + The manifest token to use. + + + + + + + A strategy that is used to execute a command or query against the database, possibly with logic to retry when a failure occurs. + + + + + Executes the specified operation. + + A delegate representing an executable operation that doesn't return any results. + + + + Executes the specified operation and returns the result. + + + The return type of . + + + A delegate representing an executable operation that returns the result of type . + + The result from the operation. + + + + Executes the specified asynchronous operation. + + A function that returns a started task. + + A cancellation token used to cancel the retry operation, but not operations that are already in flight + or that already completed successfully. + + + A task that will run to completion if the original task completes successfully (either the + first time or after retrying transient failures). If the task fails with a non-transient error or + the retry limit is reached, the returned task will become faulted and the exception must be observed. + + + + + Executes the specified asynchronous operation and returns the result. + + + The result type of the returned by . + + + A function that returns a started task of type . + + + A cancellation token used to cancel the retry operation, but not operations that are already in flight + or that already completed successfully. + + + A task that will run to completion if the original task completes successfully (either the + first time or after retrying transient failures). If the task fails with a non-transient error or + the retry limit is reached, the returned task will become faulted and the exception must be observed. + + + + + Indicates whether this might retry the execution after a failure. + + + + + Provides the base implementation of the retry mechanism for unreliable operations and transient conditions that uses + exponentially increasing delays between retries. + + + A new instance will be created each time an operation is executed. + The following formula is used to calculate the delay after retryCount number of attempts: + min(random(1, 1.1) * (2 ^ retryCount - 1), maxDelay) + The retryCount starts at 0. + The random factor distributes uniformly the retry attempts from multiple simultaneous operations failing simultaneously. + + + + + Creates a new instance of . + + + The default retry limit is 5, which means that the total amount of time spent between retries is 26 seconds plus the random factor. + + + + + Creates a new instance of with the specified limits for number of retries and the delay between retries. + + The maximum number of retry attempts. + The maximum delay in milliseconds between retries. + + + + Repetitively executes the specified operation while it satisfies the current retry policy. + + A delegate representing an executable operation that doesn't return any results. + if the retry delay strategy determines the operation shouldn't be retried anymore + if an existing transaction is detected and the execution strategy doesn't support it + if this instance was already used to execute an operation + + + + Repetitively executes the specified operation while it satisfies the current retry policy. + + The type of result expected from the executable operation. + + A delegate representing an executable operation that returns the result of type . + + The result from the operation. + if the retry delay strategy determines the operation shouldn't be retried anymore + if an existing transaction is detected and the execution strategy doesn't support it + if this instance was already used to execute an operation + + + + Repetitively executes the specified asynchronous operation while it satisfies the current retry policy. + + A function that returns a started task. + + A cancellation token used to cancel the retry operation, but not operations that are already in flight + or that already completed successfully. + + + A task that will run to completion if the original task completes successfully (either the + first time or after retrying transient failures). If the task fails with a non-transient error or + the retry limit is reached, the returned task will become faulted and the exception must be observed. + + if the retry delay strategy determines the operation shouldn't be retried anymore + if an existing transaction is detected and the execution strategy doesn't support it + if this instance was already used to execute an operation + + + + Repeatedly executes the specified asynchronous operation while it satisfies the current retry policy. + + + The result type of the returned by . + + + A function that returns a started task of type . + + + A cancellation token used to cancel the retry operation, but not operations that are already in flight + or that already completed successfully. + + + A task that will run to completion if the original task completes successfully (either the + first time or after retrying transient failures). If the task fails with a non-transient error or + the retry limit is reached, the returned task will become faulted and the exception must be observed. + + if the retry delay strategy determines the operation shouldn't be retried anymore + if an existing transaction is detected and the execution strategy doesn't support it + if this instance was already used to execute an operation + + + + Determines whether the operation should be retried and the delay before the next attempt. + + The exception thrown during the last execution attempt. + + Returns the delay indicating how long to wait for before the next execution attempt if the operation should be retried; + null otherwise + + + + + Recursively gets InnerException from as long as it's an + , or + and passes it to + + The type of the unwrapped exception. + The exception to be unwrapped. + A delegate that will be called with the unwrapped exception. + + The result from . + + + + + Determines whether the specified exception represents a transient failure that can be compensated by a retry. + + The exception object to be verified. + + true if the specified exception is considered as transient, otherwise false. + + + + + Returns true to indicate that might retry the execution after a failure. + + + + + A key used for resolving . It consists of the ADO.NET provider invariant name + and the database server name as specified in the connection string. + + + + + Initializes a new instance of + + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which this execution strategy will be used. + + A string that will be matched against the server name in the connection string. + + + + + + + + + + The ADO.NET provider invariant name indicating the type of ADO.NET connection for which this execution strategy will be used. + + + + + A string that will be matched against the server name in the connection string. + + + + + Implement this interface on your context to use custom logic to calculate the key used to lookup an already created model in the cache. + This interface allows you to have a single context type that can be used with different models in the same AppDomain, + or multiple context types that use the same model. + + + + Gets the cached key associated with the provider. + The cached key associated with the provider. + + + + Used by and when resolving + a provider invariant name from a . + + + + Gets the name of the provider. + The name of the provider. + + + + Represents a custom pluralization term to be used by the + + + + + Create a new instance + + A non null or empty string representing the singular. + A non null or empty string representing the plural. + + + + Get the singular. + + + + + Get the plural. + + + + + Default pluralization service implementation to be used by Entity Framework. This pluralization + service is based on English locale. + + + + + Pluralization services to be used by the EF runtime implement this interface. + By default the is used, but the pluralization service to use + can be set in a class derived from . + + + + + Pluralize a word using the service. + + The word to pluralize. + The pluralized word + + + + Singularize a word using the service. + + The word to singularize. + The singularized word. + + + + Constructs a new instance of default pluralization service + used in Entity Framework. + + + + + Constructs a new instance of default pluralization service + used in Entity Framework. + + + A collection of user dictionary entries to be used by this service.These inputs + can customize the service according the user needs. + + + + Returns the plural form of the specified word. + The plural form of the input parameter. + The word to be made plural. + + + Returns the singular form of the specified word. + The singular form of the input parameter. + The word to be made singular. + + + + The exception that is thrown when the action failed again after being retried the configured number of times. + + + + + Provider exception - Used by the entity client. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The message that describes the error. + + + + Initializes a new instance of the class. + + The error message that explains the reason for the exception. + The exception that caused the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Initializes a new instance of the class. + + + The that holds the serialized object data about the exception being thrown. + + + The that contains contextual information about the source or destination. + + + + + Initializes a new instance of the class with no error message. + + + + + Initializes a new instance of the class with a specified error message. + + The message that describes the error. + + + + Initializes a new instance of the class. + + The message that describes the error. + The exception that is the cause of the current exception. + + + + An that doesn't retry operations if they fail. + + + + + Executes the specified operation once. + + A delegate representing an executable operation that doesn't return any results. + + + + Executes the specified operation once and returns the result. + + + The return type of . + + + A delegate representing an executable operation that returns the result of type . + + The result from the operation. + + + + Executes the specified asynchronous operation once, without retrying on failure. + + A function that returns a started task. + + A cancellation token used to cancel the retry operation, but not operations that are already in flight + or that already completed successfully. + + + A task that will run to completion if the original task completes successfully. + + + + + Executes the specified asynchronous operation once, without retrying on failure. + + + The result type of the returned by . + + A function that returns a started task. + + A cancellation token used to cancel the retry operation, but not operations that are already in flight + or that already completed successfully. + + + A task that will run to completion if the original task completes successfully. + + + + + Returns false to indicate that will not retry the execution after a failure. + + + + + Asynchronous version of the interface that allows elements to be retrieved asynchronously. + This interface is used to interact with Entity Framework queries and shouldn't be implemented by custom classes. + + + + + Gets an enumerator that can be used to asynchronously enumerate the sequence. + + Enumerator for asynchronous enumeration over the sequence. + + + + Asynchronous version of the interface that allows elements of the enumerable sequence to be retrieved asynchronously. + This interface is used to interact with Entity Framework queries and shouldn't be implemented by custom classes. + + The type of objects to enumerate. + + + + Gets an enumerator that can be used to asynchronously enumerate the sequence. + + Enumerator for asynchronous enumeration over the sequence. + + + + Represents a SQL query for entities that is created from a + and is executed using the connection from that context. + Instances of this class are obtained from the instance for the + entity type. The query is not executed when this object is created; it is executed + each time it is enumerated, for example by using foreach. + SQL queries for non-entities are created using . + See for a generic version of this class. + + + + + Represents a SQL query for non-entities that is created from a + and is executed using the connection from that context. + Instances of this class are obtained from the instance. + The query is not executed when this object is created; it is executed + each time it is enumerated, for example by using foreach. + SQL queries for entities are created using . + See for a generic version of this class. + + + + + Returns a new query that will stream the results instead of buffering. + + A new query with AsStreaming applied. + + + + Returns an which when enumerated will execute the SQL query against the database. + + + An object that can be used to iterate through the elements. + + + + + Returns an which when enumerated will execute the SQL query against the database. + + + An object that can be used to iterate through the elements. + + + + + Asynchronously enumerates the query results and performs the specified action on each element. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The action to perform on each element. + A task that represents the asynchronous operation. + + + + Asynchronously enumerates the query results and performs the specified action on each element. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The action to perform on each element. + + A to observe while waiting for the task to complete. + + A task that represents the asynchronous operation. + + + + Creates a from the query by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains a that contains elements from the query. + + + + + Creates a from the query by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains elements from the query. + + + + + Returns a that contains the SQL string that was set + when the query was created. The parameters are not included. + + + A that represents this instance. + + + + + Throws an exception indicating that binding directly to a store query is not supported. + + Never returns; always throws. + + + + + + + + + + + + + Returns false. + + + false . + + + + + Creates an instance of a when called from the constructor of a derived + type that will be used as a test double for . Methods and properties + that will be used by the test double must be implemented by the test double except AsNoTracking + and AsStreaming where the default implementation is a no-op. + + + + + Returns a new query where the results of the query will not be tracked by the associated + . + + A new query with NoTracking applied. + + + + Returns a new query that will stream the results instead of buffering. + + A new query with AsStreaming applied. + + + + + + + + + + + + + + + + Represents a SQL query for entities that is created from a + and is executed using the connection from that context. + Instances of this class are obtained from the instance for the + entity type. The query is not executed when this object is created; it is executed + each time it is enumerated, for example by using foreach. + SQL queries for non-entities are created using . + See for a non-generic version of this class. + + The type of entities returned by the query. + + + + Represents a SQL query for non-entities that is created from a + and is executed using the connection from that context. + Instances of this class are obtained from the instance. + The query is not executed when this object is created; it is executed + each time it is enumerated, for example by using foreach. + SQL queries for entities are created using . + See for a non-generic version of this class. + + The type of elements returned by the query. + + + + Returns a new query that will stream the results instead of buffering. + + A new query with AsStreaming applied. + + + + Returns an which when enumerated will execute the SQL query against the database. + + + An object that can be used to iterate through the elements. + + + + + Returns an which when enumerated will execute the SQL query against the database. + + + An object that can be used to iterate through the elements. + + + + + Returns an which when enumerated will execute the SQL query against the database. + + + An object that can be used to iterate through the elements. + + + + + Returns an which when enumerated will execute the SQL query against the database. + + + An object that can be used to iterate through the elements. + + + + + Asynchronously enumerates the query results and performs the specified action on each element. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The action to be executed. + A task that represents the asynchronous operation. + + + + Asynchronously enumerates the query results and performs the specified action on each element. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The action to be executed. + + A to observe while waiting for the task to complete. + + A task that represents the asynchronous operation. + + + + Creates a from the query by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains a that contains elements from the input sequence. + + + + + Creates a from the query by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains elements from the input sequence. + + + + + Creates an array from the query by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains an array that contains elements from the input sequence. + + + + + Creates an array from the query by enumerating it asynchronously. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains an array that contains elements from the input sequence. + + + + + Creates a from the query by enumerating it asynchronously + according to a specified key selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the key returned by . + + A function to extract a key from each element. + + A task that represents the asynchronous operation. + The task result contains a that contains selected keys and values. + + + + + Creates a from the query by enumerating it asynchronously + according to a specified key selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the key returned by . + + A function to extract a key from each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains selected keys and values. + + + + + Creates a from the query by enumerating it asynchronously + according to a specified key selector function and a comparer. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the key returned by . + + A function to extract a key from each element. + + An to compare keys. + + + A task that represents the asynchronous operation. + The task result contains a that contains selected keys and values. + + + + + Creates a from the query by enumerating it asynchronously + according to a specified key selector function and a comparer. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the key returned by . + + A function to extract a key from each element. + + An to compare keys. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains selected keys and values. + + + + + Creates a from the query by enumerating it asynchronously + according to a specified key selector and an element selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the key returned by . + + + The type of the value returned by . + + A function to extract a key from each element. + A transform function to produce a result element value from each element. + + A task that represents the asynchronous operation. + The task result contains a that contains values of type + selected from the query. + + + + + Creates a from the query by enumerating it asynchronously + according to a specified key selector and an element selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the key returned by . + + + The type of the value returned by . + + A function to extract a key from each element. + A transform function to produce a result element value from each element. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains values of type + selected from the query. + + + + + Creates a from the query by enumerating it asynchronously + according to a specified key selector function, a comparer, and an element selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the key returned by . + + + The type of the value returned by . + + A function to extract a key from each element. + A transform function to produce a result element value from each element. + + An to compare keys. + + + A task that represents the asynchronous operation. + The task result contains a that contains values of type + selected from the input sequence. + + + + + Creates a from the query by enumerating it asynchronously + according to a specified key selector function, a comparer, and an element selector function. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The type of the key returned by . + + + The type of the value returned by . + + A function to extract a key from each element. + A transform function to produce a result element value from each element. + + An to compare keys. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains a that contains values of type + selected from the input sequence. + + + + + Asynchronously returns the first element of the query. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains the first element in the query result. + + The query result is empty. + + + + Asynchronously returns the first element of the query. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the first element in the query result. + + The query result is empty. + + + + Asynchronously returns the first element of the query that satisfies a specified condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains the first element in the query result that satisfies a specified condition. + + + + is + null + . + + The query result is empty. + + + + Asynchronously returns the first element of the query that satisfies a specified condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the first element in the query result that satisfies a specified condition. + + + + is + null + . + + The query result is empty. + + + + Asynchronously returns the first element of the query, or a default value if the the query result contains no elements. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains default ( ) if query result is empty; + otherwise, the first element in the query result. + + + + + Asynchronously returns the first element of the query, or a default value if the the query result contains no elements. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains default ( ) if query result is empty; + otherwise, the first element in the query result. + + + + + Asynchronously returns the first element of the query that satisfies a specified condition + or a default value if no such element is found. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains default ( ) if query result is empty + or if no element passes the test specified by ; otherwise, the first element + in the query result that passes the test specified by . + + + + is + null + . + + + + + Asynchronously returns the first element of the query that satisfies a specified condition + or a default value if no such element is found. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains default ( ) if query result is empty + or if no element passes the test specified by ; otherwise, the first element + in the query result that passes the test specified by . + + + + is + null + . + + + + + Asynchronously returns the only element of the query, and throws an exception + if there is not exactly one element in the sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains the single element of the query result. + + The query result has more than one element. + The query result is empty. + + + + Asynchronously returns the only element of the query, and throws an exception + if there is not exactly one element in the sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the single element of the query result. + + The query result has more than one element. + The query result is empty. + + + + Asynchronously returns the only element of the query that satisfies a specified condition, + and throws an exception if more than one such element exists. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains the single element of the query result that satisfies the condition in + . + + + + is + null + . + + + No element satisfies the condition in + + . + + + More than one element satisfies the condition in + + . + + + + + Asynchronously returns the only element of the query that satisfies a specified condition, + and throws an exception if more than one such element exists. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the single element of the query result that satisfies the condition in + . + + + + is + null + . + + + No element satisfies the condition in + + . + + + More than one element satisfies the condition in + + . + + + + + Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; + this method throws an exception if there is more than one element in the sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains the single element of the query result, or default () + if the sequence contains no elements. + + The query result has more than one element. + + + + Asynchronously returns the only element of a sequence, or a default value if the sequence is empty; + this method throws an exception if there is more than one element in the sequence. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the single element of the query result, or default () + if the sequence contains no elements. + + The query result has more than one element. + + + + Asynchronously returns the only element of the query that satisfies a specified condition or + a default value if no such element exists; this method throws an exception if more than one element + satisfies the condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains the single element of the query result that satisfies the condition in + , or default ( ) if no such element is found. + + + + is + null + . + + + More than one element satisfies the condition in + + . + + + + + Asynchronously returns the only element of the query that satisfies a specified condition or + a default value if no such element exists; this method throws an exception if more than one element + satisfies the condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the single element of the query result that satisfies the condition in + , or default ( ) if no such element is found. + + + + is + null + . + + + More than one element satisfies the condition in + + . + + + + + Asynchronously determines whether the query contains a specified element by using the default equality comparer. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The object to locate in the query result. + + A task that represents the asynchronous operation. + The task result contains true if the query result contains the specified value; otherwise, false. + + + + + Asynchronously determines whether the query contains a specified element by using the default equality comparer. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The object to locate in the query result. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains true if the query result contains the specified value; otherwise, false. + + + + + Asynchronously determines whether the query contains any elements. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains true if the query result contains any elements; otherwise, false. + + + + + Asynchronously determines whether the query contains any elements. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains true if the query result contains any elements; otherwise, false. + + + + + Asynchronously determines whether any element of the query satisfies a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains true if any elements in the query result pass the test in the specified predicate; otherwise, false. + + + + + Asynchronously determines whether any element of the query satisfies a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains true if any elements in the query result pass the test in the specified predicate; otherwise, false. + + + + + Asynchronously determines whether all the elements of the query satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains true if every element of the query result passes the test in the specified predicate; otherwise, false. + + + + is + null + . + + + + + Asynchronously determines whether all the elements of the query satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains true if every element of the query result passes the test in the specified predicate; otherwise, false. + + + + is + null + . + + + + + Asynchronously returns the number of elements in the query. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the query result. + + + The number of elements in the query result is larger than + + . + + + + + Asynchronously returns the number of elements in the query. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the query result. + + + The number of elements in the query result is larger than + + . + + + + + Asynchronously returns the number of elements in the query that satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains the number of elements in the query result that satisfy the condition in the predicate function. + + + The number of elements in the query result that satisfy the condition in the predicate function + is larger than + + . + + + + + Asynchronously returns the number of elements in the query that satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the query result that satisfy the condition in the predicate function. + + + The number of elements in the query result that satisfy the condition in the predicate function + is larger than + + . + + + + + Asynchronously returns an that represents the total number of elements in the query. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the query result. + + + The number of elements in the query result is larger than + + . + + + + + Asynchronously returns an that represents the total number of elements in the query. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the query result. + + + The number of elements in the query result is larger than + + . + + + + + Asynchronously returns an that represents the number of elements in the query + that satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A task that represents the asynchronous operation. + The task result contains the number of elements in the query result that satisfy the condition in the predicate function. + + + The number of elements in the query result that satisfy the condition in the predicate function + is larger than + + . + + + + + Asynchronously returns an that represents the number of elements in the query + that satisfy a condition. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + A function to test each element for a condition. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the number of elements in the query result that satisfy the condition in the predicate function. + + + The number of elements in the query result that satisfy the condition in the predicate function + is larger than + + . + + + + + Asynchronously returns the minimum value of the query. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains the minimum value in the query result. + + + + + Asynchronously returns the minimum value of the query. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the minimum value in the query result. + + + + + Asynchronously returns the maximum value of the query. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains the maximum value in the query result. + + + + + Asynchronously returns the maximum value of the query. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the maximum value in the query result. + + + + + Returns a that contains the SQL string that was set + when the query was created. The parameters are not included. + + + A that represents this instance. + + + + + Throws an exception indicating that binding directly to a store query is not supported. + + Never returns; always throws. + + + + + + + + + + + + + Returns false. + + + false . + + + + + Creates an instance of a when called from the constructor of a derived + type that will be used as a test double for . Methods and properties + that will be used by the test double must be implemented by the test double except AsNoTracking and + AsStreaming where the default implementation is a no-op. + + + + + Returns a new query where the entities returned will not be cached in the . + + A new query with NoTracking applied. + + + + Returns a new query that will stream the results instead of buffering. + + A new query with AsStreaming applied. + + + + + + + + + + + + + + + + Asynchronous version of the interface that allows elements to be retrieved asynchronously. + This interface is used to interact with Entity Framework queries and shouldn't be implemented by custom classes. + + + + + Advances the enumerator to the next element in the sequence, returning the result asynchronously. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains true if the enumerator was successfully advanced to the next element; false if the enumerator has passed the end of the sequence. + + + + + Gets the current element in the iteration. + + + + + Defines methods to create and asynchronously execute queries that are described by an + object. + This interface is used to interact with Entity Framework queries and shouldn't be implemented by custom classes. + + + + + Asynchronously executes the query represented by a specified expression tree. + + An expression tree that represents a LINQ query. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the value that results from executing the specified query. + + + + + Asynchronously executes the strongly-typed query represented by a specified expression tree. + + The type of the value that results from executing the query. + An expression tree that represents a LINQ query. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the value that results from executing the specified query. + + + + + Asynchronous version of the interface that allows elements to be retrieved asynchronously. + This interface is used to interact with Entity Framework queries and shouldn't be implemented by custom classes. + + The type of objects to enumerate. + + + + Gets the current element in the iteration. + + + + + Represents a key value that uniquely identifies an Entity Framework model that has been loaded into memory. + + + + Determines whether the current cached model key is equal to the specified cached model key. + true if the current cached model key is equal to the specified cached model key; otherwise, false. + The cached model key to compare to the current cached model key. + + + Returns the hash function for this cached model key. + The hash function for this cached model key. + + + + Thrown when an operation can't be performed because there are existing migrations that have not been applied to the database. + + + + + Represents errors that occur inside the Code First Migrations pipeline. + + + + + Initializes a new instance of the MigrationsException class. + + + + + Initializes a new instance of the MigrationsException class. + + The message that describes the error. + + + + Initializes a new instance of the MigrationsException class. + + The message that describes the error. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Initializes a new instance of the MigrationsException class with serialized data. + + + The that holds the serialized object data about the exception being thrown. + + + The that contains contextual information about the source or destination. + + + + + Initializes a new instance of the MigrationsPendingException class. + + + + + Initializes a new instance of the MigrationsPendingException class. + + The message that describes the error. + + + + Initializes a new instance of the MigrationsPendingException class. + + The message that describes the error. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + A migration operation to add a new stored procedure to the database. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the stored procedure. + The body of the stored procedure expressed in SQL. + Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets an operation to drop the stored procedure. + + + + + Allows configuration to be performed for a lightweight convention based on + the properties in a model. + + + + + Filters the properties that this convention applies to based on a predicate. + + A function to test each property for a condition. + + A instance so that multiple calls can be chained. + + + + + Filters the properties that this convention applies to based on a predicate + while capturing a value to use later during configuration. + + Type of the captured value. + + A function to capture a value for each property. If the value is null, the + property will be filtered out. + + + A instance so that multiple calls can be chained. + + + + + Allows configuration of the properties that this convention applies to. + + + An action that performs configuration against a + + . + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Allows configuration to be performed for a lightweight convention based on + the properties of entity types in a model and a captured value. + + The type of the captured value. + + + + Allows configuration of the properties that this convention applies to. + + + An action that performs configuration against a + using a captured value. + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Allows configuration to be performed for a stored procedure that is used to modify a relationship. + + The type of the entity that the relationship is being configured from. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + The type of the property. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + The type of the property. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + + Creates a convention that configures stored procedures to be used to delete entities in the database. + + + + + Creates a convention that configures stored procedures to be used to modify entities in the database. + + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + The schema name. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + The name of the property to configure the parameter for. + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + The property to configure the parameter for. + The name of the parameter. + + + Configures the output parameter that returns the rows affected by this stored procedure. + The same configuration instance so that multiple calls can be chained. + The name of the parameter. + + + + + + + + + + + + + + + + Creates a convention that configures stored procedures to be used to insert entities in the database. + + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + The schema name. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + The name of the property to configure the parameter for. + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + The property to configure the parameter for. + The name of the parameter. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + The name of the property to configure the result for. + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + The property to configure the result for. + The name of the result column. + + + + + + + + + + + + + + + + Creates a convention that configures stored procedures to be used to modify entities in the database. + + + + Configures stored procedure used to insert entities. + The same configuration instance so that multiple calls can be chained. + A lambda expression that performs configuration for the stored procedure. + + + Configures stored procedure used to update entities. + The same configuration instance so that multiple calls can be chained. + A lambda expression that performs configuration for the stored procedure. + + + Configures stored procedure used to delete entities. + The same configuration instance so that multiple calls can be chained. + A lambda expression that performs configuration for the stored procedure. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Creates a convention that configures stored procedures to be used to update entities in the database. + + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + The schema name. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + The name of the property to configure the parameter for. + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + The property to configure the parameter for. + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + The name of the property to configure the parameter for. + The current value parameter name. + The original value parameter name. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + The property to configure the parameter for. + The current value parameter name. + The original value parameter name. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + The name of the property to configure the result for. + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + The property to configure the result for. + The name of the result column. + + + Configures the output parameter that returns the rows affected by this stored procedure. + The same configuration instance so that multiple calls can be chained. + The name of the parameter. + + + + + + + + + + + + + + + + Allows configuration to be performed for a stored procedure that is used to modify a many to many relationship. + + The type of the entity that the relationship is being configured from. + The type of the entity that the other end of the relationship targets. + + + + Performs configuration of a stored procedure uses to modify an entity in the database. + + + + + Sets the name of the stored procedure. + + Name of the procedure. + The same configuration instance so that multiple calls can be chained. + + + + Sets the name of the stored procedure. + + Name of the procedure. + Name of the schema. + The same configuration instance so that multiple calls can be chained. + + + + Configures the parameter for the left key value(s). + + The type of the property to configure. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + Name of the parameter. + The same configuration instance so that multiple calls can be chained. + + + + Configures the parameter for the left key value(s). + + The type of the property to configure. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + Name of the parameter. + The same configuration instance so that multiple calls can be chained. + + + + Configures the parameter for the left key value(s). + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + Name of the parameter. + The same configuration instance so that multiple calls can be chained. + + + + Configures the parameter for the left key value(s). + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + Name of the parameter. + The same configuration instance so that multiple calls can be chained. + + + + Configures the parameter for the right key value(s). + + The type of the property to configure. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + Name of the parameter. + The same configuration instance so that multiple calls can be chained. + + + + Configures the parameter for the right key value(s). + + The type of the property to configure. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + Name of the parameter. + The same configuration instance so that multiple calls can be chained. + + + + Configures the parameter for the right key value(s). + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + Name of the parameter. + The same configuration instance so that multiple calls can be chained. + + + + Configures the parameter for the right key value(s). + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + Name of the parameter. + The same configuration instance so that multiple calls can be chained. + + + + + + + + + + + + + + + + Allows configuration to be performed for a stored procedure that is used to modify a many to many relationship. + + The type of the entity that the relationship is being configured from. + The type of the entity that the other end of the relationship targets. + + + Configures stored procedure used to insert relationships. + The same configuration instance so that multiple calls can be chained. + A lambda expression that performs configuration for the stored procedure. + + + Configures stored procedure used to delete relationships. + The same configuration instance so that multiple calls can be chained. + A lambda expression that performs configuration for the stored procedure. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Allows configuration to be performed for a stored procedure that is used to delete entities. + + The type of the entity that the stored procedure can be used to delete. + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + The schema name. + + + Configures a parameter for this stored procedure. + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures the output parameter that returns the rows affected by this stored procedure. + The same configuration instance so that multiple calls can be chained. + The name of the parameter. + + + Configures parameters for a relationship where the foreign key property is not included in the class. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the navigation property for the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A lambda expression that performs the configuration. + The type of the principal entity in the relationship. + + + Configures parameters for a relationship where the foreign key property is not included in the class. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the navigation property for the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A lambda expression that performs the configuration. + The type of the principal entity in the relationship. + + + + + + + + + + + + + + + + Allows configuration to be performed for a stored procedure that is used to insert entities. + + The type of the entity that the stored procedure can be used to insert. + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + The schema name. + + + Configures a parameter for this stored procedure. + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + Configures parameters for a relationship where the foreign key property is not included in the class. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the navigation property for the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A lambda expression that performs the configuration. + The type of the principal entity in the relationship. + + + Configures parameters for a relationship where the foreign key property is not included in the class. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the navigation property for the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A lambda expression that performs the configuration. + The type of the principal entity in the relationship. + + + + + + + + + + + + + + + + Allows configuration to be performed for a stored procedure that is used to update entities. + + The type of the entity that the stored procedure can be used to update. + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + + + Configures the name of the stored procedure. + The same configuration instance so that multiple calls can be chained. + The stored procedure name. + The schema name. + + + Configures a parameter for this stored procedure. + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the parameter. + + + Configures a parameter for this stored procedure. + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The current value parameter name. + The original value parameter name. + + + Configures a parameter for this stored procedure. + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The current value parameter name. + The original value parameter name. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The current value parameter name. + The original value parameter name. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The current value parameter name. + The original value parameter name. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The current value parameter name. + The original value parameter name. + + + Configures a parameter for this stored procedure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the parameter for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The current value parameter name. + The original value parameter name. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The type of the property to configure. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + + Configures a column of the result for this stored procedure to map to a property. + This is used for database generated columns. + + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the property to configure the result for. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The name of the result column. + + + Configures the output parameter that returns the rows affected by this stored procedure. + The same configuration instance so that multiple calls can be chained. + The name of the parameter. + + + Configures parameters for a relationship where the foreign key property is not included in the class. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the navigation property for the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A lambda expression that performs the configuration. + The type of the principal entity in the relationship. + + + Configures parameters for a relationship where the foreign key property is not included in the class. + The same configuration instance so that multiple calls can be chained. + A lambda expression representing the navigation property for the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A lambda expression that performs the configuration. + The type of the principal entity in the relationship. + + + + + + + + + + + + + + + + Allows configuration to be performed for a stored procedure that is used to modify entities. + + The type of the entity that the stored procedure can be used to modify. + + + Configures stored procedure used to insert entities. + The same configuration instance so that multiple calls can be chained. + A lambda expression that performs configuration for the stored procedure. + + + Configures stored procedure used to update entities. + The same configuration instance so that multiple calls can be chained. + A lambda expression that performs configuration for the stored procedure. + + + Configures stored procedure used to delete entities. + The same configuration instance so that multiple calls can be chained. + A lambda expression that performs configuration for the stored procedure. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Used to configure a primitive property of an entity type or complex type. + This configuration functionality is available via lightweight conventions. + + + + + Configures the name of the database column used to store the property. + + The name of the column. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Sets an annotation in the model for the database column used to store the property. The annotation + value can later be used when processing the column such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Calling this method will have no effect if the + annotation with the given name has already been configured. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same configuration instance so that multiple calls can be chained. + + + + Configures the name of the parameter used in stored procedures for this property. + + Name of the parameter. + + The same instance so that multiple calls can be chained. + + + + + Configures the order of the database column used to store the property. + This method is also used to specify key ordering when an entity type has a composite key. + + The order that this column should appear in the database table. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Configures the data type of the database column used to store the property. + + Name of the database provider specific data type. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Configures the property to be used as an optimistic concurrency token. + + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Configures whether or not the property is to be used as an optimistic concurrency token. + + Value indicating if the property is a concurrency token or not. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Configures how values for the property are generated by the database. + + The pattern used to generate values for the property in the database. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Configures the property to be optional. + The database column used to store this property will be nullable. + + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Configures the property to be required. + The database column used to store this property will be non-nullable. + + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + + + + + Configures the property to support Unicode string content. + + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + This method throws if the property is not a . + + + + + Configures whether or not the property supports Unicode string content. + + Value indicating if the property supports Unicode string content or not. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + This method throws if the property is not a . + + + + + Configures the property to be fixed length. + Use HasMaxLength to set the length that the property is fixed to. + + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + This method throws if the property does not have length facets. + + + + + Configures the property to be variable length. + Properties are variable length by default. + + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + This method throws if the property does not have length facets. + + + + + Configures the property to have the specified maximum length. + + The maximum length for the property. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + This method throws if the property does not have length facets. + + + + + Configures the property to allow the maximum length supported by the database provider. + + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + This method throws if the property does not have length facets. + + + + + Configures the precision of the property. + If the database provider does not support precision for the data type of the column then the value is ignored. + + Precision of the property. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + This method will throw if the property is not a . + + + + + Configures the precision and scale of the property. + + The precision of the property. + The scale of the property. + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + This method will throw if the property is not a . + + + + + Configures the property to be a row version in the database. + The actual data type will vary depending on the database provider being used. + Setting the property to be a row version will automatically configure it to be an + optimistic concurrency token. + + + The same instance so that multiple calls can be chained. + + + Calling this will have no effect once it has been configured. + This method throws if the property is not a . + + + + + Configures this property to be part of the entity type's primary key. + + + The same instance so that + multiple calls can be chained. + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Gets the for this property. + + + + + An implementation of that does nothing. Using this + initializer disables database initialization for the given context type. Passing an instance + of this class to is equivalent to passing null. + When is being used to resolve initializers an instance of + this class must be used to disable initialization. + + The type of the context. + + + + + + + FieldMetadata class providing the correlation between the column ordinals and MemberMetadata. + + + + + Initializes a new object with the specified ordinal value and field type. + + An integer specified the location of the metadata. + The field type. + + + + Gets the type of field for this object. + + + The type of field for this object. + + + + + Gets the ordinal for this object. + + An integer representing the ordinal value. + + + + Class representing a parameter collection used in EntityCommand + + + + + Adds the specified object to the . + + + The index of the new object. + + + An . + + + + + Adds an array of values to the end of the + + . + + + The values to add. + + + + + Removes all the objects from the + + . + + + + + Determines whether the specified is in this + + . + + + true if the contains the value; otherwise false. + + + The value. + + + + + Copies all the elements of the current to the specified one-dimensional + + starting at the specified destination index. + + + The one-dimensional that is the destination of the elements copied from the current + + . + + + A 32-bit integer that represents the index in the at which copying starts. + + + + + Returns an enumerator that iterates through the + + . + + + An for the + + . + + + + + + + + + + + Gets the location of the specified with the specified name. + + + The zero-based location of the specified with the specified case-sensitive name. Returns -1 when the object does not exist in the + + . + + + The case-sensitive name of the to find. + + + + + Gets the location of the specified in the collection. + + + The zero-based location of the specified that is a + + in the collection. Returns -1 when the object does not exist in the + + . + + + The to find. + + + + + Inserts an into the + + at the specified index. + + The zero-based index at which value should be inserted. + + An to be inserted in the + + . + + + + Removes the specified parameter from the collection. + + A object to remove from the collection. + + + + + Removes the from the + + at the specified index. + + + The zero-based index of the object to remove. + + + + + Removes the from the + + at the specified parameter name. + + + The name of the to remove. + + + + + + + + + + + Adds the specified object to the + + . + + + A new object. + + + The to add to the collection. + + + The specified in the value parameter is already added to this or another + + . + + + The parameter passed was not a . + + The value parameter is null. + + + + Adds a value to the end of the . + + + A object. + + The name of the parameter. + The value to be added. + + + + Adds a to the + + given the parameter name and the data type. + + + A new object. + + The name of the parameter. + + One of the values. + + + + + Adds a to the + + with the parameter name, the data type, and the column length. + + + A new object. + + The name of the parameter. + + One of the values. + + The column length. + + + + Adds an array of values to the end of the + + . + + + The values to add. + + + + + Determines whether the specified is in this + + . + + + true if the contains the value; otherwise false. + + + The value. + + + + + Copies all the elements of the current to the specified + + starting at the specified destination index. + + + The that is the destination of the elements copied from the current + + . + + + A 32-bit integer that represents the index in the + + at which copying starts. + + + + + Gets the location of the specified in the collection. + + + The zero-based location of the specified that is a + + in the collection. Returns -1 when the object does not exist in the + + . + + + The to find. + + + + + Inserts a object into the + + at the specified index. + + The zero-based index at which value should be inserted. + + A object to be inserted in the + + . + + + + + Removes the specified from the collection. + + + A object to remove from the collection. + + + The parameter is not a . + + The parameter does not exist in the collection. + + + + Gets an Integer that contains the number of elements in the + + . + + + The number of elements in the as an Integer. + + + + + Gets a value that indicates whether the + + has a fixed size. + + + Returns true if the has a fixed size; otherwise false. + + + + + Gets a value that indicates whether the + + is read-only. + + + Returns true if the is read only; otherwise false. + + + + + Gets a value that indicates whether the + + is synchronized. + + + Returns true if the is synchronized; otherwise false. + + + + + Gets an object that can be used to synchronize access to the + + . + + + An object that can be used to synchronize access to the + + . + + + + + Gets the at the specified index. + + + The at the specified index. + + The zero-based index of the parameter to retrieve. + The specified index does not exist. + + + + Gets the with the specified name. + + + The with the specified name. + + The name of the parameter to retrieve. + The specified name does not exist. + + + + Class representing a command for the conceptual layer + + + + + Initializes a new instance of the class using the specified values. + + + + + Initializes a new instance of the class with the specified statement. + + The text of the command. + + + + Constructs the EntityCommand object with the given eSQL statement and the connection object to use + + The eSQL command text to execute + The connection object + Resolver used to resolve DbProviderServices + + + + Initializes a new instance of the class with the specified statement and connection. + + The text of the command. + A connection to the data source. + + + + Initializes a new instance of the class with the specified statement, connection and transaction. + + The text of the command. + A connection to the data source. + The transaction in which the command executes. + + + + Cancels the execution of an . + + + + + Creates a new instance of an object. + + + A new instance of an object. + + + + + Create and return a new parameter object representing a parameter in the eSQL statement + + The parameter object. + + + Executes the command and returns a data reader. + + The that contains the results. + + + + + Compiles the into a command tree and passes it to the underlying store provider for execution, then builds an + + out of the produced result set using the specified + + . + + + The that contains the results. + + + One of the values. + + + + + Asynchronously executes the command and returns a data reader for reading the results. May only + be called on CommandType.CommandText (otherwise, use the standard Execute* methods) + + + A task that represents the asynchronous operation. + The task result contains an EntityDataReader object. + + + For stored procedure commands, if called + for anything but an entity collection result + + + + + Asynchronously executes the command and returns a data reader for reading the results. May only + be called on CommandType.CommandText (otherwise, use the standard Execute* methods) + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains an EntityDataReader object. + + + For stored procedure commands, if called + for anything but an entity collection result + + + + + Asynchronously executes the command and returns a data reader for reading the results. May only + be called on CommandType.CommandText (otherwise, use the standard Execute* methods) + + The behavior to use when executing the command + + A task that represents the asynchronous operation. + The task result contains an EntityDataReader object. + + + For stored procedure commands, if called + for anything but an entity collection result + + + + + Asynchronously executes the command and returns a data reader for reading the results. May only + be called on CommandType.CommandText (otherwise, use the standard Execute* methods) + + The behavior to use when executing the command + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains an EntityDataReader object. + + + For stored procedure commands, if called + for anything but an entity collection result + + + + + Executes the command and returns a data reader for reading the results + + The behavior to use when executing the command + A DbDataReader object + + + + Asynchronously executes the command and returns a data reader for reading the results + + The behavior to use when executing the command + The token to monitor for cancellation requests + + A task that represents the asynchronous operation. + The task result contains a DbDataReader object. + + + + Executes the current command. + The number of rows affected. + + + + Asynchronously executes the command and discard any results returned from the command + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the number of rows affected. + + + + Executes the command, and returns the first column of the first row in the result set. Additional columns or rows are ignored. + The first column of the first row in the result set, or a null reference (Nothing in Visual Basic) if the result set is empty. + + + Compiles the entity-level command and creates a prepared version of the command. + + + Compiles the entity-level command and returns the store command text. + The store command text. + + + + Gets or sets the used by the + + . + + The connection used by the entity command. + + + + The connection object used for executing the command + + + + Gets or sets an Entity SQL statement that specifies a command or stored procedure to execute. + The Entity SQL statement that specifies a command or stored procedure to execute. + + + Gets or sets the command tree to execute; only one of the command tree or the command text can be set, not both. + The command tree to execute. + + + Gets or sets the amount of time to wait before timing out. + The time in seconds to wait for the command to execute. + + + + Gets or sets a value that indicates how the + + property is to be interpreted. + + + One of the enumeration values. + + + + Gets the parameters of the Entity SQL statement or stored procedure. + The parameters of the Entity SQL statement or stored procedure. + + + + The collection of parameters for this command + + + + + Gets or sets the transaction within which the executes. + + + The transaction within which the executes. + + + + + The transaction that this command executes in + + + + Gets or sets how command results are applied to rows being updated. + + One of the values. + + + + Gets or sets a value that indicates whether the command object should be visible in a Windows Form Designer control. + true if the command object should be visible in a Windows Form Designer control; otherwise, false. + + + Gets or sets a value that indicates whether the query plan caching is enabled. + true if the query plan caching is enabled; otherwise, false. + + + + Class representing a connection for the conceptual layer. An entity connection may only + be initialized once (by opening the connection). It is subsequently not possible to change + the connection string, attach a new store connection, or change the store connection string. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class, based on the connection string. + + The provider-specific connection string. + An invalid connection string keyword has been provided, or a required connection string keyword has not been provided. + + + + Initializes a new instance of the class with a specified + and + . + + + A to be associated with this + . + + + The underlying data source connection for this object. + + The workspace or connection parameter is null. + The conceptual model is missing from the workspace.-or-The mapping file is missing from the workspace.-or-The storage model is missing from the workspace.-or-The connection is not in a closed state. + The connection is not from an ADO.NET Entity Framework-compatible provider. + + + + Constructs the EntityConnection from Metadata loaded in memory + + Workspace containing metadata information. + Store connection. + If set to true the store connection is disposed when the entity connection is disposed, otherwise the caller must dispose the store connection. + + + + Returns the associated with this + + . + + + The associated with this + + . + + The inline connection string contains an invalid Metadata keyword value. + + + Establishes a connection to the data source by calling the underlying data provider's Open method. + An error occurs when you open the connection, or the name of the underlying data provider is not known. + The inline connection string contains an invalid Metadata keyword value. + + + + Asynchronously establishes a connection to the data store by calling the Open method on the underlying data provider + + + A to observe while waiting for the task to complete. + + A task that represents the asynchronous operation. + + + + Creates a new instance of an , with the + + set to this + + . + + + An object. + + The name of the underlying data provider is not known. + + + + Create a new command object that uses this connection object + + The command object. + + + Closes the connection to the database. + An error occurred when closing the connection. + + + Not supported. + Not supported. + When the method is called. + + + Begins a transaction by using the underlying provider. + + A new . The returned + + instance can later be associated with the + + to execute the command under that transaction. + + + The underlying provider is not known.-or-The call to + + was made on an + + that already has a current transaction.-or-The state of the + + is not + + . + + + + Begins a transaction with the specified isolation level by using the underlying provider. + + A new . The returned + + instance can later be associated with the + + to execute the command under that transaction. + + The isolation level of the transaction. + + The underlying provider is not known.-or-The call to + + was made on an + + that already has a current transaction.-or-The state of the + + is not + + . + + + + + Begins a database transaction + + The isolation level of the transaction + An object representing the new transaction + + + + Enlists this in the specified transaction. + + The transaction object to enlist into. + + The state of the is not + + . + + + + + Cleans up this connection object + + true to release both managed and unmanaged resources; false to release only unmanaged resources + + + + Gets or sets the connection string. + + The connection string required to establish the initial connection to a data source. The default value is an empty string. On a closed connection, the currently set value is returned. If no value has been set, an empty string is returned. + + An attempt was made to set the property after the + + ’s was initialized. The + + is initialized either when the instance is constructed through the overload that takes a + + as a parameter, or when the + + instance has been opened. + + An invalid connection string keyword has been provided or a required connection string keyword has not been provided. + + + Gets the number of seconds to wait when attempting to establish a connection before ending the attempt and generating an error. + The time (in seconds) to wait for a connection to open. The default value is the underlying data provider's default time-out. + The value set is less than 0. + + + Gets the name of the current database, or the database that will be used after a connection is opened. + The value of the Database property of the underlying data provider. + The underlying data provider is not known. + + + + Gets the state of the EntityConnection, which is set up to track the state of the underlying + database connection that is wrapped by this EntityConnection. + + + + Gets the name or network address of the data source to connect to. + The name of the data source. The default value is an empty string. + The underlying data provider is not known. + + + Gets a string that contains the version of the data source to which the client is connected. + The version of the data source that is contained in the provider connection string. + The connection is closed. + + + + Gets the provider factory associated with EntityConnection + + + + + Provides access to the underlying data source connection that is used by the + + object. + + + The for the data source connection. + + + + + Gets the current transaction that this connection is enlisted in. May be null. + + + + + Class representing a connection string builder for the entity client provider + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class using the supplied connection string. + + A provider-specific connection string to the underlying data source. + + + + Clears the contents of the instance. + + + + + Determines whether the contains a specific key. + + + Returns true if the contains an element that has the specified key; otherwise, false. + + + The key to locate in the . + + + + + Retrieves a value corresponding to the supplied key from this + + . + + Returns true if keyword was found in the connection string; otherwise, false. + The key of the item to retrieve. + The value corresponding to keyword. + keyword contains a null value (Nothing in Visual Basic). + + + + Removes the entry with the specified key from the + + instance. + + Returns true if the key existed in the connection string and was removed; false if the key did not exist. + + The key of the keyword/value pair to be removed from the connection string in this + + . + + keyword is null (Nothing in Visual Basic) + + + Gets or sets the name of a section as defined in a configuration file. + The name of a section in a configuration file. + + + Gets or sets the name of the underlying .NET Framework data provider in the connection string. + The invariant name of the underlying .NET Framework data provider. + + + Gets or sets the metadata locations in the connection string. + Gets or sets the metadata locations in the connection string. + + + Gets or sets the inner, provider-specific connection string. + The inner, provider-specific connection string. + + + + Gets a value that indicates whether the + + has a fixed size. + + + Returns true in every case, because the + + supplies a fixed-size collection of keyword/value pairs. + + + + + Gets an that contains the keys in the + + . + + + An that contains the keys in the + + . + + + + Gets or sets the value associated with the specified key. In C#, this property is the indexer. + The value associated with the specified key. + The key of the item to get or set. + keyword is a null reference (Nothing in Visual Basic). + Tried to add a key that does not exist in the available keys. + Invalid value in the connection string (specifically, a Boolean or numeric value was expected but not supplied). + + + + A data reader class for the entity client provider + + + + + Closes the object. + + + + + Releases the resources consumed by this and calls + + . + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the value of the specified column as a Boolean. + The value of the specified column. + The zero-based column ordinal. + + + Gets the value of the specified column as a byte. + The value of the specified column. + The zero-based column ordinal. + + + Reads a stream of bytes from the specified column, starting at location indicated by dataIndex , into the buffer, starting at the location indicated by bufferIndex . + The actual number of bytes read. + The zero-based column ordinal. + The index within the row from which to begin the read operation. + The buffer into which to copy the data. + The index with the buffer to which the data will be copied. + The maximum number of characters to read. + + + Gets the value of the specified column as a single character. + The value of the specified column. + The zero-based column ordinal. + + + Reads a stream of characters from the specified column, starting at location indicated by dataIndex , into the buffer, starting at the location indicated by bufferIndex . + The actual number of characters read. + The zero-based column ordinal. + The index within the row from which to begin the read operation. + The buffer into which to copy the data. + The index with the buffer to which the data will be copied. + The maximum number of characters to read. + + + Gets the name of the data type of the specified column. + The name of the data type. + The zero-based column ordinal. + + + + Gets the value of the specified column as a object. + + The value of the specified column. + The zero-based column ordinal. + + + + Returns a object for the requested column ordinal that can be overridden with a provider-specific implementation. + + A data reader. + The zero-based column ordinal. + + + + Gets the value of the specified column as a object. + + The value of the specified column. + The zero-based column ordinal. + + + Gets the value of the specified column as a double-precision floating point number. + The value of the specified column. + The zero-based column ordinal. + + + Gets the data type of the specified column. + The data type of the specified column. + The zero-based column ordinal. + + + Gets the value of the specified column as a single-precision floating point number. + The value of the specified column. + The zero-based column ordinal. + + + Gets the value of the specified column as a globally-unique identifier (GUID). + The value of the specified column. + The zero-based column ordinal. + + + Gets the value of the specified column as a 16-bit signed integer. + The value of the specified column. + The zero-based column ordinal. + + + Gets the value of the specified column as a 32-bit signed integer. + The value of the specified column. + The zero-based column ordinal. + + + Gets the value of the specified column as a 64-bit signed integer. + The value of the specified column. + The zero-based column ordinal. + + + Gets the name of the column, given the zero-based column ordinal. + The name of the specified column. + The zero-based column ordinal. + + + Gets the column ordinal given the name of the column. + The zero-based column ordinal. + The name of the column. + The name specified is not a valid column name. + + + Returns the provider-specific field type of the specified column. + + The object that describes the data type of the specified column. + + The zero-based column ordinal. + + + + Gets the value of the specified column as an instance of . + + The value of the specified column. + The zero-based column ordinal. + + + Gets all provider-specific attribute columns in the collection for the current row. + + The number of instances of in the array. + + + An array of into which to copy the attribute columns. + + + + + Returns a that describes the column metadata of the + + . + + + A that describes the column metadata. + + + + + Gets the value of the specified column as an instance of . + + The value of the specified column. + The zero-based column ordinal. + + + + Gets the value of the specified column as an instance of . + + The value of the specified column. + The zero-based column ordinal. + + + Populates an array of objects with the column values of the current row. + + The number of instances of in the array. + + + An array of into which to copy the attribute columns. + + + + Gets a value that indicates whether the column contains nonexistent or missing values. + + true if the specified column is equivalent to ; otherwise, false. + + The zero-based column ordinal. + + + Advances the reader to the next result when reading the results of a batch of statements. + true if there are more result sets; otherwise, false. + + + + Asynchronously moves the reader to the next result set when reading a batch of statements + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains true if there are more result sets; false otherwise. + + + + Advances the reader to the next record in a result set. + true if there are more rows; otherwise, false. + + + + Asynchronously moves the reader to the next row of the current result set + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains true if there are more rows; false otherwise. + + + + + Returns an that can be used to iterate through the rows in the data reader. + + + An that can be used to iterate through the rows in the data reader. + + + + + Returns a nested . + + The nested data record. + The number of the DbDataRecord to return. + + + + Returns nested readers as objects. + + + The nested readers as objects. + + The ordinal of the column. + + + Gets a value indicating the depth of nesting for the current row. + The depth of nesting for the current row. + + + Gets the number of columns in the current row. + The number of columns in the current row. + + + + Gets a value that indicates whether this contains one or more rows. + + + true if the contains one or more rows; otherwise, false. + + + + + Gets a value indicating whether the is closed. + + + true if the is closed; otherwise, false. + + + + Gets the number of rows changed, inserted, or deleted by execution of the SQL statement. + The number of rows changed, inserted, or deleted. Returns -1 for SELECT statements; 0 if no rows were affected or the statement failed. + + + + Gets the value of the specified column as an instance of . + + The value of the specified column. + The zero-based column ordinal + + + + Gets the value of the specified column as an instance of . + + The value of the specified column. + The name of the column. + + + + Gets the number of fields in the that are not hidden. + + The number of fields that are not hidden. + + + + Gets for this + + . + + The information of a data record. + + + + Class representing a parameter used in EntityCommand + + + + + Initializes a new instance of the class using the default values. + + + + + Initializes a new instance of the class using the specified parameter name and data type. + + The name of the parameter. + + One of the values. + + + + + Initializes a new instance of the class using the specified parameter name, data type and size. + + The name of the parameter. + + One of the values. + + The size of the parameter. + + + + Initializes a new instance of the class using the specified properties. + + The name of the parameter. + + One of the values. + + The size of the parameter. + The name of the source column. + + + + Initializes a new instance of the class using the specified properties. + + The name of the parameter. + + One of the values. + + The size of the parameter. + + One of the values. + + true to indicate that the parameter accepts null values; otherwise, false. + The number of digits used to represent the value. + The number of decimal places to which value is resolved. + The name of the source column. + + One of the values. + + The value of the parameter. + + + + Resets the type associated with the . + + + + Returns a string representation of the parameter. + A string representation of the parameter. + + + Gets or sets the name of the entity parameter. + The name of the entity parameter. + + + + Gets or sets the of the parameter. + + + One of the values. + + + + Gets or sets the type of the parameter, expressed as an EdmType. + The type of the parameter, expressed as an EdmType. + + + + Gets or sets the number of digits used to represent the + + property. + + The number of digits used to represent the value. + + + + Gets or sets the number of decimal places to which + + is resolved. + + The number of decimal places to which value is resolved. + + + Gets or sets the value of the parameter. + The value of the parameter. + + + Gets or sets the direction of the parameter. + + One of the values. + + + + Gets or sets a value that indicates whether the parameter accepts null values. + true if null values are accepted; otherwise, false. + + + Gets or sets the maximum size of the data within the column. + The maximum size of the data within the column. + + + + Gets or sets the name of the source column mapped to the and used for loading or returning the + + . + + The name of the source column mapped to the dataset and used for loading or returning the value. + + + Gets or sets a value that indicates whether source column is nullable. + true if source column is nullable; otherwise, false. + + + + Gets or sets the to use when loading the value. + + + One of the values. + + + + + Class representing a provider factory for the entity client provider + + + + + A singleton object for the entity client provider factory object. + This remains a public field (not property) because DbProviderFactory expects a field. + + + + + Returns a new instance of the provider's class that implements the + + class. + + + A new instance of . + + + + + Throws a . This method is currently not supported. + + This method is currently not supported. + + + + Returns a new instance of the provider's class that implements the + + class. + + + A new instance of . + + + + + Returns a new instance of the provider's class that implements the + + class. + + + A new instance of . + + + + + Throws a . This method is currently not supported. + + This method is currently not supported. + + + + Returns a new instance of the provider's class that implements the + + class. + + + A new instance of . + + + + + Throws a . This method is currently not supported. + + This method is currently not supported. + This method is currently not supported. + + + + Returns the requested class. + + + A new instance of . The supported types are + + , + + , and + + . Returns null (or Nothing in Visual Basic) for every other type. + + + The to return. + + + + + Class representing a transaction for the conceptual layer + + + + Commits the underlying transaction. + + + Rolls back the underlying transaction. + + + + Cleans up this transaction object + + true to release both managed and unmanaged resources; false to release only unmanaged resources + + + + Gets for this + + . + + + An to the underlying data source. + + + + + The connection object owning this transaction object + + + + + Gets the isolation level of this . + + + An enumeration value that represents the isolation level of the underlying transaction. + + + + + Gets the DbTransaction for the underlying provider transaction. + + + + + Represents a failure while trying to prepare or execute a CommandCompilation + This exception is intended to provide a common exception that people can catch to + hold provider exceptions (SqlException, OracleException) when using the EntityCommand + to execute statements. + + + + + Initializes a new instance of . + + + + + Initializes a new instance of . + + The message that describes the error. + + + + Initializes a new instance of . + + The error message that explains the reason for the exception. + The exception that caused the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Represents a failure while trying to prepare or execute a CommandExecution + This exception is intended to provide a common exception that people can catch to + hold provider exceptions (SqlException, OracleException) when using the EntityCommand + to execute statements. + + + + + Initializes a new instance of . + + + + + Initializes a new instance of . + + The message that describes the error. + + + + Initializes a new instance of . + + The error message that explains the reason for the exception. + The exception that caused the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + An identifier for an entity. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with an entity set name and a generic + + collection. + + + A that is the entity set name qualified by the entity container name. + + + A generic collection.Each key/value pair has a property name as the key and the value of that property as the value. There should be one pair for each property that is part of the + + . The order of the key/value pairs is not important, but each key property should be included. The property names are simple names that are not qualified with an entity type name or the schema name. + + + + + Initializes a new instance of the class with an entity set name and an + + collection of + + objects. + + + A that is the entity set name qualified by the entity container name. + + + An collection of + + objects with which to initialize the key. + + + + + Initializes a new instance of the class with an entity set name and specific entity key pair. + + + A that is the entity set name qualified by the entity container name. + + + A that is the name of the key. + + + An that is the key value. + + + + Gets the entity set for this entity key from the given metadata workspace. + + The for the entity key. + + The metadata workspace that contains the entity. + The entity set could not be located in the specified metadata workspace. + + + Returns a value that indicates whether this instance is equal to a specified object. + true if this instance and obj have equal values; otherwise, false. + + An to compare with this instance. + + + + + Returns a value that indicates whether this instance is equal to a specified + + . + + true if this instance and other have equal values; otherwise, false. + + An object to compare with this instance. + + + + + Serves as a hash function for the current object. + + is suitable for hashing algorithms and data structures such as a hash table. + + + A hash code for the current . + + + + + Compares two objects. + + true if the key1 and key2 values are equal; otherwise, false. + + A to compare. + + + A to compare. + + + + + Compares two objects. + + true if the key1 and key2 values are not equal; otherwise, false. + + A to compare. + + + A to compare. + + + + + Helper method that is used to deserialize an . + + Describes the source and destination of a given serialized stream, and provides an additional caller-defined context. + + + + Helper method that is used to deserialize an . + + Describes the source and destination of a given serialized stream and provides an additional caller-defined context. + + + + Gets a singleton EntityKey by which a read-only entity is identified. + + + + + Gets a singleton EntityKey identifying an entity resulted from a failed TREAT. + + + + Gets or sets the name of the entity set. + + A value that is the name of the entity set for the entity to which the + + belongs. + + + + Gets or sets the name of the entity container. + + A value that is the name of the entity container for the entity to which the + + belongs. + + + + + Gets or sets the key values associated with this . + + + A of key values for this + + . + + + + + Gets a value that indicates whether the is temporary. + + + true if the is temporary; otherwise, false. + + + + + Information about a key that is part of an EntityKey. + A key member contains the key name and value. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified entity key pair. + + The name of the key. + The key value. + + + Returns a string representation of the entity key. + A string representation of the entity key. + + + Gets or sets the name of the entity key. + The key name. + + + Gets or sets the value of the entity key. + The key value. + + + + Kind of collection (applied to Properties) + + + + + Property is not a Collection + + + + + Collection has Bag semantics( unordered and duplicates ok) + + + + + Collection has List semantics + (Order is deterministic and duplicates ok) + + + + + The concurrency mode for properties. + + + + + Default concurrency mode: the property is never validated + at write time + + + + + Fixed concurrency mode: the property is always validated at + write time + + + + + The pattern for Server Generated Properties. + + + + + Not a Server Generated Property. This is the default. + + + + + A value is generated on INSERT, and remains unchanged on update. + + + + + A value is generated on both INSERT and UPDATE. + + + + + Represents an eSQL Query compilation exception; + The class of exceptional conditions that may cause this exception to be raised are mainly: + 1) Syntax Errors: raised during query text parsing and when a given query does not conform to eSQL formal grammar; + 2) Semantic Errors: raised when semantic rules of eSQL language are not met such as metadata or schema information + not accurate or not present, type validation errors, scoping rule violations, user of undefined variables, etc. + For more information, see eSQL Language Spec. + + + + + Initializes a new instance of . + + + + + Initializes a new instance of with a specialized error message. + + The message that describes the error. + + + + Initializes a new instance of the class that uses 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 caused the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + Gets a description of the error. + A string that describes the error. + + + Gets the approximate context where the error occurred, if available. + A string that describes the approximate context where the error occurred, if available. + + + Gets the approximate line number where the error occurred. + An integer that describes the line number where the error occurred. + + + Gets the approximate column number where the error occurred. + An integer that describes the column number where the error occurred. + + + + Thrown to indicate that a command tree is invalid. + + + + + Initializes a new instance of the class with a default message. + + + + + Initializes a new instance of the class with the specified message. + + The exception message. + + + + Initializes a new instance of the class with the specified message and inner exception. + + The exception message. + + The exception that is the cause of this . + + + + + Mapping exception class. Note that this class has state - so if you change even + its internals, it can be a breaking change + + + + + Initializes a new instance of . + + + + + Initializes a new instance of with a specialized error message. + + The message that describes the error. + + + + Initializes a new instance of that uses a specified error message and a reference to the inner exception. + + The message that describes the error. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Class for representing a collection of mapping items in Edm space. + + + + + Base class for the type created at design time to store the generated views. + + + + Returns the key/value pair at the specified index, which contains the view and its key. + The key/value pair at index , which contains the view and its key. + The index of the view. + + + + Gets or sets the name of . + + The container name. + + + + Gets or sets in storage schema. + + Container name. + + + Hash value. + Hash value. + + + Hash value of views. + Hash value. + + + Gets or sets view count. + View count. + + + + Attribute to mark the assemblies that contain the generated views type. + + + + + Initializes a new instance of the class. + + The view type. + + + Gets the T:System.Type of the view. + The T:System.Type of the view. + + + + Represents a complex type mapping for a function import result. + + + + + Specifies a function import structural type mapping. + + + + + Gets the property mappings for the result type of a function import. + + + + + Initializes a new FunctionImportComplexTypeMapping instance. + + The return type. + The property mappings for the result type of a function import. + + + + Ges the return type. + + + + + Represents a function import entity type mapping. + + + + + Initializes a new FunctionImportEntityTypeMapping instance. + + The entity types at the base of + the type hierarchies to be mapped. + The entity types to be mapped. + The property mappings for the result types of a function import. + The mapping conditions. + + + + Gets the entity types being mapped. + + + + + Gets the entity types at the base of the hierarchies being mapped. + + + + + Gets the mapping conditions. + + + + + Represents a mapping condition for a function import result. + + + + + + + + Gets the name of the column used to evaluate the condition. + + + + + Represents a mapping condition for the result of a function import + evaluated by checking null or not null. + + + + + Initializes a new FunctionImportEntityTypeMappingConditionIsNull instance. + + The name of the column used to evaluate the condition. + Flag that indicates whether a null or not null check is performed. + + + + Gets a flag that indicates whether a null or not null check is performed. + + + + + Represents a mapping condition for the result of a function import, + evaluated by comparison with a specified value. + + + + + Initializes a new FunctionImportEntityTypeMappingConditionValue instance. + + The name of the column used to evaluate the condition. + The value to compare with. + + + + Gets the value used for comparison. + + + + + Represents a mapping from a model function import to a store composable or non-composable function. + + + + + Gets model function (or source of the mapping) + + + + + Gets store function (or target of the mapping) + + + + + Represents a mapping from a model function import to a store composable function. + + + + + Initializes a new FunctionImportMappingComposable instance. + + The model function import. + The store composable function. + The result mapping for the function import. + The parent container mapping. + + + + Gets the result mapping for the function import. + + + + + Represents a mapping from a model function import to a store non-composable function. + + + + + Initializes a new FunctionImportMappingNonComposable instance. + + The model function import. + The store non-composable function. + The function import result mappings. + The parent container mapping. + + + + Gets the function import result mappings. + + + + + Base class for mapping a property of a function import return type. + + + + + Maps a function import return type property to a table column. + + + + + Initializes a new FunctionImportReturnTypeScalarPropertyMapping instance. + + The mapped property name. + The mapped column name. + + + + Gets the mapped property name. + + + + + Gets the mapped column name. + + + + + Represents the base item class for all the mapping metadata + + + + + Represents the base item class for all the metadata + + + + + Describes modification function mappings for an association set. + + + + + Initalizes a new AssociationSetModificationFunctionMapping instance. + + An association set. + A delete function mapping. + An insert function mapping. + + + + + + + Gets the association set. + + + + + Gets the delete function mapping. + + + + + Gets the insert function mapping. + + + + + Describes modification function mappings for an entity type within an entity set. + + + + + Initializes a new EntityTypeModificationFunctionMapping instance. + + An entity type. + A delete function mapping. + An insert function mapping. + An updated function mapping. + + + + + + + Gets the entity type. + + + + + Gets the delete function mapping. + + + + + Gets the insert function mapping. + + + + + Gets hte update function mapping. + + + + + Describes the location of a member within an entity or association type structure. + + + + + Initializes a new ModificationFunctionMemberPath instance. + + Gets the members in the path from the leaf (the member being bound) + to the root of the structure. + Gets the association set to which we are navigating + via this member. If the value is null, this is not a navigation member path. + + + + + + + Gets the members in the path from the leaf (the member being bound) + to the Root of the structure. + + + + + Gets the association set to which we are navigating via this member. If the value + is null, this is not a navigation member path. + + + + + Binds a modification function parameter to a member of the entity or association being modified. + + + + + Initializes a new ModificationFunctionParameterBinding instance. + + The parameter taking the value. + The path to the entity or association member defining the value. + A flag indicating whether the current or original member value is being bound. + + + + + + + Gets the parameter taking the value. + + + + + Gets the path to the entity or association member defining the value. + + + + + Gets a flag indicating whether the current or original + member value is being bound. + + + + + Defines a binding from a named result set column to a member taking the value. + + + + + Initializes a new ModificationFunctionResultBinding instance. + + The name of the column to bind from the function result set. + The property to be set on the entity. + + + + + + + Gets the name of the column to bind from the function result set. + + + + + Gets the property to be set on the entity. + + + + + Represents the Mapping metadata for an AssociationSet in CS space. + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityTypeMapping + --MappingFragment + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + This class represents the metadata for the AssociationSetMapping elements in the + above example. And it is possible to access the AssociationTypeMap underneath it. + There will be only one TypeMap under AssociationSetMap. + + + + + Represents the Mapping metadata for an Extent in CS space. + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityTypeMapping + --MappingFragment + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + This class represents the metadata for all the extent map elements in the + above example namely EntitySetMapping, AssociationSetMapping and CompositionSetMapping. + The EntitySetBaseMapping elements that are children of the EntityContainerMapping element + can be accessed through the properties on this type. + + + + + Gets the parent container mapping. + + + + + Gets or sets the query view associated with this mapping. + + + + + Initializes a new AssociationSetMapping instance. + + The association set to be mapped. + The store entity set to be mapped. + The parent container mapping. + + + + Adds a property mapping condition. + + The condition to add. + + + + Removes a property mapping condition. + + The property mapping condition to remove. + + + + Gets the association set that is mapped. + + + + + Gets the contained association type mapping. + + + + + Gets or sets the corresponding function mapping. Can be null. + + + + + Gets the store entity set that is mapped. + + + + + Gets or sets the source end property mapping. + + + + + Gets or sets the target end property mapping. + + + + + Gets the property mapping conditions. + + + + + Represents the Mapping metadata for an association type map in CS space. + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap + --ScalarPropertyMap + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap + --ComplexPropertyMap + --ComplexTypeMap + --ScalarPropertyMap + --ScalarProperyMap + --ScalarPropertyMap + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + --EndPropertyMap + --ScalarPropertyMap + --ScalarProperyMap + --EndPropertyMap + --ScalarPropertyMap + This class represents the metadata for all association Type map elements in the + above example. Users can access the table mapping fragments under the + association type mapping through this class. + + + + + Represents the Mapping metadata for a type map in CS space. + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap + --ScalarPropertyMap + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap + --ComplexPropertyMap + --ScalarPropertyMap + --ScalarProperyMap + --ScalarPropertyMap + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + --EndPropertyMap + --ScalarPropertyMap + --ScalarProperyMap + --EndPropertyMap + --ScalarPropertyMap + This class represents the metadata for all the Type map elements in the + above example namely EntityTypeMapping, AssociationTypeMapping and CompositionTypeMapping. + The TypeMapping elements contain TableMappingFragments which in turn contain the property maps. + + + + + Creates an AssociationTypeMapping instance. + + The AssociationSetMapping that + the contains this AssociationTypeMapping. + + + + Gets the AssociationSetMapping that contains this AssociationTypeMapping. + + + + + Gets the association type being mapped. + + + + + Gets the single mapping fragment. + + + + + Mapping metadata for Complex properties. + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ComplexPropertyMap + --ComplexTypeMapping + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --DiscriminatorProperyMap ( constant value-->SMemberMetadata ) + --ComplexTypeMapping + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --DiscriminatorProperyMap ( constant value-->SMemberMetadata ) + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + --EndPropertyMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --EndPropertyMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + This class represents the metadata for all the complex property map elements in the + above example. ComplexPropertyMaps contain ComplexTypeMaps which define mapping based + on the type of the ComplexProperty in case of inheritance. + + + + + Construct a new Complex Property mapping object + + The MemberMetadata object that represents this Complex member + + + + Adds a type mapping corresponding to a nested complex type. + + The complex type mapping to be added. + + + + Removes a type mapping corresponding to a nested complex type. + + The complex type mapping to be removed. + + + + Gets a read only collections of type mappings corresponding to the + nested complex types. + + + + + Mapping metadata for Complex Types. + + + + + Creates a ComplexTypeMapping instance. + + The ComplexType being mapped. + + + + Adds a property mapping. + + The property mapping to be added. + + + + Removes a property mapping. + + The property mapping to be removed. + + + + Adds a property mapping condition. + + The property mapping condition to be added. + + + + Removes a property mapping condition. + + The property mapping condition to be removed. + + + + Gets the ComplexType being mapped. + + + + + Gets a read-only collection of property mappings. + + + + + Gets a read-only collection of property mapping conditions. + + + + + Mapping metadata for End property of an association. + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ComplexPropertyMap + --ComplexTypeMapping + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --DiscriminatorProperyMap ( constant value-->SMemberMetadata ) + --ComplexTypeMapping + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --DiscriminatorProperyMap ( constant value-->SMemberMetadata ) + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + --EndPropertyMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --EndPropertyMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + This class represents the metadata for all the end property map elements in the + above example. EndPropertyMaps provide mapping for each end of the association. + + + + + Creates an association end property mapping. + + An AssociationEndMember that specifies + the association end to be mapped. + + + + Adds a child property-column mapping. + + A ScalarPropertyMapping that specifies + the property-column mapping to be added. + + + + Removes a child property-column mapping. + + A ScalarPropertyMapping that specifies + the property-column mapping to be removed. + + + + Gets an AssociationEndMember that specifies the mapped association end. + + + + + Gets a ReadOnlyCollection of ScalarPropertyMapping that specifies the children + of this association end property mapping. + + + + + Represents the Mapping metadata for the EntityContainer map in CS space. + Only one EntityContainerMapping element is allowed in the MSL file for CS mapping. + + + For Example if conceptually you could represent the CS MSL file as following + ---Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --AssociationSetMapping + The type represents the metadata for EntityContainerMapping element in the above example. + The EntitySetBaseMapping elements that are children of the EntityContainerMapping element + can be accessed through the properties on this type. + + + We currently assume that an Entity Container on the C side + is mapped to a single Entity Container in the S - space. + + + + + Initializes a new EntityContainerMapping instance. + + The conceptual entity container to be mapped. + The store entity container to be mapped. + The parent mapping item collection. + Flag indicating whether to generate update views. + + + + Adds an entity set mapping. + + The entity set mapping to add. + + + + Removes an association set mapping. + + The association set mapping to remove. + + + + Adds an association set mapping. + + The association set mapping to add. + + + + Removes an association set mapping. + + The association set mapping to remove. + + + + Adds a function import mapping. + + The function import mapping to add. + + + + Removes a function import mapping. + + The function import mapping to remove. + + + + Gets the parent mapping item collection. + + + + + Gets the type kind for this item + + + + + Gets the conceptual entity container. + + + + + Gets the store entity container. + + + + + Gets the entity set mappings. + + + + + Gets the association set mappings. + + + + + Gets the function import mappings. + + + + + Gets a flag that indicates whether to generate the update views or not. + + + + + Represents the Mapping metadata for an EnitytSet in CS space. + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityTypeMapping + --MappingFragment + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + This class represents the metadata for the EntitySetMapping elements in the + above example. And it is possible to access the EntityTypeMaps underneath it. + + + + + Initialiazes a new EntitySetMapping instance. + + The entity set to be mapped. + The parent container mapping. + + + + Adds a type mapping. + + The type mapping to add. + + + + Removes a type mapping. + + The type mapping to remove. + + + + Adds a function mapping. + + The function mapping to add. + + + + Removes a function mapping. + + The function mapping to remove. + + + + Gets the entity set that is mapped. + + + + + Gets the contained entity type mappings. + + + + + Gets the corresponding function mappings. + + + + + Mapping metadata for Entity type. + If an EntitySet represents entities of more than one type, than we will have + more than one EntityTypeMapping for an EntitySet( For ex : if + PersonSet Entity extent represents entities of types Person and Customer, + than we will have two EntityType Mappings under mapping for PersonSet). + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap + --ScalarPropertyMap + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap + --ComplexPropertyMap + --ScalarPropertyMap + --ScalarProperyMap + --ScalarPropertyMap + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + --EndPropertyMap + --ScalarPropertyMap + --ScalarProperyMap + --EndPropertyMap + --ScalarPropertyMap + This class represents the metadata for all entity Type map elements in the + above example. Users can access the table mapping fragments under the + entity type mapping through this class. + + + + + Creates an EntityTypeMapping instance. + + The EntitySetMapping that contains this EntityTypeMapping. + + + + Adds an entity type to the mapping. + + The EntityType to be added. + + + + Removes an entity type from the mapping. + + The EntityType to be removed. + + + + Adds an entity type hierarchy to the mapping. + The hierarchy is represented by the specified root entity type. + + The root EntityType of the hierarchy to be added. + + + + Removes an entity type hierarchy from the mapping. + The hierarchy is represented by the specified root entity type. + + The root EntityType of the hierarchy to be removed. + + + + Adds a mapping fragment. + + The mapping fragment to be added. + + + + Removes a mapping fragment. + + The mapping fragment to be removed. + + + + Gets the EntitySetMapping that contains this EntityTypeMapping. + + + + + Gets the single EntityType being mapped. Throws exception in case of hierarchy type mapping. + + + + + Gets a flag that indicates whether this is a type hierarchy mapping. + + + + + Gets a read-only collection of mapping fragments. + + + + + Gets the mapped entity types. + + + + + Gets the mapped base types for a hierarchy mapping. + + + + + Represents the metadata for mapping fragment. + A set of mapping fragments makes up the Set mappings( EntitySet, AssociationSet or CompositionSet ) + Each MappingFragment provides mapping for those properties of a type that map to a single table. + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ComplexPropertyMap + --ComplexTypeMapping + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --DiscriminatorProperyMap ( constant value-->SMemberMetadata ) + --ComplexTypeMapping + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --DiscriminatorProperyMap ( constant value-->SMemberMetadata ) + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + --EndPropertyMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --EndPropertyMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + This class represents the metadata for all the mapping fragment elements in the + above example. Users can access all the top level constructs of + MappingFragment element like EntityKey map, Property Maps, Discriminator + property through this mapping fragment class. + + + + + Creates a MappingFragment instance. + + The EntitySet corresponding to the table of view being mapped. + The TypeMapping that contains this MappingFragment. + Flag that indicates whether to include 'DISTINCT' when generating queries. + + + + Adds a property mapping. + + The property mapping to be added. + + + + Removes a property mapping. + + The property mapping to be removed. + + + + Adds a property mapping condition. + + The property mapping condition to be added. + + + + Removes a property mapping condition. + + The property mapping condition to be removed. + + + + Gets the EntitySet corresponding to the table or view being mapped. + + + + + Gets the TypeMapping that contains this MappingFragment. + + + + + Gets a flag that indicates whether to include 'DISTINCT' when generating queries. + + + + + Gets a read-only collection of property mappings. + + + + + Gets a read-only collection of property mapping conditions. + + + + + Represents a collection of items in Storage Mapping (CS Mapping) space. + + + + Initializes a new instance of the class using the specified , and a collection of string indicating the metadata file paths. + The that this mapping is to use. + The that this mapping is to use. + The file paths that this mapping is to use. + + + Initializes a new instance of the class using the specified , and XML readers. + The that this mapping is to use. + The that this mapping is to use. + The XML readers that this mapping is to use. + + + + Computes a hash value for the container mapping specified by the names of the mapped containers. + + The name of a container in the conceptual model. + The name of a container in the store model. + A string that specifies the computed hash value. + + + + Computes a hash value for the single container mapping in the collection. + + A string that specifies the computed hash value. + + + + Creates a dictionary of (extent, generated view) for a container mapping specified by + the names of the mapped containers. + + The name of a container in the conceptual model. + The name of a container in the store model. + A list that accumulates potential errors. + + A dictionary of (, ) that specifies the generated views. + + + + + Creates a dictionary of (extent, generated view) for the single container mapping + in the collection. + + A list that accumulates potential errors. + + A dictionary of (, ) that specifies the generated views. + + + + + Factory method that creates a . + + + The edm metadata collection to map. Must not be null. + + + The store metadata collection to map. Must not be null. + + + MSL artifacts to load. Must not be null. + + + Paths to MSL artifacts. Used in error messages. Can be null in which case + the base Uri of the XmlReader will be used as a path. + + + The collection of errors encountered while loading. + + + instance if no errors encountered. Otherwise null. + + + + + Gets or sets a for creating instances + that are used to retrieve pre-generated mapping views. + + + + Gets the version of this represents. + The version of this represents. + + + + Describes modification function binding for change processing of entities or associations. + + + + + Initializes a new ModificationFunctionMapping instance. + + The entity or association set. + The entity or association type. + The metadata of function to which we should bind. + Bindings for function parameters. + The output parameter producing number of rows affected. + Bindings for the results of function evaluation + + + + + + + Gets output parameter producing number of rows affected. May be null. + + + + + Gets Metadata of function to which we should bind. + + + + + Gets bindings for function parameters. + + + + + Gets bindings for the results of function evaluation. + + + + + Mapping metadata for scalar properties. + + + For Example if conceptually you could represent the CS MSL file as following + --Mapping + --EntityContainerMapping ( CNorthwind-->SNorthwind ) + --EntitySetMapping + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --EntityTypeMapping + --MappingFragment + --EntityKey + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ComplexPropertyMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --AssociationSetMapping + --AssociationTypeMapping + --MappingFragment + --EndPropertyMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + --ScalarProperyMap ( CMemberMetadata-->SMemberMetadata ) + --EndPropertyMap + --ScalarPropertyMap ( CMemberMetadata-->SMemberMetadata ) + This class represents the metadata for all the scalar property map elements in the + above example. + + + + + Creates a mapping between a simple property and a column. + + The property to be mapped. + The column to be mapped. + + + + Gets an EdmProperty that specifies the mapped column. + + + + + metadata exception class + + + + + Initializes a new instance of the class with a default message. + + + + + Initializes a new instance of the class with the specified message. + + The exception message. + + + + Initializes a new instance of the class with the specified message and inner exception. + + The exception message. + + The exception that is the cause of this . + + + + + DataSpace + + + + + OSpace indicates the item in the clr space + + + + + CSpace indicates the item in the CSpace - edm primitive types + + types defined in csdl + + + + + SSpace indicates the item in the SSpace + + + + + Mapping between OSpace and CSpace + + + + + Mapping between CSpace and SSpace + + + + + This class encapsulates the error information for a generic EDM error. + + + + Gets the error message. + The error message. + + + + Class for representing a collection of items in Edm space. + + + + + Initializes a new instance of the class by using the collection of the XMLReader objects where the conceptual schema definition language (CSDL) files exist. + + The collection of the XMLReader objects where the conceptual schema definition language (CSDL) files exist. + + + Initializes a new instance of the class. + The entity data model. + + + + Initializes a new instance of the class by using the paths where the conceptual schema definition language (CSDL) files exist. + + The paths where the conceptual schema definition language (CSDL) files exist. + + + + Returns a collection of the objects. + + + A ReadOnlyCollection object that represents a collection of the + + objects. + + + + + Returns a collection of the objects with the specified conceptual model version. + + + A ReadOnlyCollection object that represents a collection of the + + objects. + + The conceptual model version. + + + + Factory method that creates an . + + + CSDL artifacts to load. Must not be null. + + + Paths to CSDL artifacts. Used in error messages. Can be null in which case + the base Uri of the XmlReader will be used as a path. + + + The collection of errors encountered while loading. + + + instance if no errors encountered. Otherwise null. + + + + Gets the conceptual model version for this collection. + The conceptual model version for this collection. + + + + This class encapsulates the error information for a schema error that was encountered. + + + + + Constructs a EdmSchemaError object. + + The explanation of the error. + The code associated with this error. + The severity of the error. + + + Returns the error message. + The error message. + + + Gets the error code. + The error code. + + + Gets the severity level of the error. + + One of the values. The default is + + . + + + + Gets the line number where the error occurred. + The line number where the error occurred. + + + Gets the column where the error occurred. + The column where the error occurred. + + + Gets the location of the schema that contains the error. This string also includes the name of the schema at the end. + The location of the schema that contains the error. + + + Gets the name of the schema that contains the error. + The name of the schema that contains the error. + + + Gets a string representation of the stack trace at the time the error occurred. + A string representation of the stack trace at the time the error occurred. + + + + Defines the different severities of errors that can occur when validating an Entity Framework model. + + + + + A warning that does not prevent the model from being used. + + + + + An error that prevents the model from being used. + + + + + Represents a end of a Association Type + + + + + Initializes a new instance of the RelationshipEndMember class + + + + + Represents the edm member class + + + + Returns the name of this member. + The name of this member. + + + + Gets or sets the name of the property. Setting this from a store-space model-convention will change the name of the database + column for this property. In the conceptual model, this should align with the corresponding property from the entity class + and should not be changed. + + The name of this member. + + + Gets the type on which this member is declared. + + A object that represents the type on which this member is declared. + + + + + Gets the instance of the class that contains both the type of the member and facets for the type. + + + A object that contains both the type of the member and facets for the type. + + + + + Tells whether this member is marked as a Computed member in the EDM definition + + + + + Tells whether this member's Store generated pattern is marked as Identity in the EDM definition + + + + Access the EntityType of the EndMember in an association. + The EntityType of the EndMember in an association. + + + Gets the operational behavior of this relationship end member. + + One of the values. The default is + + . + + + + Gets the multiplicity of this relationship end member. + + One of the values. + + + + + Creates a read-only AssociationEndMember instance. + + The name of the association end member. + The reference type for the end. + The multiplicity of the end. + Flag that indicates the delete behavior of the end. + Metadata properties to be associated with the instance. + The newly created AssociationEndMember instance. + The specified name is null or empty. + The specified reference type is null. + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Class for representing an Association set + + + + + Class for representing a relationship set + + + + + Class for representing a entity set + + + + Returns the name of the current entity or relationship set. + The name of the current entity or relationship set. + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets escaped provider specific SQL describing this entity set. + + + + + Gets or sets the name of the current entity or relationship set. + If this property is changed from store-space, the mapping layer must also be updated to reflect the new name. + To change the table name of a store space use the Table property. + + The name of the current entity or relationship set. + Thrown if the setter is called when EntitySetBase instance is in ReadOnly state + + + Gets the entity container of the current entity or relationship set. + + An object that represents the entity container of the current entity or relationship set. + + Thrown if the setter is called when the EntitySetBase instance or the EntityContainer passed into the setter is in ReadOnly state + + + + Gets the entity type of this . + + + An object that represents the entity type of this + + . + + Thrown if the setter is called when EntitySetBase instance is in ReadOnly state + + + + Gets or sets the database table name for this entity set. + + if value passed into setter is null + Thrown if the setter is called when EntitySetBase instance is in ReadOnly state + + + + Gets or sets the database schema for this entity set. + + if value passed into setter is null + Thrown if the setter is called when EntitySetBase instance is in ReadOnly state + + + + Gets the relationship type of this . + + + An object that represents the relationship type of this + + . + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Creates a read-only AssociationSet instance from the specified parameters. + + The name of the association set. + The association type of the elements in the association set. + The entity set for the source association set end. + The entity set for the target association set end. + Metadata properties to be associated with the instance. + The newly created AssociationSet instance. + The specified name is null or empty. + The specified association type is null. + + The entity type of one of the ends of the specified + association type does not match the entity type of the corresponding entity set end. + + + + + Gets the association related to this . + + + An object that represents the association related to this + + . + + + + + Gets the ends of this . + + + A collection of type that contains the ends of this + + . + + + + + Gets the built-in type kind for this . + + + A object that represents built-in type kind for this + + . + + + + + Class representing a AssociationSet End + + + + + Returns the name of the End role for this . + + + The name of the End role for this . + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the parent association set of this . + + + An object that represents the parent association set of this + + . + + Thrown if Setter is called when the AssociationSetEnd instance is in ReadOnly state + + + + Gets the End member that this object corresponds to. + + + An object that represents the End member that this + + object corresponds to. + + Thrown if Setter is called when the AssociationSetEnd instance is in ReadOnly state + + + + Gets the name of the End for this . + + + The name of the End for this . + + + + + Gets the name of the End role for this . + + + The name of the End role for this . + + Thrown if Setter is called when the AssociationSetEnd instance is in ReadOnly state + + + Gets the entity set referenced by this End role. + + An object that represents the entity set referred by this End role. + + + + + Describes an association/relationship between two entities in the conceptual model or a foreign key relationship + between two tables in the store model. In the conceptual model the dependant class may or may not define a foreign key property. + If a foreign key is defined the property will be true and the property will contain details of the foreign keys + + + + + Represents the Relationship type + + + + + Represents the Entity Type + + + + + Represents the Structural Type + + + + + Base EdmType class for all the model types + + + + Returns the full name of this type. + The full name of this type. + + + + Returns an instance of the whose element type is this type. + + + The object whose element type is this type. + + + + Gets the name of this type. + The name of this type. + + + Gets the namespace of this type. + The namespace of this type. + + + Gets a value indicating whether this type is abstract or not. + true if this type is abstract; otherwise, false. + Thrown if the setter is called on instance that is in ReadOnly state + + + Gets the base type of this type. + The base type of this type. + Thrown if the setter is called on instance that is in ReadOnly state + Thrown if the value passed in for setter will create a loop in the inheritance chain + + + Gets the full name of this type. + The full name of this type. + + + + Adds a member to this type + + The member to add + + + Removes a member from this type. + The member to remove. + + + Gets the list of members on this type. + + A collection of type that contains a set of members on this type. + + + + + Adds the specified property to the list of keys for the current entity. + + The property to add. + if member argument is null + Thrown if the EntityType has a base type of another EntityTypeBase. In this case KeyMembers should be added to the base type + If the EntityType instance is in ReadOnly state + + + Removes the specified key member from the collection. + The key member to remove. + + + Gets the list of all the key members for the current entity or relationship type. + + A object that represents the list of key members for the current entity or relationship type. + + + + Gets the list of all the key properties for this entity type. + The list of all the key properties for this entity type. + + + Gets the list of ends for this relationship type. + + A collection of type that contains the list of Ends for this relationship type. + + + + + Creates a read-only AssociationType instance from the specified parameters. + + The name of the association type. + The namespace of the association type. + Flag that indicates a foreign key (FK) relationship. + The data space for the association type. + The source association end member. + The target association end member. + A referential constraint. + Metadata properties to be associated with the instance. + The newly created AssociationType instance. + The specified name is null or empty. + The specified namespace is null or empty. + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the list of ends for this . + + + A collection of type that contains the list of ends for this + + . + + + + Gets or sets the referential constraint. + The referential constraint. + + + + Gets the list of constraints for this . + + + A collection of type that contains the list of constraints for this + + . + + + + Gets the Boolean property value that specifies whether the column is a foreign key. + A Boolean value that specifies whether the column is a foreign key. If true, the column is a foreign key. If false (default), the column is not a foreign key. + + + + Represents the structure of an . In the conceptual-model this represents the shape and structure + of an entity. In the store model this represents the structure of a table. To change the Schema and Table name use EntitySet. + + + + + Returns a object that references this + + . + + + A object that references this + + . + + + + + The factory method for constructing the EntityType object. + + The name of the entity type. + The namespace of the entity type. + The dataspace in which the EntityType belongs to. + Name of key members for the type. + Members of the entity type (primitive and navigation properties). + Metadata properties to be associated with the instance. + The EntityType object. + Thrown if either name, namespace arguments are null. + The newly created EntityType will be read only. + + + + The factory method for constructing the EntityType object. + + The name of the entity type. + The namespace of the entity type. + The dataspace in which the EntityType belongs to. + The base type. + Name of key members for the type. + Members of the entity type (primitive and navigation properties). + Metadata properties to be associated with the instance. + The EntityType object. + Thrown if either name, namespace arguments are null. + The newly created EntityType will be read only. + + + + Adds the specified navigation property to the members of this type. + The navigation property is added regardless of the read-only flag. + + The navigation property to be added. + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + Gets the declared navigation properties associated with the entity type. + The declared navigation properties associated with the entity type. + + + + Gets the navigation properties of this . + + + A collection of type that contains the list of navigation properties on this + + . + + + + Gets the list of declared properties for the entity type. + The declared properties for the entity type. + + + Gets the collection of declared members for the entity type. + The collection of declared members for the entity type. + + + + Gets the list of properties for this . + + + A collection of type that contains the list of properties for this + + . + + + + + Represents an enumeration type. + + + + + Class representing a simple type + + + + + Creates a read-only EnumType instance. + + The name of the enumeration type. + The namespace of the enumeration type. + The underlying type of the enumeration type. + Indicates whether the enumeration type can be treated as a bit field; that is, a set of flags. + The members of the enumeration type. + Metadata properties to be associated with the enumeration type. + The newly created EnumType instance. + underlyingType is null. + + name is null or empty. + -or- + namespaceName is null or empty. + -or- + underlyingType is not a supported underlying type. + -or- + The specified members do not have unique names. + -or- + The value of a specified member is not in the range of the underlying type. + + + + Returns the kind of the type + + + Gets a collection of enumeration members for this enumeration type. + + + Gets a value indicating whether the enum type is defined as flags (i.e. can be treated as a bit field) + + + Gets the underlying type for this enumeration type. + + + + Specifies the kinds of item attributes in the conceptual model. + + + + + An enumeration member indicating that an item attribute is System + + + + + An enumeration member indicating that an item attribute is Extended. + + + + + List of all the built in types + + + + + Association Type Kind + + + + + AssociationSetEnd Kind + + + + + AssociationSet Kind + + + + + Association Type Kind + + + + + EntitySetBase Kind + + + + + Entity Type Base Kind + + + + + Collection Type Kind + + + + + Collection Kind + + + + + Complex Type Kind + + + + + Documentation Kind + + + + + DeleteAction Type Kind + + + + + Edm Type Kind + + + + + Entity Container Kind + + + + + Entity Set Kind + + + + + Entity Type Kind + + + + + Enumeration Type Kind + + + + + Enum Member Kind + + + + + Facet Kind + + + + + EdmFunction Kind + + + + + Function Parameter Kind + + + + + Global Item Type Kind + + + + + Metadata Property Kind + + + + + Navigation Property Kind + + + + + Metadata Item Type Kind + + + + + EdmMember Type Kind + + + + + Parameter Mode Kind + + + + + Primitive Type Kind + + + + + Primitive Type Kind Kind + + + + + EdmProperty Type Kind + + + + + ProviderManifest Type Kind + + + + + Referential Constraint Type Kind + + + + + Ref Type Kind + + + + + RelationshipEnd Type Kind + + + + + Relationship Multiplicity Type Kind + + + + + Relationship Set Type Kind + + + + + Relationship Type + + + + + Row Type Kind + + + + + Simple Type Kind + + + + + Structural Type Kind + + + + + Type Information Kind + + + + + Represents the Edm Collection Type + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the instance of the class that contains the type of the element that this current + + object includes and facets for that type. + + + The instance of the class that contains the type of the element that this current + + object includes and facets for that type. + + + + + Represents the Edm Complex Type. This can be used to configure complex types + from a conceptual-space model-based convention. Complex types are not supported in the store model. + + + + + Creates a new instance of the type. + + The name of the complex type. + The namespace of the complex type. + The dataspace to which the complex type belongs to. + Members of the complex type. + Metadata properties to be associated with the instance. + Thrown if either name, namespace or members argument is null. + + A new instance a the type. + + + The newly created will be read only. + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the list of properties for this . + + + A collection of type that contains the list of properties for this + + . + + + + + Class representing the Documentation associated with an item + + + + + Initializes a new Documentation instance. + + A summary string. + A long description string. + + + + Returns the summary for this . + + + The summary for this . + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the summary for this . + + + The summary for this . + + + + + Gets the long description for this . + + + The long description for this . + + + + + Gets a value indicating whether this object contains only a null or an empty + + and a + + . + + + true if this object contains only a null or an empty + + and a + + ; otherwise, false. + + + + + Class for representing a function + + + + + Adds a parameter to this function. + + The parameter to be added. + + + + The factory method for constructing the object. + + The name of the function. + The namespace of the function. + The namespace the function belongs to. + Additional function attributes and properties. + Metadata properties that will be added to the function. Can be null. + + A new, read-only instance of the type. + + + + + Gets the built-in type kind for this . + + + One of the enumeration values of the enumeration. + + + + Returns the full name (namespace plus name) of this type. + The full name of the type. + + + + Gets the parameters of this . + + + A collection of type that contains the parameters of this + + . + + + + + Gets the return parameter of this . + + + A object that represents the return parameter of this + + . + + + + + Gets the return parameters of this . + + + A collection of type that represents the return parameters of this + + . + + + + Gets the store function name attribute of this function. + + + Gets the parameter type semantics attribute of this function. + + + Gets the aggregate attribute of this function. + + + + Gets a value indicating whether built in attribute is present on this function. + + + true if the attribute is present; otherwise, false. + + + + + Gets a value indicating whether this instance is from the provider manifest. + + + true if this instance is from the provider manifest; otherwise, false. + + + + + Gets a value indicating whether the is a niladic function (a function that accepts no arguments). + + + true if the function is niladic; otherwise, false. + + + + Gets whether this instance is mapped to a function or to a stored procedure. + true if this instance is mapped to a function; false if this instance is mapped to a stored procedure. + + + Gets a query in the language that is used by the database management system or storage model. + + A string value in the syntax used by the database management system or storage model that contains the query or update statement of the + + . + + + + Gets or sets the schema associated with the function. + The schema associated with the function. + + + + In conceptual-space, EdmProperty represents a property on an Entity. + In store-space, EdmProperty represents a column in a table. + + + + Creates a new primitive property. + The newly created property. + The name of the property. + The type of the property. + + + Creates a new enum property. + The newly created property. + The name of the property. + The type of the property. + + + Creates a new complex property. + The newly created property. + The name of the property. + The type of the property. + + + + Creates a new instance of EdmProperty type. + + Name of the property. + + Property + + A new instance of EdmProperty type + + + Sets the metadata properties. + The metadata properties to be set. + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets a value indicating whether this can have a null value. + + + Nullability in the conceptual model and store model is a simple indication of whether or not + the property is considered nullable. Nullability in the object model is more complex. + When using convention based mapping (as usually happens with POCO entities), a property in the + object model is considered nullable if and only if the underlying CLR type is nullable and + the property is not part of the primary key. + When using attribute based mapping (usually used with entities that derive from the EntityObject + base class), a property is considered nullable if the IsNullable flag is set to true in the + attribute. This flag can + be set to true even if the underlying type is not nullable, and can be set to false even if the + underlying type is nullable. The latter case happens as part of default code generation when + a non-nullable property in the conceptual model is mapped to a nullable CLR type such as a string. + In such a case, the Entity Framework treats the property as non-nullable even though the CLR would + allow null to be set. + There is no good reason to set a non-nullable CLR type as nullable in the object model and this + should not be done even though the attribute allows it. + + + true if this can have a null value; otherwise, false. + + Thrown if the setter is called when the EdmProperty instance is in ReadOnly state + + + Gets the type name of the property. + The type name of the property. + + + + Gets the default value for this . + + + The default value for this . + + Thrown if the setter is called when the EdmProperty instance is in ReadOnly state + + + Gets whether the property is a collection type property. + true if the property is a collection type property; otherwise, false. + + + Gets whether this property is a complex type property. + true if this property is a complex type property; otherwise, false. + + + Gets whether this property is a primitive type. + true if this property is a primitive type; otherwise, false. + + + Gets whether this property is an enumeration type property. + true if this property is an enumeration type property; otherwise, false. + + + Gets whether this property is an underlying primitive type. + true if this property is an underlying primitive type; otherwise, false. + + + Gets the complex type information for this property. + The complex type information for this property. + + + Gets the primitive type information for this property. + The primitive type information for this property. + + + Gets the enumeration type information for this property. + The enumeration type information for this property. + + + Gets the underlying primitive type information for this property. + The underlying primitive type information for this property. + + + Gets or sets the concurrency mode for the property. + The concurrency mode for the property. + + + Gets or sets the database generation method for the database column associated with this property + The store generated pattern for the property. + + + Gets or sets the kind of collection for this model. + The kind of collection for this model. + + + Gets whether the maximum length facet is constant for the database provider. + true if the facet is constant; otherwise, false. + + + Gets or sets the maximum length of the property. + The maximum length of the property. + + + Gets or sets whether this property uses the maximum length supported by the provider. + true if this property uses the maximum length supported by the provider; otherwise, false. + + + Gets whether the fixed length facet is constant for the database provider. + true if the facet is constant; otherwise, false. + + + Gets or sets whether the length of this property is fixed. + true if the length of this property is fixed; otherwise, false. + + + Gets whether the Unicode facet is constant for the database provider. + true if the facet is constant; otherwise, false. + + + Gets or sets whether this property is a Unicode property. + true if this property is a Unicode property; otherwise, false. + + + Gets whether the precision facet is constant for the database provider. + true if the facet is constant; otherwise, false. + + + Gets or sets the precision of this property. + The precision of this property. + + + Gets whether the scale facet is constant for the database provider. + true if the facet is constant; otherwise, false. + + + Gets or sets the scale of this property. + The scale of this property. + + + + Class for representing an entity container + + + + + Creates an entity container with the specified name and data space. + + The entity container name. + The entity container data space. + Thrown if the name argument is null. + Thrown if the name argument is empty string. + + + + Returns an object by using the specified name for the entity set. + + + An object that represents the entity set that has the specified name. + + The name of the entity set that is searched for. + true to perform the case-insensitive search; otherwise, false. + + + + Returns an object by using the specified name for the entity set. + + true if there is an entity set that matches the search criteria; otherwise, false. + The name of the entity set that is searched for. + true to perform the case-insensitive search; otherwise, false. + + When this method returns, contains an object. If there is no entity set, this output parameter contains null. + + + + + Returns a object by using the specified name for the relationship set. + + + An object that represents the relationship set that has the specified name. + + The name of the relationship set that is searched for. + true to perform the case-insensitive search; otherwise, false. + + + + Returns a object by using the specified name for the relationship set. + + true if there is a relationship set that matches the search criteria; otherwise, false. + The name of the relationship set that is searched for. + true to perform the case-insensitive search; otherwise, false. + + When this method returns, contains a object. + + + + + Returns the name of this . + + + The name of this . + + + + + Adds the specified entity set to the container. + + The entity set to add. + + + Removes a specific entity set from the container. + The entity set to remove. + + + + Adds a function import to the container. + + The function import to add. + + + + The factory method for constructing the EntityContainer object. + + The name of the entity container to be created. + DataSpace in which this entity container belongs to. + Entity sets that will be included in the new container. Can be null. + Functions that will be included in the new container. Can be null. + Metadata properties to be associated with the instance. + The EntityContainer object. + Thrown if the name argument is null or empty string. + The newly created EntityContainer will be read only. + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the name of this . + + + The name of this . + + + + + Gets a list of entity sets and association sets that this + + includes. + + + A object that contains a list of entity sets and association sets that this + + includes. + + + + Gets the association sets for this entity container. + The association sets for this entity container . + + + Gets the entity sets for this entity container. + The entity sets for this entity container . + + + + Specifies a collection of elements. Each function contains the details of a stored procedure that exists in the database or equivalent CommandText that is mapped to an entity and its properties. + + + A that contains + + elements. + + + + + Represents a particular usage of a structure defined in EntityType. In the conceptual-model, this represents a set that can + query and persist entities. In the store-model it represents a table. + From a store-space model-convention it can be used to configure + table name with property and table schema with property. + + + + + The factory method for constructing the EntitySet object. + + The name of the EntitySet. + The db schema. Can be null. + The db table. Can be null. + + The provider specific query that should be used to retrieve data for this EntitySet. Can be null. + + The entity type of the entities that this entity set type contains. + + Metadata properties that will be added to the newly created EntitySet. Can be null. + + The EntitySet object. + Thrown if the name argument is null or empty string. + The newly created EntitySet will be read only. + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the entity type of this . + + + An object that represents the entity type of this + + . + + + + + Represents an enumeration member. + + + + Overriding System.Object.ToString to provide better String representation for this type. + The name of this enumeration member. + + + + Creates a read-only EnumMember instance. + + The name of the enumeration member. + The value of the enumeration member. + Metadata properties to be associated with the enumeration member. + The newly created EnumMember instance. + name is null or empty. + + + + Creates a read-only EnumMember instance. + + The name of the enumeration member. + The value of the enumeration member. + Metadata properties to be associated with the enumeration member. + The newly created EnumMember instance. + name is null or empty. + + + + Creates a read-only EnumMember instance. + + The name of the enumeration member. + The value of the enumeration member. + Metadata properties to be associated with the enumeration member. + The newly created EnumMember instance. + name is null or empty. + + + + Creates a read-only EnumMember instance. + + The name of the enumeration member. + The value of the enumeration member. + Metadata properties to be associated with the enumeration member. + The newly created EnumMember instance. + name is null or empty. + + + + Creates a read-only EnumMember instance. + + The name of the enumeration member. + The value of the enumeration member. + Metadata properties to be associated with the enumeration member. + The newly created EnumMember instance. + name is null or empty. + + + Gets the kind of this type. + + + Gets the name of this enumeration member. + + + Gets the value of this enumeration member. + + + + Class for representing a Facet object + This object is Immutable (not just set to readonly) and + some parts of the system are depending on that behavior + + + + + Returns the name of this . + + + The name of this . + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the description of this . + + + The object that represents the description of this + + . + + + + + Gets the name of this . + + + The name of this . + + + + + Gets the type of this . + + + The object that represents the type of this + + . + + + + + Gets the value of this . + + + The value of this . + + Thrown if the Facet instance is in ReadOnly state + + + Gets a value indicating whether the value of the facet is unbounded. + true if the value of the facet is unbounded; otherwise, false. + + + + Class for representing a FacetDescription object + + + + Returns the name of this facet. + The name of this facet. + + + Gets the name of this facet. + The name of this facet. + + + Gets the type of this facet. + + An object that represents the type of this facet. + + + + Gets the minimum value for this facet. + The minimum value for this facet. + + + Gets the maximum value for this facet. + The maximum value for this facet. + + + Gets the default value of a facet with this facet description. + The default value of a facet with this facet description. + + + Gets a value indicating whether the value of this facet is a constant. + true if this facet is a constant; otherwise, false. + + + Gets a value indicating whether this facet is a required facet. + true if this facet is a required facet; otherwise, false. + + + + Class representing a function parameter + + + + + Returns the name of this . + + + The name of this . + + + + + The factory method for constructing the object. + + The name of the parameter. + The EdmType of the parameter. + + The of the parameter. + + + A new, read-only instance of the type. + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the mode of this . + + + One of the values. + + Thrown if the FunctionParameter instance is in ReadOnly state + + + + Gets the name of this . + + + The name of this . + + + + + Gets the instance of the class that contains both the type of the parameter and facets for the type. + + + A object that contains both the type of the parameter and facets for the type. + + + + Gets the type name of this parameter. + The type name of this parameter. + + + Gets whether the max length facet is constant for the database provider. + true if the facet is constant; otherwise, false. + + + Gets the maximum length of the parameter. + The maximum length of the parameter. + + + Gets whether the parameter uses the maximum length supported by the database provider. + true if parameter uses the maximum length supported by the database provider; otherwise, false. + + + Gets whether the precision facet is constant for the database provider. + true if the facet is constant; otherwise, false. + + + Gets the precision value of the parameter. + The precision value of the parameter. + + + Gets whether the scale facet is constant for the database provider. + true if the facet is constant; otherwise, false. + + + Gets the scale value of the parameter. + The scale value of the parameter. + + + + Gets the on which this parameter is declared. + + + A object that represents the function on which this parameter is declared. + + + + + Class representing a metadata attribute for an item + + + + + The factory method for constructing the MetadataProperty object. + + The name of the metadata property. + The type usage of the metadata property. + The value of the metadata property. + The MetadataProperty object. + + Thrown is null. + + The newly created MetadataProperty will be read only. + + + + Creates a metadata annotation having the specified name and value. + + The annotation name. + The annotation value. + A MetadataProperty instance representing the created annotation. + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the name of this . + + + The name of this . + + + + + Gets the value of this . + + + The value of this . + + Thrown if the MetadataProperty instance is in readonly state + + + + Gets the instance of the class that contains both the type of this + + and facets for the type. + + + A object that contains both the type of this + + and facets for the type. + + Thrown if the MetadataProperty instance is in readonly state + + + + Gets the value of this . + + + The value of this . + + + + + Gets a boolean that indicates whether the metadata property is an annotation. + + + + + Represent the edm navigation property class + + + + + Where the given navigation property is on the dependent end of a referential constraint, + returns the foreign key properties. Otherwise, returns an empty set. We will return the members in the order + of the principal end key properties. + + A collection of the foreign key properties. + + + + Creates a NavigationProperty instance from the specified parameters. + + The name of the navigation property. + Specifies the navigation property type and its facets. + The relationship type for the navigation. + The source end member in the navigation. + The target end member in the navigation. + The metadata properties of the navigation property. + The newly created NavigationProperty instance. + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + Gets the relationship type that this navigation property operates on. + The relationship type that this navigation property operates on. + Thrown if the NavigationProperty instance is in ReadOnly state + + + Gets the "to" relationship end member of this navigation. + The "to" relationship end member of this navigation. + Thrown if the NavigationProperty instance is in ReadOnly state + + + Gets the "from" relationship end member in this navigation. + The "from" relationship end member in this navigation. + Thrown if the NavigationProperty instance is in ReadOnly state + + + + Represents the list of possible actions for delete operation + + + + + no action + + + + + Cascade to other ends + + + + + The enumeration defining the mode of a parameter + + + + + In parameter + + + + + Out parameter + + + + + Both in and out parameter + + + + + Return Parameter + + + + + Class representing a primitive type + + + + + Returns the equivalent of this + + . + + + For example if this instance is nvarchar and it's + base type is Edm String then the return type is Edm String. + If the type is actually already a model type then the + return type is "this". + + + An object that is an equivalent of this + + . + + + + Returns the list of primitive types. + + A collection of type that contains the list of primitive types. + + + + + Returns the equivalent of a + + . + + + An object that is an equivalent of a specified + + . + + + A value of type . + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets a enumeration value that indicates a primitive type of this + + . + + + A enumeration value that indicates a primitive type of this + + . + + + + + Gets the list of facet descriptions for this . + + + A collection of type that contains the list of facet descriptions for this + + . + + + + + Returns an equivalent common language runtime (CLR) type of this + + . Note that the + + property always returns a non-nullable type value. + + + A object that represents an equivalent common language runtime (CLR) type of this + + . + + + + + Primitive Types as defined by EDM + + + + + Binary Type Kind + + + + + Boolean Type Kind + + + + + Byte Type Kind + + + + + DateTime Type Kind + + + + + Decimal Type Kind + + + + + Double Type Kind + + + + + Guid Type Kind + + + + + Single Type Kind + + + + + SByte Type Kind + + + + + Int16 Type Kind + + + + + Int32 Type Kind + + + + + Int64 Type Kind + + + + + String Type Kind + + + + + Time Type Kind + + + + + DateTimeOffset Type Kind + + + + + Geometry Type Kind + + + + + Geography Type Kind + + + + + Geometric point type kind + + + + + Geometric linestring type kind + + + + + Geometric polygon type kind + + + + + Geometric multi-point type kind + + + + + Geometric multi-linestring type kind + + + + + Geometric multi-polygon type kind + + + + + Geometric collection type kind + + + + + Geographic point type kind + + + + + Geographic linestring type kind + + + + + Geographic polygon type kind + + + + + Geographic multi-point type kind + + + + + Geographic multi-linestring type kind + + + + + Geographic multi-polygon type kind + + + + + Geographic collection type kind + + + + + This class represents a referential constraint between two entities specifying the "to" and "from" ends of the relationship. + + + + + Constructs a new constraint on the relationship + + role from which the relationship originates + role to which the relationship is linked/targeted to + properties on entity type of to role which take part in the constraint + properties on entity type of from role which take part in the constraint + Argument Null exception if any of the arguments is null + + + + Returns the combination of the names of the + + and the + + . + + + The combination of the names of the + + and the + + . + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the "from role" that takes part in this + + . + + + A object that represents the "from role" that takes part in this + + . + + Thrown if value passed into setter is null + Thrown if the ReferentialConstraint instance is in ReadOnly state + + + + Gets the "to role" that takes part in this . + + + A object that represents the "to role" that takes part in this + + . + + Thrown if value passed into setter is null + Thrown if the ReferentialConstraint instance is in ReadOnly state + + + + Gets the list of properties for the "from role" on which this + + is defined. + + + A collection of type that contains the list of properties for "from role" on which this + + is defined. + + + + + Gets the list of properties for the "to role" on which this + + is defined. + + + A collection of type that contains the list of properties for the "to role" on which this + + is defined. + + + + + Class representing a ref type + + + + + + + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the entity type referenced by this . + + + An object that represents the entity type referenced by this + + . + + + + + Represents the multiplicity information about the end of a relationship type + + + + + Lower Bound is Zero and Upper Bound is One + + + + + Both lower bound and upper bound is one + + + + + Lower bound is zero and upper bound is null + + + + + Represents the Edm Row Type + + + + + The factory method for constructing the object. + + Properties of the row type object. + Metadata properties that will be added to the function. Can be null. + + A new, read-only instance of the object. + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the list of properties on this . + + + A collection of type that contains the list of properties on this + + . + + + + Gets a collection of the properties defined by the current type. + A collection of the properties defined by the current type. + + + + Class representing a type information for an item + + + + + Factory method for creating a TypeUsage with specified EdmType and facets + + EdmType for which to create a type usage + facets to be copied into the new TypeUsage + new TypeUsage instance + + + + Creates a object with the specified conceptual model type. + + + A object with the default facet values for the specified + + . + + + A for which the + + object is created. + + + + + Creates a object to describe a string type by using the specified facet values. + + + A object describing a string type by using the specified facet values. + + + A for which the + + object is created. + + true to set the character-encoding standard of the string type to Unicode; otherwise, false. + true to set the character-encoding standard of the string type to Unicode; otherwise, false. + true to set the length of the string type to fixed; otherwise, false. + + + + Creates a object to describe a string type by using the specified facet values and unbounded MaxLength. + + + A object describing a string type by using the specified facet values and unbounded MaxLength. + + + A for which the + + object is created. + + true to set the character-encoding standard of the string type to Unicode; otherwise, false. + true to set the length of the string type to fixed; otherwise, false + + + + Creates a object to describe a binary type by using the specified facet values. + + + A object describing a binary type by using the specified facet values. + + + A for which the + + object is created. + + true to set the length of the binary type to fixed; otherwise, false. + The maximum length of the binary type. + + + + Creates a object to describe a binary type by using the specified facet values. + + + A object describing a binary type by using the specified facet values. + + + A for which the + + object is created. + + true to set the length of the binary type to fixed; otherwise, false. + + + + Creates a object of the type that the parameters describe. + + + A object. + + + The simple type that defines the units of measurement of the DateTime object. + + + The degree of granularity of the DateTimeOffset in fractions of a second, based on the number of decimal places supported. For example a precision of 3 means the granularity supported is milliseconds. + + + + + Creates a object of the type that the parameters describe. + + + A object. + + The simple type that defines the units of measurement of the offset. + + The degree of granularity of the DateTimeOffset in fractions of a second, based on the number of decimal places supported. For example a precision of 3 means the granularity supported is milliseconds. + + + + + Creates a object of the type that the parameters describe. + + + A object. + + + The simple type that defines the units of measurement of the DateTime object. + + + The degree of granularity of the DateTimeOffset in fractions of a second, based on the number of decimal places supported. For example a precision of 3 means the granularity supported is milliseconds. + + + + + Creates a object to describe a decimal type by using the specified facet values. + + + A object describing a decimal type by using the specified facet values. + + + A for which the + + object is created. + + + The precision of the decimal type as type . + + + The scale of the decimal type as type . + + + + + Creates a object to describe a decimal type with unbounded precision and scale facet values. + + + A object describing a decimal type with unbounded precision and scale facet values. + + + A for which the + + object is created. + + + + + Checks whether this is a subtype of the specified + + . + + + true if this is a subtype of the specified + + ; otherwise, false. + + + The object to be checked. + + + + + Returns the full name of the type described by this . + + + The full name of the type described by this as string. + + + + + Gets the built-in type kind for this . + + + A object that represents the built-in type kind for this + + . + + + + + Gets the type information described by this . + + + An object that represents the type information described by this + + . + + + + + Gets the list of facets for the type that is described by this + + . + + + A collection of type that contains the list of facets for the type that is described by this + + . + + + + + Returns a Model type usage for a provider type + + Model (CSpace) type usage + + + + Do not perform any extension check + + + + + Check the extension against a specific value + + + + + Check the extension against the set of acceptable extensions + + + + + Runtime Metadata Workspace + + + + + Initializes a new instance of the class. + + + + + Constructs a with loaders for all item collections () + needed by EF except the o/c mapping which will be created automatically based on the given o-space and c-space + loaders. The item collection delegates are executed lazily when a given collection is used for the first + time. It is acceptable to pass a delegate that returns null if the collection will never be used, but this + is rarely done, and any attempt by EF to use the collection in such cases will result in an exception. + + Delegate to return the c-space (CSDL) item collection. + Delegate to return the s-space (SSDL) item collection. + Delegate to return the c/s mapping (MSL) item collection. + Delegate to return the o-space item collection. + + + + Constructs a with loaders for all item collections () + that come from traditional EDMX mapping. Default o-space and o/c mapping collections will be used. + The item collection delegates are executed lazily when a given collection is used for the first + time. It is acceptable to pass a delegate that returns null if the collection will never be used, but this + is rarely done, and any attempt by EF to use the collection in such cases will result in an exception. + + Delegate to return the c-space (CSDL) item collection. + Delegate to return the s-space (SSDL) item collection. + Delegate to return the c/s mapping (MSL) item collection. + + + + Initializes a new instance of the class using the specified paths and assemblies. + + The paths to workspace metadata. + The names of assemblies used to construct workspace. + + + + Creates an configured to use the + + data space. + + The created parser object. + + + + Creates a new bound to this metadata workspace based on the specified query expression. + + + A new with the specified expression as it's + + property. + + + A that defines the query. + + + If + + is null + + + If + + contains metadata that cannot be resolved in this metadata workspace + + + If + + is not structurally valid because it contains unresolvable variable references + + + + + Gets items. + + + The items. + + + The from which to retrieve items. + + + + Registers the item collection with each associated data model. + The output parameter collection that needs to be filled up. + + + Loads metadata from the given assembly. + The assembly from which the metadata will be loaded. + + + Loads metadata from the given assembly. + The assembly from which the metadata will be loaded. + The delegate for logging the load messages. + + + Returns an item by using the specified identity and the data model. + The item that matches the given identity in the specified data model. + The identity of the item. + The conceptual model in which the item is searched. + The type returned by the method. + Thrown if the space is not a valid space. Valid space is either C, O, CS or OCSpace + + + Returns an item by using the specified identity and the data model. + true if there is an item that matches the search criteria; otherwise, false. + The conceptual model on which the item is searched. + The conceptual model on which the item is searched. + + When this method returns, contains a object. This parameter is passed uninitialized. + + The type returned by the method. + + + Returns an item by using the specified identity and the data model. + The item that matches the given identity in the specified data model. + The identity of the item. + true to perform the case-insensitive search; otherwise, false. + The conceptual model on which the item is searched. + The type returned by the method. + Thrown if the space is not a valid space. Valid space is either C, O, CS or OCSpace + + + Returns an item by using the specified identity and the data model. + true if there is an item that matches the search criteria; otherwise, false. + The conceptual model on which the item is searched. + true to perform the case-insensitive search; otherwise, false. + The conceptual model on which the item is searched. + + When this method returns, contains a object. This parameter is passed uninitialized. + + The type returned by the method. + + + Gets all the items in the specified data model. + + A collection of type that contains all the items in the specified data model. + + The conceptual model for which the list of items is needed. + The type returned by the method. + Thrown if the space is not a valid space. Valid space is either C, O, CS or OCSpace + + + + Returns an object by using the specified type name, namespace name, and data model. + + + An object that represents the type that matches the given type name and the namespace name in the specified data model. If there is no matched type, this method returns null. + + The name of the type. + The namespace of the type. + The conceptual model on which the type is searched. + Thrown if the space is not a valid space. Valid space is either C, O, CS or OCSpace + + + + Returns an object by using the specified type name, namespace name, and data model. + + true if there is a type that matches the search criteria; otherwise, false. + The name of the type. + The namespace of the type. + The conceptual model on which the type is searched. + + When this method returns, contains an object. This parameter is passed uninitialized. + + + + + Returns an object by using the specified type name, namespace name, and data model. + + + An object. + + The name of the type. + The namespace of the type. + true to perform the case-insensitive search; otherwise, false. + The conceptual model on which the type is searched. + Thrown if the space is not a valid space. Valid space is either C, O, CS or OCSpace + + + + Returns an object by using the specified type name, namespace name, and data model. + + true if there is a type that matches the search criteria; otherwise, false. + The name of the type. + The namespace of the type. + true to perform the case-insensitive search; otherwise, false. + The conceptual model on which the type is searched. + + When this method returns, contains an object. This parameter is passed uninitialized. + + + + + Returns an object by using the specified entity container name and the data model. + + If there is no entity container, this method returns null; otherwise, it returns the first entity container. + The name of the entity container. + The conceptual model on which the entity container is searched. + Thrown if the space is not a valid space. Valid space is either C, O, CS or OCSpace + + + + Returns an object by using the specified entity container name and the data model. + + true if there is an entity container that matches the search criteria; otherwise, false. + The name of the entity container. + The conceptual model on which the entity container is searched. + + When this method returns, contains an object. If there is no entity container, this output parameter contains null; otherwise, it returns the first entity container. This parameter is passed uninitialized. + + + + + Returns an object by using the specified entity container name and the data model. + + If there is no entity container, this method returns null; otherwise, it returns the first entity container. + The name of the entity container. + true to perform the case-insensitive search; otherwise, false. + The conceptual model on which the entity container is searched. + Thrown if the space is not a valid space. Valid space is either C, O, CS or OCSpace + + + + Returns an object by using the specified entity container name and the data model. + + true if there is an entity container that matches the search criteria; otherwise, false. + The name of the entity container. + true to perform the case-insensitive search; otherwise, false. + The conceptual model on which the entity container is searched. + + When this method returns, contains an object. If there is no entity container, this output parameter contains null; otherwise, it returns the first entity container. This parameter is passed uninitialized. + + + + Returns all the overloads of the functions by using the specified name, namespace name, and data model. + + A collection of type that contains all the functions that match the specified name in a given namespace and a data model. + + The name of the function. + The namespace of the function. + The conceptual model in which the functions are searched. + Thrown if the space is not a valid space. Valid space is either C, O, CS or OCSpace + + + Returns all the overloads of the functions by using the specified name, namespace name, and data model. + + A collection of type that contains all the functions that match the specified name in a given namespace and a data model. + + The name of the function. + The namespace of the function. + The conceptual model in which the functions are searched. + true to perform the case-insensitive search; otherwise, false. + Thrown if the space is not a valid space. Valid space is either C, O, CS or OCSpace + + + Returns the list of primitive types in the specified data model. + + A collection of type that contains all the primitive types in the specified data model. + + The data model for which you need the list of primitive types. + Thrown if the space is not a valid space. Valid space is either C, O, CS or OCSpace + + + Gets all the items in the specified data model. + + A collection of type that contains all the items in the specified data model. + + The conceptual model for which the list of items is needed. + Thrown if the space is not a valid space. Valid space is either C, O, CS or OCSpace + + + + Tests the retrieval of . + + true if the retrieval was successful; otherwise, false. + + The from which to attempt retrieval of + + . + + When this method returns, contains the item collection. This parameter is passed uninitialized. + + + + Returns a object that represents the object space type that matches the type supplied by the parameter edmSpaceType . + + + A object that represents the Object space type. If there is no matched type, this method returns null. + + + A object that represents the + + . + + + + + Returns a object via the out parameter objectSpaceType that represents the type that matches the + + supplied by the parameter edmSpaceType . + + true if there is a type that matches the search criteria; otherwise, false. + + A object that represents the + + . + + + When this method returns, contains a object that represents the Object space type. This parameter is passed uninitialized. + + + + + Returns a object that represents the object space type that matches the type supplied by the parameter edmSpaceType . + + + A object that represents the Object space type. If there is no matched type, this method returns null. + + + A object that represents the + + . + + + + + Returns a object via the out parameter objectSpaceType that represents the type that matches the + + supplied by the parameter edmSpaceType . + + true if there is a type that matches the search criteria; otherwise, false. + + A object that represents the + + . + + + When this method returns, contains a object that represents the Object space type. This parameter is passed uninitialized. + + + + + Returns a object that represents the + + that matches the type supplied by the parameter objectSpaceType . + + + A object that represents the + + . If there is no matched type, this method returns null. + + + A that supplies the type in the object space. + + + + + Returns a object via the out parameter edmSpaceType that represents the + + that matches the type supplied by the parameter objectSpaceType . + + true if there is a type that matches the search criteria; otherwise, false. + + A object that represents the object space type. + + + When this method returns, contains a object that represents the + + . This parameter is passed uninitialized. + + + + + Returns a object that represents the + + that matches the type supplied by the parameter objectSpaceType . + + + A object that represents the + + . If there is no matched type, this method returns null. + + + A that supplies the type in the object space. + + + + + Returns a object via the out parameter edmSpaceType that represents the + + that matches the type supplied by the parameter objectSpaceType . + + true on success, false on failure. + + A object that represents the object space type. + + + When this method returns, contains a object that represents the + + . This parameter is passed uninitialized. + + + + Clears all the metadata cache entries. + + + Gets original value members from an entity set and entity type. + The original value members from an entity set and entity type. + The entity set from which to retrieve original values. + The entity type of which to retrieve original values. + + + + Returns members of a given / + + for which original values are needed when modifying an entity. + + + The s for which original value is required. + + + An belonging to the C-Space. + + + An that participates in the given + + . + + true if entities may be updated partially; otherwise, false. + + + + The Max EDM version thats going to be supported by the runtime. + + + + + Class for representing a collection of items for the object layer. + Most of the implementation for actual maintenance of the collection is + done by ItemCollection + + + + + Initializes a new instance of the class. + + + + Loads metadata from the given assembly. + The assembly from which the metadata will be loaded. + + + Loads metadata from the given assembly. + The assembly from which the metadata will be loaded. + The EDM metadata source for the O space metadata. + The delegate to which log messages are sent. + + + Loads metadata from the specified assembly. + The assembly from which the metadata will be loaded. + The EDM metadata source for the O space metadata. + + + Returns a collection of primitive type objects. + A collection of primitive type objects. + + + + Returns the CLR type that corresponds to the supplied by the objectSpaceType parameter. + + The CLR type of the OSpace argument. + + A that represents the object space type. + + + + + Returns a CLR type corresponding to the supplied by the objectSpaceType parameter. + + true if there is a type that matches the search criteria; otherwise, false. + + A that represents the object space type. + + The CLR type. + + + The method returns the underlying CLR type for the specified OSpace type argument. If the DataSpace of the parameter is not OSpace, an ArgumentException is thrown. + The CLR type of the OSpace argument. + The OSpace type to look up. + + + Returns the underlying CLR type for the specified OSpace enum type argument. If the DataSpace of the parameter is not OSpace, the method returns false and sets the out parameter to null. + true on success, false on failure + The OSpace enum type to look up + The CLR enum type of the OSpace argument + + + Returns all the items of the specified type from this item collection. + + A collection of type that contains all items of the specified type. + + The type returned by the method. + + + + The enumeration defining the type semantics used to resolve function overloads. + These flags are defined in the provider manifest per function definition. + + + + + Allow Implicit Conversion between given and formal argument types (default). + + + + + Allow Type Promotion between given and formal argument types. + + + + + Use strict Equivalence only. + + + + + Class for representing a collection of items in Store space. + + + + + Initializes a new instance of the class using the specified XMLReader. + + The XMLReader used to create metadata. + + + Initializes a new instances of the class. + The model of the . + + + + Initializes a new instance of the class using the specified file paths. + + The file paths used to create metadata. + + + + Returns a collection of the objects. + + + A object that represents the collection of the + + objects. + + + + + Factory method that creates a . + + + SSDL artifacts to load. Must not be null. + + + Paths to SSDL artifacts. Used in error messages. Can be null in which case + the base Uri of the XmlReader will be used as a path. + + + Custom resolver. Currently used to resolve DbProviderServices implementation. If null + the default resolver will be used. + + + The collection of errors encountered while loading. + + + instance if no errors encountered. Otherwise null. + + + + Gets the provider factory of the StoreItemCollection. + The provider factory of the StoreItemCollection. + + + Gets the provider manifest of the StoreItemCollection. + The provider manifest of the StoreItemCollection. + + + Gets the manifest token of the StoreItemCollection. + The manifest token of the StoreItemCollection. + + + Gets the invariant name of the StoreItemCollection. + The invariant name of the StoreItemCollection. + + + Gets the version of the store schema for this collection. + The version of the store schema for this collection. + + + + This exception is thrown when a requested object is not found in the store. + + + + + Initializes a new instance of . + + + + + Initializes a new instance of with a specialized error message. + + The message that describes the error. + + + + Initializes a new instance of class that uses a specified error message and a reference to the inner exception. + + The message that describes the error. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Caches an ELinq query + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg5 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg6 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg7 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg8 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg9 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg10 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg11 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg12 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg13 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg14 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg15 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg5 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg6 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg7 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg8 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg9 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg10 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg11 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg12 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg13 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg14 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg5 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg6 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg7 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg8 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg9 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg10 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg11 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg12 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg13 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg5 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg6 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg7 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg8 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg9 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg10 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg11 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg12 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg5 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg6 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg7 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg8 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg9 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg10 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg11 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg5 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg6 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg7 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg8 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg9 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg10 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg5 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg6 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg7 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg8 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg9 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg5 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg6 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg7 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg8 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg5 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg6 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg7 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg5 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg6 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg5 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg4 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg3 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg2 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + Represents the type of the parameter that has to be passed in when executing the delegate returned by this method. TArg1 must be a primitive type. + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + Creates a new delegate that represents the compiled LINQ to Entities query. + + , a generic delegate that represents the compiled LINQ to Entities query. + + The lambda expression to compile. + + A type derived from . + + + The type T of the query results returned by executing the delegate returned by the + + method. + + + + + The values currently assigned to the properties of an entity. + + + + + Provides access to the original values of object data. The DbUpdatableDataRecord implements methods that allow updates to the original values of an object. + + + + Retrieves the field value as a Boolean. + The field value as a Boolean. + The ordinal of the field. + + + Retrieves the field value as a byte. + The field value as a byte. + The ordinal of the field. + + + Retrieves the field value as a byte array. + The number of bytes copied. + The ordinal of the field. + The index at which to start copying data. + The destination buffer where data is copied. + The index in the destination buffer where copying will begin. + The number of bytes to copy. + + + Retrieves the field value as a char. + The field value as a char. + The ordinal of the field. + + + Retrieves the field value as a char array. + The number of characters copied. + The ordinal of the field. + The index at which to start copying data. + The destination buffer where data is copied. + The index in the destination buffer where copying will begin. + The number of characters to copy. + + + + Retrieves the field value as an . + + + The field value as an . + + The ordinal of the field. + + + + Retrieves the field value as a + + + The field value as a . + + The ordinal of the field. + + + Retrieves the name of the field data type. + The name of the field data type. + The ordinal of the field. + + + + Retrieves the field value as a . + + + The field value as a . + + The ordinal of the field. + + + Retrieves the field value as a decimal. + The field value as a decimal. + The ordinal of the field. + + + Retrieves the field value as a double. + The field value as a double. + The ordinal of the field. + + + Retrieves the type of a field. + The field type. + The ordinal of the field. + + + Retrieves the field value as a float. + The field value as a float. + The ordinal of the field. + + + + Retrieves the field value as a . + + + The field value as a . + + The ordinal of the field. + + + + Retrieves the field value as an . + + + The field value as an . + + The ordinal of the field. + + + + Retrieves the field value as an . + + + The field value as an . + + The ordinal of the field. + + + + Retrieves the field value as an . + + + The field value as an . + + The ordinal of the field. + + + Retrieves the name of a field. + The name of the field. + The ordinal of the field. + + + Retrieves the ordinal of a field by using the name of the field. + The ordinal of the field. + The name of the field. + + + Retrieves the field value as a string. + The field value. + The ordinal of the field. + + + Retrieves the value of a field. + The field value. + The ordinal of the field. + + + Retrieves the value of a field. + The field value. + The ordinal of the field. + + + Populates an array of objects with the field values of the current record. + The number of field values returned. + An array of objects to store the field values. + + + + Returns whether the specified field is set to . + + + true if the field is set to ; otherwise false. + + The ordinal of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Sets field values in a record. + The number of the fields that were set. + The values of the field. + + + + Sets a field to the value. + + The ordinal of the field. + + + + Retrieves a field value as a . + + + A field value as a . + + The ordinal of the field. + + + + Retrieves the field value as a . + + + The field value as a . + + The ordinal of the field. + + + Sets the value of a field in a record. + The ordinal of the field. + The value of the field. + + + Gets the number of fields in the record. + An integer value that is the field count. + + + Returns a value that has the given field ordinal. + The value that has the given field ordinal. + The ordinal of the field. + + + Gets a value that has the given field name. + The field value. + The name of the field. + + + Gets data record information. + + A object. + + + + + This is the interface that represent the minimum interface required + to be an entity in ADO.NET. + + + + + This class contains the common methods need for an date object. + + + + + Public constant name used for change tracking + Providing this definition allows users to use this constant instead of + hard-coding the string. This helps to ensure the property name is correct + and allows faster comparisons in places where we are looking for this specific string. + Users can still use the case-sensitive string directly instead of the constant, + it will just be slightly slower on comparison. + Including the dash (-) character around the name ensures that this will not conflict with + a real data property, because -EntityKey- is not a valid identifier name + + + + + Raises the event. + + The name of the changed property. + + + + Raises the event. + + The name of the property changing. + + + Returns the minimum date time value supported by the data source. + + A value that is the minimum date time that is supported by the data source. + + + + Raises an event that is used to report that a property change is pending. + The name of the changing property. + + + Raises an event that is used to report that a property change has occurred. + The name for the changed property. + + + Returns a complex type for the specified property. + + Unlike most of the other helper methods in this class, this one is not static + because it references the SetValidValue for complex objects, which is also not static + because it needs a reference to this. + + A complex type object for the property. + A complex object that inherits from complex object. + The name of the complex property that is the complex object. + Indicates whether the type supports null values. + Indicates whether the type is initialized. + The type of the complex object being requested. + + + Determines whether the specified byte arrays contain identical values. + true if both arrays are of the same length and contain the same byte values or if both arrays are null; otherwise, false. + The first byte array value to compare. + The second byte array to compare. + + + Returns a copy of the current byte value. + + A copy of the current value. + + The current byte array value. + + + + Makes sure the value being set for a property is valid. + + + The value being validated. + + The value passed into the property setter. + Flag indicating if this property is allowed to be null. + The name of the property that is being validated. + If value is null for a non nullable value. + + + + Makes sure the value being set for a property is valid. + + + A value being set. + + The value being set. + Indicates whether the property is nullable. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + The Boolean value. + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + The Boolean value. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + A that is set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value that is set. + + The value that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + A value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + Makes sure the Single value being set for a property is valid. + + The value being set. + + + The value. + + The name of the property that is being validated. + + + Makes sure the Single value being set for a property is valid. + + The value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + Name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The nullable value being set. + + + The nullable value. + + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + Makes sure the UInt16 value being set for a property is valid. + The nullable UInt16 value being set. + The nullable UInt16 value. + The name of the property that is being validated. + + + Makes sure the UInt16 value being set for a property is valid. + The nullable UInt16 value being set. + The nullable UInt16 value. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + Makes sure the UInt32 value being set for a property is valid. + The nullable UInt32 value being set. + The nullable UInt32 value. + The name of the property that is being validated. + + + Makes sure the UInt32 value being set for a property is valid. + The nullable UInt32 value being set. + The nullable UInt32 value. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + + The value being set. + + + The value. + + + + + Makes sure the value being set for a property is valid. + + The nullable UInt64 value being set. + The nullable UInt64 value. + The name of the property that is being validated. + + + + Makes sure the value being set for a property is valid. + + The nullable UInt64 value being set. + The nullable UInt64 value. + + + Validates that the property is not null, and throws if it is. + The validated property. + The string value to be checked. + Flag indicating if this property is allowed to be null. + The name of the property that is being validated. + The string value is null for a non-nullable string. + + + Validates that the property is not null, and throws if it is. + + The validated value. + + The string value to be checked. + Flag indicating if this property is allowed to be null. + + + Validates that the property is not null, and throws if it is. + + The value being set. + + + The value to be checked. + + Flag indicating if this property is allowed to be null. + Name of the property that is being validated. + The value is null for a non-nullable property. + + + Validates that the property is not null, and throws if it is. + + The value being set. + + + value to be checked. + + Flag indicating if this property is allowed to be null. + The value is null for a non-nullable property. + + + Validates that the property is not null, and throws if it is. + + The value being set. + + + value to be checked. + + Flag indicating if this property is allowed to be null. + The name of the property that is being validated. + The value is null for a non-nullable property. + + + Validates that the property is not null, and throws if it is. + + The value being set. + + + The value to be checked. + + Flag indicating if this property is allowed to be null. + The value is null for a non-nullable property. + + + Sets a complex object for the specified property. + A complex type that derives from complex object. + The original complex object for the property, if any. + The complex object is being set. + The complex property that is being set to the complex object. + The type of the object being replaced. + + + Verifies that a complex object is not null. + The complex object being validated. + The complex object that is being validated. + The complex property on the parent object that is associated with complexObject . + The type of the complex object being verified. + + + + Notification that a property has been changed. + + + The PropertyChanged event can indicate all properties on the + object have changed by using either a null reference + (Nothing in Visual Basic) or String.Empty as the property name + in the PropertyChangedEventArgs. + + + + + Notification that a property is about to be changed. + + + The PropertyChanging event can indicate all properties on the + object are changing by using either a null reference + (Nothing in Visual Basic) or String.Empty as the property name + in the PropertyChangingEventArgs. + + + + Notifies the change tracker that a property change is pending on a complex object. + The name of the changing property. + property is null. + + + Notifies the change tracker that a property of a complex object has changed. + The name of the changed property. + property is null. + + + + Attribute for complex properties + Implied default AttributeUsage properties Inherited=True, AllowMultiple=False, + The metadata system expects this and will only look at the first of each of these attributes, even if there are more. + + + + + Base attribute for properties mapped to store elements. + Implied default AttributeUsage properties Inherited=True, AllowMultiple=False, + The metadata system expects this and will only look at the first of each of these attributes, even if there are more. + + + + + attribute for complex types + + + + + Base attribute for schematized types + + + + The name of the type in the conceptual schema that maps to the class to which this attribute is applied. + + A that is the name. + + + + The namespace name of the entity object type or complex type in the conceptual schema that maps to this type. + + A that is the namespace name. + + + + + Attribute identifying the Edm base class + + + + + Attribute indicating an enum type. + + + + + Attribute identifying the Ends defined for a RelationshipSet + Implied default AttributeUsage properties Inherited=True, AllowMultiple=False, + The metadata system expects this and will only look at the first of each of these attributes, even if there are more. + + + + + Initializes a new instance of the + + class. + + The namespace name of the relationship property. + The name of the relationship. The relationship name is not namespace qualified. + The role name at the other end of the relationship. + + + The namespace name of the navigation property. + + A that is the namespace name. + + + + Gets the unqualified relationship name. + The relationship name. + + + Gets the role name at the other end of the relationship. + The target role name is specified by the Role attribute of the other End element in the association that defines this relationship in the conceptual model. For more information, see Association (EDM). + + + + Defines a relationship between two entity types based on an association in the conceptual model. + + + + + Creates an instance of the class. + + The name of the namespace for the association in which this entity participates. + The name of a relationship in which this entity participates. + Name of the role for the type at one end of the association. + + A value of that indicates the multiplicity at one end of the association, such as one or many. + + The type of the entity at one end of the association. + Name of the role for the type at the other end of the association. + + A value of that indicates the multiplicity at the other end of the association, such as one or many. + + The type of the entity at the other end of the association. + + + + Initializes a new instance of the + + class. + + The name of the namespace for the association in which this entity participates. + The name of a relationship in which this entity participates. + Name of the role for the type at one end of the association. + + A value of that indicates the multiplicity at one end of the association, such as one or many. + + The type of the entity at one end of the association. + Name of the role for the type at the other end of the association. + + A value of that indicates the multiplicity at the other end of the association, such as one or many. + + The type of the entity at the other end of the association. + A value that indicates whether the relationship is based on the foreign key value. + + + The namespace for the relationship. + + A that is the namespace for the relationship. + + + + Name of the relationship. + + A that is the name of a relationship that is defined by this + + . + + + + Name of the role at one end of the relationship. + + A that is the name of the role. + + + + Multiplicity at one end of the relationship. + + A value that indicates the multiplicity. + + + + Type of the entity at one end of the relationship. + + A that is the type of the object at this end of the association. + + + + Name of the role at the other end of the relationship. + + A that is the name of the role. + + + + Multiplicity at the other end of the relationship. + + A value that indicates the multiplicity. + + + + Type of the entity at the other end of the relationship. + + A that is the type of the object t the other end of the association. + + + + Gets a Boolean value that indicates whether the relationship is based on the foreign key value. + true if the relationship is based on the foreign key value; otherwise false. + + + + Attribute for scalar properties in an IEntity. + Implied default AttributeUsage properties Inherited=True, AllowMultiple=False, + The metadata system expects this and will only look at the first of each of these attributes, even if there are more. + + + + Gets or sets the value that indicates whether the property can have a null value. + The value that indicates whether the property can have a null value. + + + Gets or sets the value that indicates whether the property is part of the entity key. + The value that indicates whether the property is part of the entity key. + + + + Attribute for static types + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with a unique value for each model referenced by the assembly. + + + Setting this parameter to a unique value for each model file in a Visual Basic + assembly will prevent the following error: + "'System.Data.Entity.Core.Objects.DataClasses.EdmSchemaAttribute' cannot be specified more than once in this project, even with identical parameter values." + + A string that is a unique GUID value for the model in the assembly. + + + + Collection of entities modeling a particular EDM construct + which can either be all entities of a particular type or + entities participating in a particular relationship. + + The type of entities in this collection. + + + + Base class for EntityCollection and EntityReference + + + + + Represents one end of a relationship. + + + + Loads the related object or objects into this related end with the default merge option. + + + Asynchronously loads the related object or objects into this related end with the default merge option. + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + + + Loads the related object or objects into the related end with the specified merge option. + + The to use when merging objects into an existing + . + + + + Asynchronously loads the related object or objects into the related end with the specified merge option. + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The to use when merging objects into an existing + . + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + + + Adds an object to the related end. + + An object to add to the collection. entity must implement + + . + + + + Adds an object to the related end. + An object to add to the collection. + + + Removes an object from the collection of objects at the related end. + + true if entity was successfully removed, false if entity was not part of the + + . + + + The object to remove from the collection. entity must implement + + . + + + + Removes an object from the collection of objects at the related end. + + true if entity was successfully removed; false if entity was not part of the + + . + + An object to remove from the collection. + + + Defines a relationship between two attached objects. + + The object being attached. entity must implement + + . + + + + Defines a relationship between two attached objects. + The object being attached. + + + + Returns an that represents the objects that belong to the related end. + + + An that represents the objects that belong to the related end. + + + + + Returns an that iterates through the collection of related objects. + + + An that iterates through the collection of related objects. + + + + + Gets or sets a value indicating whether the entity (for an or all entities + in the collection (for an have been loaded from the database. + + + Loading the related entities from the database either using lazy-loading, as part of a query, or explicitly + with one of the Load methods will set the IsLoaded flag to true. + IsLoaded can be explicitly set to true to prevent the related entities from being lazy-loaded. + This can be useful if the application has caused a subset of related entities to be loaded + and wants to prevent any other entities from being loaded automatically. + Note that explicit loading using will load all related entities from the database + regardless of whether or not IsLoaded is true. + When any related entity is detached the IsLoaded flag is reset to false indicating that not all related entities + are now loaded. + + + True if all the related entities are loaded or the IsLoaded has been explicitly set to true; otherwise false. + + + + Gets the name of the relationship in which this related end participates. + + The name of the relationship in which this is participating. The relationship name is not namespace qualified. + + + + Gets the role name at the source end of the relationship. + The role name at the source end of the relationship. + + + Gets the role name at the target end of the relationship. + The role name at the target end of the relationship. + + + Returns a reference to the metadata for the related end. + + A object that contains metadata for the end of a relationship. + + + + + Returns an that represents the objects that belong to the related end. + + + An that represents the objects that belong to the related end. + + + + + Loads the related object or objects into the related end with the default merge option. + + + When the source object was retrieved by using a query + and the is not + or the related objects are already loaded + or when the source object is not attached to the + or when the source object is being tracked but is in the + or state + or the + used for + is . + + + + + Asynchronously loads the related object or objects into the related end with the default merge option. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + + When the source object was retrieved by using a query + and the is not + or the related objects are already loaded + or when the source object is not attached to the + or when the source object is being tracked but is in the + or state + or the + used for + is . + + + + + Loads an object or objects from the related end with the specified merge option. + + + The to use when merging objects into an existing + . + + + When the source object was retrieved by using a query + and the + is not + or the related objects are already loaded + or when the source object is not attached to the + or when the source object is being tracked but is in the + or state + or the + used for + is . + + + + + Asynchronously loads an object or objects from the related end with the specified merge option. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The to use when merging objects into an existing + . + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + + When the source object was retrieved by using a query + and the + is not + or the related objects are already loaded + or when the source object is not attached to the + or when the source object is being tracked but is in the + or state + or the + used for + is . + + + + + Attaches an entity to the related end. This method works in exactly the same way as Attach(object). + It is maintained for backward compatibility with previous versions of IRelatedEnd. + + The entity to attach to the related end + + Thrown when + + is null. + + Thrown when the entity cannot be related via the current relationship end. + + + + Attaches an entity to the related end. If the related end is already filled + or partially filled, this merges the existing entities with the given entity. The given + entity is not assumed to be the complete set of related entities. + Owner and all entities passed in must be in Unchanged or Modified state. + Deleted elements are allowed only when the state manager is already tracking the relationship + instance. + + The entity to attach to the related end + + Thrown when + + is null. + + Thrown when the entity cannot be related via the current relationship end. + + + + Adds an entity to the related end. This method works in exactly the same way as Add(object). + It is maintained for backward compatibility with previous versions of IRelatedEnd. + + Entity instance to add to the related end + + + + Adds an entity to the related end. If the owner is + attached to a cache then the all the connected ends are + added to the object cache and their corresponding relationships + are also added to the ObjectStateManager. The RelatedEnd of the + relationship is also fixed. + + Entity instance to add to the related end + + + + Removes an entity from the related end. This method works in exactly the same way as Remove(object). + It is maintained for backward compatibility with previous versions of IRelatedEnd. + + Entity instance to remove from the related end + Returns true if the entity was successfully removed, false if the entity was not part of the RelatedEnd. + + + + Removes an entity from the related end. If owner is + attached to a cache, marks relationship for deletion and if + the relationship is composition also marks the entity for deletion. + + Entity instance to remove from the related end + Returns true if the entity was successfully removed, false if the entity was not part of the RelatedEnd. + + + + Returns an that iterates through the collection of related objects. + + + An that iterates through the collection of related objects. + + + + + Used internally to deserialize entity objects along with the + + instances. + + The serialized stream. + + + Occurs when a change is made to a related end. + + + Gets the name of the relationship in which this related end participates. + + The name of the relationship in which this participates. The relationship name is not namespace qualified. + + + + Gets the role name at the source end of the relationship. + + A that is the role name. + + + + Gets the role name at the target end of the relationship. + + A that is the role name. + + + + Gets a reference to the metadata for the related end. + + A object that contains metadata for the end of a relationship. + + + + + + + + Initializes a new instance of the class. + + + + + Returns the collection as an used for data binding. + + + An of entity objects. + + + + Loads related objects into the collection, using the specified merge option. + + Specifies how the objects in this collection should be merged with the objects that might have been returned from previous queries against the same + + . + + + + + + + Defines relationships between an object and a collection of related objects in an object context. + + Loads related entities into the local collection. If the collection is already filled + or partially filled, merges existing entities with the given entities. The given + entities are not assumed to be the complete set of related entities. + Owner and all entities passed in must be in Unchanged or Modified state. We allow + deleted elements only when the state manager is already tracking the relationship + instance. + + Collection of objects in the object context that are related to the source object. + entities collection is null. + + The source object or an object in the entities collection is null or is not in an + + or state.-or-The relationship cannot be defined based on the EDM metadata. This can occur when the association in the conceptual schema does not support a relationship between the two types. + + + + Defines a relationship between two attached objects in an object context. + The object being attached. + When the entity is null. + + When the entity cannot be related to the source object. This can occur when the association in the conceptual schema does not support a relationship between the two types.-or-When either object is null or is not in an + + or state. + + + + Adds an object to the collection. + + An object to add to the collection. entity must implement + + . + + entity is null. + + + Removes an object from the collection and marks the relationship for deletion. + true if item was successfully removed; otherwise, false. + The object to remove from the collection. + entity object is null. + The entity object is not attached to the same object context.-or-The entity object does not have a valid relationship manager. + + + Returns an enumerator that is used to iterate through the objects in the collection. + + An that iterates through the set of values cached by + + . + + + + + Returns an enumerator that is used to iterate through the set of values cached by + + . + + + An that iterates through the set of values cached by + + . + + + + Removes all entities from the collection. + + + Determines whether a specific object exists in the collection. + + true if the object is found in the ; otherwise, false. + + + The object to locate in the . + + + + Copies all the contents of the collection to an array, starting at the specified index of the target array. + The array to copy to. + The zero-based index in the array at which copying begins. + + + Used internally to serialize entity objects. + The streaming context. + + + Used internally to deserialize entity objects. + The streaming context. + + + Returns an object query that, when it is executed, returns the same set of objects that exists in the current collection. + + An that represents the entity collection. + + + When the object is in an state + or when the object is in a + state with a + other than + . + + + + Gets the number of objects that are contained in the collection. + + The number of elements that are contained in the + + . + + + + + Gets a value that indicates whether the + + is read-only. + + Always returns false. + + + + IListSource.ContainsListCollection implementation. Always returns false. + This means that the IList we return is the one which contains our actual data, + it is not a list of collections. + + + + + This is the class is the basis for all perscribed EntityObject classes. + + + + + Interface that defines an entity containing a key. + + + + + Gets or sets the for instances of entity types that implement this interface. + + + If an object is being managed by a change tracker, it is expected that + IEntityChangeTracker methods EntityMemberChanging and EntityMemberChanged will be + used to report changes on EntityKey. This allows the change tracker to validate the + EntityKey's new value and to verify if the change tracker is in a state where it can + allow updates to the EntityKey. + + + The for instances of entity types that implement this interface. + + + + + Minimum interface that a data class must implement in order to be managed by a change tracker. + + + + + Gets or sets the used to report changes. + + + The used to report changes. + + + + + Interface that a data class must implement if exposes relationships + + + + Returns the relationship manager that manages relationships for an instance of an entity type. + + Classes that expose relationships must implement this property + by constructing and setting RelationshipManager in their constructor. + The implementation of this property should use the static method RelationshipManager.Create + to create a new RelationshipManager when needed. Once created, it is expected that this + object will be stored on the entity and will be provided through this property. + + + The for this entity. + + + + + Used by the ObjectStateManager to attach or detach this EntityObject to the cache. + + Reference to the ObjectStateEntry that contains this entity + + + Notifies the change tracker that a property change is pending. + The name of the changing property. + property is null. + + + Notifies the change tracker that a property has changed. + The name of the changed property. + property is null. + + + Gets the entity state of the object. + + The of this object. + + + + Gets or sets the key for this object. + + The for this object. + + + + + Returns the container for the lazily created relationship + navigation property objects, collections and refs. + + + + + This interface is implemented by a change tracker and is used by data classes to report changes + + + + Notifies the change tracker of a pending change to a property of an entity type. + The name of the property that is changing. + + + Notifies the change tracker that a property of an entity type has changed. + The name of the property that has changed. + + + Notifies the change tracker of a pending change to a complex property. + The name of the top-level entity property that is changing. + The complex type that contains the property that is changing. + The name of the property that is changing on complex type. + + + Notifies the change tracker that a property of a complex type has changed. + The name of the complex property of the entity type that has changed. + The complex type that contains the property that changed. + The name of the property that changed on complex type. + + + Gets current state of a tracked object. + + An that is the state of the tracked object.For more information, see Identity Resolution, State Managment, and Change Tracking and Tracking Changes in POCO Entities. + + + + + Models a relationship end with multiplicity 1. + + + + Returns the key for the related object. + + Returns the EntityKey of the target entity associated with this EntityReference. + Is non-null in the following scenarios: + (a) Entities are tracked by a context and an Unchanged or Added client-side relationships exists for this EntityReference's owner with the + same RelationshipName and source role. This relationship could have been created explicitly by the user (e.g. by setting + the EntityReference.Value, setting this property directly, or by calling EntityCollection.Add) or automatically through span queries. + (b) If the EntityKey was non-null before detaching an entity from the context, it will still be non-null after detaching, until any operation + occurs that would set it to null, as described below. + (c) Entities are detached and the EntityKey is explicitly set to non-null by the user. + (d) Entity graph was created using a NoTracking query with full span + Is null in the following scenarios: + (a) Entities are tracked by a context but there is no Unchanged or Added client-side relationship for this EntityReference's owner with the + same RelationshipName and source role. + (b) Entities are tracked by a context and a relationship exists, but the target entity has a temporary key (i.e. it is Added) or the key + is one of the special keys + (c) Entities are detached and the relationship was explicitly created by the user. + + + An that is the key of the related object. + + + + + Models a relationship end with multiplicity 1. + + The type of the entity being referenced. + + + + Creates a new instance of . + + + The default constructor is required for some serialization scenarios. It should not be used to + create new EntityReferences. Use the GetRelatedReference or GetRelatedEnd methods on the RelationshipManager + class instead. + + + + + Loads the related object for this with the specified merge option. + + + Specifies how the object should be returned if it already exists in the + + . + + + The source of the is null + or a query returned more than one related end + or a query returned zero related ends, and one related end was expected. + + + + + + + Creates a many-to-one or one-to-one relationship between two objects in the object context. + The object being attached. + When the entity is null. + When the entity cannot be related to the current related end. This can occur when the association in the conceptual schema does not support a relationship between the two types. + + + Creates an equivalent object query that returns the related object. + + An that returns the related object. + + + When the object is in an state + or when the object is in a + state with a + other than . + + + + This method is used internally to serialize related entity objects. + The serialized stream. + + + This method is used internally to serialize related entity objects. + The serialized stream. + + + + Gets or sets the related object returned by this + + . + + + The object returned by this . + + + + + Identifies the kind of a relationship + + + + + The relationship is an Association + + + + + Container for the lazily created relationship navigation + property objects (collections and refs). + + + + + Creates a new object. + + + Used by data classes that support relationships. If the change tracker + requests the RelationshipManager property and the data class does not + already have a reference to one of these objects, it calls this method + to create one, then saves a reference to that object. On subsequent accesses + to that property, the data class should return the saved reference. + The reason for using a factory method instead of a public constructor is to + emphasize that this is not something you would normally call outside of a data class. + By requiring that these objects are created via this method, developers should + give more thought to the operation, and will generally only use it when + they explicitly need to get an object of this type. It helps define the intended usage. + + + The requested . + + Reference to the entity that is calling this method. + + + + Returns either an or + + of the correct type for the specified target role in a relationship. + + + representing the + + or + + that was retrieved. + + Name of the relationship in which targetRoleName is defined. The relationship name is not namespace qualified. + Target role to use to retrieve the other end of relationshipName . + relationshipName or targetRoleName is null. + The source type does not match the type of the owner. + targetRoleName is invalid or unable to find the relationship type in the metadata. + + + + Takes an existing EntityReference that was created with the default constructor and initializes it using the provided relationship and target role names. + This method is designed to be used during deserialization only, and will throw an exception if the provided EntityReference has already been initialized, + if the relationship manager already contains a relationship with this name and target role, or if the relationship manager is already attached to a ObjectContext.W + + The relationship name. + The role name of the related end. + + The to initialize. + + + The type of the being initialized. + + + When the provided + is already initialized.-or-When the relationship manager is already attached to an + + or when the relationship manager already contains a relationship with this name and target role. + + + + + Takes an existing EntityCollection that was created with the default constructor and initializes it using the provided relationship and target role names. + This method is designed to be used during deserialization only, and will throw an exception if the provided EntityCollection has already been initialized, + or if the relationship manager is already attached to a ObjectContext. + + The relationship name. + The target role name. + An existing EntityCollection. + Type of the entity represented by targetRoleName + + + + Gets an of related objects with the specified relationship name and target role name. + + + The of related objects. + + Name of the relationship to navigate. The relationship name is not namespace qualified. + Name of the target role for the navigation. Indicates the direction of navigation across the relationship. + + The type of the returned . + + + The specified role returned an instead of an + + . + + + + + Gets the for a related object by using the specified combination of relationship name and target role name. + + + The of a related object. + + Name of the relationship to navigate. The relationship name is not namespace qualified. + Name of the target role for the navigation. Indicates the direction of navigation across the relationship. + + The type of the returned . + + + The specified role returned an instead of an + + . + + + + Returns an enumeration of all the related ends managed by the relationship manager. + + An of objects that implement + + . An empty enumeration is returned when the relationships have not yet been populated. + + + + + Called by Object Services to prepare an for binary serialization with a serialized relationship. + + Describes the source and destination of a given serialized stream, and provides an additional caller-defined context. + + + + Used internally to deserialize entity objects along with the + + instances. + + The serialized stream. + + + + Represents either a entity, entity stub or relationship + + + + + Gets the updatable version of original values of the object associated with this + + . + + The updatable original values of object data. + + + Accepts the current values as original values. + + + Marks an entity as deleted. + + + + Returns the names of an object’s properties that have changed since the last time + + was called. + + + An collection of names as string. + + + + Sets the state of the object or relationship to modify. + If State is not Modified or Unchanged + + + Marks the specified property as modified. + The name of the property. + If State is not Modified or Unchanged + + + Rejects any changes made to the property with the given name since the property was last loaded, attached, saved, or changes were accepted. The orginal value of the property is stored and the property will no longer be marked as modified. + The name of the property to change. + + + Uses DetectChanges to determine whether or not the current value of the property with the given name is different from its original value. Note that this may be different from the property being marked as modified since a property which has not changed can still be marked as modified. + + Note that this property always returns the same result as the modified state of the property for change tracking + proxies and entities that derive from the EntityObject base class. This is because original values are not tracked + for these entity types and hence there is no way to know if the current value is really different from the + original value. + + true if the property has changed; otherwise, false. + The name of the property. + + + + Changes state of the entry to the specified value. + + + The value to set for the + + property of the entry. + + + + Sets the current values of the entry to match the property values of a supplied object. + The detached object that has updated values to apply to the object. currentEntity can also be the object’s entity key. + + + Sets the original values of the entry to match the property values of a supplied object. + The detached object that has original values to apply to the object. originalEntity can also be the object’s entity key. + + + + Used to report that a scalar entity property is about to change + The current value of the specified property is cached when this method is called. + + The name of the entity property that is changing + + + + Used to report that a scalar entity property has been changed + The property value that was cached during EntityMemberChanging is now + added to OriginalValues + + The name of the entity property that has changing + + + + Used to report that a complex property is about to change + The current value of the specified property is cached when this method is called. + + The name of the top-level entity property that is changing + The complex object that contains the property that is changing + The name of the property that is changing on complexObject + + + + Used to report that a complex property has been changed + The property value that was cached during EntityMemberChanging is now added to OriginalValues + + The name of the top-level entity property that has changed + The complex object that contains the property that changed + The name of the property that changed on complexObject + + + + Gets the for the + + . + + + The for the + + . + + + + + Gets the for the object or relationship. + + + The for the object or relationship. + + + + + Gets the state of the . + + + The state of the . + + + + Gets the entity object. + The entity object. + + + Gets the entity key. + The entity key. + + + + Gets a value that indicates whether the represents a relationship. + + + true if the represents a relationship; otherwise, false. + + + + Gets the read-only version of original values of the object or relationship. + The read-only version of original values of the relationship set entry or entity. + + + + Gets the current property values of the object or relationship associated with this + + . + + + A that contains the current values of the object or relationship associated with this + + . + + + + + Gets the instance for the object represented by entry. + + + The object. + + The entry is a stub or represents a relationship + + + + Returns the EntityState from the ObjectStateEntry + + + + + Defines behavior for implementations of IQueryable that allow modifications to the membership of the resulting set. + + Type of entities returned from the queryable. + + + Notifies the set that an object that represents a new entity must be added to the set. + + Depending on the implementation, the change to the set may not be visible in an enumeration of the set + until changes to that set have been persisted in some manner. + + The new object to add to the set. + + + Notifies the set that an object that represents an existing entity must be added to the set. + + Depending on the implementation, the change to the set may not be visible in an enumeration of the set + until changes to that set have been persisted in some manner. + + The existing object to add to the set. + + + Notifies the set that an object that represents an existing entity must be deleted from the set. + + Depending on the implementation, the change to the set may not be visible in an enumeration of the set + until changes to that set have been persisted in some manner. + + The existing object to delete from the set. + + + Notifies the set that an object that represents an existing entity must be detached from the set. + + Depending on the implementation, the change to the set may not be visible in an enumeration of the set + until changes to that set have been persisted in some manner. + + The object to detach from the set. + + + + The different ways that new objects loaded from the database can be merged with existing objects already in memory. + + + + + Will only append new (top level-unique) rows. This is the default behavior. + + + + + Same behavior as LoadOption.OverwriteChanges. + + + + + Same behavior as LoadOption.PreserveChanges. + + + + + Will not modify cache. + + + + + ObjectContext is the top-level object that encapsulates a connection between the CLR and the database, + serving as a gateway for Create, Read, Update, and Delete operations. + + + + + Initializes a new instance of the class with the given connection. During construction, the metadata workspace is extracted from the + + object. + + + An that contains references to the model and to the data source connection. + + The connection is null. + The connection is invalid or the metadata workspace is invalid. + + + + Creates an ObjectContext with the given connection and metadata workspace. + + connection to the store + If set to true the connection is disposed when the context is disposed, otherwise the caller must dispose the connection. + + + + Initializes a new instance of the class with the given connection string and default entity container name. + + The connection string, which also provides access to the metadata information. + The connectionString is null. + The connectionString is invalid or the metadata workspace is not valid. + + + + Initializes a new instance of the class with a given connection string and entity container name. + + The connection string, which also provides access to the metadata information. + The name of the default entity container. When the defaultContainerName is set through this method, the property becomes read-only. + The connectionString is null. + The connectionString , defaultContainerName , or metadata workspace is not valid. + + + + Initializes a new instance of the class with a given connection and entity container name. + + + An that contains references to the model and to the data source connection. + + The name of the default entity container. When the defaultContainerName is set through this method, the property becomes read-only. + The connection is null. + The connection , defaultContainerName , or metadata workspace is not valid. + + + Accepts all changes made to objects in the object context. + + + Adds an object to the object context. + Represents the entity set name, which may optionally be qualified by the entity container name. + + The to add. + + The entity parameter is null or the entitySetName does not qualify. + + + Explicitly loads an object related to the supplied object by the specified navigation property and using the default merge option. + The entity for which related objects are to be loaded. + The name of the navigation property that returns the related objects to be loaded. + + The entity is in a , + + or state or the entity is attached to another instance of + + . + + + + Explicitly loads an object that is related to the supplied object by the specified navigation property and using the specified merge option. + The entity for which related objects are to be loaded. + The name of the navigation property that returns the related objects to be loaded. + + The value to use when you load the related objects. + + + The entity is in a , + + or state or the entity is attached to another instance of + + . + + + + Explicitly loads an object that is related to the supplied object by the specified LINQ query and by using the default merge option. + The type of the entity. + The source object for which related objects are to be loaded. + A LINQ expression that defines the related objects to be loaded. + selector does not supply a valid input parameter. + selector is null. + + The entity is in a , + + or state or the entity is attached to another instance of + + . + + + + Explicitly loads an object that is related to the supplied object by the specified LINQ query and by using the specified merge option. + The type of the entity. + The source object for which related objects are to be loaded. + A LINQ expression that defines the related objects to be loaded. + + The value to use when you load the related objects. + + selector does not supply a valid input parameter. + selector is null. + + The entity is in a , + + or state or the entity is attached to another instance of + + . + + + + Applies property changes from a detached object to an object already attached to the object context. + The name of the entity set to which the object belongs. + The detached object that has property updates to apply to the original object. + When entitySetName is null or an empty string or when changed is null. + + When the from entitySetName does not match the + + of the object + + or when the entity is in a state other than + + or + + or the original object is not attached to the context. + + When the type of the changed object is not the same type as the original object. + + + + Copies the scalar values from the supplied object into the object in the + + that has the same key. + + The updated object. + The name of the entity set to which the object belongs. + + The detached object that has property updates to apply to the original object. The entity key of currentEntity must match the + + property of an entry in the + + . + + The entity type of the object. + entitySetName or current is null. + + The from entitySetName does not match the + + of the object + + or the object is not in the + + or it is in a + + state or the entity key of the supplied object is invalid. + + entitySetName is an empty string. + + + + Copies the scalar values from the supplied object into set of original values for the object in the + + that has the same key. + + The updated object. + The name of the entity set to which the object belongs. + + The detached object that has original values to apply to the object. The entity key of originalEntity must match the + + property of an entry in the + + . + + The type of the entity object. + entitySetName or original is null. + + The from entitySetName does not match the + + of the object + + or an + + for the object cannot be found in the + + or the object is in an + + or a + + state or the entity key of the supplied object is invalid or has property changes. + + entitySetName is an empty string. + + + Attaches an object or object graph to the object context in a specific entity set. + Represents the entity set name, which may optionally be qualified by the entity container name. + + The to attach. + + The entity is null. + + Invalid entity set or the object has a temporary key or the object has an + + and the + + does not match with the entity set passed in as an argument of the method or the object does not have an + + and no entity set is provided or any object from the object graph has a temporary + + or any object from the object graph has an invalid + + (for example, values in the key do not match values in the object) or the entity set could not be found from a given entitySetName name and entity container name or any object from the object graph already exists in another state manager. + + + + Attaches an object or object graph to the object context when the object has an entity key. + The object to attach. + The entity is null. + Invalid entity key. + + + Creates the entity key for a specific object, or returns the entity key if it already exists. + + The of the object. + + The fully qualified name of the entity set to which the entity object belongs. + The object for which the entity key is being retrieved. + When either parameter is null. + When entitySetName is empty or when the type of the entity object does not exist in the entity set or when the entitySetName is not fully qualified. + When the entity key cannot be constructed successfully based on the supplied parameters. + + + + Creates a new instance that is used to query, add, modify, and delete objects of the specified entity type. + + + The new instance. + + + Entity type of the requested . + + + The property is not set on the + + or the specified type belongs to more than one entity set. + + + + + Creates a new instance that is used to query, add, modify, and delete objects of the specified type and with the specified entity set name. + + + The new instance. + + + Name of the entity set for the returned . The string must be qualified by the default container name if the + + property is not set on the + + . + + + Entity type of the requested . + + + The from entitySetName does not match the + + of the object + + or the + + property is not set on the + + and the name is not qualified as part of the entitySetName parameter or the specified type belongs to more than one entity set. + + + + + Creates an in the current object context by using the specified query string. + + + An of the specified type. + + The query string to be executed. + Parameters to pass to the query. + + The entity type of the returned . + + The queryString or parameters parameter is null. + + + Marks an object for deletion. + + An object that specifies the entity to delete. The object can be in any state except + + . + + + + Removes the object from the object context. + + Object to be detached. Only the entity is removed; if there are any related objects that are being tracked by the same + + , those will not be detached automatically. + + The entity is null. + + The entity is not associated with this (for example, was newly created and not associated with any context yet, or was obtained through some other context, or was already detached). + + + + + Finalizes an instance of the class. + + + + Releases the resources used by the object context. + + + + Releases the resources used by the object context. + + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + Returns an object that has the specified entity key. + + An that is an instance of an entity type. + + The key of the object to be found. + The key parameter is null. + + The object is not found in either the or the data source. + + + + Updates a collection of objects in the object context with data from the database. + + A value that indicates whether + property changes in the object context are overwritten with property values from the database. + + + An collection of objects to refresh. + + collection is null. + refreshMode is not valid. + collection is empty or an object is not attached to the context. + + + Updates an object in the object context with data from the database. + + A value that indicates whether + property changes in the object context are overwritten with property values from the database. + + The object to be refreshed. + entity is null. + refreshMode is not valid. + entity is not attached to the context. + + + Asynchronously updates a collection of objects in the object context with data from the database. + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A value that indicates whether + property changes in the object context are overwritten with property values from the database. + + + An collection of objects to refresh. + + + A task that represents the asynchronous operation. + + collection is null. + refreshMode is not valid. + collection is empty or an object is not attached to the context. + + + Asynchronously updates a collection of objects in the object context with data from the database. + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A value that indicates whether + property changes in the object context are overwritten with property values from the database. + + + An collection of objects to refresh. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + collection is null. + refreshMode is not valid. + collection is empty or an object is not attached to the context. + + + Asynchronously updates an object in the object context with data from the database. + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A value that indicates whether + property changes in the object context are overwritten with property values from the database. + + The object to be refreshed. + + A task that represents the asynchronous operation. + + entity is null. + refreshMode is not valid. + entity is not attached to the context. + + + Asynchronously updates an object in the object context with data from the database. + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A value that indicates whether + property changes in the object context are overwritten with property values from the database. + + The object to be refreshed. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + entity is null. + refreshMode is not valid. + entity is not attached to the context. + + + Persists all updates to the database and resets change tracking in the object context. + + The number of state entries written to the underlying database. This can include + state entries for entities and/or relationships. Relationship state entries are created for + many-to-many relationships and relationships where there is no foreign key property + included in the entity class (often referred to as independent associations). + + An optimistic concurrency violation has occurred while saving changes. + + + Asynchronously persists all updates to the database and resets change tracking in the object context. + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous save operation. + The task result contains the number of state entries written to the underlying database. This can include + state entries for entities and/or relationships. Relationship state entries are created for + many-to-many relationships and relationships where there is no foreign key property + included in the entity class (often referred to as independent associations). + + An optimistic concurrency violation has occurred while saving changes. + + + Asynchronously persists all updates to the database and resets change tracking in the object context. + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous save operation. + The task result contains the number of state entries written to the underlying database. This can include + state entries for entities and/or relationships. Relationship state entries are created for + many-to-many relationships and relationships where there is no foreign key property + included in the entity class (often referred to as independent associations). + + An optimistic concurrency violation has occurred while saving changes. + + + Persists all updates to the database and optionally resets change tracking in the object context. + + This parameter is needed for client-side transaction support. If true, the change tracking on all objects is reset after + + finishes. If false, you must call the + method after . + + + The number of state entries written to the underlying database. This can include + state entries for entities and/or relationships. Relationship state entries are created for + many-to-many relationships and relationships where there is no foreign key property + included in the entity class (often referred to as independent associations). + + An optimistic concurrency violation has occurred while saving changes. + + + Persists all updates to the database and optionally resets change tracking in the object context. + + A value that determines the behavior of the operation. + + + The number of state entries written to the underlying database. This can include + state entries for entities and/or relationships. Relationship state entries are created for + many-to-many relationships and relationships where there is no foreign key property + included in the entity class (often referred to as independent associations). + + An optimistic concurrency violation has occurred while saving changes. + + + Asynchronously persists all updates to the database and optionally resets change tracking in the object context. + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A value that determines the behavior of the operation. + + + A task that represents the asynchronous save operation. + The task result contains the number of state entries written to the underlying database. This can include + state entries for entities and/or relationships. Relationship state entries are created for + many-to-many relationships and relationships where there is no foreign key property + included in the entity class (often referred to as independent associations). + + An optimistic concurrency violation has occurred while saving changes. + + + Asynchronously persists all updates to the database and optionally resets change tracking in the object context. + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A value that determines the behavior of the operation. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous save operation. + The task result contains the number of state entries written to the underlying database. This can include + state entries for entities and/or relationships. Relationship state entries are created for + many-to-many relationships and relationships where there is no foreign key property + included in the entity class (often referred to as independent associations). + + An optimistic concurrency violation has occurred while saving changes. + + + + Ensures that changes are synchronized with changes in all objects that are tracked by the + + . + + + + Returns an object that has the specified entity key. + true if the object was retrieved successfully. false if the key is temporary, the connection is null, or the value is null. + The key of the object to be found. + When this method returns, contains the object. + Incompatible metadata for key . + key is null. + + + + Executes a stored procedure or function that is defined in the data source and mapped in the conceptual model, with the specified parameters. Returns a typed + + . + + + An for the data that is returned by the stored procedure. + + The name of the stored procedure or function. The name can include the container name, such as <Container Name>.<Function Name>. When the default container name is known, only the function name is required. + + An array of objects. If output parameters are used, + their values will not be available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + The entity type of the returned when the function is executed against the data source. This type must implement + + . + + function is null or empty or function is not found. + The entity reader does not support this function or there is a type mismatch on the reader and the function . + + + + Executes the given stored procedure or function that is defined in the data source and expressed in the conceptual model, with the specified parameters, and merge option. Returns a typed + + . + + + An for the data that is returned by the stored procedure. + + The name of the stored procedure or function. The name can include the container name, such as <Container Name>.<Function Name>. When the default container name is known, only the function name is required. + + The to use when executing the query. + + + An array of objects. If output parameters are used, + their values will not be available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + The entity type of the returned when the function is executed against the data source. This type must implement + + . + + function is null or empty or function is not found. + The entity reader does not support this function or there is a type mismatch on the reader and the function . + + + + Executes the given function on the default container. + + Element type for function results. + + Name of function. May include container (e.g. ContainerName.FunctionName) or just function name when DefaultContainerName is known. + + The options for executing this function. + + The parameter values to use for the function. If output parameters are used, their values + will not be available until the results have been read completely. This is due to the underlying + behavior of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + An object representing the result of executing this function. + If function is null or empty + + If function is invalid (syntax, + does not exist, refers to a function with return type incompatible with T) + + + + Executes a stored procedure or function that is defined in the data source and expressed in the conceptual model; discards any results returned from the function; and returns the number of rows affected by the execution. + The number of rows affected. + The name of the stored procedure or function. The name can include the container name, such as <Container Name>.<Function Name>. When the default container name is known, only the function name is required. + + An array of objects. If output parameters are used, + their values will not be available until the results have been read completely. This is due to the underlying + behavior of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + function is null or empty or function is not found. + The entity reader does not support this function or there is a type mismatch on the reader and the function . + + + Generates an equivalent type that can be used with the Entity Framework for each type in the supplied enumeration. + + An enumeration of objects that represent custom data classes that map to the conceptual model. + + + + Returns all the existing proxy types. + + An of all the existing proxy types. + + + + Returns the entity type of the POCO entity associated with a proxy object of a specified type. + + The of the associated POCO entity. + + + The of the proxy object. + + + + Creates and returns an instance of the requested type . + An instance of the requested type T , or an instance of a derived type that enables T to be used with the Entity Framework. The returned object is either an instance of the requested type or an instance of a derived type that enables the requested type to be used with the Entity Framework. + Type of object to be returned. + + + + Executes an arbitrary command directly against the data source using the existing connection. + The command is specified using the server's native query language, such as SQL. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + If there isn't an existing local transaction a new transaction will be used + to execute the command. + + The command specified in the server's native query language. + The parameter values to use for the query. + The number of rows affected. + + + + Executes an arbitrary command directly against the data source using the existing connection. + The command is specified using the server's native query language, such as SQL. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + Controls the creation of a transaction for this command. + The command specified in the server's native query language. + The parameter values to use for the query. + The number of rows affected. + + + + Asynchronously executes an arbitrary command directly against the data source using the existing connection. + The command is specified using the server's native query language, such as SQL. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + If there isn't an existing local transaction a new transaction will be used + to execute the command. + + The command specified in the server's native query language. + The parameter values to use for the query. + + A task that represents the asynchronous operation. + The task result contains the number of rows affected. + + + + + Asynchronously executes an arbitrary command directly against the data source using the existing connection. + The command is specified using the server's native query language, such as SQL. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + Controls the creation of a transaction for this command. + The command specified in the server's native query language. + The parameter values to use for the query. + + A task that represents the asynchronous operation. + The task result contains the number of rows affected. + + + + + Asynchronously executes an arbitrary command directly against the data source using the existing connection. + The command is specified using the server's native query language, such as SQL. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + If there isn't an existing local transaction a new transaction will be used + to execute the command. + + The command specified in the server's native query language. + + A to observe while waiting for the task to complete. + + The parameter values to use for the query. + + A task that represents the asynchronous operation. + The task result contains the number of rows affected. + + + + + Asynchronously executes an arbitrary command directly against the data source using the existing connection. + The command is specified using the server's native query language, such as SQL. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + Controls the creation of a transaction for this command. + The command specified in the server's native query language. + + A to observe while waiting for the task to complete. + + The parameter values to use for the query. + + A task that represents the asynchronous operation. + The task result contains the number of rows affected. + + + + + Executes a query directly against the data source and returns a sequence of typed results. + The query is specified using the server's native query language, such as SQL. + Results are not tracked by the context, use the overload that specifies an entity set name to track results. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreQuery<Post>("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreQuery<Post>("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + The element type of the result sequence. + The query specified in the server's native query language. + + The parameter values to use for the query. If output parameters are used, their values will not be + available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + An enumeration of objects of type . + + + + + Executes a query directly against the data source and returns a sequence of typed results. + The query is specified using the server's native query language, such as SQL. + Results are not tracked by the context, use the overload that specifies an entity set name to track results. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreQuery<Post>("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreQuery<Post>("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + The element type of the result sequence. + The query specified in the server's native query language. + The options for executing this query. + + The parameter values to use for the query. If output parameters are used, their values will not be + available until the results have been read completely. This is due to the underlying behavior of + DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + An enumeration of objects of type . + + + + + Executes a query directly against the data source and returns a sequence of typed results. + The query is specified using the server's native query language, such as SQL. + If an entity set name is specified, results are tracked by the context. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreQuery<Post>("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreQuery<Post>("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + The element type of the result sequence. + The query specified in the server's native query language. + The entity set of the TResult type. If an entity set name is not provided, the results are not going to be tracked. + + The to use when executing the query. The default is + . + + + The parameter values to use for the query. If output parameters are used, their values will not be + available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + An enumeration of objects of type . + + + + + Executes a query directly against the data source and returns a sequence of typed results. + The query is specified using the server's native query language, such as SQL. + If an entity set name is specified, results are tracked by the context. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreQuery<Post>("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreQuery<Post>("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + The element type of the result sequence. + The query specified in the server's native query language. + The entity set of the TResult type. If an entity set name is not provided, the results are not going to be tracked. + The options for executing this query. + + The parameter values to use for the query. If output parameters are used, their values will not be + available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + An enumeration of objects of type . + + + + + Asynchronously executes a query directly against the data source and returns a sequence of typed results. + The query is specified using the server's native query language, such as SQL. + Results are not tracked by the context, use the overload that specifies an entity set name to track results. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The element type of the result sequence. + The query specified in the server's native query language. + + The parameter values to use for the query. If output parameters are used, their values will not be + available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + A task that represents the asynchronous operation. + The task result contains an enumeration of objects of type . + + + + + Asynchronously executes a query directly against the data source and returns a sequence of typed results. + The query is specified using the server's native query language, such as SQL. + Results are not tracked by the context, use the overload that specifies an entity set name to track results. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The element type of the result sequence. + The query specified in the server's native query language. + + A to observe while waiting for the task to complete. + + + The parameter values to use for the query. If output parameters are used, their values will not be + available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + A task that represents the asynchronous operation. + The task result contains an enumeration of objects of type . + + + + + Asynchronously executes a query directly against the data source and returns a sequence of typed results. + The query is specified using the server's native query language, such as SQL. + Results are not tracked by the context, use the overload that specifies an entity set name to track results. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The element type of the result sequence. + The query specified in the server's native query language. + The options for executing this query. + + The parameter values to use for the query. If output parameters are used, their values will not be + available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + A task that represents the asynchronous operation. + The task result contains an enumeration of objects of type . + + + + + Asynchronously executes a query directly against the data source and returns a sequence of typed results. + The query is specified using the server's native query language, such as SQL. + Results are not tracked by the context, use the overload that specifies an entity set name to track results. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The element type of the result sequence. + The query specified in the server's native query language. + The options for executing this query. + + A to observe while waiting for the task to complete. + + + The parameter values to use for the query. If output parameters are used, their values will not be + available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + A task that represents the asynchronous operation. + The task result contains an enumeration of objects of type . + + + + + Asynchronously executes a query directly against the data source and returns a sequence of typed results. + The query is specified using the server's native query language, such as SQL. + If an entity set name is specified, results are tracked by the context. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The element type of the result sequence. + The query specified in the server's native query language. + The entity set of the TResult type. If an entity set name is not provided, the results are not going to be tracked. + The options for executing this query. + + The parameter values to use for the query. If output parameters are used, their values will not be + available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + A task that represents the asynchronous operation. + The task result contains an enumeration of objects of type . + + + + + Asynchronously executes a query directly against the data source and returns a sequence of typed results. + The query is specified using the server's native query language, such as SQL. + If an entity set name is specified, results are tracked by the context. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.ExecuteStoreQueryAsync<Post>("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The element type of the result sequence. + The query specified in the server's native query language. + The entity set of the TResult type. If an entity set name is not provided, the results are not going to be tracked. + The options for executing this query. + + A to observe while waiting for the task to complete. + + + The parameter values to use for the query. If output parameters are used, their values will not be + available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + A task that represents the asynchronous operation. + The task result contains an enumeration of objects of type . + + + + + Translates a that contains rows of entity data to objects of the requested entity type. + + The entity type. + An enumeration of objects of type TResult . + + The that contains entity data to translate into entity objects. + + When reader is null. + + + + Translates a that contains rows of entity data to objects of the requested entity type, in a specific entity set, and with the specified merge option. + + The entity type. + An enumeration of objects of type TResult . + + The that contains entity data to translate into entity objects. + + The entity set of the TResult type. + + The to use when translated objects are added to the object context. The default is + + . + + When reader is null. + + When the supplied mergeOption is not a valid value. + + When the supplied entitySetName is not a valid entity set for the TResult type. + + + + Creates the database by using the current data source connection and the metadata in the + + . + + + + Deletes the database that is specified as the database in the current data source connection. + + + + Checks if the database that is specified as the database in the current store connection exists on the store. Most of the actual work + is done by the DbProviderServices implementation for the current store connection. + + true if the database exists; otherwise, false. + + + + Generates a data definition language (DDL) script that creates schema objects (tables, primary keys, foreign keys) for the metadata in the + + . The + + loads metadata from store schema definition language (SSDL) files. + + + A DDL script that creates schema objects for the metadata in the + + . + + + + Gets the connection used by the object context. + + A object that is the connection. + + + When the instance has been disposed. + + + + Gets or sets the default container name. + + A that is the default container name. + + + + Gets the metadata workspace used by the object context. + + The object associated with this + + . + + + + Gets the object state manager used by the object context to track object changes. + + The used by this + + . + + + + Gets or sets the timeout value, in seconds, for all object context operations. A null value indicates that the default value of the underlying provider will be used. + + An value that is the timeout value, in seconds. + + The timeout value is less than 0. + + + Gets the LINQ query provider associated with this object context. + + The instance used by this object context. + + + + + Gets the instance that contains options that affect the behavior of the + + . + + + The instance that contains options that affect the behavior of the + + . + + + + + Returns itself. ObjectContext implements to provide a common + interface for and ObjectContext both of which will return the underlying + ObjectContext. + + + + + Gets the transaction handler in use by this context. May be null if no transaction have been started. + + + The transaction handler. + + + + + Returns the being used for this context. + + + + Occurs when changes are saved to the data source. + + + Occurs when a new entity object is created from data in the data source as part of a query or load operation. + + + + Defines options that affect the behavior of the ObjectContext. + + + + + Gets or sets the value that determines whether SQL functions and commands should be always executed in a transaction. + + + This flag determines whether a new transaction will be started when methods such as + and are executed outside of a transaction. + Note that this does not change the behavior of . + + + The default transactional behavior. + + + + Gets or sets a Boolean value that determines whether related objects are loaded automatically when a navigation property is accessed. + true if lazy loading is enabled; otherwise, false. + + + Gets or sets a Boolean value that determines whether proxy instances are created for custom data classes that are persistence ignorant. + true if proxies are created; otherwise, false. The default value is true. + + + Gets or sets a Boolean value that determines whether to use the legacy PreserveChanges behavior. + true if the legacy PreserveChanges behavior should be used; otherwise, false. + + + Gets or sets a Boolean value that determines whether to use the consistent NullReference behavior. + + If this flag is set to false then setting the Value property of the for an + FK relationship to null when it is already null will have no effect. When this flag is set to true, then + setting the value to null will always cause the FK to be nulled and the relationship to be deleted + even if the value is currently null. The default value is false when using ObjectContext and true + when using DbContext. + + true if the consistent NullReference behavior should be used; otherwise, false. + + + Gets or sets a Boolean value that determines whether to use the C# NullComparison behavior. + + This flag determines whether C# behavior should be exhibited when comparing null values in LinqToEntities. + If this flag is set, then any equality comparison between two operands, both of which are potentially + nullable, will be rewritten to show C# null comparison semantics. As an example: + (operand1 = operand2) will be rewritten as + (((operand1 = operand2) AND NOT (operand1 IS NULL OR operand2 IS NULL)) || (operand1 IS NULL && operand2 IS NULL)) + The default value is false when using . + + true if the C# NullComparison behavior should be used; otherwise, false. + + + + EventArgs for the ObjectMaterialized event. + + + + Gets the entity object that was created. + The entity object that was created. + + + + Delegate for the ObjectMaterialized event. + + The ObjectContext responsable for materializing the object. + EventArgs containing a reference to the materialized object. + + + + This class represents a query parameter at the object layer, which consists + of a Name, a Type and a Value. + + + + + Initializes a new instance of the class with the specified name and type. + + The parameter name. This name should not include the "@" parameter marker that is used in the Entity SQL statements, only the actual name. The first character of the expression must be a letter. Any successive characters in the expression must be either letters, numbers, or an underscore (_) character. + The common language runtime (CLR) type of the parameter. + If the value of either argument is null. + If the value of the name argument is invalid. Parameter names must start with a letter and can only contain letters, numbers, and underscores. + + + + Initializes a new instance of the class with the specified name and value. + + The parameter name. This name should not include the "@" parameter marker that is used in Entity SQL statements, only the actual name. The first character of the expression must be a letter. Any successive characters in the expression must be either letters, numbers, or an underscore (_) character. + The initial value (and inherently, the type) of the parameter. + If the value of either argument is null. + If the value of the name argument is not valid. Parameter names must start with a letter and can only contain letters, numbers, and underscores. + + + Gets the parameter name, which can only be set through a constructor. + The parameter name, which can only be set through a constructor. + + + Gets the parameter type. + + The of the parameter. + + + + Gets or sets the parameter value. + The parameter value. + + + + This class represents a collection of query parameters at the object layer. + + + + + Adds the specified to the collection. + + The parameter to add to the collection. + The parameter argument is null. + + The parameter argument already exists in the collection. This behavior differs from that of most collections that allow duplicate entries. -or-Another parameter with the same name as the parameter argument already exists in the collection. Note that the lookup is case-insensitive. This behavior differs from that of most collections, and is more like that of a + + . + + The type of the parameter is not valid. + + + + Deletes all instances from the collection. + + + + + Checks for the existence of a specified in the collection by reference. + + Returns true if the parameter object was found in the collection; otherwise, false. + + The to find in the collection. + + The parameter argument is null. + + + + Determines whether an with the specified name is in the collection. + + Returns true if a parameter with the specified name was found in the collection; otherwise, false. + The name of the parameter to look for in the collection. This name should not include the "@" parameter marker that is used in the Entity SQL statements, only the actual name. + The name parameter is null. + + + Allows the parameters in the collection to be copied into a supplied array, starting with the object at the specified index. + The array into which to copy the parameters. + The index in the array at which to start copying the parameters. + + + + Removes an instance of an from the collection by reference if it exists in the collection. + + Returns true if the parameter object was found and removed from the collection; otherwise, false. + An object to remove from the collection. + The parameter argument is null. + + + + These methods return enumerator instances, which allow the collection to + be iterated through and traversed. + + An object that can be used to iterate through the collection. + + + Returns an untyped enumerator over the collection. + + An instance. + + + + Gets the number of parameters currently in the collection. + + The number of objects that are currently in the collection. + + + + + This collection is read-write - parameters may be added, removed + and [somewhat] modified at will (value only) - provided that the + implementation the collection belongs to has not locked its parameters + because it's command definition has been prepared. + + + + Provides an indexer that allows callers to retrieve parameters by name. + + The instance. + + The name of the parameter to find. This name should not include the "@" parameter marker that is used in the Entity SQL statements, only the actual name. + No parameter with the specified name is found in the collection. + + + + This class implements untyped queries at the object-layer. + + + + Returns the commands to execute against the data source. + A string that represents the commands that the query executes against the data source. + + + Returns information about the result type of the query. + + A value that contains information about the result type of the query. + + + + Executes the untyped object query with the specified merge option. + + The to use when executing the query. + The default is . + + + An that contains a collection of entity objects returned by the query. + + + + + Asynchronously executes the untyped object query with the specified merge option. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The to use when executing the query. + The default is . + + + A task that represents the asynchronous operation. + The task result contains an an + that contains a collection of entity objects returned by the query. + + + + + Asynchronously executes the untyped object query with the specified merge option. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The to use when executing the query. + The default is . + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains an an + that contains a collection of entity objects returned by the query. + + + + + Returns the collection as an used for data binding. + + + An of entity objects. + + + + Returns an enumerator that iterates through a collection. + + An that can be used to iterate through the collection. + + + + + Returns an which when enumerated will execute the given SQL query against the database. + + The query results. + + + Returns the command text for the query. + A string value. + + + Gets the object context associated with this object query. + + The associated with this + + instance. + + + + Gets or sets how objects returned from a query are added to the object context. + + The query . + + + + + Whether the query is streaming or buffering + + + + Gets the parameter collection for this object query. + + The parameter collection for this . + + + + Gets or sets a value that indicates whether the query plan should be cached. + A value that indicates whether the query plan should be cached. + + + + Gets the result element type for this query instance. + + + + + Gets the expression describing this query. For queries built using + LINQ builder patterns, returns a full LINQ expression tree; otherwise, + returns a constant expression wrapping this query. Note that the + default expression is not cached. This allows us to differentiate + between LINQ and Entity-SQL queries. + + + + + Gets the associated with this query instance. + + + + + ObjectQuery implements strongly-typed queries at the object-layer. + Queries are specified using Entity-SQL strings and may be created by calling + the Entity-SQL-based query builder methods declared by ObjectQuery. + + The result type of this ObjectQuery + + + + Creates a new instance using the specified Entity SQL command as the initial query. + + The Entity SQL query. + + The on which to execute the query. + + + + + Creates a new instance using the specified Entity SQL command as the initial query and the specified merge option. + + The Entity SQL query. + + The on which to execute the query. + + + Specifies how the entities that are retrieved through this query should be merged with the entities that have been returned from previous queries against the same + + . + + + + Executes the object query with the specified merge option. + + The to use when executing the query. + The default is . + + + An that contains a collection of entity objects returned by the query. + + + + + Asynchronously executes the object query with the specified merge option. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The to use when executing the query. + The default is . + + + A task that represents the asynchronous operation. + The task result contains an + that contains a collection of entity objects returned by the query. + + + + + Asynchronously executes the object query with the specified merge option. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + The to use when executing the query. + The default is . + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains an + that contains a collection of entity objects returned by the query. + + + + Specifies the related objects to include in the query results. + + A new with the defined query path. + + Dot-separated list of related objects to return in the query results. + path is null. + path is empty. + + + Limits the query to unique results. + + A new instance that is equivalent to the original instance with SELECT DISTINCT applied. + + + + + This query-builder method creates a new query whose results are all of + the results of this query, except those that are also part of the other + query specified. + + A query representing the results to exclude. + a new ObjectQuery instance. + If the query parameter is null. + + + Groups the query results by the specified criteria. + + A new instance of type + + that is equivalent to the original instance with GROUP BY applied. + + The key columns by which to group the results. + The list of selected properties that defines the projection. + Zero or more parameters that are used in this method. + The query parameter is null or an empty string + or the projection parameter is null or an empty string. + + + + This query-builder method creates a new query whose results are those that + are both in this query and the other query specified. + + A query representing the results to intersect with. + a new ObjectQuery instance. + If the query parameter is null. + + + Limits the query to only results of a specific type. + + A new instance that is equivalent to the original instance with OFTYPE applied. + + + The type of the returned when the query is executed with the applied filter. + + The type specified is not valid. + + + Orders the query results by the specified criteria. + + A new instance that is equivalent to the original instance with ORDER BY applied. + + The key columns by which to order the results. + Zero or more parameters that are used in this method. + The keys or parameters parameter is null. + The key is an empty string. + + + Limits the query results to only the properties that are defined in the specified projection. + + A new instance of type + + that is equivalent to the original instance with SELECT applied. + + The list of selected properties that defines the projection. + Zero or more parameters that are used in this method. + projection is null or parameters is null. + The projection is an empty string. + + + Limits the query results to only the property specified in the projection. + + A new instance of a type compatible with the specific projection. The returned + + is equivalent to the original instance with SELECT VALUE applied. + + The projection list. + An optional set of query parameters that should be in scope when parsing. + + The type of the returned by the + + method. + + projection is null or parameters is null. + The projection is an empty string. + + + Orders the query results by the specified criteria and skips a specified number of results. + + A new instance that is equivalent to the original instance with both ORDER BY and SKIP applied. + + The key columns by which to order the results. + The number of results to skip. This must be either a constant or a parameter reference. + An optional set of query parameters that should be in scope when parsing. + Any argument is null. + keys is an empty string or count is an empty string. + + + Limits the query results to a specified number of items. + + A new instance that is equivalent to the original instance with TOP applied. + + The number of items in the results as a string. + An optional set of query parameters that should be in scope when parsing. + count is null. + count is an empty string. + + + + This query-builder method creates a new query whose results are all of + the results of this query, plus all of the results of the other query, + without duplicates (i.e., results are unique). + + A query representing the results to add. + a new ObjectQuery instance. + If the query parameter is null. + + + + This query-builder method creates a new query whose results are all of + the results of this query, plus all of the results of the other query, + including any duplicates (i.e., results are not necessarily unique). + + A query representing the results to add. + a new ObjectQuery instance. + If the query parameter is null. + + + Limits the query to results that match specified filtering criteria. + + A new instance that is equivalent to the original instance with WHERE applied. + + The filter predicate. + Zero or more parameters that are used in this method. + predicate is null or parameters is null. + The predicate is an empty string. + + + + Returns an which when enumerated will execute the given SQL query against the database. + + The query results. + + + + Returns an which when enumerated will execute the given SQL query against the database. + + The query results. + + + Gets or sets the name of this object query. + + A string value that is the name of this . + + The value specified on set is not valid. + + + + This class implements IEnumerable and IDisposable. Instance of this class + is returned from ObjectQuery.Execute method. + + + + + This constructor is intended only for use when creating test doubles that will override members + with mocked or faked behavior. Use of this constructor for other purposes may result in unexpected + behavior including but not limited to throwing . + + + + + + + Returns an enumerator that iterates through the query results. + An enumerator that iterates through the query results. + + + Returns the results in a format useful for data binding. + + An of entity objects. + + + + Performs tasks associated with freeing, releasing, or resetting resources. + + + Releases the resources used by the object result. + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + Gets the next result set of a stored procedure. + An ObjectResult that enumerates the values of the next result set. Null, if there are no more, or if the ObjectResult is not the result of a stored procedure call. + The type of the element. + + + + IListSource.ContainsListCollection implementation. Always returns false. + + + + + When overridden in a derived class, gets the type of the generic + + . + + + The type of the generic . + + + + + This class represents the result of the method. + + The type of the result. + + + + This constructor is intended only for use when creating test doubles that will override members + with mocked or faked behavior. Use of this constructor for other purposes may result in unexpected + behavior including but not limited to throwing . + + + + Returns an enumerator that iterates through the query results. + An enumerator that iterates through the query results. + + + + + + Releases the unmanaged resources used by the and optionally releases the managed resources. + true to release managed and unmanaged resources; false to release only unmanaged resources. + + + + Gets the type of the . + + + A that is the type of the . + + + + + Represents a typed entity set that is used to perform create, read, update, and delete operations. + + The type of the entity. + + + Adds an object to the object context in the current entity set. + The object to add. + + + Attaches an object or object graph to the object context in the current entity set. + The object to attach. + + + Marks an object for deletion. + + An object that represents the entity to delete. The object can be in any state except + + . + + + + Removes the object from the object context. + + Object to be detached. Only the entity is removed; if there are any related objects that are being tracked by the same + + , those will not be detached automatically. + + + + + Copies the scalar values from the supplied object into the object in the + + that has the same key. + + The updated object. + + The detached object that has property updates to apply to the original object. The entity key of currentEntity must match the + + property of an entry in the + + . + + + + + Sets the property of an + + to match the property values of a supplied object. + + The updated object. + + The detached object that has property updates to apply to the original object. The entity key of originalEntity must match the + + property of an entry in the + + . + + + + Creates a new entity type object. + The new entity type object, or an instance of a proxy type that corresponds to the entity type. + + + Creates an instance of the specified type. + An instance of the requested type T , or an instance of a proxy type that corresponds to the type T . + Type of object to be returned. + + + + Gets the metadata of the entity set represented by this instance. + + + An object. + + + + + The original values of the properties of an entity when it was retrieved from the database. + + + + + Maintains object state and identity management for entity type instances and relationship instances. + + + + + Initializes a new instance of the class. + + + The , which supplies mapping and metadata information. + + + + + Returns a collection of objects for objects or relationships with the given state. + + + A collection of objects in the given + + . + + + An used to filter the returned + + objects. + + + When state is . + + + + + Changes state of the for a specific object to the specified entityState . + + + The for the supplied entity . + + The object for which the state must be changed. + The new state of the object. + When entity is null. + + When the object is not detached and does not have an entry in the state manager + or when you try to change the state to + from any other + or when state is not a valid value. + + + + Changes the state of the relationship between two entity objects that is specified based on the two related objects and the name of the navigation property. + + The for the relationship that was changed. + + + The object instance or of the source entity at one end of the relationship. + + + The object instance or of the target entity at the other end of the relationship. + + The name of the navigation property on source that returns the specified target . + + The requested of the specified relationship. + + When source or target is null. + + When trying to change the state of the relationship to a state other than + or + when either source or target is in a state + or when you try to change the state of the relationship to a state other than + or + when either source or target is in an state + or when state is not a valid value + + + + Changes the state of the relationship between two entity objects that is specified based on the two related objects and a LINQ expression that defines the navigation property. + + The for the relationship that was changed. + + + The object instance or of the source entity at one end of the relationship. + + + The object instance or of the target entity at the other end of the relationship. + + A LINQ expression that selects the navigation property on source that returns the specified target . + + The requested of the specified relationship. + + The entity type of the source object. + When source , target , or selector is null. + selector is malformed or cannot return a navigation property. + + When you try to change the state of the relationship to a state other than + or + when either source or target is in a + state + or when you try to change the state of the relationship to a state other than + or + when either source or target is in an state + or when state is not a valid value. + + + + Changes the state of the relationship between two entity objects that is specified based on the two related objects and the properties of the relationship. + + The for the relationship that was changed. + + + The object instance or of the source entity at one end of the relationship. + + + The object instance or of the target entity at the other end of the relationship. + + The name of the relationship. + The role name at the target end of the relationship. + + The requested of the specified relationship. + + When source or target is null. + + When you try to change the state of the relationship to a state other than + or + when either source or target is in a state + or when you try to change the state of the relationship to a state other than + or + when either source or target is in an + state + or when state is not a valid value. + + + + + Returns an for the object or relationship entry with the specified key. + + + The corresponding for the given + + . + + + The . + + When key is null. + When the specified key cannot be found in the state manager. + + No entity with the specified exists in the + + . + + + + + Returns an for the specified object. + + + The corresponding for the given + + . + + + The to which the retrieved + + belongs. + + + No entity for the specified exists in the + + . + + + + + Tries to retrieve the corresponding for the specified + + . + + + A Boolean value that is true if there is a corresponding + + for the given object; otherwise, false. + + + The to which the retrieved + + belongs. + + + When this method returns, contains the for the given + + This parameter is passed uninitialized. + + + + + Tries to retrieve the corresponding for the object or relationship with the specified + + . + + + A Boolean value that is true if there is a corresponding + + for the given + + ; otherwise, false. + + + The given . + + + When this method returns, contains an for the given + + This parameter is passed uninitialized. + + A null (Nothing in Visual Basic) value is provided for key . + + + + Returns the that is used by the specified object. + + + The for the specified object. + + + The object for which to return the . + + + The entity does not implement IEntityWithRelationships and is not tracked by this ObjectStateManager + + + + + Returns the that is used by the specified object. + + + true if a instance was returned for the supplied entity ; otherwise false. + + + The object for which to return the . + + + When this method returns, contains the + + for the entity . + + + + + Gets the associated with this state manager. + + + The associated with this + + . + + + + Occurs when entities are added to or removed from the state manager. + + + + A DataContractResolver that knows how to resolve proxy types created for persistent + ignorant classes to their base types. This is used with the DataContractSerializer. + + + + During deserialization, maps any xsi:type information to the actual type of the persistence-ignorant object. + Returns the type that the xsi:type is mapped to. Returns null if no known type was found that matches the xsi:type. + The xsi:type information to map. + The namespace of the xsi:type. + The declared type. + + An instance of . + + + + During serialization, maps actual types to xsi:type information. + true if the type was resolved; otherwise, false. + The actual type of the persistence-ignorant object. + The declared type. + + An instance of . + + When this method returns, contains a list of xsi:type declarations. + When this method returns, contains a list of namespaces used. + + + + Defines the different ways to handle modified properties when refreshing in-memory data from the database. + + + + + For unmodified client objects, same behavior as StoreWins. For modified client + objects, Refresh original values with store value, keeping all values on client + object. The next time an update happens, all the client change units will be + considered modified and require updating. + + + + + Discard all changes on the client and refresh values with store values. + Client original values is updated to match the store. + + + + + Flags used to modify behavior of ObjectContext.SaveChanges() + + + + + Changes are saved without the DetectChanges or the AcceptAllChangesAfterSave methods being called. + + + + + After changes are saved, the AcceptAllChangesAfterSave method is called, which resets change tracking in the ObjectStateManager. + + + + + Before changes are saved, the DetectChanges method is called to synchronize the property values of objects that are attached to the object context with data in the ObjectStateManager. + + + + + This exception is thrown when a update operation violates the concurrency constraint. + + + + + Exception during save changes to store + + + + + Initializes a new instance of . + + + + + Initializes a new instance of with a specialized error message. + + The message that describes the error. + + + + Initializes a new instance of the class that uses a specified error message and a reference to the inner exception that is the cause of this exception. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Initializes a new instance of the class that uses a specified error message, a reference to the inner exception, and an enumerable collection of + + objects. + + The error message that explains the reason for the exception. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + The collection of objects. + + + + + Initializes a new instance of with serialized data. + + + The that holds the serialized object data about the exception being thrown. + + + The that contains contextual information about the source or destination. + + + + + Gets the objects for this + + . + + + A collection of objects comprised of either a single entity and 0 or more relationships, or 0 entities and 1 or more relationships. + + + + + Initializes a new instance of . + + + + + Initializes a new instance of with a specialized error message. + + The message that describes the error. + + + + Initializes a new instance of that uses a specified error message and a reference to the inner exception. + + The message that describes the error. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Initializes a new instance of that uses a specified error message, a reference to the inner exception, and an enumerable collection of + + objects. + + The message that describes the error. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + The enumerable collection of objects. + + + + + Property constraint exception class. Note that this class has state - so if you change even + its internals, it can be a breaking change + + + + + Initializes a new instance of the class with default message. + + + + + Initializes a new instance of the class with supplied message. + + A localized error message. + + + + Initializes a new instance of the class with supplied message and inner exception. + + A localized error message. + The inner exception. + + + + Initializes a new instance of the class. + + A localized error message. + The name of the property. + + + + Initializes a new instance of the class. + + A localized error message. + The name of the property. + The inner exception. + + + Gets the name of the property that violated the constraint. + The name of the property that violated the constraint. + + + + This exception is thrown when the store provider exhibits a behavior incompatible with the entity client provider + + + + + Initializes a new instance of . + + + + + Initializes a new instance of with a specialized error message. + + The message that describes the error. + + + + Initializes a new instance of that uses a specified error message. + + The message that describes the error. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Provides common language runtime (CLR) methods that expose EDM canonical functions + for use in or LINQ to Entities queries. + + + Note that this class was called EntityFunctions in some previous versions of Entity Framework. + + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDev EDM function to calculate + the standard deviation of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical StDevP EDM function to calculate + the standard deviation for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The standard deviation for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Var EDM function to calculate + the variance of the collection. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical VarP EDM function to calculate + the variance for the population. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The collection over which to perform the calculation. + The variance for the population. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Left EDM function to return a given + number of the leftmost characters in a string. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input string. + The number of characters to return + A string containing the number of characters asked for from the left of the input string. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Right EDM function to return a given + number of the rightmost characters in a string. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input string. + The number of characters to return + A string containing the number of characters asked for from the right of the input string. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Reverse EDM function to return a given + string with the order of the characters reversed. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input string. + The input string with the order of the characters reversed. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical GetTotalOffsetMinutes EDM function to + return the number of minutes that the given date/time is offset from UTC. This is generally between +780 + and -780 (+ or - 13 hrs). + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The date/time value to use. + The offset of the input from UTC. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical TruncateTime EDM function to return + the given date with the time portion cleared. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The date/time value to use. + The input date with the time portion cleared. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical TruncateTime EDM function to return + the given date with the time portion cleared. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The date/time value to use. + The input date with the time portion cleared. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical CreateDateTime EDM function to + create a new object. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The year. + The month (1-based). + The day (1-based). + The hours. + The minutes. + The seconds, including fractional parts of the seconds if desired. + The new date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical CreateDateTimeOffset EDM function to + create a new object. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The year. + The month (1-based). + The day (1-based). + The hours. + The minutes. + The seconds, including fractional parts of the seconds if desired. + The time zone offset part of the new date. + The new date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical CreateTime EDM function to + create a new object. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The hours. + The minutes. + The seconds, including fractional parts of the seconds if desired. + The new time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddYears EDM function to + add the given number of years to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of years to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddYears EDM function to + add the given number of years to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of years to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMonths EDM function to + add the given number of months to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of months to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMonths EDM function to + add the given number of months to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of months to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddDays EDM function to + add the given number of days to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of days to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddDays EDM function to + add the given number of days to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of days to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddHours EDM function to + add the given number of hours to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of hours to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddHours EDM function to + add the given number of hours to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of hours to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddHours EDM function to + add the given number of hours to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of hours to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMinutes EDM function to + add the given number of minutes to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of minutes to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMinutes EDM function to + add the given number of minutes to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of minutes to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMinutes EDM function to + add the given number of minutes to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of minutes to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddSeconds EDM function to + add the given number of seconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of seconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddSeconds EDM function to + add the given number of seconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of seconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddSeconds EDM function to + add the given number of seconds to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of seconds to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMilliseconds EDM function to + add the given number of milliseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of milliseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMilliseconds EDM function to + add the given number of milliseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of milliseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMilliseconds EDM function to + add the given number of milliseconds to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of milliseconds to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMicroseconds EDM function to + add the given number of microseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of microseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMicroseconds EDM function to + add the given number of microseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of microseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddMicroseconds EDM function to + add the given number of microseconds to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of microseconds to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddNanoseconds EDM function to + add the given number of nanoseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of nanoseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddNanoseconds EDM function to + add the given number of nanoseconds to a date/time. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of nanoseconds to add. + A resulting date/time. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical AddNanoseconds EDM function to + add the given number of nanoseconds to a time span. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The input date/time. + The number of nanoseconds to add. + A resulting time span. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffYears EDM function to + calculate the number of years between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of years between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffYears EDM function to + calculate the number of years between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of years between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMonths EDM function to + calculate the number of months between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of months between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMonths EDM function to + calculate the number of months between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of months between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffDays EDM function to + calculate the number of days between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of days between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffDays EDM function to + calculate the number of days between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of days between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffHours EDM function to + calculate the number of hours between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of hours between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffHours EDM function to + calculate the number of hours between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of hours between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffHours EDM function to + calculate the number of hours between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of hours between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMinutes EDM function to + calculate the number of minutes between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of minutes between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMinutes EDM function to + calculate the number of minutes between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of minutes between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMinutes EDM function to + calculate the number of minutes between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of minutes between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffSeconds EDM function to + calculate the number of seconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of seconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffSeconds EDM function to + calculate the number of seconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of seconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffSeconds EDM function to + calculate the number of seconds between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of seconds between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMilliseconds EDM function to + calculate the number of milliseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of milliseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMilliseconds EDM function to + calculate the number of milliseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of milliseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMilliseconds EDM function to + calculate the number of milliseconds between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of milliseconds between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMicroseconds EDM function to + calculate the number of microseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of microseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMicroseconds EDM function to + calculate the number of microseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of microseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffMicroseconds EDM function to + calculate the number of microseconds between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of microseconds between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffNanoseconds EDM function to + calculate the number of nanoseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of nanoseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffNanoseconds EDM function to + calculate the number of nanoseconds between two date/times. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first date/time. + The second date/time. + The number of nanoseconds between the first and second date/times. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical DiffNanoseconds EDM function to + calculate the number of nanoseconds between two time spans. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The first time span. + The second time span. + The number of nanoseconds between the first and second time spans. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Truncate EDM function to + truncate the given value to the number of specified digits. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The value to truncate. + The number of digits to preserve. + The truncated value. + + + + When used as part of a LINQ to Entities query, this method invokes the canonical Truncate EDM function to + truncate the given value to the number of specified digits. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function is translated to a corresponding function in the database. + + The value to truncate. + The number of digits to preserve. + The truncated value. + + + + When used as part of a LINQ to Entities query, this method acts as an operator that ensures the input + is treated as a Unicode string. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function impacts the way the LINQ query is translated to a query that can be run in the database. + + The input string. + The input string treated as a Unicode string. + + + + When used as part of a LINQ to Entities query, this method acts as an operator that ensures the input + is treated as a non-Unicode string. + + + You cannot call this function directly. This function can only appear within a LINQ to Entities query. + This function impacts the way the LINQ query is translated to a query that can be run in the database. + + The input string. + The input string treated as a non-Unicode string. + + + + Describes the state of an entity. + + + + + The entity is not being tracked by the context. + An entity is in this state immediately after it has been created with the new operator + or with one of the Create methods. + + + + + The entity is being tracked by the context and exists in the database, and its property + values have not changed from the values in the database. + + + + + The entity is being tracked by the context but does not yet exist in the database. + + + + + The entity is being tracked by the context and exists in the database, but has been marked + for deletion from the database the next time SaveChanges is called. + + + + + The entity is being tracked by the context and exists in the database, and some or all of its + property values have been modified. + + + + + Represents information about a database connection. + + + + + Creates a new instance of DbConnectionInfo representing a connection that is specified in the application configuration file. + + The name of the connection string in the application configuration. + + + + Creates a new instance of DbConnectionInfo based on a connection string. + + The connection string to use for the connection. + The name of the provider to use for the connection. Use 'System.Data.SqlClient' for SQL Server. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Instances of this class are used to create DbConnection objects for + SQL Server LocalDb based on a given database name or connection string. + + + An instance of this class can be set on the class or in the + app.config/web.config for the application to cause all DbContexts created with no + connection information or just a database name to use SQL Server LocalDb by default. + This class is immutable since multiple threads may access instances simultaneously + when creating connections. + + + + + Implementations of this interface are used to create DbConnection objects for + a type of database server based on a given database name. + An Instance is set on the class to + cause all DbContexts created with no connection information or just a database + name or connection string to use a certain type of database server by default. + Two implementations of this interface are provided: + is used to create connections to Microsoft SQL Server, including EXPRESS editions. + is used to create connections to Microsoft SQL + Server Compact Editions. + Other implementations for other database servers can be added as needed. + Note that implementations should be thread safe or immutable since they may + be accessed by multiple threads at the same time. + + + + + Creates a connection based on the given database name or connection string. + + The database name or connection string. + An initialized DbConnection. + + + + Creates a new instance of the connection factory for the given version of LocalDb. + For SQL Server 2012 LocalDb use "v11.0". + For SQL Server 2014 and later LocalDb use "mssqllocaldb". + + The LocalDb version to use. + + + + Creates a new instance of the connection factory for the given version of LocalDb. + For SQL Server 2012 LocalDb use "v11.0". + For SQL Server 2014 and later LocalDb use "mssqllocaldb". + + The LocalDb version to use. + The connection string to use for options to the database other than the 'Initial Catalog', 'Data Source', and 'AttachDbFilename'. The 'Initial Catalog' and 'AttachDbFilename' will be prepended to this string based on the database name when CreateConnection is called. The 'Data Source' will be set based on the LocalDbVersion argument. + + + + Creates a connection for SQL Server LocalDb based on the given database name or connection string. + If the given string contains an '=' character then it is treated as a full connection string, + otherwise it is treated as a database name only. + + The database name or connection string. + An initialized DbConnection. + + + + The connection string to use for options to the database other than the 'Initial Catalog', + 'Data Source', and 'AttachDbFilename'. + The 'Initial Catalog' and 'AttachDbFilename' will be prepended to this string based on the + database name when CreateConnection is called. + The 'Data Source' will be set based on the LocalDbVersion argument. + The default is 'Integrated Security=True;'. + + + + + An implementation of that will use Code First Migrations + to update the database to the latest version. + + The type of the context. + The type of the migrations configuration to use during initialization. + + + + Initializes a new instance of the MigrateDatabaseToLatestVersion class that will use + the connection information from a context constructed using the default constructor + or registered factory if applicable + + + + + Initializes a new instance of the MigrateDatabaseToLatestVersion class specifying whether to + use the connection information from the context that triggered initialization to perform the migration. + + + If set to true the initializer is run using the connection information from the context that + triggered initialization. Otherwise, the connection information will be taken from a context constructed + using the default constructor or registered factory if applicable. + + + + + Initializes a new instance of the MigrateDatabaseToLatestVersion class specifying whether to + use the connection information from the context that triggered initialization to perform the migration. + Also allows specifying migrations configuration to use during initialization. + + + If set to true the initializer is run using the connection information from the context that + triggered initialization. Otherwise, the connection information will be taken from a context constructed + using the default constructor or registered factory if applicable. + + Migrations configuration to use during initialization. + + + + Initializes a new instance of the MigrateDatabaseToLatestVersion class that will + use a specific connection string from the configuration file to connect to + the database to perform the migration. + + The name of the connection string to use for migration. + + + + + + + Helper class that is used to configure a column. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Creates a new column definition to store Binary data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + The maximum allowable length of the array data. + Value indicating whether or not all data should be padded to the maximum length. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + Value indicating whether or not this column should be configured as a timestamp. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store Boolean data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store Byte data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + Value indicating whether or not the database will generate values for this column during insert. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store DateTime data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + The precision of the column. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store Decimal data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + The numeric precision of the column. + The numeric scale of the column. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Value indicating whether or not the database will generate values for this column during insert. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store Double data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store GUID data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + Value indicating whether or not the database will generate values for this column during insert. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store Single data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store Short data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + Value indicating whether or not the database will generate values for this column during insert. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store Integer data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + Value indicating whether or not the database will generate values for this column during insert. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store Long data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + Value indicating whether or not the database will generate values for this column during insert. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store String data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + The maximum allowable length of the string data. + Value indicating whether or not all data should be padded to the maximum length. + Value indicating whether or not the column supports Unicode content. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store Time data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + The precision of the column. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store DateTimeOffset data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + The precision of the column. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store geography data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + Creates a new column definition to store geometry data. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Value indicating whether or not the column allows null values. + Constant value to use as the default value for this column. + SQL expression used as the default value for this column. + The name of the column. + Provider specific data type to use for this column. + Custom annotations usually from the Code First model. + The newly constructed column definition. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Creates a shallow copy of the current . + + A shallow copy of the current . + + + + Helper class that is used to further configure a table being created from a CreateTable call on + + . + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The type that represents the table's columns. + + + + Initializes a new instance of the TableBuilder class. + + The table creation operation to be further configured. + The migration the table is created in. + + + + Specifies a primary key for the table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + A lambda expression representing the property to be used as the primary key. C#: t => t.Id VB.Net: Function(t) t.Id If the primary key is made up of multiple properties then specify an anonymous type including the properties. C#: t => new { t.Id1, t.Id2 } VB.Net: Function(t) New With { t.Id1, t.Id2 } + The name of the primary key. If null is supplied, a default name will be generated. + A value indicating whether or not this is a clustered primary key. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + Itself, so that multiple calls can be chained. + + + + Specifies an index to be created on the table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + A lambda expression representing the property to be indexed. C#: t => t.PropertyOne VB.Net: Function(t) t.PropertyOne If multiple properties are to be indexed then specify an anonymous type including the properties. C#: t => new { t.PropertyOne, t.PropertyTwo } VB.Net: Function(t) New With { t.PropertyOne, t.PropertyTwo } + The name of the index. + A value indicating whether or not this is a unique index. + A value indicating whether or not this is a clustered index. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + Itself, so that multiple calls can be chained. + + + + Specifies a foreign key constraint to be created on the table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Name of the table that the foreign key constraint targets. + A lambda expression representing the properties of the foreign key. C#: t => t.PropertyOne VB.Net: Function(t) t.PropertyOne If multiple properties make up the foreign key then specify an anonymous type including the properties. C#: t => new { t.PropertyOne, t.PropertyTwo } VB.Net: Function(t) New With { t.PropertyOne, t.PropertyTwo } + A value indicating whether or not cascade delete should be configured on the foreign key constraint. + The name of this foreign key constraint. If no name is supplied, a default name will be calculated. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + Itself, so that multiple calls can be chained. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Creates a shallow copy of the current . + + A shallow copy of the current . + + + + Base class for code-based migrations. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Operations to be performed during the upgrade process. + + + + + Operations to be performed during the downgrade process. + + + + + Adds an operation to create a new stored procedure. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the stored procedure. Schema name is optional, if no schema is specified then dbo is + assumed. + + The body of the stored procedure. + + The additional arguments that may be processed by providers. Use anonymous type syntax + to specify arguments. For example, 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to create a new stored procedure. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the stored procedure. Schema name is optional, if no schema is specified then dbo is + assumed. + + The action that specifies the parameters of the stored procedure. + The body of the stored procedure. + + The additional arguments that may be processed by providers. Use anonymous type syntax + to specify arguments. For example, 'new { SampleArgument = "MyValue" }'. + + + The parameters in this create stored procedure operation. You do not need to specify this + type, it will be inferred from the parameter you supply. + + + + + Adds an operation to alter a stored procedure. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the stored procedure. Schema name is optional, if no schema is specified then dbo is + assumed. + + The body of the stored procedure. + + The additional arguments that may be processed by providers. Use anonymous type syntax + to specify arguments. For example, 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to alter a stored procedure. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The parameters in this alter stored procedure operation. You do not need to specify this + type, it will be inferred from the parameter you supply. + + + The name of the stored procedure. Schema name is optional, if no schema is specified then dbo is + assumed. + + The action that specifies the parameters of the stored procedure. + The body of the stored procedure. + + The additional arguments that may be processed by providers. Use anonymous type syntax + to specify arguments. For example, 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop an existing stored procedure with the specified name. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the procedure to drop. Schema name is optional, if no schema is specified then dbo is + assumed. + + + The additional arguments that may be processed by providers. Use anonymous type syntax + to specify arguments. For example, 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to create a new table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The columns in this create table operation. You do not need to specify this type, it will + be inferred from the columnsAction parameter you supply. + + The name of the table. Schema name is optional, if no schema is specified then dbo is assumed. + + An action that specifies the columns to be included in the table. i.e. t => new { Id = + t.Int(identity: true), Name = t.String() } + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + An object that allows further configuration of the table creation operation. + + + + Adds an operation to create a new table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The columns in this create table operation. You do not need to specify this type, it will + be inferred from the columnsAction parameter you supply. + + The name of the table. Schema name is optional, if no schema is specified then dbo is assumed. + + An action that specifies the columns to be included in the table. i.e. t => new { Id = + t.Int(identity: true), Name = t.String() } + + Custom annotations that exist on the table to be created. May be null or empty. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + An object that allows further configuration of the table creation operation. + + + + Adds an operation to handle changes in the annotations defined on tables. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The columns in this operation. You do not need to specify this type, it will + be inferred from the columnsAction parameter you supply. + + The name of the table. Schema name is optional, if no schema is specified then dbo is assumed. + + An action that specifies the columns to be included in the table. i.e. t => new { Id = + t.Int(identity: true), Name = t.String() } + + The custom annotations on the table that have changed. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to create a new foreign key constraint. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The table that contains the foreign key column. Schema name is optional, if no schema is + specified then dbo is assumed. + + The foreign key column. + + The table that contains the column this foreign key references. Schema name is optional, + if no schema is specified then dbo is assumed. + + + The column this foreign key references. If no value is supplied the primary key of the + principal table will be referenced. + + + A value indicating if cascade delete should be configured for the foreign key + relationship. If no value is supplied, cascade delete will be off. + + + The name of the foreign key constraint in the database. If no value is supplied a unique name will + be generated. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to create a new foreign key constraint. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The table that contains the foreign key columns. Schema name is optional, if no schema is + specified then dbo is assumed. + + The foreign key columns. + + The table that contains the columns this foreign key references. Schema name is optional, + if no schema is specified then dbo is assumed. + + + The columns this foreign key references. If no value is supplied the primary key of the + principal table will be referenced. + + + A value indicating if cascade delete should be configured for the foreign key + relationship. If no value is supplied, cascade delete will be off. + + + The name of the foreign key constraint in the database. If no value is supplied a unique name will + be generated. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop a foreign key constraint based on its name. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The table that contains the foreign key column. Schema name is optional, if no schema is + specified then dbo is assumed. + + The name of the foreign key constraint in the database. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop a foreign key constraint based on the column it targets. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The table that contains the foreign key column. Schema name is optional, if no schema is + specified then dbo is assumed. + + The foreign key column. + + The table that contains the column this foreign key references. Schema name is optional, + if no schema is specified then dbo is assumed. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop a foreign key constraint based on the column it targets. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The table that contains the foreign key column. + Schema name is optional, if no schema is specified then dbo is assumed. + + The foreign key column. + + The table that contains the column this foreign key references. + Schema name is optional, if no schema is specified then dbo is assumed. + + The columns this foreign key references. + + Additional arguments that may be processed by providers. + Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop a foreign key constraint based on the columns it targets. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The table that contains the foreign key columns. Schema name is optional, if no schema is + specified then dbo is assumed. + + The foreign key columns. + + The table that contains the columns this foreign key references. Schema name is optional, + if no schema is specified then dbo is assumed. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop a table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to be dropped. Schema name is optional, if no schema is specified then dbo is + assumed. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop a table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to be dropped. Schema name is optional, if no schema is specified then dbo is + assumed. + + Custom annotations that exist on columns of the table that is being dropped. May be null or empty. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop a table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to be dropped. Schema name is optional, if no schema is specified then dbo is + assumed. + + Custom annotations that exist on the table that is being dropped. May be null or empty. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop a table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to be dropped. Schema name is optional, if no schema is specified then dbo is + assumed. + + Custom annotations that exist on the table that is being dropped. May be null or empty. + Custom annotations that exist on columns of the table that is being dropped. May be null or empty. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to move a table to a new schema. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to be moved. Schema name is optional, if no schema is specified then dbo is + assumed. + + The schema the table is to be moved to. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to move a stored procedure to a new schema. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the stored procedure to be moved. Schema name is optional, if no schema is specified + then dbo is assumed. + + The schema the stored procedure is to be moved to. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to rename a table. To change the schema of a table use MoveTable. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to be renamed. Schema name is optional, if no schema is specified then dbo is + assumed. + + + The new name for the table. Schema name is optional, if no schema is specified then dbo is + assumed. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to rename a stored procedure. To change the schema of a stored procedure use MoveStoredProcedure + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the stored procedure to be renamed. Schema name is optional, if no schema is specified + then dbo is assumed. + + + The new name for the stored procedure. Schema name is optional, if no schema is specified then + dbo is assumed. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to rename a column. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table that contains the column to be renamed. Schema name is optional, if no + schema is specified then dbo is assumed. + + The name of the column to be renamed. + The new name for the column. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to add a column to an existing table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to add the column to. Schema name is optional, if no schema is specified + then dbo is assumed. + + The name of the column to be added. + + An action that specifies the column to be added. i.e. c => c.Int(nullable: false, + defaultValue: 3) + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop an existing column. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to drop the column from. Schema name is optional, if no schema is specified + then dbo is assumed. + + The name of the column to be dropped. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop an existing column. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to drop the column from. Schema name is optional, if no schema is specified + then dbo is assumed. + + The name of the column to be dropped. + Custom annotations that exist on the column that is being dropped. May be null or empty. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to alter the definition of an existing column. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table the column exists in. Schema name is optional, if no schema is specified + then dbo is assumed. + + The name of the column to be changed. + + An action that specifies the new definition for the column. i.e. c => c.String(nullable: + false, defaultValue: "none") + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to create a new primary key. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The table that contains the primary key column. Schema name is optional, if no schema is specified + then dbo is assumed. + + The primary key column. + + The name of the primary key in the database. If no value is supplied a unique name will be + generated. + + A value indicating whether or not this is a clustered primary key. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to create a new primary key based on multiple columns. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The table that contains the primary key columns. Schema name is optional, if no schema is + specified then dbo is assumed. + + The primary key columns. + + The name of the primary key in the database. If no value is supplied a unique name will be + generated. + + A value indicating whether or not this is a clustered primary key. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop an existing primary key that does not have the default name. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The table that contains the primary key column. Schema name is optional, if no schema is specified + then dbo is assumed. + + The name of the primary key to be dropped. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop an existing primary key that was created with the default name. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The table that contains the primary key column. Schema name is optional, if no schema is specified + then dbo is assumed. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to create an index on a single column. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to create the index on. Schema name is optional, if no schema is specified + then dbo is assumed. + + The name of the column to create the index on. + + A value indicating if this is a unique index. If no value is supplied a non-unique index will be + created. + + + The name to use for the index in the database. If no value is supplied a unique name will be + generated. + + A value indicating whether or not this is a clustered index. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to create an index on multiple columns. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to create the index on. Schema name is optional, if no schema is specified + then dbo is assumed. + + The name of the columns to create the index on. + + A value indicating if this is a unique index. If no value is supplied a non-unique index will be + created. + + + The name to use for the index in the database. If no value is supplied a unique name will be + generated. + + A value indicating whether or not this is a clustered index. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop an index based on its name. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to drop the index from. Schema name is optional, if no schema is specified + then dbo is assumed. + + The name of the index to be dropped. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to drop an index based on the columns it targets. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table to drop the index from. Schema name is optional, if no schema is specified + then dbo is assumed. + + The name of the column(s) the index targets. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to rename an index. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The name of the table that contains the index to be renamed. Schema name is optional, if no + schema is specified then dbo is assumed. + + The name of the index to be renamed. + The new name for the index. + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to execute a SQL command or set of SQL commands. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The SQL to be executed. + + A value indicating if the SQL should be executed outside of the transaction being + used for the migration process. If no value is supplied the SQL will be executed within the transaction. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to execute a SQL file. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The SQL file to be executed. Relative paths are assumed to be relative to the current AppDomain's BaseDirectory. + + + A value indicating if the SQL should be executed outside of the transaction being + used for the migration process. If no value is supplied the SQL will be executed within the transaction. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Adds an operation to execute a SQL resource file. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The manifest resource name of the SQL resource file to be executed. + + The assembly containing the resource file. The calling assembly is assumed if not provided. + + + A value indicating if the SQL should be executed outside of the transaction being + used for the migration process. If no value is supplied the SQL will be executed within the transaction. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + + + + + + + + + + + + + + + + + + + Configuration relating to the use of migrations for a given model. + You will typically create a configuration class that derives + from rather than + using this class. + + + + + The default directory that migrations are stored in. + + + + + Initializes a new instance of the DbMigrationsConfiguration class. + + + + + Adds a new SQL generator to be used for a given database provider. + + Name of the database provider to set the SQL generator for. + The SQL generator to be used. + + + + Gets the SQL generator that is set to be used with a given database provider. + + Name of the database provider to get the SQL generator for. + The SQL generator that is set for the database provider. + + + + Adds a new factory for creating instances to be used for a given database provider. + + Name of the database provider to set the SQL generator for. + + A factory for creating instances for a given and + representing the default schema. + + + + + Gets the history context factory that is set to be used with a given database provider. + + Name of the database provider to get thefactory for. + The history context factory that is set for the database provider. + + + + Gets or sets a value indicating if automatic migrations can be used when migrating the database. + + + + + Gets or sets the string used to distinguish migrations belonging to this configuration + from migrations belonging to other configurations using the same database. + This property enables migrations from multiple different models to be applied to applied to a single database. + + + + + Gets or sets a value indicating if data loss is acceptable during automatic migration. + If set to false an exception will be thrown if data loss may occur as part of an automatic migration. + + + + + Gets or sets the derived DbContext representing the model to be migrated. + + + + + Gets or sets the namespace used for code-based migrations. + + + + + Gets or sets the sub-directory that code-based migrations are stored in. + Note that this property must be set to a relative path for a sub-directory under the + Visual Studio project root; it cannot be set to an absolute path. + + + + + Gets or sets the code generator to be used when scaffolding migrations. + + + + + Gets or sets the assembly containing code-based migrations. + + + + + Gets or sets a value to override the connection of the database to be migrated. + + + + + Gets or sets the timeout value used for the individual commands within a + migration. A null value indicates that the default value of the underlying + provider will be used. + + + + + Configuration relating to the use of migrations for a given model. + + The context representing the model that this configuration applies to. + + + + Initializes a new instance of the DbMigrationsConfiguration class. + + + + + Runs after upgrading to the latest migration to allow seed data to be updated. + + + Note that the database may already contain seed data when this method runs. This means that + implementations of this method must check whether or not seed data is present and/or up-to-date + and then only make changes if necessary and in a non-destructive way. The + + can be used to help with this, but for seeding large amounts of data it may be necessary to do less + granular checks if performance is an issue. + If the database + initializer is being used, then this method will be called each time that the initializer runs. + If one of the , , + or initializers is being used, then this method will not be + called and the Seed method defined in the initializer should be used instead. + + Context to be used for updating seed data. + + + + + + + + + + + + + + + + + + + DbMigrator is used to apply existing migrations to a database. + DbMigrator can be used to upgrade and downgrade to any given migration. + To scaffold migrations based on changes to your model use + + + + + Base class for decorators that wrap the core + + + + + Initializes a new instance of the MigratorBase class. + + The migrator that this decorator is wrapping. + + + + Gets a list of the pending migrations that have not been applied to the database. + + List of migration Ids + + + + Updates the target database to the latest migration. + + + + + Updates the target database to a given migration. + + The migration to upgrade/downgrade to. + + + + Gets a list of the migrations that are defined in the assembly. + + List of migration Ids + + + + Gets a list of the migrations that have been applied to the database. + + List of migration Ids + + + + Gets the configuration being used for the migrations process. + + + + + Migration Id representing the state of the database before any migrations are applied. + + + + + Initializes a new instance of the DbMigrator class. + + Configuration to be used for the migration process. + + + + Gets all migrations that are defined in the configured migrations assembly. + + The list of migrations. + + + + Gets all migrations that have been applied to the target database. + + The list of migrations. + + + + Gets all migrations that are defined in the assembly but haven't been applied to the target database. + + The list of migrations. + + + + Updates the target database to a given migration. + + The migration to upgrade/downgrade to. + + + + Gets the configuration that is being used for the migration process. + + + + + A set of extension methods for + + + + + Adds or updates entities by key when SaveChanges is called. Equivalent to an "upsert" operation + from database terminology. + This method can useful when seeding data using Migrations. + + The type of entities to add or update. + The set to which the entities belong. + The entities to add or update. + + When the parameter is a custom or fake IDbSet implementation, this method will + attempt to locate and invoke a public, instance method with the same signature as this extension method. + + + + + Adds or updates entities by a custom identification expression when SaveChanges is called. + Equivalent to an "upsert" operation from database terminology. + This method can useful when seeding data using Migrations. + + The type of entities to add or update. + The set to which the entities belong. + An expression specifying the properties that should be used when determining whether an Add or Update operation should be performed. + The entities to add or update. + + When the parameter is a custom or fake IDbSet implementation, this method will + attempt to locate and invoke a public, instance method with the same signature as this extension method. + + + + + Generates C# code for a code-based migration. + + + + + Base class for providers that generate code for code-based migrations. + + + + + Generates the code that should be added to the users project. + + Unique identifier of the migration. + Operations to be performed by the migration. + Source model to be stored in the migration metadata. + Target model to be stored in the migration metadata. + Namespace that code should be generated in. + Name of the class that should be generated. + The generated code. + + + + Gets the namespaces that must be output as "using" or "Imports" directives to handle + the code generated by the given operations. + + The operations for which code is going to be generated. + An ordered list of namespace names. + + + + Gets the default namespaces that must be output as "using" or "Imports" directives for + any code generated. + + A value indicating if this class is being generated for a code-behind file. + An ordered list of namespace names. + + + + Gets the instances that are being used. + + + + + + + + Generates the primary code file that the user can view and edit. + + Operations to be performed by the migration. + Namespace that code should be generated in. + Name of the class that should be generated. + The generated code. + + + + Generates the code behind file with migration metadata. + + Unique identifier of the migration. + Source model to be stored in the migration metadata. + Target model to be stored in the migration metadata. + Namespace that code should be generated in. + Name of the class that should be generated. + The generated code. + + + + Generates a property to return the source or target model in the code behind file. + + Name of the property. + Value to be returned. + Text writer to add the generated code to. + + + + Generates class attributes. + + Text writer to add the generated code to. + A value indicating if this class is being generated for a code-behind file. + + + + Generates a namespace, using statements and class definition. + + Namespace that code should be generated in. + Name of the class that should be generated. + Text writer to add the generated code to. + Base class for the generated class. + A value indicating if this class is being generated for a code-behind file. + Namespaces for which using directives will be added. If null, then the namespaces returned from GetDefaultNamespaces will be used. + + + + Generates the closing code for a class that was started with WriteClassStart. + + Namespace that code should be generated in. + Text writer to add the generated code to. + + + + Generates code to perform an . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform an . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code for to re-create the given dictionary of annotations for use when passing + these annotations as a parameter of a . call. + + The annotations to generate. + The writer to which generated code should be written. + + + + Generates code for to re-create the given dictionary of annotations for use when passing + these annotations as a parameter of a . call. + + The annotations to generate. + The writer to which generated code should be written. + + + + Generates code for the given annotation value, which may be null. The default behavior is to use an + if one is registered, otherwise call ToString on the annotation value. + + + Note that a can be registered to generate code for custom annotations + without the need to override the entire code generator. + + The name of the annotation for which code is needed. + The annotation value to generate. + The writer to which generated code should be written. + + + Generates code to perform a . + The operation to generate code for. + Text writer to add the generated code to. + + + Generates code to perform a . + The operation to generate code for. + Text writer to add the generated code to. + + + Generates code to specify the definition for a . + The parameter definition to generate code for. + Text writer to add the generated code to. + A value indicating whether to include the column name in the definition. + + + Generates code to perform a . + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code for an . + + The operation for which code should be generated. + The writer to which generated code should be written. + + + + Generates code to perform an as part of a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform an as part of a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a as part of a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to specify a set of column names using a lambda expression. + + The columns to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform an . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform an . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to specify the definition for a . + + The column definition to generate code for. + Text writer to add the generated code to. + A value indicating whether to include the column name in the definition. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column of unknown data type. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Removes any invalid characters from the name of an database artifact. + + The name to be scrubbed. + The scrubbed name. + + + + Gets the type name to use for a column of the given data type. + + The data type to translate. + The type name to use in the generated migration. + + + + Quotes an identifier using appropriate escaping to allow it to be stored in a string. + + The identifier to be quoted. + The quoted identifier. + + + + Scaffolds code-based migrations to apply pending model changes to the database. + + + + + Initializes a new instance of the MigrationScaffolder class. + + Configuration to be used for scaffolding. + + + + Scaffolds a code based migration to apply any pending model changes to the database. + + The name to use for the scaffolded migration. + The scaffolded migration. + + + + Scaffolds a code based migration to apply any pending model changes to the database. + + The name to use for the scaffolded migration. + Whether or not to include model changes. + The scaffolded migration. + + + + Scaffolds the initial code-based migration corresponding to a previously run database initializer. + + The scaffolded migration. + + + + Gets or sets the namespace used in the migration's generated code. + By default, this is the same as MigrationsNamespace on the migrations + configuration object passed into the constructor. For VB.NET projects, this + will need to be updated to take into account the project's root namespace. + + + + + Represents a code-based migration that has been scaffolded and is ready to be written to a file. + + + + + Gets or sets the unique identifier for this migration. + Typically used for the file name of the generated code. + + + + + Gets or sets the scaffolded migration code that the user can edit. + + + + + Gets or sets the scaffolded migration code that should be stored in a code behind file. + + + + + Gets or sets the programming language used for this migration. + Typically used for the file extension of the generated code. + + + + + Gets or sets the subdirectory in the user's project that this migration should be saved in. + + + + + Gets a dictionary of string resources to add to the migration resource file. + + + + + Gets or sets whether the migration was re-scaffolded. + + + + + Helper class that is used by design time tools to run migrations related + commands that need to interact with an application that is being edited + in Visual Studio. + Because the application is being edited the assemblies need to + be loaded in a separate AppDomain to ensure the latest version + is always loaded. + The App/Web.config file from the startup project is also copied + to ensure that any configuration is applied. + + + + + Initializes a new instance of the ToolingFacade class. + + The name of the assembly that contains the migrations configuration to be used. + The name of the assembly that contains the DbContext to be used. + The namespace qualified name of migrations configuration to be used. + The working directory containing the compiled assemblies. + The path of the config file from the startup project. + The path of the application data directory from the startup project. Typically the App_Data directory for web applications or the working directory for executables. + The connection to the database to be migrated. If null is supplied, the default connection for the context will be used. + + + + Releases all unmanaged resources used by the facade. + + + + + Gets the fully qualified name of all types deriving from . + + All context types found. + + + + Gets the fully qualified name of a type deriving from . + + The name of the context type. If null, the single context type found in the assembly will be returned. + The context type found. + + + + Gets a list of all migrations that have been applied to the database. + + Ids of applied migrations. + + + + Gets a list of all migrations that have not been applied to the database. + + Ids of pending migrations. + + + + Updates the database to the specified migration. + + The Id of the migration to migrate to. If null is supplied, the database will be updated to the latest migration. + Value indicating if data loss during automatic migration is acceptable. + + + + Generates a SQL script to migrate between two migrations. + + The migration to update from. If null is supplied, a script to update the current database will be produced. + The migration to update to. If null is supplied, a script to update to the latest migration will be produced. + Value indicating if data loss during automatic migration is acceptable. + The generated SQL script. + + + + Scaffolds a code-based migration to apply any pending model changes. + + The name for the generated migration. + The programming language of the generated migration. + The root namespace of the project the migration will be added to. + Whether or not to include model changes. + The scaffolded migration. + + + + Scaffolds the initial code-based migration corresponding to a previously run database initializer. + + The programming language of the generated migration. + The root namespace of the project the migration will be added to. + The scaffolded migration. + + + + + + + Releases all resources used by the facade. + + + true to release both managed and unmanaged resources; false to release only unmanaged resources. + + + + + Gets or sets an action to be run to log information. + + + + + Gets or sets an action to be run to log warnings. + + + + + Gets or sets an action to be run to log verbose information. + + + + + Base class for loggers that can be used for the migrations process. + + + + + Logs an informational message. + + The message to be logged. + + + + Logs a warning that the user should be made aware of. + + The message to be logged. + + + + Logs some additional information that should only be presented to the user if they request verbose output. + + The message to be logged. + + + + Generates VB.Net code for a code-based migration. + + + + + + + + Generates the primary code file that the user can view and edit. + + Operations to be performed by the migration. + Namespace that code should be generated in. + Name of the class that should be generated. + The generated code. + + + + Generates the code behind file with migration metadata. + + Unique identifier of the migration. + Source model to be stored in the migration metadata. + Target model to be stored in the migration metadata. + Namespace that code should be generated in. + Name of the class that should be generated. + The generated code. + + + + Generates a property to return the source or target model in the code behind file. + + Name of the property. + Value to be returned. + Text writer to add the generated code to. + + + + Generates class attributes. + + Text writer to add the generated code to. + A value indicating if this class is being generated for a code-behind file. + + + + Generates a namespace, using statements and class definition. + + Namespace that code should be generated in. + Name of the class that should be generated. + Text writer to add the generated code to. + Base class for the generated class. + A value indicating if this class is being generated for a code-behind file. + Namespaces for which Imports directives will be added. If null, then the namespaces returned from GetDefaultNamespaces will be used. + + + + Generates the closing code for a class that was started with WriteClassStart. + + Namespace that code should be generated in. + Text writer to add the generated code to. + + + + Generates code to perform an . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform an . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code for to re-create the given dictionary of annotations for use when passing + these annotations as a parameter of a . call. + + The annotations to generate. + The writer to which generated code should be written. + + + + Generates code for to re-create the given dictionary of annotations for use when passing + these annotations as a parameter of a . call. + + The annotations to generate. + The writer to which generated code should be written. + + + + Generates code for the given annotation value, which may be null. The default behavior is to use an + if one is registered, otherwise call ToString on the annotation value. + + + Note that a can be registered to generate code for custom annotations + without the need to override the entire code generator. + + The name of the annotation for which code is needed. + The annotation value to generate. + The writer to which generated code should be written. + + + Generates code to perform a . + The operation to generate code for. + Text writer to add the generated code to. + + + Generates code to perform a . + The operation to generate code for. + Text writer to add the generated code to. + + + Generates code to perform a . + The parameter model definition to generate code for. + Text writer to add the generated code to. + true to include the column name in the definition; otherwise, false. + + + Generates code to perform a . + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code for an . + + The operation for which code should be generated. + The writer to which generated code should be written. + + + + Generates code to perform an as part of a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform an as part of a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a as part of a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to specify a set of column names using a lambda expression. + + The columns to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform an . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform an . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to specify the definition for a . + + The column definition to generate code for. + Text writer to add the generated code to. + A value indicating whether to include the column name in the definition. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to specify the default value for a column of unknown data type. + + The value to be used as the default. + Code representing the default value. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Generates code to perform a . + + The operation to generate code for. + Text writer to add the generated code to. + + + + Removes any invalid characters from the name of an database artifact. + + The name to be scrubbed. + The scrubbed name. + + + + Gets the type name to use for a column of the given data type. + + The data type to translate. + The type name to use in the generated migration. + + + + Quotes an identifier using appropriate escaping to allow it to be stored in a string. + + The identifier to be quoted. + The quoted identifier. + + + + Contains extension methods for the class. + + + + + Configures an awaiter used to await this to avoid + marshalling the continuation + back to the original context, but preserve the current culture and UI culture. + + + The type of the result produced by the associated . + + The task to be awaited on. + An object used to await this task. + + + + Configures an awaiter used to await this to avoid + marshalling the continuation + back to the original context, but preserve the current culture and UI culture. + + The task to be awaited on. + An object used to await this task. + + + + Provides an awaitable object that allows for awaits on that + preserve the culture. + + + The type of the result produced by the associated . + + This type is intended for compiler use only. + + + + Constructs a new instance of the class. + + The task to be awaited on. + + + Gets an awaiter used to await this . + An awaiter instance. + 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 canceled. + The task completed in a Faulted state. + + + This method is not implemented and should not be called. + The action to invoke when the await operation completes. + + + + 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. + + + + Gets whether this Task has completed. + + + will return true when the Task is in one of the three + final states: RanToCompletion, + Faulted, or + Canceled. + + + + + Provides an awaitable object that allows for awaits on that + preserve the culture. + + This type is intended for compiler use only. + + + + Constructs a new instance of the class. + + The task to be awaited on. + + + Gets an awaiter used to await this . + An awaiter instance. + 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 canceled. + The task completed in a Faulted state. + + + This method is not implemented and should not be called. + The action to invoke when the await operation completes. + + + + 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. + + + + Gets whether this Task has completed. + + + will return true when the Task is in one of the three + final states: RanToCompletion, + Faulted, or + Canceled. + + + + + This class is used by Code First Migrations to read and write migration history + from the database. + To customize the definition of the migrations history table you can derive from + this class and override OnModelCreating. Derived instances can either be registered + on a per migrations configuration basis using , + or globally using . + + + + + The default name used for the migrations history table. + + + + + Initializes a new instance of the HistoryContext class. + If you are creating a derived history context you will generally expose a constructor + that accepts these same parameters and passes them to this base constructor. + + + An existing connection to use for the new context. + + + The default schema of the model being migrated. + This schema will be used for the migrations history table unless a different schema is configured in OnModelCreating. + + + + + Applies the default configuration for the migrations history table. If you override + this method it is recommended that you call this base implementation before applying your + custom configuration. + + The builder that defines the model for the context being created. + + + + Gets the key used to locate a model that was previously built for this context. This is used + to avoid processing OnModelCreating and calculating the model every time a new context instance is created. + By default this property returns the default schema. + In most cases you will not need to override this property. However, if your implementation of OnModelCreating + contains conditional logic that results in a different model being built for the same database provider and + default schema you should override this property and calculate an appropriate key. + + + + + Gets the default schema of the model being migrated. + This schema will be used for the migrations history table unless a different schema is configured in OnModelCreating. + + + + + Gets or sets a that can be used to read and write instances. + + + + + This class is used by Code First Migrations to read and write migration history + from the database. + + + + + Gets or sets the Id of the migration this row represents. + + + + + Gets or sets a key representing to which context the row applies. + + + + + Gets or sets the state of the model after this migration was applied. + + + + + Gets or sets the version of Entity Framework that created this entry. + + + + + Represents an error that occurs when an automatic migration would result in data loss. + + + + + Initializes a new instance of the AutomaticDataLossException class. + + + + + Initializes a new instance of the AutomaticDataLossException class. + + The message that describes the error. + + + + Initializes a new instance of the MigrationsException class. + + The message that describes the error. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Represents an error that occurs when there are pending model changes after applying the last migration and automatic migration is disabled. + + + + + Initializes a new instance of the AutomaticMigrationsDisabledException class. + + + + + Initializes a new instance of the AutomaticMigrationsDisabledException class. + + The message that describes the error. + + + + Initializes a new instance of the MigrationsException class. + + The message that describes the error. + The exception that is the cause of the current exception, or a null reference (Nothing in Visual Basic) if no inner exception is specified. + + + + Provides additional metadata about a code-based migration. + + + + + Gets the unique identifier for the migration. + + + + + Gets the state of the model before this migration is run. + + + + + Gets the state of the model after this migration is run. + + + + + Decorator to provide logging during migrations operations.. + + + + + Initializes a new instance of the MigratorLoggingDecorator class. + + The migrator that this decorator is wrapping. + The logger to write messages to. + + + + Decorator to produce a SQL script instead of applying changes to the database. + Using this decorator to wrap will prevent + from applying any changes to the target database. + + + + + Initializes a new instance of the MigratorScriptingDecorator class. + + The migrator that this decorator is wrapping. + + + + Produces a script to update the database. + + + The migration to update from. If null is supplied, a script to update the + current database will be produced. + + + The migration to update to. If null is supplied, + a script to update to the latest migration will be produced. + + The generated SQL script. + + + + Represents a column being added to a table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the AddColumnOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the table the column should be added to. + Details of the column being added. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the table the column should be added to. + + + + + Gets the details of the column being added. + + + + + Gets an operation that represents dropping the added column. + + + + + + + + Represents a foreign key constraint being added to a table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Base class for changes that affect foreign key constraints. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the ForeignKeyOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets or sets the name of the table that the foreign key constraint targets. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets or sets the name of the table that the foreign key columns exist in. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + The names of the foreign key column(s). + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets a value indicating if a specific name has been supplied for this foreign key constraint. + + + + + Gets or sets the name of this foreign key constraint. + If no name is supplied, a default name will be calculated. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the AddForeignKeyOperation class. + The PrincipalTable, PrincipalColumns, DependentTable and DependentColumns properties should also be populated. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets an operation to create an index on the foreign key column(s). + + An operation to add the index. + + + + The names of the column(s) that the foreign key constraint should target. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets or sets a value indicating if cascade delete should be configured on the foreign key constraint. + + + + + Gets an operation to drop the foreign key constraint. + + + + + + + + Represents adding a primary key to a table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Common base class to represent operations affecting primary keys. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Returns the default name for the primary key. + + The target table name. + The default primary key name. + + + + Initializes a new instance of the PrimaryKeyOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets or sets the name of the table that contains the primary key. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets the column(s) that make up the primary key. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets a value indicating if a specific name has been supplied for this primary key. + + + + + Gets or sets the name of this primary key. + If no name is supplied, a default name will be calculated. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + + + + Initializes a new instance of the AddPrimaryKeyOperation class. + The Table and Columns properties should also be populated. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets an operation to drop the primary key. + + + + + Gets or sets whether this is a clustered primary key. + + + + + Represents altering an existing column. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the AlterColumnOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the table that the column belongs to. + Details of what the column should be altered to. + Value indicating if this change will result in data loss. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Initializes a new instance of the AlterColumnOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the table that the column belongs to. + Details of what the column should be altered to. + Value indicating if this change will result in data loss. + An operation to revert this alteration of the column. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the table that the column belongs to. + + + + + Gets the new definition for the column. + + + + + Gets an operation that represents reverting the alteration. + The inverse cannot be automatically calculated, + if it was not supplied to the constructor this property will return null. + + + + + + + + Represents information about a column. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the ColumnModel class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The data type for this column. + + + + Initializes a new instance of the ColumnModel class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The data type for this column. + Additional details about the data type. This includes details such as maximum length, nullability etc. + + + + Determines if this column is a narrower data type than another column. + Used to determine if altering the supplied column definition to this definition will result in data loss. + + The column to compare to. + Details of the database provider being used. + True if this column is of a narrower data type. + + + + Gets the CLR type corresponding to the database type of this column. + + + + + Gets the default value for the CLR type corresponding to the database type of this column. + + + + + Gets or sets a value indicating if this column can store null values. + + + + + Gets or sets a value indicating if values for this column will be generated by the database using the identity pattern. + + + + + Gets or sets a value indicating if this property model should be configured as a timestamp. + + + + + Gets or sets the custom annotations that have changed on the column. + + + + + Represents creating a database index. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Common base class for operations affecting indexes. + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Creates a default index name based on the supplied column names. + + The column names used to create a default index name. + A default index name. + + + + Initializes a new instance of the IndexOperation class. + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + Additional arguments that may be processed by providers. Use anonymous type syntax to + specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + + Gets or sets the table the index belongs to. + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets the columns that are indexed. + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets a value indicating if a specific name has been supplied for this index. + + + + + Gets or sets the name of this index. + If no name is supplied, a default name will be calculated. + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the CreateIndexOperation class. + The Table and Columns properties should also be populated. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets or sets a value indicating if this is a unique index. + + + + + Gets an operation to drop this index. + + + + + + + + Gets or sets whether this is a clustered index. + + + + + Represents creating a table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the CreateTableOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Name of the table to be created. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Initializes a new instance of the CreateTableOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Name of the table to be created. + Custom annotations that exist on the table to be created. May be null or empty. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the table to be created. + + + + + Gets the columns to be included in the new table. + + + + + Gets or sets the primary key for the new table. + + + + + Gets custom annotations that exist on the table to be created. + + + + + Gets an operation to drop the table. + + + + + + + + Represents a column being dropped from a table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the DropColumnOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the table the column should be dropped from. + The name of the column to be dropped. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Initializes a new instance of the DropColumnOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the table the column should be dropped from. + The name of the column to be dropped. + Custom annotations that exist on the column that is being dropped. May be null or empty. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Initializes a new instance of the DropColumnOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the table the column should be dropped from. + The name of the column to be dropped. + The operation that represents reverting the drop operation. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Initializes a new instance of the DropColumnOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the table the column should be dropped from. + The name of the column to be dropped. + Custom annotations that exist on the column that is being dropped. May be null or empty. + The operation that represents reverting the drop operation. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the table the column should be dropped from. + + + + + Gets the name of the column to be dropped. + + + + + Gets custom annotations that exist on the column that is being dropped. + + + + + Gets an operation that represents reverting dropping the column. + The inverse cannot be automatically calculated, + if it was not supplied to the constructor this property will return null. + + + + + + + + Represents a foreign key constraint being dropped from a table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the DropForeignKeyOperation class. + The PrincipalTable, DependentTable and DependentColumns properties should also be populated. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Initializes a new instance of the DropForeignKeyOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc.. + + The operation that represents reverting dropping the foreign key constraint. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets an operation to drop the associated index on the foreign key column(s). + + An operation to drop the index. + + + + Gets an operation that represents reverting dropping the foreign key constraint. + The inverse cannot be automatically calculated, + if it was not supplied to the constructor this property will return null. + + + + + + + + Represents dropping an existing index. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the DropIndexOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Initializes a new instance of the DropIndexOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The operation that represents reverting dropping the index. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets an operation that represents reverting dropping the index. + The inverse cannot be automatically calculated, + if it was not supplied to the constructor this property will return null. + + + + + + + + Represents dropping a primary key from a table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the DropPrimaryKeyOperation class. + The Table and Columns properties should also be populated. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets an operation to add the primary key. + + + + + Used when altering the migrations history table so that the table can be rebuilt rather than just dropping and adding the primary key. + + + The create table operation for the migrations history table. + + + + + Represents dropping an existing table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the DropTableOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the table to be dropped. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Initializes a new instance of the DropTableOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the table to be dropped. + Custom annotations that exist on the table that is being dropped. May be null or empty. + Custom annotations that exist on columns of the table that is being dropped. May be null or empty. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Initializes a new instance of the DropTableOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the table to be dropped. + An operation that represents reverting dropping the table. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Initializes a new instance of the DropTableOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The name of the table to be dropped. + Custom annotations that exist on the table that is being dropped. May be null or empty. + Custom annotations that exist on columns of the table that is being dropped. May be null or empty. + An operation that represents reverting dropping the table. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the table to be dropped. + + + + + Gets custom annotations that exist on the table that is being dropped. + + + + + Gets custom annotations that exist on columns of the table that is being dropped. + + + + + Gets an operation that represents reverting dropping the table. + The inverse cannot be automatically calculated, + if it was not supplied to the constructor this property will return null. + + + + + + + + Operation representing DML changes to the migrations history table. + The migrations history table is used to store a log of the migrations that have been applied to the database. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the HistoryOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + A sequence of command trees representing the operations being applied to the history table. + Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + A sequence of commands representing the operations being applied to the history table. + + + + + + + + Represents moving a table from one schema to another. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the MoveTableOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Name of the table to be moved. + Name of the schema to move the table to. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the table to be moved. + + + + + Gets the name of the schema to move the table to. + + + + + Gets an operation that moves the table back to its original schema. + + + + + + + + Used when altering the migrations history table so that data can be moved to the new table. + + + The context key for the model. + + + + + Gets a value that indicates whether this is a system table. + + + true if the table is a system table; otherwise, false. + + + + + Used when altering the migrations history table so that the table can be rebuilt rather than just dropping and adding the primary key. + + + The create table operation for the migrations history table. + + + + + Represents renaming an existing column. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the RenameColumnOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Name of the table the column belongs to. + Name of the column to be renamed. + New name for the column. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the table the column belongs to. + + + + + Gets the name of the column to be renamed. + + + + + Gets the new name for the column. + + + + + Gets an operation that reverts the rename. + + + + + + + + Represents renaming an existing table. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the RenameTableOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + Name of the table to be renamed. + New name for the table. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the name of the table to be renamed. + + + + + Gets the new name for the table. + + + + + Gets an operation that reverts the rename. + + + + + + + + Represents a provider specific SQL statement to be executed directly against the target database. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Initializes a new instance of the SqlOperation class. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + The SQL to be executed. + Additional arguments that may be processed by providers. Use anonymous type syntax to specify arguments e.g. 'new { SampleArgument = "MyValue" }'. + + + + Gets the SQL to be executed. + + + + + Gets or sets a value indicating whether this statement should be performed outside of + the transaction scope that is used to make the migration process transactional. + If set to true, this operation will not be rolled back if the migration process fails. + + + + + + + + Common base class for providers that convert provider agnostic migration + operations into database provider specific SQL commands. + + + + + Converts a set of migration operations into database provider specific SQL. + + The operations to be converted. + Token representing the version of the database being targeted. + A list of SQL statements to be executed to perform the migration operations. + + + + Generates the SQL body for a stored procedure. + + The command trees representing the commands for an insert, update or delete operation. + The rows affected parameter name. + The provider manifest token. + The SQL body for the stored procedure. + + + + Builds the store type usage for the specified using the facets from the specified . + + Name of the store type. + The target property. + A store-specific TypeUsage + + + + Gets or sets the provider manifest. + + + The provider manifest. + + + + + Represents a migration operation that has been translated into a SQL statement. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets or sets the SQL to be executed to perform this migration operation. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + + + Gets or sets a value indicating whether this statement should be performed outside of + the transaction scope that is used to make the migration process transactional. + If set to true, this operation will not be rolled back if the migration process fails. + + + + + Gets or sets the batch terminator for the database provider. + + Entity Framework Migrations APIs are not designed to accept input provided by untrusted sources + (such as the end user of an application). If input is accepted from such sources it should be validated + before being passed to these APIs to protect against SQL injection attacks etc. + + + The batch terminator for the database provider. + + + + + Extension methods for . + + + + + Returns an implementation that stays in sync with the given + . + + The element type. + The collection that the binding list will stay in sync with. + The binding list. + + + + Represents data in a geodetic (round earth) coordinate system. + + + + + Creates a new value based on the specified well known binary value. + + + A new DbGeography value as defined by the well known binary value with the default geography coordinate system identifier (SRID)( + + ). + + A byte array that contains a well known binary representation of the geography value. + + + + Creates a new value based on the specified well known binary value and coordinate system identifier (SRID). + + A new DbGeography value as defined by the well known binary value with the specified coordinate system identifier. + A byte array that contains a well known binary representation of the geography value. + The identifier of the coordinate system that the new DbGeography value should use. + + + + Creates a new line value based on the specified well known binary value and coordinate system identifier (SRID). + + A new DbGeography value as defined by the well known binary value with the specified coordinate system identifier. + A byte array that contains a well known binary representation of the geography value. + The identifier of the coordinate system that the new DbGeography value should use. + + + + Creates a new point value based on the specified well known binary value and coordinate system identifier (SRID). + + A new DbGeography value as defined by the well known binary value with the specified coordinate system identifier. + A byte array that contains a well known binary representation of the geography value. + The identifier of the coordinate system that the new DbGeography value should use. + + + + Creates a new polygon value based on the specified well known binary value and coordinate system identifier (SRID). + + A new DbGeography value as defined by the well known binary value with the specified coordinate system identifier. + A byte array that contains a well known binary representation of the geography value. + The identifier of the coordinate system that the new DbGeography value should use. + + + Returns the multiline value from a binary value. + The multiline value from a binary value. + The well-known binary value. + The coordinate system identifier. + + + Returns the multipoint value from a well-known binary value. + The multipoint value from a well-known binary value. + The well-known binary value. + The coordinate system identifier. + + + Returns the multi polygon value from a well-known binary value. + The multi polygon value from a well-known binary value. + The multi polygon well-known binary value. + The coordinate system identifier. + + + + Creates a new collection value based on the specified well known binary value and coordinate system identifier (SRID). + + A new DbGeography value as defined by the well known binary value with the specified coordinate system identifier. + A byte array that contains a well known binary representation of the geography value. + The identifier of the coordinate system that the new DbGeography value should use. + + + + Creates a new value based on the specified Geography Markup Language (GML) value. + + + A new DbGeography value as defined by the GML value with the default geography coordinate system identifier (SRID) ( + + ). + + A string that contains a Geography Markup Language (GML) representation of the geography value. + + + + Creates a new value based on the specified Geography Markup Language (GML) value and coordinate system identifier (SRID). + + A new DbGeography value as defined by the GML value with the specified coordinate system identifier. + A string that contains a Geography Markup Language (GML) representation of the geography value. + The identifier of the coordinate system that the new DbGeography value should use. + + + + Creates a new value based on the specified well known text value. + + + A new DbGeography value as defined by the well known text value with the default geography coordinate system identifier (SRID) ( + + ). + + A string that contains a well known text representation of the geography value. + + + + Creates a new value based on the specified well known text value and coordinate system identifier (SRID). + + A new DbGeography value as defined by the well known text value with the specified coordinate system identifier. + A string that contains a well known text representation of the geography value. + The identifier of the coordinate system that the new DbGeography value should use. + + + + Creates a new line value based on the specified well known text value and coordinate system identifier (SRID). + + A new DbGeography value as defined by the well known text value with the specified coordinate system identifier. + A string that contains a well known text representation of the geography value. + The identifier of the coordinate system that the new DbGeography value should use. + + + + Creates a new point value based on the specified well known text value and coordinate system identifier (SRID). + + A new DbGeography value as defined by the well known text value with the specified coordinate system identifier. + A string that contains a well known text representation of the geography value. + The identifier of the coordinate system that the new DbGeography value should use. + + + + Creates a new polygon value based on the specified well known text value and coordinate system identifier (SRID). + + A new DbGeography value as defined by the well known text value with the specified coordinate system identifier. + A string that contains a well known text representation of the geography value. + The identifier of the coordinate system that the new DbGeography value should use. + + + Returns the multiline value from a well-known text value. + The multiline value from a well-known text value. + The well-known text. + The coordinate system identifier. + + + Returns the multipoint value from a well-known text value. + The multipoint value from a well-known text value. + The well-known text value. + The coordinate system identifier. + + + Returns the multi polygon value from a well-known text value. + The multi polygon value from a well-known text value. + The multi polygon well-known text value. + The coordinate system identifier. + + + + Creates a new collection value based on the specified well known text value and coordinate system identifier (SRID). + + A new DbGeography value as defined by the well known text value with the specified coordinate system identifier. + A string that contains a well known text representation of the geography value. + The identifier of the coordinate system that the new DbGeography value should use. + + + Generates the well known text representation of this DbGeography value. Includes only Longitude and Latitude for points. + A string containing the well known text representation of this DbGeography value. + + + Generates the well known binary representation of this DbGeography value. + The well-known binary representation of this DbGeography value. + + + Generates the Geography Markup Language (GML) representation of this DbGeography value. + A string containing the GML representation of this DbGeography value. + + + Determines whether this DbGeography is spatially equal to the specified DbGeography argument. + true if other is spatially equal to this geography value; otherwise false. + The geography value that should be compared with this geography value for equality. + + + Determines whether this DbGeography is spatially disjoint from the specified DbGeography argument. + true if other is disjoint from this geography value; otherwise false. + The geography value that should be compared with this geography value for disjointness. + + + Determines whether this DbGeography value spatially intersects the specified DbGeography argument. + true if other intersects this geography value; otherwise false. + The geography value that should be compared with this geography value for intersection. + + + Returns a geography object that represents the union of all points whose distance from a geography instance is less than or equal to a specified value. + A geography object that represents the union of all points + The distance. + + + Computes the distance between the closest points in this DbGeography value and another DbGeography value. + A double value that specifies the distance between the two closest points in this geography value and other. + The geography value for which the distance from this value should be computed. + + + Computes the intersection of this DbGeography value and another DbGeography value. + A new DbGeography value representing the intersection between this geography value and other. + The geography value for which the intersection with this value should be computed. + + + Computes the union of this DbGeography value and another DbGeography value. + A new DbGeography value representing the union between this geography value and other. + The geography value for which the union with this value should be computed. + + + Computes the difference of this DbGeography value and another DbGeography value. + A new DbGeography value representing the difference between this geography value and other. + The geography value for which the difference with this value should be computed. + + + Computes the symmetric difference of this DbGeography value and another DbGeography value. + A new DbGeography value representing the symmetric difference between this geography value and other. + The geography value for which the symmetric difference with this value should be computed. + + + Returns an element of this DbGeography value from a specific position, if it represents a geography collection. <param name="index">The position within this geography value from which the element should be taken.</param><returns>The element in this geography value at the specified position, if it represents a collection of other geography values; otherwise null.</returns> + An element of this DbGeography value from a specific position + The index. + + + Returns an element of this DbGeography value from a specific position, if it represents a linestring or linear ring. <param name="index">The position within this geography value from which the element should be taken.</param><returns>The element in this geography value at the specified position, if it represents a linestring or linear ring; otherwise null.</returns> + An element of this DbGeography value from a specific position + The index. + + + Returns a string representation of the geography value. + A string representation of the geography value. + + + Gets the default coordinate system id (SRID) for geography values (WGS 84) + The default coordinate system id (SRID) for geography values (WGS 84) + + + Gets a representation of this DbGeography value that is specific to the underlying provider that constructed it. + A representation of this DbGeography value. + + + + Gets the spatial provider that will be used for operations on this spatial type. + + + + Gets or sets a data contract serializable well known representation of this DbGeography value. + A data contract serializable well known representation of this DbGeography value. + + + Gets the identifier associated with the coordinate system. + The identifier associated with the coordinate system. + + + + Gets the dimension of the given value or, if the value is a collections, the largest element dimension. + + + The dimension of the given value. + + + + Gets the spatial type name of the DBGeography. + The spatial type name of the DBGeography. + + + Gets a nullable Boolean value indicating whether this DbGeography value is empty. + True if this DbGeography value is empty; otherwise, false. + + + Gets the number of elements in this DbGeography value, if it represents a geography collection. <returns>The number of elements in this geography value, if it represents a collection of other geography values; otherwise null.</returns> + The number of elements in this DbGeography value. + + + Gets the Latitude coordinate of this DbGeography value, if it represents a point. <returns>The Latitude coordinate value of this geography value, if it represents a point; otherwise null.</returns> + The Latitude coordinate of this DbGeography value. + + + Gets the Longitude coordinate of this DbGeography value, if it represents a point. <returns>The Longitude coordinate value of this geography value, if it represents a point; otherwise null.</returns> + The Longitude coordinate of this DbGeography value. + + + Gets the elevation (Z coordinate) of this DbGeography value, if it represents a point. <returns>The elevation (Z coordinate) value of this geography value, if it represents a point; otherwise null.</returns> + The elevation (Z coordinate) of this DbGeography value. + + + Gets the M (Measure) coordinate of this DbGeography value, if it represents a point. <returns>The M (Measure) coordinate value of this geography value, if it represents a point; otherwise null.</returns> + The M (Measure) coordinate of this DbGeography value. + + + Gets a nullable double value that indicates the length of this DbGeography value, which may be null if this value does not represent a curve. + A nullable double value that indicates the length of this DbGeography value. + + + Gets a DbGeography value representing the start point of this value, which may be null if this DbGeography value does not represent a curve. + A DbGeography value representing the start point of this value. + + + Gets a DbGeography value representing the start point of this value, which may be null if this DbGeography value does not represent a curve. + A DbGeography value representing the start point of this value. + + + Gets a nullable Boolean value indicating whether this DbGeography value is closed, which may be null if this value does not represent a curve. + True if this DbGeography value is closed; otherwise, false. + + + Gets the number of points in this DbGeography value, if it represents a linestring or linear ring. <returns>The number of elements in this geography value, if it represents a linestring or linear ring; otherwise null.</returns> + The number of points in this DbGeography value. + + + Gets a nullable double value that indicates the area of this DbGeography value, which may be null if this value does not represent a surface. + A nullable double value that indicates the area of this DbGeography value. + + + + A data contract serializable representation of a value. + + + + Gets or sets the coordinate system identifier (SRID) of this value. + + + Gets or sets the well known text representation of this value. + + + Gets or sets the well known binary representation of this value. + + + + Represents geometric shapes. + + + + + Creates a new value based on the specified well known binary value. + + + A new DbGeometry value as defined by the well known binary value with the default geometry coordinate system identifier ( + + ). + + A byte array that contains a well known binary representation of the geometry value. + wellKnownBinary + + + + Creates a new value based on the specified well known binary value and coordinate system identifier (SRID). + + A new DbGeometry value as defined by the well known binary value with the specified coordinate system identifier. + A byte array that contains a well known binary representation of the geometry value. + The identifier of the coordinate system that the new DbGeometry value should use. + wellKnownBinary + coordinateSystemId + + + + Creates a new line value based on the specified well known binary value and coordinate system identifier (SRID). + + A new DbGeometry value as defined by the well known binary value with the specified coordinate system identifier. + A byte array that contains a well known binary representation of the geometry value. + The identifier of the coordinate system that the new DbGeometry value should use. + lineWellKnownBinary + coordinateSystemId + + + + Creates a new point value based on the specified well known binary value and coordinate system identifier (SRID). + + A new DbGeometry value as defined by the well known binary value with the specified coordinate system identifier. + A byte array that contains a well known binary representation of the geometry value. + The identifier of the coordinate system that the new DbGeometry value should use. + pointWellKnownBinary + coordinateSystemId + + + + Creates a new polygon value based on the specified well known binary value and coordinate system identifier (SRID). + + A new DbGeometry value as defined by the well known binary value with the specified coordinate system identifier. + A byte array that contains a well known binary representation of the geometry value. + The identifier of the coordinate system that the new DbGeometry value should use. + polygonWellKnownBinary + coordinateSystemId + + + Returns the multiline value from a binary value. + The multiline value from a binary value. + The well-known binary value. + The coordinate system identifier. + + + Returns the multipoint value from a well-known binary value. + The multipoint value from a well-known binary value. + The well-known binary value. + The coordinate system identifier. + + + Returns the multi polygon value from a well-known binary value. + The multipoint value from a well-known text value. + The multi polygon well-known text value. + The coordinate system identifier. + + + + Creates a new collection value based on the specified well known binary value and coordinate system identifier (SRID). + + A new DbGeometry value as defined by the well known binary value with the specified coordinate system identifier. + A byte array that contains a well known binary representation of the geometry value. + The identifier of the coordinate system that the new DbGeometry value should use. + geometryCollectionWellKnownBinary + coordinateSystemId + + + + Creates a new value based on the specified Geography Markup Language (GML) value. + + + A new DbGeometry value as defined by the GML value with the default geometry coordinate system identifier (SRID) ( + + ). + + A string that contains a Geography Markup Language (GML) representation of the geometry value. + geometryMarkup + + + + Creates a new value based on the specified Geography Markup Language (GML) value and coordinate system identifier (SRID). + + A new DbGeometry value as defined by the GML value with the specified coordinate system identifier. + A string that contains a Geography Markup Language (GML) representation of the geometry value. + The identifier of the coordinate system that the new DbGeometry value should use. + geometryMarkup + coordinateSystemId + + + + Creates a new value based on the specified well known text value. + + + A new DbGeometry value as defined by the well known text value with the default geometry coordinate system identifier (SRID) ( + + ). + + A string that contains a well known text representation of the geometry value. + wellKnownText + + + + Creates a new value based on the specified well known text value and coordinate system identifier (SRID). + + A new DbGeometry value as defined by the well known text value with the specified coordinate system identifier. + A string that contains a well known text representation of the geometry value. + The identifier of the coordinate system that the new DbGeometry value should use. + wellKnownText + coordinateSystemId + + + + Creates a new line value based on the specified well known text value and coordinate system identifier (SRID). + + A new DbGeometry value as defined by the well known text value with the specified coordinate system identifier. + A string that contains a well known text representation of the geometry value. + The identifier of the coordinate system that the new DbGeometry value should use. + lineWellKnownText + coordinateSystemId + + + + Creates a new point value based on the specified well known text value and coordinate system identifier (SRID). + + A new DbGeometry value as defined by the well known text value with the specified coordinate system identifier. + A string that contains a well known text representation of the geometry value. + The identifier of the coordinate system that the new DbGeometry value should use. + pointWellKnownText + coordinateSystemId + + + + Creates a new polygon value based on the specified well known text value and coordinate system identifier (SRID). + + A new DbGeometry value as defined by the well known text value with the specified coordinate system identifier. + A string that contains a well known text representation of the geometry value. + The identifier of the coordinate system that the new DbGeometry value should use. + polygonWellKnownText + coordinateSystemId + + + Returns the multiline value from a well-known text value. + The multiline value from a well-known text value. + The well-known text. + The coordinate system identifier. + + + Returns the multipoint value from a well-known text value. + The multipoint value from a well-known text value. + The well-known text value. + The coordinate system identifier. + + + Returns the multi polygon value from a well-known binary value. + The multi polygon value from a well-known binary value. + The multi polygon well-known text value. + The coordinate system identifier. + + + + Creates a new collection value based on the specified well known text value and coordinate system identifier (SRID). + + A new DbGeometry value as defined by the well known text value with the specified coordinate system identifier. + A string that contains a well known text representation of the geometry value. + The identifier of the coordinate system that the new DbGeometry value should use. + geometryCollectionWellKnownText + coordinateSystemId + + + Generates the well known text representation of this DbGeometry value. Includes only X and Y coordinates for points. + A string containing the well known text representation of this DbGeometry value. + + + Generates the well known binary representation of this DbGeometry value. + The well-known binary representation of this DbGeometry value. + + + Generates the Geography Markup Language (GML) representation of this DbGeometry value. + A string containing the GML representation of this DbGeometry value. + + + Determines whether this DbGeometry is spatially equal to the specified DbGeometry argument. + true if other is spatially equal to this geometry value; otherwise false. + The geometry value that should be compared with this geometry value for equality. + other + + + Determines whether this DbGeometry is spatially disjoint from the specified DbGeometry argument. + true if other is disjoint from this geometry value; otherwise false. + The geometry value that should be compared with this geometry value for disjointness. + other + + + Determines whether this DbGeometry value spatially intersects the specified DbGeometry argument. + true if other intersects this geometry value; otherwise false. + The geometry value that should be compared with this geometry value for intersection. + other + + + Determines whether this DbGeometry value spatially touches the specified DbGeometry argument. + true if other touches this geometry value; otherwise false. + The geometry value that should be compared with this geometry value. + other + + + Determines whether this DbGeometry value spatially crosses the specified DbGeometry argument. + true if other crosses this geometry value; otherwise false. + The geometry value that should be compared with this geometry value. + other + + + Determines whether this DbGeometry value is spatially within the specified DbGeometry argument. + true if this geometry value is within other; otherwise false. + The geometry value that should be compared with this geometry value for containment. + other + + + Determines whether this DbGeometry value spatially contains the specified DbGeometry argument. + true if this geometry value contains other; otherwise false. + The geometry value that should be compared with this geometry value for containment. + other + + + Determines whether this DbGeometry value spatially overlaps the specified DbGeometry argument. + true if this geometry value overlaps other; otherwise false. + The geometry value that should be compared with this geometry value for overlap. + other + + + Determines whether this DbGeometry value spatially relates to the specified DbGeometry argument according to the given Dimensionally Extended Nine-Intersection Model (DE-9IM) intersection pattern. + true if this geometry value relates to other according to the specified intersection pattern matrix; otherwise false. + The geometry value that should be compared with this geometry value for relation. + A string that contains the text representation of the (DE-9IM) intersection pattern that defines the relation. + othermatrix + + + Returns a geometry object that represents the union of all points whose distance from a geometry instance is less than or equal to a specified value. + A geometry object that represents the union of all points. + The distance. + + + Computes the distance between the closest points in this DbGeometry value and another DbGeometry value. + A double value that specifies the distance between the two closest points in this geometry value and other. + The geometry value for which the distance from this value should be computed. + other + + + Computes the intersection of this DbGeometry value and another DbGeometry value. + A new DbGeometry value representing the intersection between this geometry value and other. + The geometry value for which the intersection with this value should be computed. + other + + + Computes the union of this DbGeometry value and another DbGeometry value. + A new DbGeometry value representing the union between this geometry value and other. + The geometry value for which the union with this value should be computed. + other + + + Computes the difference between this DbGeometry value and another DbGeometry value. + A new DbGeometry value representing the difference between this geometry value and other. + The geometry value for which the difference with this value should be computed. + other + + + Computes the symmetric difference between this DbGeometry value and another DbGeometry value. + A new DbGeometry value representing the symmetric difference between this geometry value and other. + The geometry value for which the symmetric difference with this value should be computed. + other + + + Returns an element of this DbGeometry value from a specific position, if it represents a geometry collection. <param name="index">The position within this geometry value from which the element should be taken.</param><returns>The element in this geometry value at the specified position, if it represents a collection of other geometry values; otherwise null.</returns> + An element of this DbGeometry value from a specific position. + The index. + + + Returns an element of this DbGeometry value from a specific position, if it represents a linestring or linear ring. <param name="index">The position within this geometry value from which the element should be taken.</param><returns>The element in this geometry value at the specified position, if it represents a linestring or linear ring; otherwise null.</returns> + An element of this DbGeometry value from a specific position. + The index. + + + Returns an interior ring from this DbGeometry value at a specific position, if it represents a polygon. <param name="index">The position within this geometry value from which the interior ring should be taken.</param><returns>The interior ring in this geometry value at the specified position, if it represents a polygon; otherwise null.</returns> + An interior ring from this DbGeometry value at a specific position. + The index. + + + Returns a string representation of the geometry value. + A string representation of the geometry value. + + + Gets the default coordinate system id (SRID) for geometry values. + The default coordinate system id (SRID) for geometry values. + + + Gets a representation of this DbGeometry value that is specific to the underlying provider that constructed it. + A representation of this DbGeometry value. + + + + Gets the spatial provider that will be used for operations on this spatial type. + + + + Gets or sets a data contract serializable well known representation of this DbGeometry value. + A data contract serializable well known representation of this DbGeometry value. + + + Gets the coordinate system identifier of the DbGeometry object. + The coordinate system identifier of the DbGeometry object. + + + Gets the boundary of the DbGeometry objects. + The boundary of the DbGeometry objects. + + + + Gets the dimension of the given value or, if the value is a collection, the dimension of its largest element. + + + The dimension of the given value. + + + + Gets the envelope (minimum bounding box) of this DbGeometry value, as a geometry value. + The envelope (minimum bounding box) of this DbGeometry value. + + + Gets a spatial type name representation of this DbGeometry value. + A spatial type name representation of this DbGeometry value. + + + Gets a nullable Boolean value indicating whether this DbGeometry value is empty, which may be null if this value does not represent a curve. + True if this DbGeometry value is empty; otherwise, false. + + + Gets a nullable Boolean value indicating whether this DbGeometry value is simple. + True if this DbGeometry value is simple; otherwise, false. + + + Gets a nullable Boolean value indicating whether this DbGeometry value is valid. + True if this DbGeometry value is valid; otherwise, false. + + + Gets the convex hull of this DbGeometry value as another DbGeometry value. + The convex hull of this DbGeometry value as another DbGeometry value. + + + Gets the number of elements in this DbGeometry value, if it represents a geometry collection. <returns>The number of elements in this geometry value, if it represents a collection of other geometry values; otherwise null.</returns> + The number of elements in this DbGeometry value. + + + Gets the X coordinate of this DbGeometry value, if it represents a point. <returns>The X coordinate value of this geometry value, if it represents a point; otherwise null.</returns> + The X coordinate of this DbGeometry value. + + + Gets the Y coordinate of this DbGeometry value, if it represents a point. <returns>The Y coordinate value of this geometry value, if it represents a point; otherwise null.</returns> + The Y coordinate of this DbGeometry value. + + + Gets the elevation (Z coordinate) of this DbGeometry value, if it represents a point. <returns>The elevation (Z coordinate) of this geometry value, if it represents a point; otherwise null.</returns> + The elevation (Z coordinate) of this DbGeometry value. + + + Gets the Measure (M coordinate) of this DbGeometry value, if it represents a point. <returns>The Measure (M coordinate) value of this geometry value, if it represents a point; otherwise null.</returns> + The Measure (M coordinate) of this DbGeometry value. + + + Gets a nullable double value that indicates the length of this DbGeometry value, which may be null if this value does not represent a curve. + The length of this DbGeometry value. + + + Gets a DbGeometry value representing the start point of this value, which may be null if this DbGeometry value does not represent a curve. + A DbGeometry value representing the start point of this value. + + + Gets a DbGeometry value representing the start point of this value, which may be null if this DbGeometry value does not represent a curve. + A DbGeometry value representing the start point of this value. + + + Gets a nullable Boolean value indicating whether this DbGeometry value is closed, which may be null if this value does not represent a curve. + True if this DbGeometry value is closed; otherwise, false. + + + Gets a nullable Boolean value indicating whether this DbGeometry value is a ring, which may be null if this value does not represent a curve. + True if this DbGeometry value is a ring; otherwise, false. + + + Gets the number of points in this DbGeometry value, if it represents a linestring or linear ring. <returns>The number of elements in this geometry value, if it represents a linestring or linear ring; otherwise null.</returns> + The number of points in this DbGeometry value. + + + Gets a nullable double value that indicates the area of this DbGeometry value, which may be null if this value does not represent a surface. + A nullable double value that indicates the area of this DbGeometry value. + + + Gets the DbGeometry value that represents the centroid of this DbGeometry value, which may be null if this value does not represent a surface. + The DbGeometry value that represents the centroid of this DbGeometry value. + + + Gets a point on the surface of this DbGeometry value, which may be null if this value does not represent a surface. + A point on the surface of this DbGeometry value. + + + Gets the DbGeometry value that represents the exterior ring of this DbGeometry value, which may be null if this value does not represent a polygon. + The DbGeometry value that represents the exterior ring of this DbGeometry value. + + + Gets the number of interior rings in this DbGeometry value, if it represents a polygon. <returns>The number of elements in this geometry value, if it represents a polygon; otherwise null.</returns> + The number of interior rings in this DbGeometry value. + + + + A data contract serializable representation of a value. + + + + Gets or sets the coordinate system identifier (SRID) of this value. + + + Gets or sets the well known text representation of this value. + + + Gets or sets the well known binary representation of this value. + + + + A provider-independent service API for geospatial (Geometry/Geography) type support. + + + + + When implemented in derived types, reads an instance of from the column at the specified column ordinal. + + The instance of DbGeography at the specified column value + The ordinal of the column that contains the geography value + + + + Asynchronously reads an instance of from the column at the specified column ordinal. + + + Providers should override with an appropriate implementation. + The default implementation invokes the synchronous method and returns + a completed task, blocking the calling thread. + + The ordinal of the column that contains the geography value. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the instance of at the specified column value. + + + + + When implemented in derived types, reads an instance of from the column at the specified column ordinal. + + The instance of DbGeometry at the specified column value + The ordinal of the data record column that contains the provider-specific geometry data + + + + Asynchronously reads an instance of from the column at the specified column ordinal. + + + Providers should override with an appropriate implementation. + The default implementation invokes the synchronous method and returns + a completed task, blocking the calling thread. + + The ordinal of the data record column that contains the provider-specific geometry data. + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the instance of at the specified column value. + + + + + Returns whether the column at the specified column ordinal is of geography type + + The column ordinal. + + true if the column at the specified column ordinal is of geography type; + false otherwise. + + + + + Returns whether the column at the specified column ordinal is of geometry type + + The column ordinal. + + true if the column at the specified column ordinal is of geometry type; + false otherwise. + + + + + A provider-independent service API for geospatial (Geometry/Geography) type support. + + + + + This method is intended for use by derived implementations of + + after suitable validation of the specified provider value to ensure it is suitable for use with the derived implementation. + + + A new instance that contains the specified providerValue and uses the specified spatialServices as its spatial implementation. + + + The spatial services instance that the returned value will depend on for its implementation of spatial functionality. + + The provider value. + + + + Creates a new value based on a provider-specific value that is compatible with this spatial services implementation. + + + A new value backed by this spatial services implementation and the specified provider value. + + A provider-specific value that this spatial services implementation is capable of interpreting as a geography value. + A new DbGeography value backed by this spatial services implementation and the specified provider value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Creates a provider-specific value compatible with this spatial services implementation based on the specified well-known + + representation. + + A provider-specific value that encodes the information contained in wellKnownValue in a fashion compatible with this spatial services implementation. + + An instance of that contains the well-known representation of a geography value. + + + + + Creates an instance of that represents the specified + + value using one or both of the standard well-known spatial formats. + + + The well-known representation of geographyValue, as a new + + . + + The geography value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Creates a new value based on the specified well-known binary value. + + + A new value as defined by the well-known binary value with the default + + coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geography value. + + + + Creates a new value based on the specified well-known binary value and coordinate system identifier (SRID). + + + A new value as defined by the well-known binary value with the specified coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geography value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new line value based on the specified well-known binary value and coordinate system identifier (SRID). + + + A new value as defined by the well-known binary value with the specified coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geography value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new point value based on the specified well-known binary value and coordinate system identifier (SRID). + + + A new value as defined by the well-known binary value with the specified coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geography value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new polygon value based on the specified well-known binary value and coordinate system identifier (SRID). + + + A new value as defined by the well-known binary value with the specified coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geography value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new multiline value based on the specified well-known binary value and coordinate system identifier. + + + The new multiline value. + + The well-known binary value. + The coordinate system identifier. + + + + Creates a new multipoint value based on the specified well-known binary value and coordinate system identifier. + + + A new multipoint value. + + The well-known binary value. + The coordinate system identifier. + + + + Creates a new multi polygon value based on the specified well-known binary value and coordinate system identifier. + + + A new multi polygon value. + + The well-known binary value. + The coordinate system identifier. + + + + Creates a new collection value based on the specified well-known binary value and coordinate system identifier (SRID). + + + A new value as defined by the well-known binary value with the specified coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geography value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new value based on the specified well-known text value. + + + A new value as defined by the well-known text value with the default + + coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geography value. + + + + Creates a new value based on the specified well-known text value and coordinate system identifier (SRID). + + + A new value as defined by the well-known text value with the specified coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geography value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new line value based on the specified well-known text value and coordinate system identifier (SRID). + + + A new value as defined by the well-known text value with the specified coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geography value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new point value based on the specified well-known text value and coordinate system identifier (SRID). + + + A new value as defined by the well-known text value with the specified coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geography value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new polygon value based on the specified well-known text value and coordinate system identifier (SRID). + + + A new value as defined by the well-known text value with the specified coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geography value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new multiline value based on the specified well-known text value and coordinate system identifier. + + + A new multiline value. + + The well-known text value. + The coordinate system identifier. + + + + Creates a new multipoint value based on the specified well-known text value and coordinate system identifier. + + + A new multipoint value. + + The well-known text value. + The coordinate system identifier. + + + + Creates a new multi polygon value based on the specified well-known text value and coordinate system identifier. + + + A new multi polygon value. + + The well-known text value. + The coordinate system identifier. + + + + Creates a new collection value based on the specified well-known text value and coordinate system identifier (SRID). + + + A new value as defined by the well-known text value with the specified coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geography value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new value based on the specified Geography Markup Language (GML) value. + + + A new value as defined by the GML value with the default + + coordinate system identifier (SRID) ( + + ). + + A string that contains a Geometry Markup Language (GML) representation of the geography value. + + + + Creates a new value based on the specified Geography Markup Language (GML) value and coordinate system identifier (SRID). + + + A new value as defined by the GML value with the specified coordinate system identifier (SRID). + + A string that contains a Geometry Markup Language (GML) representation of the geography value. + + The identifier of the coordinate system that the new value should use. + + + + + Returns the coordinate system identifier of the given value. + + + The coordinate system identifier of the given value. + + The geography value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Gets the dimension of the given value or, if the value is a collections, the largest element dimension. + + + The dimension of geographyValue, or the largest element dimension if + + is a collection. + + The geography value for which the dimension value should be retrieved. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a value that indicates the spatial type name of the given + + value. + + + The spatial type name of the given value. + + The geography value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable Boolean value that whether the given value is empty. + + + True if the given value is empty; otherwise, false. + + The geography value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Gets the well-known text representation of the given value. This value should include only the Longitude and Latitude of points. + + A string containing the well-known text representation of geographyValue. + The geography value for which the well-known text should be generated. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a text representation of with elevation and measure. + + + A text representation of . + + The geography value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Gets the well-known binary representation of the given value. + + + The well-known binary representation of the given value. + + The geography value for which the well-known binary should be generated. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Generates the Geography Markup Language (GML) representation of this + + value. + + A string containing the GML representation of this DbGeography value. + The geography value for which the GML should be generated. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Determines whether the two given values are spatially equal. + + true if geographyValue is spatially equal to otherGeography; otherwise false. + The first geography value to compare for equality. + The second geography value to compare for equality. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Determines whether the two given values are spatially disjoint. + + true if geographyValue is disjoint from otherGeography; otherwise false. + The first geography value to compare for disjointness. + The second geography value to compare for disjointness. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Determines whether the two given values spatially intersect. + + true if geographyValue intersects otherGeography; otherwise false. + The first geography value to compare for intersection. + The second geography value to compare for intersection. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Creates a geography value representing all points less than or equal to distance from the given + + value. + + A new DbGeography value representing all points less than or equal to distance from geographyValue. + The geography value. + A double value specifying how far from geographyValue to buffer. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Computes the distance between the closest points in two values. + + A double value that specifies the distance between the two closest points in geographyValue and otherGeography. + The first geography value. + The second geography value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Computes the intersection of two values. + + + A new value representing the intersection of geographyValue and otherGeography. + + The first geography value. + The second geography value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Computes the union of two values. + + + A new value representing the union of geographyValue and otherGeography. + + The first geography value. + The second geography value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Computes the difference of two values. + + A new DbGeography value representing the difference of geographyValue and otherGeography. + The first geography value. + The second geography value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Computes the symmetric difference of two values. + + + A new value representing the symmetric difference of geographyValue and otherGeography. + + The first geography value. + The second geography value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Returns the number of elements in the given value, if it represents a geography collection. + + The number of elements in geographyValue, if it represents a collection of other geography values; otherwise null. + The geography value, which need not represent a geography collection. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns an element of the given value, if it represents a geography collection. + + The element in geographyValue at position index, if it represents a collection of other geography values; otherwise null. + The geography value, which need not represent a geography collection. + The position within the geography value from which the element should be taken. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns the Latitude coordinate of the given value, if it represents a point. + + + The Latitude coordinate of the given value. + + The geography value, which need not represent a point. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns the Longitude coordinate of the given value, if it represents a point. + + + The Longitude coordinate of the given value. + + The geography value, which need not represent a point. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns the elevation (Z coordinate) of the given value, if it represents a point. + + The elevation (Z coordinate) of geographyValue, if it represents a point; otherwise null. + The geography value, which need not represent a point. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns the M (Measure) coordinate of the given value, if it represents a point. + + + The M (Measure) coordinate of the given value. + + The geography value, which need not represent a point. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable double value that indicates the length of the given + + value, which may be null if the value does not represent a curve. + + + The length of the given value. + + The geography value, which need not represent a curve. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a value that represents the start point of the given DbGeography value, which may be null if the value does not represent a curve. + + + The start point of the given value. + + The geography value, which need not represent a curve. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a value that represents the end point of the given DbGeography value, which may be null if the value does not represent a curve. + + The end point of geographyValue, if it represents a curve; otherwise null. + The geography value, which need not represent a curve. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable Boolean value that whether the given value is closed, which may be null if the value does not represent a curve. + + + True if the given value is closed; otherwise, false. + + The geography value, which need not represent a curve. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns the number of points in the given value, if it represents a linestring or linear ring. + + + The number of points in the given value. + + The geography value, which need not represent a linestring or linear ring. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a point element of the given value, if it represents a linestring or linear ring. + + The point in geographyValue at position index, if it represents a linestring or linear ring; otherwise null. + The geography value, which need not represent a linestring or linear ring. + The position within the geography value from which the element should be taken. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable double value that indicates the area of the given + + value, which may be null if the value does not represent a surface. + + + A nullable double value that indicates the area of the given value. + + The geography value, which need not represent a surface. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + This method is intended for use by derived implementations of + + after suitable validation of the specified provider value to ensure it is suitable for use with the derived implementation. + + + A new instance that contains the specified providerValue and uses the specified spatialServices as its spatial implementation. + + + The spatial services instance that the returned value will depend on for its implementation of spatial functionality. + + A provider value. + + + + Creates a provider-specific value compatible with this spatial services implementation based on the specified well-known + + representation. + + A provider-specific value that encodes the information contained in wellKnownValue in a fashion compatible with this spatial services implementation. + + An instance of that contains the well-known representation of a geometry value. + + + + + Creates an instance of that represents the specified + + value using one or both of the standard well-known spatial formats. + + + The well-known representation of geometryValue, as a new + + . + + The geometry value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Creates a new value based on a provider-specific value that is compatible with this spatial services implementation. + + + A new value backed by this spatial services implementation and the specified provider value. + + A provider-specific value that this spatial services implementation is capable of interpreting as a geometry value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Creates a new value based on the specified well-known binary value. + + + A new value as defined by the well-known binary value with the default + + coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geometry value. + + + + Creates a new value based on the specified well-known binary value and coordinate system identifier (SRID). + + + A new value as defined by the well-known binary value with the specified coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geometry value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new line value based on the specified well-known binary value and coordinate system identifier (SRID). + + + A new value as defined by the well-known binary value with the specified coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geometry value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new point value based on the specified well-known binary value and coordinate system identifier (SRID). + + + A new value as defined by the well-known binary value with the specified coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geometry value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new polygon value based on the specified well-known binary value and coordinate system identifier (SRID). + + + A new value as defined by the well-known binary value with the specified coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geometry value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new multiline value based on the specified well-known binary value and coordinate system identifier. + + + The new multiline value + + The well-known binary value. + The coordinate system identifier. + + + + Creates a new multipoint value based on the specified well-known binary value and coordinate system identifier. + + + A new multipoint value. + + The well-known binary value. + The coordinate system identifier. + + + + Creates a new multi polygon value based on the specified well-known binary value and coordinate system identifier. + + + A new multi polygon value. + + The well-known binary value. + The coordinate system identifier. + + + + Creates a new collection value based on the specified well-known binary value and coordinate system identifier (SRID). + + + A new value as defined by the well-known binary value with the specified coordinate system identifier (SRID) ( + + ). + + A byte array that contains a well-known binary representation of the geometry value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new value based on the specified well-known text value. + + + A new value as defined by the well-known text value with the default + + coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geometry value. + + + + Creates a new value based on the specified well-known text value and coordinate system identifier (SRID). + + + A new value as defined by the well-known text value with the specified coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geometry value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new line value based on the specified well-known text value and coordinate system identifier (SRID). + + + A new value as defined by the well-known text value with the specified coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geometry value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new point value based on the specified well-known text value and coordinate system identifier (SRID). + + + A new value as defined by the well-known text value with the specified coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geometry value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new polygon value based on the specified well-known text value and coordinate system identifier (SRID). + + + A new value as defined by the well-known text value with the specified coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geometry value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new multiline value based on the specified well-known text value and coordinate system identifier. + + + A new multiline value + + The well-known text value. + The coordinate system identifier. + + + + Creates a new multipoint value based on the specified well-known text value and coordinate system identifier. + + + A new multipoint value. + + The well-known text value. + The coordinate system identifier. + + + + Creates a new multi polygon value based on the specified well-known text value and coordinate system identifier. + + + A new multi polygon value. + + The well-known text value. + The coordinate system identifier. + + + + Creates a new collection value based on the specified well-known text value and coordinate system identifier (SRID). + + + A new value as defined by the well-known text value with the specified coordinate system identifier (SRID) ( + + ). + + A string that contains a well-known text representation of the geometry value. + + The identifier of the coordinate system that the new value should use. + + + + + Creates a new value based on the specified Geography Markup Language (GML) value. + + + A new value as defined by the GML value with the default + + coordinate system identifier (SRID) ( + + ). + + A string that contains a Geography Markup Language (GML) representation of the geometry value. + + + + Creates a new value based on the specified Geography Markup Language (GML) value and coordinate system identifier (SRID). + + + A new value as defined by the GML value with the specified coordinate system identifier (SRID). + + A string that contains a Geography Markup Language (GML) representation of the geometry value. + + The identifier of the coordinate system that the new value should use. + + + + + Returns the coordinate system identifier of the given value. + + + The coordinate system identifier of the given value. + + The geometry value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable double value that indicates the boundary of the given + + value. + + + The boundary of the given value. + + The geometry value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Gets the dimension of the given value or, if the value is a collections, the largest element dimension. + + + The dimension of geometryValue, or the largest element dimension if + + is a collection. + + The geometry value for which the dimension value should be retrieved. + + + + Gets the envelope (minimum bounding box) of the given value, as a geometry value. + + + The envelope of geometryValue, as a value. + + The geometry value for which the envelope value should be retrieved. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a value that indicates the spatial type name of the given + + value. + + + The spatial type name of the given value. + + The geometry value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable Boolean value that whether the given value is empty. + + + True if the given value is empty; otherwise, false. + + The geometry value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable Boolean value that whether the given value is simple. + + + True if the given value is simple; otherwise, false. + + The geometry value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable Boolean value that whether the given value is valid. + + + True if the given value is valid; otherwise, false. + + The geometry value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Gets the well-known text representation of the given value, including only X and Y coordinates for points. + + A string containing the well-known text representation of geometryValue. + The geometry value for which the well-known text should be generated. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a text representation of with elevation and measure. + + + A text representation of with elevation and measure. + + The geometry value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Gets the well-known binary representation of the given value. + + + The well-known binary representation of the given value. + + The geometry value for which the well-known binary should be generated. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Generates the Geography Markup Language (GML) representation of this + + value. + + A string containing the GML representation of this DbGeometry value. + The geometry value for which the GML should be generated. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Determines whether the two given values are spatially equal. + + true if geometryValue is spatially equal to otherGeometry; otherwise false. + The first geometry value to compare for equality. + The second geometry value to compare for equality. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Determines whether the two given values are spatially disjoint. + + true if geometryValue is disjoint from otherGeometry; otherwise false. + The first geometry value to compare for disjointness. + The second geometry value to compare for disjointness. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Determines whether the two given values spatially intersect. + + true if geometryValue intersects otherGeometry; otherwise false. + The first geometry value to compare for intersection. + The second geometry value to compare for intersection. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Determines whether the two given values spatially touch. + + true if geometryValue touches otherGeometry; otherwise false. + The first geometry value. + The second geometry value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Determines whether the two given values spatially cross. + + true if geometryValue crosses otherGeometry; otherwise false. + The first geometry value. + The second geometry value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Determines whether one value is spatially within the other. + + true if geometryValue is within otherGeometry; otherwise false. + The first geometry value. + The second geometry value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Determines whether one value spatially contains the other. + + true if geometryValue contains otherGeometry; otherwise false. + The first geometry value. + The second geometry value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Determines whether the two given values spatially overlap. + + true if geometryValue overlaps otherGeometry; otherwise false. + The first geometry value. + The second geometry value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Determines whether the two given values are spatially related according to the given Dimensionally Extended Nine-Intersection Model (DE-9IM) intersection pattern. + + true if this geometryValue value relates to otherGeometry according to the specified intersection pattern matrix; otherwise false. + The first geometry value. + The geometry value that should be compared with the first geometry value for relation. + A string that contains the text representation of the (DE-9IM) intersection pattern that defines the relation. + + + , + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Creates a geometry value representing all points less than or equal to distance from the given + + value. + + A new DbGeometry value representing all points less than or equal to distance from geometryValue. + The geometry value. + A double value specifying how far from geometryValue to buffer. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Computes the distance between the closest points in two values. + + A double value that specifies the distance between the two closest points in geometryValue and otherGeometry. + The first geometry value. + The second geometry value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Returns a nullable double value that indicates the convex hull of the given + + value. + + + The convex hull of the given value. + + The geometry value. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Computes the intersection of two values. + + + A new value representing the intersection of geometryValue and otherGeometry. + + The first geometry value. + The second geometry value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Computes the union of two values. + + + A new value representing the union of geometryValue and otherGeometry. + + The first geometry value. + The second geometry value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Computes the difference between two values. + + A new DbGeometry value representing the difference between geometryValue and otherGeometry. + The first geometry value. + The second geometry value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Computes the symmetric difference between two values. + + + A new value representing the symmetric difference between geometryValue and otherGeometry. + + The first geometry value. + The second geometry value. + + + or + + is null. + + + + or + + is not compatible with this spatial services implementation. + + + + + Returns the number of elements in the given value, if it represents a geometry collection. + + The number of elements in geometryValue, if it represents a collection of other geometry values; otherwise null. + The geometry value, which need not represent a geometry collection. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns an element of the given value, if it represents a geometry collection. + + The element in geometryValue at position index, if it represents a collection of other geometry values; otherwise null. + The geometry value, which need not represent a geometry collection. + The position within the geometry value from which the element should be taken. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns the X coordinate of the given value, if it represents a point. + + + The X coordinate of the given value. + + The geometry value, which need not represent a point. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns the Y coordinate of the given value, if it represents a point. + + + The Y coordinate of the given value. + + The geometry value, which need not represent a point. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns the elevation (Z) of the given value, if it represents a point. + + The elevation (Z) of geometryValue, if it represents a point; otherwise null. + The geometry value, which need not represent a point. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns the M (Measure) coordinate of the given value, if it represents a point. + + + The M (Measure) coordinate of the given value. + + The geometry value, which need not represent a point. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable double value that indicates the length of the given + + value, which may be null if the value does not represent a curve. + + + The length of the given value. + + The geometry value, which need not represent a curve. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a value that represents the start point of the given DbGeometry value, which may be null if the value does not represent a curve. + + + The start point of the given value. + + The geometry value, which need not represent a curve. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a value that represents the end point of the given DbGeometry value, which may be null if the value does not represent a curve. + + The end point of geometryValue, if it represents a curve; otherwise null. + The geometry value, which need not represent a curve. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable Boolean value that whether the given value is closed, which may be null if the value does not represent a curve. + + + True if the given value is closed; otherwise, false. + + The geometry value, which need not represent a curve. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable Boolean value that whether the given value is a ring, which may be null if the value does not represent a curve. + + + True if the given value is a ring; otherwise, false. + + The geometry value, which need not represent a curve. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns the number of points in the given value, if it represents a linestring or linear ring. + + + The number of points in the given value. + + The geometry value, which need not represent a linestring or linear ring. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a point element of the given value, if it represents a linestring or linear ring. + + The point in geometryValue at position index, if it represents a linestring or linear ring; otherwise null. + The geometry value, which need not represent a linestring or linear ring. + The position within the geometry value from which the element should be taken. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a nullable double value that indicates the area of the given + + value, which may be null if the value does not represent a surface. + + + A nullable double value that indicates the area of the given value. + + The geometry value, which need not represent a surface. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a value that represents the centroid of the given DbGeometry value, which may be null if the value does not represent a surface. + + The centroid of geometryValue, if it represents a surface; otherwise null. + The geometry value, which need not represent a surface. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a value that represents a point on the surface of the given DbGeometry value, which may be null if the value does not represent a surface. + + + A value that represents a point on the surface of the given DbGeometry value. + + The geometry value, which need not represent a surface. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns a value that represents the exterior ring of the given DbGeometry value, which may be null if the value does not represent a polygon. + + A DbGeometry value representing the exterior ring on geometryValue, if it represents a polygon; otherwise null. + The geometry value, which need not represent a polygon. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns the number of interior rings in the given value, if it represents a polygon. + + The number of elements in geometryValue, if it represents a polygon; otherwise null. + The geometry value, which need not represent a polygon. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Returns an interior ring from the given value, if it represents a polygon. + + The interior ring in geometryValue at position index, if it represents a polygon; otherwise null. + The geometry value, which need not represent a polygon. + The position within the geometry value from which the element should be taken. + + + is null. + + + + is not compatible with this spatial services implementation. + + + + + Gets the default services for the . + + The default services. + + + + Override this property to allow the spatial provider to fail fast when native types or other + resources needed for the spatial provider to function correctly are not available. + The default value is true which means that EF will continue with the assumption + that the provider has the necessary types/resources rather than failing fast. + + + + + The same as but works in partial trust and adds explicit caching of + generated indentation string and also recognizes writing a string that contains just \r\n or \n as a write-line to ensure + we indent the next line properly. + + + + + Specifies the default tab string. This field is constant. + + + + + Specifies the culture what will be used by the underlying TextWriter. This static property is read-only. + Note that any writer passed to one of the constructors of must use this + same culture. The culture is . + + + + + Initializes a new instance of the IndentedTextWriter class using the specified text writer and default tab string. + Note that the writer passed to this constructor must use the specified by the + property. + + + The to use for output. + + + + + Initializes a new instance of the IndentedTextWriter class using the specified text writer and tab string. + Note that the writer passed to this constructor must use the specified by the + property. + + + The to use for output. + + The tab string to use for indentation. + + + + Closes the document being written to. + + + + + Flushes the stream. + + + + + Outputs the tab string once for each level of indentation according to the + + property. + + + + + Builds a string representing the current indentation level for a new line. + + + Does NOT check if tabs are currently pending, just returns a string that would be + useful in replacing embedded newline characters. + + An empty string, or a string that contains .Indent level's worth of specified tab-string. + + + + Writes the specified string to the text stream. + + The string to write. + + + + Writes the text representation of a Boolean value to the text stream. + + The Boolean value to write. + + + + Writes a character to the text stream. + + The character to write. + + + + Writes a character array to the text stream. + + The character array to write. + + + + Writes a subarray of characters to the text stream. + + The character array to write data from. + Starting index in the buffer. + The number of characters to write. + + + + Writes the text representation of a Double to the text stream. + + The double to write. + + + + Writes the text representation of a Single to the text stream. + + The single to write. + + + + Writes the text representation of an integer to the text stream. + + The integer to write. + + + + Writes the text representation of an 8-byte integer to the text stream. + + The 8-byte integer to write. + + + + Writes the text representation of an object to the text stream. + + The object to write. + + + + Writes out a formatted string, using the same semantics as specified. + + The formatting string. + The object to write into the formatted string. + + + + Writes out a formatted string, using the same semantics as specified. + + The formatting string to use. + The first object to write into the formatted string. + The second object to write into the formatted string. + + + + Writes out a formatted string, using the same semantics as specified. + + The formatting string to use. + The argument array to output. + + + + Writes the specified string to a line without tabs. + + The string to write. + + + + Writes the specified string, followed by a line terminator, to the text stream. + + The string to write. + + + + Writes a line terminator. + + + + + Writes the text representation of a Boolean, followed by a line terminator, to the text stream. + + The Boolean to write. + + + + Writes a character, followed by a line terminator, to the text stream. + + The character to write. + + + + Writes a character array, followed by a line terminator, to the text stream. + + The character array to write. + + + + Writes a subarray of characters, followed by a line terminator, to the text stream. + + The character array to write data from. + Starting index in the buffer. + The number of characters to write. + + + + Writes the text representation of a Double, followed by a line terminator, to the text stream. + + The double to write. + + + + Writes the text representation of a Single, followed by a line terminator, to the text stream. + + The single to write. + + + + Writes the text representation of an integer, followed by a line terminator, to the text stream. + + The integer to write. + + + + Writes the text representation of an 8-byte integer, followed by a line terminator, to the text stream. + + The 8-byte integer to write. + + + + Writes the text representation of an object, followed by a line terminator, to the text stream. + + The object to write. + + + + Writes out a formatted string, followed by a line terminator, using the same semantics as specified. + + The formatting string. + The object to write into the formatted string. + + + + Writes out a formatted string, followed by a line terminator, using the same semantics as specified. + + The formatting string to use. + The first object to write into the formatted string. + The second object to write into the formatted string. + + + + Writes out a formatted string, followed by a line terminator, using the same semantics as specified. + + The formatting string to use. + The argument array to output. + + + + Writes the text representation of a UInt32, followed by a line terminator, to the text stream. + + A UInt32 to output. + + + + Gets the encoding for the text writer to use. + + + An that indicates the encoding for the text writer to use. + + + + + Gets or sets the new line character to use. + + The new line character to use. + + + + Gets or sets the number of spaces to indent. + + The number of spaces to indent. + + + + Gets the to use. + + + The to use. + + + + + Convention to apply column ordering specified via + + or the API. This convention throws if a duplicate configured column order + is detected. + + + + + Convention to apply column ordering specified via + + or the API. + + + + + + + + Validates the ordering configuration supplied for columns. + This base implementation is a no-op. + + The name of the table that the columns belong to. + The definition of the table. + + + + Validates the ordering configuration supplied for columns to ensure + that the same ordinal was not supplied for two columns. + + The name of the table that the columns belong to. + The definition of the table. + + + + Represents a conceptual or store model. This class can be used to access information about the shape of the model + and the way the that it has been configured. + + + + + Adds an association type to the model. + + The AssociationType instance to be added. + + + + Adds a complex type to the model. + + The ComplexType instance to be added. + + + + Adds an entity type to the model. + + The EntityType instance to be added. + + + + Adds an enumeration type to the model. + + The EnumType instance to be added. + + + + Adds a function to the model. + + The EdmFunction instance to be added. + + + + Removes an association type from the model. + + The AssociationType instance to be removed. + + + + Removes a complex type from the model. + + The ComplexType instance to be removed. + + + + Removes an entity type from the model. + + The EntityType instance to be removed. + + + + Removes an enumeration type from the model. + + The EnumType instance to be removed. + + + + Removes a function from the model. + + The EdmFunction instance to be removed. + + + Gets the built-in type kind for this type. + + A object that represents the built-in type kind for this type. + + + + + Gets the data space associated with the model, which indicates whether + it is a conceptual model (DataSpace.CSpace) or a store model (DataSpace.SSpace). + + + + + Gets the association types in the model. + + + + + Gets the complex types in the model. + + + + + Gets the entity types in the model. + + + + + Gets the enum types in the model. + + + + + Gets the functions in the model. + + + + + Gets the container that stores entity and association sets, and function imports. + + + + Gets the global items associated with the model. + The global items associated with the model. + + + + An implementation of IDatabaseInitializer that will recreate and optionally re-seed the + database only if the database does not exist. + To seed the database, create a derived class and override the Seed method. + + The type of the context. + + + Initializes a new instance of the class. + + + + Executes the strategy to initialize the database for the given context. + + The context. + + + + A method that should be overridden to actually add data to the context for seeding. + The default implementation does nothing. + + The context to seed. + + + + An instance of this class is obtained from an object and can be used + to manage the actual database backing a DbContext or connection. + This includes creating, deleting, and checking for the existence of a database. + Note that deletion and checking for existence of a database can be performed using just a + connection (i.e. without a full context) by using the static methods of this class. + + + + + Enables the user to pass in a database transaction created outside of the object + if you want the Entity Framework to execute commands within that external transaction. + Alternatively, pass in null to clear the framework's knowledge of that transaction. + + the external transaction + Thrown if the transaction is already completed + + Thrown if the connection associated with the object is already enlisted in a + + transaction + + + Thrown if the connection associated with the object is already participating in a transaction + + Thrown if the connection associated with the transaction does not match the Entity Framework's connection + + + + Begins a transaction on the underlying store connection + + + a object wrapping access to the underlying store's transaction object + + + + + Begins a transaction on the underlying store connection using the specified isolation level + + The database isolation level with which the underlying store transaction will be created + + a object wrapping access to the underlying store's transaction object + + + + + Sets the database initializer to use for the given context type. The database initializer is called when a + the given type is used to access a database for the first time. + The default strategy for Code First contexts is an instance of . + + The type of the context. + The initializer to use, or null to disable initialization for the given context type. + + + + Runs the the registered on this context. + If "force" is set to true, then the initializer is run regardless of whether or not it + has been run before. This can be useful if a database is deleted while an app is running + and needs to be reinitialized. + If "force" is set to false, then the initializer is only run if it has not already been + run for this context, model, and connection in this app domain. This method is typically + used when it is necessary to ensure that the database has been created and seeded + before starting some operation where doing so lazily will cause issues, such as when the + operation is part of a transaction. + + + If set to true the initializer is run even if it has already been run. + + + + + Checks whether or not the database is compatible with the the current Code First model. + + + Model compatibility currently uses the following rules. + If the context was created using either the Model First or Database First approach then the + model is assumed to be compatible with the database and this method returns true. + For Code First the model is considered compatible if the model is stored in the database + in the Migrations history table and that model has no differences from the current model as + determined by Migrations model differ. + If the model is not stored in the database but an EF 4.1/4.2 model hash is found instead, + then this is used to check for compatibility. + + + If set to true then an exception will be thrown if no model metadata is found in the database. If set to false then this method will return true if metadata is not found. + + True if the model hash in the context and the database match; false otherwise. + + + + Creates a new database on the database server for the model defined in the backing context. + Note that calling this method before the database initialization strategy has run will disable + executing that strategy. + + + + + Creates a new database on the database server for the model defined in the backing context, but only + if a database with the same name does not already exist on the server. + + True if the database did not exist and was created; false otherwise. + + + + Checks whether or not the database exists on the server. + + True if the database exists; false otherwise. + + + + Deletes the database on the database server if it exists, otherwise does nothing. + Calling this method from outside of an initializer will mark the database as having + not been initialized. This means that if an attempt is made to use the database again + after it has been deleted, then any initializer set will run again and, usually, will + try to create the database again automatically. + + True if the database did exist and was deleted; false otherwise. + + + + Checks whether or not the database exists on the server. + The connection to the database is created using the given database name or connection string + in the same way as is described in the documentation for the class. + + The database name or a connection string to the database. + True if the database exists; false otherwise. + + + + Deletes the database on the database server if it exists, otherwise does nothing. + The connection to the database is created using the given database name or connection string + in the same way as is described in the documentation for the class. + + The database name or a connection string to the database. + True if the database did exist and was deleted; false otherwise. + + + + Checks whether or not the database exists on the server. + + An existing connection to the database. + True if the database exists; false otherwise. + + + + Deletes the database on the database server if it exists, otherwise does nothing. + + An existing connection to the database. + True if the database did exist and was deleted; false otherwise. + + + + Creates a raw SQL query that will return elements of the given generic type. + The type can be any type that has properties that match the names of the columns returned + from the query, or can be a simple primitive type. The type does not have to be an + entity type. The results of this query are never tracked by the context even if the + type of object returned is an entity type. Use the + method to return entities that are tracked by the context. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.Database.SqlQuery<Post>("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.Database.SqlQuery<Post>("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + The type of object returned by the query. + The SQL query string. + + The parameters to apply to the SQL query string. If output parameters are used, their values will + not be available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + A object that will execute the query when it is enumerated. + + + + + Creates a raw SQL query that will return elements of the given type. + The type can be any type that has properties that match the names of the columns returned + from the query, or can be a simple primitive type. The type does not have to be an + entity type. The results of this query are never tracked by the context even if the + type of object returned is an entity type. Use the + method to return entities that are tracked by the context. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.Database.SqlQuery(typeof(Post), "SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.Database.SqlQuery(typeof(Post), "SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + The type of object returned by the query. + The SQL query string. + + The parameters to apply to the SQL query string. If output parameters are used, their values + will not be available until the results have been read completely. This is due to the underlying + behavior of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + A object that will execute the query when it is enumerated. + + + + + Executes the given DDL/DML command against the database. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.Database.ExecuteSqlCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.Database.ExecuteSqlCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + If there isn't an existing local or ambient transaction a new transaction will be used + to execute the command. + + The command string. + The parameters to apply to the command string. + The result returned by the database after executing the command. + + + + Executes the given DDL/DML command against the database. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.Database.ExecuteSqlCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.Database.ExecuteSqlCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + Controls the creation of a transaction for this command. + The command string. + The parameters to apply to the command string. + The result returned by the database after executing the command. + + + + Asynchronously executes the given DDL/DML command against the database. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.Database.ExecuteSqlCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.Database.ExecuteSqlCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + If there isn't an existing local transaction a new transaction will be used + to execute the command. + + The command string. + The parameters to apply to the command string. + + A task that represents the asynchronous operation. + The task result contains the result returned by the database after executing the command. + + + + + Asynchronously executes the given DDL/DML command against the database. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.Database.ExecuteSqlCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.Database.ExecuteSqlCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + Controls the creation of a transaction for this command. + The command string. + The parameters to apply to the command string. + + A task that represents the asynchronous operation. + The task result contains the result returned by the database after executing the command. + + + + + Asynchronously executes the given DDL/DML command against the database. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.Database.ExecuteSqlCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.Database.ExecuteSqlCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + If there isn't an existing local transaction a new transaction will be used + to execute the command. + + The command string. + + A to observe while waiting for the task to complete. + + The parameters to apply to the command string. + + A task that represents the asynchronous operation. + The task result contains the result returned by the database after executing the command. + + + + + Asynchronously executes the given DDL/DML command against the database. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.Database.ExecuteSqlCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.Database.ExecuteSqlCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + Controls the creation of a transaction for this command. + The command string. + + A to observe while waiting for the task to complete. + + The parameters to apply to the command string. + + A task that represents the asynchronous operation. + The task result contains the result returned by the database after executing the command. + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Gets the transaction the underlying store connection is enlisted in. May be null. + + + + + Returns the connection being used by this context. This may cause the + connection to be created if it does not already exist. + + Thrown if the context has been disposed. + + + + The connection factory to use when creating a from just + a database name or a connection string. + + + This is used when just a database name or connection string is given to or when + the no database name or connection is given to DbContext in which case the name of + the context class is passed to this factory in order to generate a DbConnection. + By default, the instance to use is read from the application's .config + file from the "EntityFramework DefaultConnectionFactory" entry in appSettings. If no entry is found in + the config file then is used. Setting this property in code + always overrides whatever value is found in the config file. + + + + + Gets or sets the timeout value, in seconds, for all context operations. + The default value is null, where null indicates that the default value of the underlying + provider will be used. + + + The timeout, in seconds, or null to use the provider default. + + + + + Set this property to log the SQL generated by the to the given + delegate. For example, to log to the console, set this property to . + + + The format of the log text can be changed by creating a new formatter that derives from + and setting it with . + For more low-level control over logging/interception see and + . + + + + + DbModelBuilder is used to map CLR classes to a database schema. + This code centric approach to building an Entity Data Model (EDM) model is known as 'Code First'. + + + DbModelBuilder is typically used to configure a model by overriding + DbContext.OnModelCreating(DbModelBuilder) + . + You can also use DbModelBuilder independently of DbContext to build a model and then construct a + or . + The recommended approach, however, is to use OnModelCreating in as + the workflow is more intuitive and takes care of common tasks, such as caching the created model. + Types that form your model are registered with DbModelBuilder and optional configuration can be + performed by applying data annotations to your classes and/or using the fluent style DbModelBuilder + API. + When the Build method is called a set of conventions are run to discover the initial model. + These conventions will automatically discover aspects of the model, such as primary keys, and + will also process any data annotations that were specified on your classes. Finally + any configuration that was performed using the DbModelBuilder API is applied. + Configuration done via the DbModelBuilder API takes precedence over data annotations which + in turn take precedence over the default conventions. + + + + + Initializes a new instance of the class. + The process of discovering the initial model will use the set of conventions included + in the most recent version of the Entity Framework installed on your machine. + + + Upgrading to newer versions of the Entity Framework may cause breaking changes + in your application because new conventions may cause the initial model to be + configured differently. There is an alternate constructor that allows a specific + version of conventions to be specified. + + + + + Initializes a new instance of the class that will use + a specific set of conventions to discover the initial model. + + The version of conventions to be used. + + + + Excludes a type from the model. This is used to remove types from the model that were added + by convention during initial model discovery. + + The type to be excluded. + The same DbModelBuilder instance so that multiple calls can be chained. + + + + Configures the default database schema name. This default database schema name is used + for database objects that do not have an explicitly configured schema name. + + The name of the default database schema. + The same DbModelBuilder instance so that multiple calls can be chained. + + + + Excludes the specified type(s) from the model. This is used to remove types from the model that were added + by convention during initial model discovery. + + The types to be excluded from the model. + The same DbModelBuilder instance so that multiple calls can be chained. + + + + Registers an entity type as part of the model and returns an object that can be used to + configure the entity. This method can be called multiple times for the same entity to + perform multiple lines of configuration. + + The type to be registered or configured. + The configuration object for the specified entity type. + + + + Registers an entity type as part of the model. + + The type to be registered. + + This method is provided as a convenience to allow entity types to be registered dynamically + without the need to use MakeGenericMethod in order to call the normal generic Entity method. + This method does not allow further configuration of the entity type using the fluent APIs since + these APIs make extensive use of generic type parameters. + + + + + Registers a type as a complex type in the model and returns an object that can be used to + configure the complex type. This method can be called multiple times for the same type to + perform multiple lines of configuration. + + The type to be registered or configured. + The configuration object for the specified complex type. + + + + Begins configuration of a lightweight convention that applies to all entities and complex types in + the model. + + A configuration object for the convention. + + + + Begins configuration of a lightweight convention that applies to all entities and complex types + in the model that inherit from or implement the type specified by the generic argument. + This method does not register types as part of the model. + + The type of the entities or complex types that this convention will apply to. + A configuration object for the convention. + + + + Begins configuration of a lightweight convention that applies to all properties + in the model. + + A configuration object for the convention. + + + + Begins configuration of a lightweight convention that applies to all primitive + properties of the specified type in the model. + + The type of the properties that the convention will apply to. + A configuration object for the convention. + + The convention will apply to both nullable and non-nullable properties of the + specified type. + + + + + Creates a based on the configuration performed using this builder. + The connection is used to determine the database provider being used as this + affects the database layer of the generated model. + + Connection to use to determine provider information. + The model that was built. + + + + Creates a based on the configuration performed using this builder. + Provider information must be specified because this affects the database layer of the generated model. + For SqlClient the invariant name is 'System.Data.SqlClient' and the manifest token is the version year (i.e. '2005', '2008' etc.) + + The database provider that the model will be used with. + The model that was built. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Provides access to the settings of this DbModelBuilder that deal with conventions. + + + + + Gets the for this DbModelBuilder. + The registrar allows derived entity and complex type configurations to be registered with this builder. + + + + + A value from this enumeration can be provided directly to the + class or can be used in the applied to + a class derived from . The value used defines which version of + the DbContext and DbModelBuilder conventions should be used when building a model from + code--also known as "Code First". + + + Using DbModelBuilderVersion.Latest ensures that all the latest functionality is available + when upgrading to a new release of the Entity Framework. However, it may result in an + application behaving differently with the new release than it did with a previous release. + This can be avoided by using a specific version of the conventions, but if a version + other than the latest is set then not all the latest functionality will be available. + + + + + Indicates that the latest version of the and + conventions should be used. + + + + + Indicates that the version of the and + conventions shipped with Entity Framework v4.1 + should be used. + + + + + Indicates that the version of the and + conventions shipped with Entity Framework v5.0 + when targeting .Net Framework 4 should be used. + + + + + Indicates that the version of the and + conventions shipped with Entity Framework v5.0 + should be used. + + + + + Indicates that the version of the and + conventions shipped with Entity Framework v6.0 + should be used. + + + + + This attribute can be applied to a class derived from to set which + version of the DbContext and conventions should be used when building + a model from code--also known as "Code First". See the + enumeration for details about DbModelBuilder versions. + + + If the attribute is missing from DbContextthen DbContext will always use the latest + version of the conventions. This is equivalent to using DbModelBuilderVersion.Latest. + + + + + Initializes a new instance of the class. + + + The conventions version to use. + + + + + Gets the conventions version. + + + The conventions version. + + + + + A non-generic version of which can be used when the type of entity + is not known at build time. + + + + + Represents a non-generic LINQ to Entities query against a DbContext. + + + + + Throws an exception indicating that binding directly to a store query is not supported. + Instead populate a DbSet with data, for example by using the Load extension method, and + then bind to local data. For WPF bind to DbSet.Local. For Windows Forms bind to + DbSet.Local.ToBindingList(). + + Never returns; always throws. + + + + Returns an which when enumerated will execute the query against the database. + + The query results. + + + + Returns an which when enumerated will execute the query against the database. + + The query results. + + + + Specifies the related objects to include in the query results. + + + Paths are all-inclusive. For example, if an include call indicates Include("Orders.OrderLines"), not only will + OrderLines be included, but also Orders. When you call the Include method, the query path is only valid on + the returned instance of the DbQuery<T>. Other instances of DbQuery<T> and the object context itself are not affected. + Because the Include method returns the query object, you can call this method multiple times on an DbQuery<T> to + specify multiple paths for the query. + + The dot-separated list of related objects to return in the query results. + + A new DbQuery<T> with the defined query path. + + + + + Returns a new query where the entities returned will not be cached in the . + + A new query with NoTracking applied. + + + + Returns a new query that will stream the results instead of buffering. + + A new query with AsStreaming applied. + + + + Returns the equivalent generic object. + + The type of element for which the query was created. + The generic set object. + + + + Returns a representation of the underlying query. + + The query string. + + + + + + + + + + + + + Returns false. + + + false . + + + + + The IQueryable element type. + + + + + The IQueryable LINQ Expression. + + + + + The IQueryable provider. + + + + + Creates an instance of a when called from the constructor of a derived + type that will be used as a test double for DbSets. Methods and properties that will be used by the + test double must be implemented by the test double except AsNoTracking, AsStreaming, an Include where + the default implementation is a no-op. + + + + + Finds an entity with the given primary key values. + If an entity with the given primary key values exists in the context, then it is + returned immediately without making a request to the store. Otherwise, a request + is made to the store for an entity with the given primary key values and this entity, + if found, is attached to the context and returned. If no entity is found in the + context or the store, then null is returned. + + + The ordering of composite key values is as defined in the EDM, which is in turn as defined in + the designer, by the Code First fluent API, or by the DataMember attribute. + + The values of the primary key for the entity to be found. + The entity found, or null. + Thrown if multiple entities exist in the context with the primary key values given. + Thrown if the type of entity is not part of the data model for this context. + Thrown if the types of the key values do not match the types of the key values for the entity type to be found. + Thrown if the context has been disposed. + + + + Asynchronously finds an entity with the given primary key values. + If an entity with the given primary key values exists in the context, then it is + returned immediately without making a request to the store. Otherwise, a request + is made to the store for an entity with the given primary key values and this entity, + if found, is attached to the context and returned. If no entity is found in the + context or the store, then null is returned. + + + The ordering of composite key values is as defined in the EDM, which is in turn as defined in + the designer, by the Code First fluent API, or by the DataMember attribute. + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The values of the primary key for the entity to be found. + A task that represents the asynchronous find operation. The task result contains the entity found, or null. + Thrown if multiple entities exist in the context with the primary key values given. + Thrown if the type of entity is not part of the data model for this context. + Thrown if the types of the key values do not match the types of the key values for the entity type to be found. + Thrown if the context has been disposed. + + + + Asynchronously finds an entity with the given primary key values. + If an entity with the given primary key values exists in the context, then it is + returned immediately without making a request to the store. Otherwise, a request + is made to the store for an entity with the given primary key values and this entity, + if found, is attached to the context and returned. If no entity is found in the + context or the store, then null is returned. + + + The ordering of composite key values is as defined in the EDM, which is in turn as defined in + the designer, by the Code First fluent API, or by the DataMember attribute. + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + The values of the primary key for the entity to be found. + A task that represents the asynchronous find operation. The task result contains the entity found, or null. + Thrown if multiple entities exist in the context with the primary key values given. + Thrown if the type of entity is not part of the data model for this context. + Thrown if the types of the key values do not match the types of the key values for the entity type to be found. + Thrown if the context has been disposed. + + + + Attaches the given entity to the context underlying the set. That is, the entity is placed + into the context in the Unchanged state, just as if it had been read from the database. + + The entity to attach. + The entity. + + Attach is used to repopulate a context with an entity that is known to already exist in the database. + SaveChanges will therefore not attempt to insert an attached entity into the database because + it is assumed to already be there. + Note that entities that are already in the context in some other state will have their state set + to Unchanged. Attach is a no-op if the entity is already in the context in the Unchanged state. + + + + + Adds the given entity to the context underlying the set in the Added state such that it will + be inserted into the database when SaveChanges is called. + + The entity to add. + The entity. + + Note that entities that are already in the context in some other state will have their state set + to Added. Add is a no-op if the entity is already in the context in the Added state. + + + + + Adds the given collection of entities into context underlying the set with each entity being put into + the Added state such that it will be inserted into the database when SaveChanges is called. + + The collection of entities to add. + + The collection of entities. + + + Note that if is set to true (which is + the default), then DetectChanges will be called once before adding any entities and will not be called + again. This means that in some situations AddRange may perform significantly better than calling + Add multiple times would do. + Note that entities that are already in the context in some other state will have their state set to + Added. AddRange is a no-op for entities that are already in the context in the Added state. + + + + + Marks the given entity as Deleted such that it will be deleted from the database when SaveChanges + is called. Note that the entity must exist in the context in some other state before this method + is called. + + The entity to remove. + The entity. + + Note that if the entity exists in the context in the Added state, then this method + will cause it to be detached from the context. This is because an Added entity is assumed not to + exist in the database such that trying to delete it does not make sense. + + + + + Removes the given collection of entities from the context underlying the set with each entity being put into + the Deleted state such that it will be deleted from the database when SaveChanges is called. + + The collection of entities to delete. + + The collection of entities. + + + Note that if is set to true (which is + the default), then DetectChanges will be called once before delete any entities and will not be called + again. This means that in some situations RemoveRange may perform significantly better than calling + Remove multiple times would do. + Note that if any entity exists in the context in the Added state, then this method + will cause it to be detached from the context. This is because an Added entity is assumed not to + exist in the database such that trying to delete it does not make sense. + + + + + Creates a new instance of an entity for the type of this set. + Note that this instance is NOT added or attached to the set. + The instance returned will be a proxy if the underlying context is configured to create + proxies and the entity type meets the requirements for creating a proxy. + + The entity instance, which may be a proxy. + + + + Creates a new instance of an entity for the type of this set or for a type derived + from the type of this set. + Note that this instance is NOT added or attached to the set. + The instance returned will be a proxy if the underlying context is configured to create + proxies and the entity type meets the requirements for creating a proxy. + + The type of entity to create. + The entity instance, which may be a proxy. + + + + Returns the equivalent generic object. + + The type of entity for which the set was created. + The generic set object. + + + + Creates a raw SQL query that will return entities in this set. By default, the + entities returned are tracked by the context; this can be changed by calling + AsNoTracking on the returned. + Note that the entities returned are always of the type for this set and never of + a derived type. If the table or tables queried may contain data for other entity + types, then the SQL query must be written appropriately to ensure that only entities of + the correct type are returned. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.Set(typeof(Blog)).SqlQuery("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.Set(typeof(Blog)).SqlQuery("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + The SQL query string. + + The parameters to apply to the SQL query string. If output parameters are used, their values + will not be available until the results have been read completely. This is due to the underlying + behavior of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + A object that will execute the query when it is enumerated. + + + + + + + + + + + + + + Gets an that represents a local view of all Added, Unchanged, + and Modified entities in this set. This local view will stay in sync as entities are added or + removed from the context. Likewise, entities added to or removed from the local view will automatically + be added to or removed from the context. + + + This property can be used for data binding by populating the set with data, for example by using the Load + extension method, and then binding to the local data through this property. For WPF bind to this property + directly. For Windows Forms bind to the result of calling ToBindingList on this property + + The local view. + + + + A DbSet represents the collection of all entities in the context, or that can be queried from the + database, of a given type. DbSet objects are created from a DbContext using the DbContext.Set method. + + + Note that DbSet does not support MEST (Multiple Entity Sets per Type) meaning that there is always a + one-to-one correlation between a type and a set. + + The type that defines the set. + + + + Represents a LINQ to Entities query against a DbContext. + + The type of entity to query for. + + + + Specifies the related objects to include in the query results. + + + Paths are all-inclusive. For example, if an include call indicates Include("Orders.OrderLines"), not only will + OrderLines be included, but also Orders. When you call the Include method, the query path is only valid on + the returned instance of the DbQuery<T>. Other instances of DbQuery<T> and the object context itself are not affected. + Because the Include method returns the query object, you can call this method multiple times on an DbQuery<T> to + specify multiple paths for the query. + + The dot-separated list of related objects to return in the query results. + + A new with the defined query path. + + + + + Returns a new query where the entities returned will not be cached in the . + + A new query with NoTracking applied. + + + + Returns a new query that will stream the results instead of buffering. + + A new query with AsStreaming applied. + + + + Throws an exception indicating that binding directly to a store query is not supported. + Instead populate a DbSet with data, for example by using the Load extension method, and + then bind to local data. For WPF bind to DbSet.Local. For Windows Forms bind to + DbSet.Local.ToBindingList(). + + Never returns; always throws. + + + + Returns an which when enumerated will execute the query against the database. + + The query results. + + + + Returns an which when enumerated will execute the query against the database. + + The query results. + + + + Returns an which when enumerated will execute the query against the database. + + The query results. + + + + Returns an which when enumerated will execute the query against the database. + + The query results. + + + + Returns a representation of the underlying query. + + The query string. + + + + Returns a new instance of the non-generic class for this query. + + The query. + A non-generic version. + + + + + + + + + + + + + Returns false. + + + false . + + + + + The IQueryable element type. + + + + + The IQueryable LINQ Expression. + + + + + The IQueryable provider. + + + + + An represents the collection of all entities in the context, or that + can be queried from the database, of a given type. is a concrete + implementation of IDbSet. + + + was originally intended to allow creation of test doubles (mocks or + fakes) for . However, this approach has issues in that adding new members + to an interface breaks existing code that already implements the interface without the new members. + Therefore, starting with EF6, no new members will be added to this interface and it is recommended + that be used as the base class for test doubles. + + The type that defines the set. + + + + Finds an entity with the given primary key values. + If an entity with the given primary key values exists in the context, then it is + returned immediately without making a request to the store. Otherwise, a request + is made to the store for an entity with the given primary key values and this entity, + if found, is attached to the context and returned. If no entity is found in the + context or the store, then null is returned. + + + The ordering of composite key values is as defined in the EDM, which is in turn as defined in + the designer, by the Code First fluent API, or by the DataMember attribute. + + The values of the primary key for the entity to be found. + The entity found, or null. + + + + Adds the given entity to the context underlying the set in the Added state such that it will + be inserted into the database when SaveChanges is called. + + The entity to add. + The entity. + + Note that entities that are already in the context in some other state will have their state set + to Added. Add is a no-op if the entity is already in the context in the Added state. + + + + + Marks the given entity as Deleted such that it will be deleted from the database when SaveChanges + is called. Note that the entity must exist in the context in some other state before this method + is called. + + The entity to remove. + The entity. + + Note that if the entity exists in the context in the Added state, then this method + will cause it to be detached from the context. This is because an Added entity is assumed not to + exist in the database such that trying to delete it does not make sense. + + + + + Attaches the given entity to the context underlying the set. That is, the entity is placed + into the context in the Unchanged state, just as if it had been read from the database. + + The entity to attach. + The entity. + + Attach is used to repopulate a context with an entity that is known to already exist in the database. + SaveChanges will therefore not attempt to insert an attached entity into the database because + it is assumed to already be there. + Note that entities that are already in the context in some other state will have their state set + to Unchanged. Attach is a no-op if the entity is already in the context in the Unchanged state. + + + + + Creates a new instance of an entity for the type of this set. + Note that this instance is NOT added or attached to the set. + The instance returned will be a proxy if the underlying context is configured to create + proxies and the entity type meets the requirements for creating a proxy. + + The entity instance, which may be a proxy. + + + + Creates a new instance of an entity for the type of this set or for a type derived + from the type of this set. + Note that this instance is NOT added or attached to the set. + The instance returned will be a proxy if the underlying context is configured to create + proxies and the entity type meets the requirements for creating a proxy. + + The type of entity to create. + The entity instance, which may be a proxy. + + + + Gets an that represents a local view of all Added, Unchanged, + and Modified entities in this set. This local view will stay in sync as entities are added or + removed from the context. Likewise, entities added to or removed from the local view will automatically + be added to or removed from the context. + + + This property can be used for data binding by populating the set with data, for example by using the Load + extension method, and then binding to the local data through this property. For WPF bind to this property + directly. For Windows Forms bind to the result of calling ToBindingList on this property + + The local view. + + + + Creates an instance of a when called from the constructor of a derived + type that will be used as a test double for DbSets. Methods and properties that will be used by the + test double must be implemented by the test double except AsNoTracking, AsStreaming, an Include where + the default implementation is a no-op. + + + + + Finds an entity with the given primary key values. + If an entity with the given primary key values exists in the context, then it is + returned immediately without making a request to the store. Otherwise, a request + is made to the store for an entity with the given primary key values and this entity, + if found, is attached to the context and returned. If no entity is found in the + context or the store, then null is returned. + + + The ordering of composite key values is as defined in the EDM, which is in turn as defined in + the designer, by the Code First fluent API, or by the DataMember attribute. + + The values of the primary key for the entity to be found. + The entity found, or null. + Thrown if multiple entities exist in the context with the primary key values given. + Thrown if the type of entity is not part of the data model for this context. + Thrown if the types of the key values do not match the types of the key values for the entity type to be found. + Thrown if the context has been disposed. + + + + Asynchronously finds an entity with the given primary key values. + If an entity with the given primary key values exists in the context, then it is + returned immediately without making a request to the store. Otherwise, a request + is made to the store for an entity with the given primary key values and this entity, + if found, is attached to the context and returned. If no entity is found in the + context or the store, then null is returned. + + + The ordering of composite key values is as defined in the EDM, which is in turn as defined in + the designer, by the Code First fluent API, or by the DataMember attribute. + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + The values of the primary key for the entity to be found. + A task that represents the asynchronous find operation. The task result contains the entity found, or null. + Thrown if multiple entities exist in the context with the primary key values given. + Thrown if the type of entity is not part of the data model for this context. + Thrown if the types of the key values do not match the types of the key values for the entity type to be found. + Thrown if the context has been disposed. + + + + Asynchronously finds an entity with the given primary key values. + If an entity with the given primary key values exists in the context, then it is + returned immediately without making a request to the store. Otherwise, a request + is made to the store for an entity with the given primary key values and this entity, + if found, is attached to the context and returned. If no entity is found in the + context or the store, then null is returned. + + + The ordering of composite key values is as defined in the EDM, which is in turn as defined in + the designer, by the Code First fluent API, or by the DataMember attribute. + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + The values of the primary key for the entity to be found. + A task that represents the asynchronous find operation. The task result contains the entity found, or null. + + + + + + + + + + Adds the given collection of entities into context underlying the set with each entity being put into + the Added state such that it will be inserted into the database when SaveChanges is called. + + The collection of entities to add. + + The collection of entities. + + + Note that if is set to true (which is + the default), then DetectChanges will be called once before adding any entities and will not be called + again. This means that in some situations AddRange may perform significantly better than calling + Add multiple times would do. + Note that entities that are already in the context in some other state will have their state set to + Added. AddRange is a no-op for entities that are already in the context in the Added state. + + + + + + + + Removes the given collection of entities from the context underlying the set with each entity being put into + the Deleted state such that it will be deleted from the database when SaveChanges is called. + + The collection of entities to delete. + + The collection of entities. + + + Note that if is set to true (which is + the default), then DetectChanges will be called once before delete any entities and will not be called + again. This means that in some situations RemoveRange may perform significantly better than calling + Remove multiple times would do. + Note that if any entity exists in the context in the Added state, then this method + will cause it to be detached from the context. This is because an Added entity is assumed not to + exist in the database such that trying to delete it does not make sense. + + + + + + + + + + + Returns the equivalent non-generic object. + + The generic set object. + The non-generic set object. + + + + Creates a raw SQL query that will return entities in this set. By default, the + entities returned are tracked by the context; this can be changed by calling + AsNoTracking on the returned. + Note that the entities returned are always of the type for this set and never of + a derived type. If the table or tables queried may contain data for other entity + types, then the SQL query must be written appropriately to ensure that only entities of + the correct type are returned. + + As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional arguments. Any parameter values you supply will automatically be converted to a DbParameter. + context.Blogs.SqlQuery("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); + Alternatively, you can also construct a DbParameter and supply it to SqlQuery. This allows you to use named parameters in the SQL query string. + context.Blogs.SqlQuery("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor)); + + The SQL query string. + + The parameters to apply to the SQL query string. If output parameters are used, their values will + not be available until the results have been read completely. This is due to the underlying behavior + of DbDataReader, see http://go.microsoft.com/fwlink/?LinkID=398589 for more details. + + + A object that will execute the query when it is enumerated. + + + + + + + + + + + + + + + + + An implementation of IDatabaseInitializer that will always recreate and optionally re-seed the + database the first time that a context is used in the app domain. + To seed the database, create a derived class and override the Seed method. + + The type of the context. + + + Initializes a new instance of the class. + + + + Executes the strategy to initialize the database for the given context. + + The context. + + + is + null + . + + + + + A method that should be overridden to actually add data to the context for seeding. + The default implementation does nothing. + + The context to seed. + + + + An implementation of IDatabaseInitializer that will DELETE, recreate, and optionally re-seed the + database only if the model has changed since the database was created. + + The type of the context. + + Whether or not the model has changed is determined by the + method. + To seed the database create a derived class and override the Seed method. + + + + Initializes a new instance of the class. + + + + Executes the strategy to initialize the database for the given context. + + The context. + + + is + null + . + + + + + A method that should be overridden to actually add data to the context for seeding. + The default implementation does nothing. + + The context to seed. + + + + Returned by the ChangeTracker method of to provide access to features of + the context that are related to change tracking of entities. + + + + + Gets objects for all the entities tracked by this context. + + The entries. + + + + Gets objects for all the entities of the given type + tracked by this context. + + The type of the entity. + The entries. + + + + Checks if the is tracking any new, deleted, or changed entities or + relationships that will be sent to the database if is called. + + + Functionally, calling this method is equivalent to checking if there are any entities or + relationships in the Added, Updated, or Deleted state. + Note that this method calls unless + has been set to false. + + + True if underlying have changes, else false. + + + + + Detects changes made to the properties and relationships of POCO entities. Note that some types of + entity (such as change tracking proxies and entities that derive from + ) + report changes automatically and a call to DetectChanges is not normally needed for these types of entities. + Also note that normally DetectChanges is called automatically by many of the methods of + and its related classes such that it is rare that this method will need to be called explicitly. + However, it may be desirable, usually for performance reasons, to turn off this automatic calling of + DetectChanges using the AutoDetectChangesEnabled flag from . + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + A non-generic version of the class. + + + + + This is an abstract base class use to represent a scalar or complex property, or a navigation property + of an entity. Scalar and complex properties use the derived class , + reference navigation properties use the derived class , and collection + navigation properties use the derived class . + + + + + Validates this property. + + + Collection of objects. Never null. If the entity is valid the collection will be empty. + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Returns the equivalent generic object. + + The type of entity on which the member is declared. + The type of the property. + The equivalent generic object. + + + + Gets the name of the property. + + The property name. + + + + Gets or sets the current value of this property. + + The current value. + + + + The to which this member belongs. + + An entry for the entity that owns this member. + + + + Loads the collection of entities from the database. + Note that entities that already exist in the context are not overwritten with values from the database. + + + + + Asynchronously loads the collection of entities from the database. + Note that entities that already exist in the context are not overwritten with values from the database. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + + + + + Asynchronously loads the collection of entities from the database. + Note that entities that already exist in the context are not overwritten with values from the database. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + + + + Returns the query that would be used to load this collection from the database. + The returned query can be modified using LINQ to perform filtering or operations in the database, such + as counting the number of entities in the collection in the database without actually loading them. + + A query for the collection. + + + + Returns the equivalent generic object. + + The type of entity on which the member is declared. + The type of the collection element. + The equivalent generic object. + + + + Gets the property name. + + The property name. + + + + Gets or sets the current value of the navigation property. The current value is + the entity that the navigation property references. + + The current value. + + + + Gets or sets a value indicating whether all entities of this collection have been loaded from the database. + + + Loading the related entities from the database either using lazy-loading, as part of a query, or explicitly + with one of the Load methods will set the IsLoaded flag to true. + IsLoaded can be explicitly set to true to prevent the related entities of this collection from being lazy-loaded. + This can be useful if the application has caused a subset of related entities to be loaded into this collection + and wants to prevent any other entities from being loaded automatically. + Note that explict loading using one of the Load methods will load all related entities from the database + regardless of whether or not IsLoaded is true. + When any related entity in the collection is detached the IsLoaded flag is reset to false indicating that the + not all related entities are now loaded. + + + true if all the related entities are loaded or the IsLoaded has been explicitly set to true; otherwise, false. + + + + + The to which this navigation property belongs. + + An entry for the entity that owns this navigation property. + + + + Instances of this class are returned from the Collection method of + and allow operations such as loading to + be performed on the an entity's collection navigation properties. + + The type of the entity to which this property belongs. + The type of the element in the collection of entities. + + + + This is an abstract base class use to represent a scalar or complex property, or a navigation property + of an entity. Scalar and complex properties use the derived class , + reference navigation properties use the derived class , and collection + navigation properties use the derived class . + + The type of the entity to which this property belongs. + The type of the property. + + + + Returns a new instance of the non-generic class for + the property represented by this object. + + The object representing the property. + A non-generic version. + + + + Validates this property. + + + Collection of objects. Never null. If the entity is valid the collection will be empty. + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + Gets the name of the property. + The name of the property. + + + + Gets or sets the current value of this property. + + The current value. + + + + The to which this member belongs. + + An entry for the entity that owns this member. + + + + Loads the collection of entities from the database. + Note that entities that already exist in the context are not overwritten with values from the database. + + + + + Asynchronously loads the collection of entities from the database. + Note that entities that already exist in the context are not overwritten with values from the database. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + + + + + Asynchronously loads the collection of entities from the database. + Note that entities that already exist in the context are not overwritten with values from the database. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + + + + Returns the query that would be used to load this collection from the database. + The returned query can be modified using LINQ to perform filtering or operations in the database, such + as counting the number of entities in the collection in the database without actually loading them. + + A query for the collection. + + + + Returns a new instance of the non-generic class for + the navigation property represented by this object. + + The object representing the navigation property. + A non-generic version. + + + + Gets the property name. + + The property name. + + + + Gets or sets the current value of the navigation property. The current value is + the entity that the navigation property references. + + The current value. + + + + Gets or sets a value indicating whether all entities of this collection have been loaded from the database. + + + Loading the related entities from the database either using lazy-loading, as part of a query, or explicitly + with one of the Load methods will set the IsLoaded flag to true. + IsLoaded can be explicitly set to true to prevent the related entities of this collection from being lazy-loaded. + This can be useful if the application has caused a subset of related entities to be loaded into this collection + and wants to prevent any other entities from being loaded automatically. + Note that explict loading using one of the Load methods will load all related entities from the database + regardless of whether or not IsLoaded is true. + When any related entity in the collection is detached the IsLoaded flag is reset to false indicating that the + not all related entities are now loaded. + + + true if all the related entities are loaded or the IsLoaded has been explicitly set to true; otherwise, false. + + + + + The to which this navigation property belongs. + + An entry for the entity that owns this navigation property. + + + + An immutable representation of an Entity Data Model (EDM) model that can be used to create an + or can be passed to the constructor of a . + For increased performance, instances of this type should be cached and re-used to construct contexts. + + + + + Creates an instance of ObjectContext or class derived from ObjectContext. Note that an instance + of DbContext can be created instead by using the appropriate DbContext constructor. + If a derived ObjectContext is used, then it must have a public constructor with a single + EntityConnection parameter. + The connection passed is used by the ObjectContext created, but is not owned by the context. The caller + must dispose of the connection once the context has been disposed. + + The type of context to create. + An existing connection to a database for use by the context. + The context. + + + + A non-generic version of the class. + + + + + A non-generic version of the class. + + + + + Returns the equivalent generic object. + + The type of entity on which the member is declared. + The type of the property. + The equivalent generic object. + + + + Gets the property name. + + The property name. + + + + Gets or sets the original value of this property. + + The original value. + + + + Gets or sets the current value of this property. + + The current value. + + + + Gets or sets a value indicating whether the value of this property has been modified since + it was loaded from the database. + + + Setting this value to false for a modified property will revert the change by setting the + current value to the original value. If the result is that no properties of the entity are + marked as modified, then the entity will be marked as Unchanged. + Setting this value to false for properties of Added, Unchanged, or Deleted entities + is a no-op. + + + true if this instance is modified; otherwise, false . + + + + + The to which this property belongs. + + An entry for the entity that owns this property. + + + + The of the property for which this is a nested property. + This method will only return a non-null entry for properties of complex objects; it will + return null for properties of the entity itself. + + An entry for the parent complex property, or null if this is an entity property. + + + + Gets an object that represents a nested property of this property. + This method can be used for both scalar or complex properties. + + The name of the nested property. + An object representing the nested property. + + + + Gets an object that represents a nested complex property of this property. + + The name of the nested property. + An object representing the nested property. + + + + Returns the equivalent generic object. + + The type of entity on which the member is declared. + The type of the complex property. + The equivalent generic object. + + + + Instances of this class are returned from the ComplexProperty method of + and allow access to the state of a complex property. + + The type of the entity to which this property belongs. + The type of the property. + + + + Instances of this class are returned from the Property method of + and allow access to the state of the scalar + or complex property. + + The type of the entity to which this property belongs. + The type of the property. + + + + Returns a new instance of the non-generic class for + the property represented by this object. + + The object representing the property. + A non-generic version. + + + + Gets the property name. + + The property name. + + + + Gets or sets the original value of this property. + + The original value. + + + + Gets or sets the current value of this property. + + The current value. + + + + Gets or sets a value indicating whether the value of this property has been modified since + it was loaded from the database. + + + true if this instance is modified; otherwise, false . + + + + + The to which this property belongs. + + An entry for the entity that owns this property. + + + + The of the property for which this is a nested property. + This method will only return a non-null entry for properties of complex objects; it will + return null for properties of the entity itself. + + An entry for the parent complex property, or null if this is an entity property. + + + + Returns a new instance of the non-generic class for + the property represented by this object. + + The object representing the property. + A non-generic version. + + + + Gets an object that represents a nested property of this property. + This method can be used for both scalar or complex properties. + + The name of the nested property. + An object representing the nested property. + + + + Gets an object that represents a nested property of this property. + This method can be used for both scalar or complex properties. + + The type of the nested property. + The name of the nested property. + An object representing the nested property. + + + + Gets an object that represents a nested property of this property. + This method can be used for both scalar or complex properties. + + The type of the nested property. + An expression representing the nested property. + An object representing the nested property. + + + + Gets an object that represents a nested complex property of this property. + + The name of the nested property. + An object representing the nested property. + + + + Gets an object that represents a nested complex property of this property. + + The type of the nested property. + The name of the nested property. + An object representing the nested property. + + + + Gets an object that represents a nested complex property of this property. + + The type of the nested property. + An expression representing the nested property. + An object representing the nested property. + + + + Describes the origin of the database connection string associated with a . + + + + + The connection string was created by convention. + + + + + The connection string was read from external configuration. + + + + + The connection string was explicitly specified at runtime. + + + + + The connection string was overriden by connection information supplied to DbContextInfo. + + + + + Returned by the Configuration method of to provide access to configuration + options for the context. + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Gets or sets the value that determines whether SQL functions and commands should be always executed in a transaction. + + + This flag determines whether a new transaction will be started when methods such as + are executed outside of a transaction. + Note that this does not change the behavior of . + + + The default transactional behavior. + + + + + Gets or sets a value indicating whether lazy loading of relationships exposed as + navigation properties is enabled. Lazy loading is enabled by default. + + + true if lazy loading is enabled; otherwise, false . + + + + + Gets or sets a value indicating whether or not the framework will create instances of + dynamically generated proxy classes whenever it creates an instance of an entity type. + Note that even if proxy creation is enabled with this flag, proxy instances will only + be created for entity types that meet the requirements for being proxied. + Proxy creation is enabled by default. + + + true if proxy creation is enabled; otherwise, false . + + + + + Gets or sets a value indicating whether database null semantics are exhibited when comparing + two operands, both of which are potentially nullable. The default value is false. + + For example (operand1 == operand2) will be translated as: + + (operand1 = operand2) + + if UseDatabaseNullSemantics is true, respectively + + (((operand1 = operand2) AND (NOT (operand1 IS NULL OR operand2 IS NULL))) OR ((operand1 IS NULL) AND (operand2 IS NULL))) + + if UseDatabaseNullSemantics is false. + + + true if database null comparison behavior is enabled, otherwise false . + + + + + Gets or sets a value indicating whether the + method is called automatically by methods of and related classes. + The default value is true. + + + true if should be called automatically; otherwise, false. + + + + + Gets or sets a value indicating whether tracked entities should be validated automatically when + is invoked. + The default value is true. + + + + + Provides runtime information about a given type. + + + + + Creates a new instance representing a given type. + + + The type deriving from . + + + + + Creates a new instance representing a given targeting a specific database. + + + The type deriving from . + + Connection information for the database to be used. + + + + Creates a new instance representing a given type. An external list of + connection strings can be supplied and will be used during connection string resolution in place + of any connection strings specified in external configuration files. + + + It is preferable to use the constructor that accepts the entire config document instead of using this + constructor. Providing the entire config document allows DefaultConnectionFactroy entries in the config + to be found in addition to explicitly specified connection strings. + + + The type deriving from . + + A collection of connection strings. + + + + Creates a new instance representing a given type. An external config + object (e.g. app.config or web.config) can be supplied and will be used during connection string + resolution. This includes looking for connection strings and DefaultConnectionFactory entries. + + + The type deriving from . + + An object representing the config file. + + + + Creates a new instance representing a given , targeting a specific database. + An external config object (e.g. app.config or web.config) can be supplied and will be used during connection string + resolution. This includes looking for connection strings and DefaultConnectionFactory entries. + + + The type deriving from . + + An object representing the config file. + Connection information for the database to be used. + + + + Creates a new instance representing a given type. A + can be supplied in order to override the default determined provider used when constructing + the underlying EDM model. + + + The type deriving from . + + + A specifying the underlying ADO.NET provider to target. + + + + + Creates a new instance representing a given type. An external config + object (e.g. app.config or web.config) can be supplied and will be used during connection string + resolution. This includes looking for connection strings and DefaultConnectionFactory entries. + A can be supplied in order to override the default determined + provider used when constructing the underlying EDM model. This can be useful to prevent EF from + connecting to discover a manifest token. + + + The type deriving from . + + An object representing the config file. + + A specifying the underlying ADO.NET provider to target. + + + + + If instances of the underlying type can be created, returns + a new instance; otherwise returns null. + + + A instance. + + + + + The concrete type. + + + + + Whether or not instances of the underlying type can be created. + + + + + The connection string used by the underlying type. + + + + + The connection string name used by the underlying type. + + + + + The ADO.NET provider name of the connection used by the underlying type. + + + + + The origin of the connection string used by the underlying type. + + + + + An action to be run on the DbModelBuilder after OnModelCreating has been run on the context. + + + + + A non-generic version of the class. + + + + + Queries the database for copies of the values of the tracked entity as they currently exist in the database. + Note that changing the values in the returned dictionary will not update the values in the database. + If the entity is not found in the database then null is returned. + + The store values. + + + + Asynchronously queries the database for copies of the values of the tracked entity as they currently exist in the database. + Note that changing the values in the returned dictionary will not update the values in the database. + If the entity is not found in the database then null is returned. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains the store values. + + + + + Asynchronously queries the database for copies of the values of the tracked entity as they currently exist in the database. + Note that changing the values in the returned dictionary will not update the values in the database. + If the entity is not found in the database then null is returned. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the store values. + + + + + Reloads the entity from the database overwriting any property values with values from the database. + The entity will be in the Unchanged state after calling this method. + + + + + Asynchronously reloads the entity from the database overwriting any property values with values from the database. + The entity will be in the Unchanged state after calling this method. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + + + + + Asynchronously reloads the entity from the database overwriting any property values with values from the database. + The entity will be in the Unchanged state after calling this method. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + + + + Gets an object that represents the reference (i.e. non-collection) navigation property from this + entity to another entity. + + The name of the navigation property. + An object representing the navigation property. + + + + Gets an object that represents the collection navigation property from this + entity to a collection of related entities. + + The name of the navigation property. + An object representing the navigation property. + + + + Gets an object that represents a scalar or complex property of this entity. + + The name of the property. + An object representing the property. + + + + Gets an object that represents a complex property of this entity. + + The name of the complex property. + An object representing the complex property. + + + + Gets an object that represents a member of the entity. The runtime type of the returned object will + vary depending on what kind of member is asked for. The currently supported member types and their return + types are: + Reference navigation property: . + Collection navigation property: . + Primitive/scalar property: . + Complex property: . + + The name of the member. + An object representing the member. + + + + Returns a new instance of the generic class for the given + generic type for the tracked entity represented by this object. + Note that the type of the tracked entity must be compatible with the generic type or + an exception will be thrown. + + The type of the entity. + A generic version. + + + + Validates this instance and returns validation result. + + + Entity validation result. Possibly null if + DbContext.ValidateEntity(DbEntityEntry, IDictionary{object,object}) + method is overridden. + + + + + Determines whether the specified is equal to this instance. + Two instances are considered equal if they are both entries for + the same entity on the same . + + + The to compare with this instance. + + + true if the specified is equal to this instance; otherwise, false . + + + + + Determines whether the specified is equal to this instance. + Two instances are considered equal if they are both entries for + the same entity on the same . + + + The to compare with this instance. + + + true if the specified is equal to this instance; otherwise, false . + + + + + Returns a hash code for this instance. + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Gets the entity. + + The entity. + + + + Gets or sets the state of the entity. + + The state. + + + + Gets the current property values for the tracked entity represented by this object. + + The current values. + + + + Gets the original property values for the tracked entity represented by this object. + The original values are usually the entity's property values as they were when last queried from + the database. + + The original values. + + + + Instances of this class provide access to information about and control of entities that + are being tracked by the . Use the Entity or Entities methods of + the context to obtain objects of this type. + + The type of the entity. + + + + Queries the database for copies of the values of the tracked entity as they currently exist in the database. + Note that changing the values in the returned dictionary will not update the values in the database. + If the entity is not found in the database then null is returned. + + The store values. + + + + Asynchronously queries the database for copies of the values of the tracked entity as they currently exist in the database. + Note that changing the values in the returned dictionary will not update the values in the database. + If the entity is not found in the database then null is returned. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + The task result contains the store values. + + + + + Asynchronously queries the database for copies of the values of the tracked entity as they currently exist in the database. + Note that changing the values in the returned dictionary will not update the values in the database. + If the entity is not found in the database then null is returned. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + The task result contains the store values. + + + + + Reloads the entity from the database overwriting any property values with values from the database. + The entity will be in the Unchanged state after calling this method. + + + + + Asynchronously reloads the entity from the database overwriting any property values with values from the database. + The entity will be in the Unchanged state after calling this method. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + + + + + Asynchronously reloads the entity from the database overwriting any property values with values from the database. + The entity will be in the Unchanged state after calling this method. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + + + + Gets an object that represents the reference (i.e. non-collection) navigation property from this + entity to another entity. + + The name of the navigation property. + An object representing the navigation property. + + + + Gets an object that represents the reference (i.e. non-collection) navigation property from this + entity to another entity. + + The type of the property. + The name of the navigation property. + An object representing the navigation property. + + + + Gets an object that represents the reference (i.e. non-collection) navigation property from this + entity to another entity. + + The type of the property. + An expression representing the navigation property. + An object representing the navigation property. + + + + Gets an object that represents the collection navigation property from this + entity to a collection of related entities. + + The name of the navigation property. + An object representing the navigation property. + + + + Gets an object that represents the collection navigation property from this + entity to a collection of related entities. + + The type of elements in the collection. + The name of the navigation property. + An object representing the navigation property. + + + + Gets an object that represents the collection navigation property from this + entity to a collection of related entities. + + The type of elements in the collection. + An expression representing the navigation property. + An object representing the navigation property. + + + + Gets an object that represents a scalar or complex property of this entity. + + The name of the property. + An object representing the property. + + + + Gets an object that represents a scalar or complex property of this entity. + + The type of the property. + The name of the property. + An object representing the property. + + + + Gets an object that represents a scalar or complex property of this entity. + + The type of the property. + An expression representing the property. + An object representing the property. + + + + Gets an object that represents a complex property of this entity. + + The name of the complex property. + An object representing the complex property. + + + + Gets an object that represents a complex property of this entity. + + The type of the complex property. + The name of the complex property. + An object representing the complex property. + + + + Gets an object that represents a complex property of this entity. + + The type of the complex property. + An expression representing the complex property. + An object representing the complex property. + + + + Gets an object that represents a member of the entity. The runtime type of the returned object will + vary depending on what kind of member is asked for. The currently supported member types and their return + types are: + Reference navigation property: . + Collection navigation property: . + Primitive/scalar property: . + Complex property: . + + The name of the member. + An object representing the member. + + + + Gets an object that represents a member of the entity. The runtime type of the returned object will + vary depending on what kind of member is asked for. The currently supported member types and their return + types are: + Reference navigation property: . + Collection navigation property: . + Primitive/scalar property: . + Complex property: . + + The type of the member. + The name of the member. + An object representing the member. + + + + Returns a new instance of the non-generic class for + the tracked entity represented by this object. + + The object representing the tracked entity. + A non-generic version. + + + + Validates this instance and returns validation result. + + + Entity validation result. Possibly null if + DbContext.ValidateEntity(DbEntityEntry, IDictionary{object, object}) + method is overridden. + + + + + Determines whether the specified is equal to this instance. + Two instances are considered equal if they are both entries for + the same entity on the same . + + + The to compare with this instance. + + + true if the specified is equal to this instance; otherwise, false . + + + + + Determines whether the specified is equal to this instance. + Two instances are considered equal if they are both entries for + the same entity on the same . + + + The to compare with this instance. + + + true if the specified is equal to this instance; otherwise, false . + + + + + Returns a hash code for this instance. + + A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Gets the entity. + + The entity. + + + + Gets or sets the state of the entity. + + The state. + + + + Gets the current property values for the tracked entity represented by this object. + + The current values. + + + + Gets the original property values for the tracked entity represented by this object. + The original values are usually the entity's property values as they were when last queried from + the database. + + The original values. + + + + Represents an Entity Data Model (EDM) created by the . + The Compile method can be used to go from this EDM representation to a + which is a compiled snapshot of the model suitable for caching and creation of + or instances. + + + + + Creates a for this mode which is a compiled snapshot + suitable for caching and creation of instances. + + The compiled model. + + + + Gets the provider information. + + + + + Gets the provider manifest. + + + + + Gets the conceptual model. + + + + + Gets the store model. + + + + + Gets the mapping model. + + + + + A collection of all the properties for an underlying entity or complex object. + + + An instance of this class can be converted to an instance of the generic class + using the Cast method. + Complex properties in the underlying entity or complex object are represented in + the property values as nested instances of this class. + + + + + Creates an object of the underlying type for this dictionary and hydrates it with property + values from this dictionary. + + The properties of this dictionary copied into a new object. + + + + Sets the values of this dictionary by reading values out of the given object. + The given object can be of any type. Any property on the object with a name that + matches a property name in the dictionary and can be read will be read. Other + properties will be ignored. This allows, for example, copying of properties from + simple Data Transfer Objects (DTOs). + + The object to read values from. + + + + Creates a new dictionary containing copies of all the properties in this dictionary. + Changes made to the new dictionary will not be reflected in this dictionary and vice versa. + + A clone of this dictionary. + + + + Sets the values of this dictionary by reading values from another dictionary. + The other dictionary must be based on the same type as this dictionary, or a type derived + from the type for this dictionary. + + The dictionary to read values from. + + + + Gets the value of the property just like using the indexed property getter but + typed to the type of the generic parameter. This is useful especially with + nested dictionaries to avoid writing expressions with lots of casts. + + The type of the property. + Name of the property. + The value of the property. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Gets the set of names of all properties in this dictionary as a read-only set. + + The property names. + + + + Gets or sets the value of the property with the specified property name. + The value may be a nested instance of this class. + + The property name. + The value of the property. + + + + Groups a pair of strings that identify a provider and server version together into a single object. + + + Instances of this class act as the key for resolving a for a specific + provider from a . This is typically used when registering spatial services + in or when the spatial services specific to a provider is + resolved by an implementation of . + + + + + Creates a new object for a given provider invariant name and manifest token. + + + A string that identifies that provider. For example, the SQL Server + provider uses the string "System.Data.SqlCient". + + + A string that identifies that version of the database server being used. For example, the SQL Server + provider uses the string "2008" for SQL Server 2008. This cannot be null but may be empty. + The manifest token is sometimes referred to as a version hint. + + + + + + + + + + + A string that identifies that provider. For example, the SQL Server + provider uses the string "System.Data.SqlCient". + + + + + A string that identifies that version of the database server being used. For example, the SQL Server + provider uses the string "2008" for SQL Server 2008. This cannot be null but may be empty. + + + + + A non-generic version of the class. + + + + + Loads the entity from the database. + Note that if the entity already exists in the context, then it will not overwritten with values from the database. + + + + + Asynchronously loads the entity from the database. + Note that if the entity already exists in the context, then it will not overwritten with values from the database. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + + + + + Asynchronously loads the entity from the database. + Note that if the entity already exists in the context, then it will not overwritten with values from the database. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + + + + Returns the query that would be used to load this entity from the database. + The returned query can be modified using LINQ to perform filtering or operations in the database. + + A query for the entity. + + + + Returns the equivalent generic object. + + The type of entity on which the member is declared. + The type of the property. + The equivalent generic object. + + + + Gets the property name. + + The property name. + + + + Gets or sets the current value of the navigation property. The current value is + the entity that the navigation property references. + + The current value. + + + + Gets or sets a value indicating whether the entity has been loaded from the database. + + + Loading the related entity from the database either using lazy-loading, as part of a query, or explicitly + with one of the Load methods will set the IsLoaded flag to true. + IsLoaded can be explicitly set to true to prevent the related entity from being lazy-loaded. + Note that explict loading using one of the Load methods will load the related entity from the database + regardless of whether or not IsLoaded is true. + When a related entity is detached the IsLoaded flag is reset to false indicating that the related entity is + no longer loaded. + + + true if the entity is loaded or the IsLoaded has been explicitly set to true; otherwise, false. + + + + + The to which this navigation property belongs. + + An entry for the entity that owns this navigation property. + + + + Instances of this class are returned from the Reference method of + and allow operations such as loading to + be performed on the an entity's reference navigation properties. + + The type of the entity to which this property belongs. + The type of the property. + + + + Loads the entity from the database. + Note that if the entity already exists in the context, then it will not overwritten with values from the database. + + + + + Asynchronously loads the entity from the database. + Note that if the entity already exists in the context, then it will not overwritten with values from the database. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A task that represents the asynchronous operation. + + + + + Asynchronously loads the entity from the database. + Note that if the entity already exists in the context, then it will not overwritten with values from the database. + + + Multiple active operations on the same context instance are not supported. Use 'await' to ensure + that any asynchronous operations have completed before calling another method on this context. + + + A to observe while waiting for the task to complete. + + + A task that represents the asynchronous operation. + + + + + Returns the query that would be used to load this entity from the database. + The returned query can be modified using LINQ to perform filtering or operations in the database. + + A query for the entity. + + + + Returns a new instance of the non-generic class for + the navigation property represented by this object. + + The object representing the navigation property. + A non-generic version. + + + + Gets the property name. + + The property name. + + + + Gets or sets the current value of the navigation property. The current value is + the entity that the navigation property references. + + The current value. + + + + Gets or sets a value indicating whether the entity has been loaded from the database. + + + Loading the related entity from the database either using lazy-loading, as part of a query, or explicitly + with one of the Load methods will set the IsLoaded flag to true. + IsLoaded can be explicitly set to true to prevent the related entity from being lazy-loaded. + Note that explict loading using one of the Load methods will load the related entity from the database + regardless of whether or not IsLoaded is true. + When a related entity is detached the IsLoaded flag is reset to false indicating that the related entity is + no longer loaded. + + + true if the entity is loaded or the IsLoaded has been explicitly set to true; otherwise, false. + + + + + The to which this navigation property belongs. + + An entry for the entity that owns this navigation property. + + + + Exception thrown by when it was expected that SaveChanges for an entity would + result in a database update but in fact no rows in the database were affected. This usually indicates + that the database has been concurrently updated such that a concurrency token that was expected to match + did not actually match. + Note that state entries referenced by this exception are not serialized due to security and accesses to + the state entries after serialization will return null. + + + + + Exception thrown by when the saving of changes to the database fails. + Note that state entries referenced by this exception are not serialized due to security and accesses to the + state entries after serialization will return null. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The message. + + + + Initializes a new instance of the class. + + The message. + The inner exception. + + + + Gets objects that represents the entities that could not + be saved to the database. + + The entries representing the entities that could not be saved. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The message. + + + + Initializes a new instance of the class. + + The message. + The inner exception. + + + + Represents an entity used to store metadata about an EDM in the database. + + + + + Attempts to get the model hash calculated by Code First for the given context. + This method will return null if the context is not being used in Code First mode. + + The context. + The hash string. + + + + Gets or sets the ID of the metadata entity, which is currently always 1. + + The id. + + + + Gets or sets the model hash which is used to check whether the model has + changed since the database was created from it. + + The model hash. + + + + Contains methods used to access the Entity Data Model created by Code First in the EDMX form. + These methods are typically used for debugging when there is a need to look at the model that + Code First creates internally. + + + + + Uses Code First with the given context and writes the resulting Entity Data Model to the given + writer in EDMX form. This method can only be used with context instances that use Code First + and create the model internally. The method cannot be used for contexts created using Database + First or Model First, for contexts created using a pre-existing , or + for contexts created using a pre-existing . + + The context. + The writer. + + + + Writes the Entity Data Model represented by the given to the + given writer in EDMX form. + + An object representing the EDM. + The writer. + + + + A factory for creating derived instances. Implement this + interface to enable design-time services for context types that do not have a + public default constructor. + At design-time, derived instances can be created in order to enable specific + design-time experiences such as model rendering, DDL generation etc. To enable design-time instantiation + for derived types that do not have a public, default constructor, implement + this interface. Design-time services will auto-discover implementations of this interface that are in the + same assembly as the derived type. + + The type of the context. + + + + Creates a new instance of a derived type. + + An instance of TContext + + + + This convention causes DbModelBuilder to include metadata about the model + when it builds the model. When creates a model by convention it will + add this convention to the list of those used by the DbModelBuilder. This will then result in + model metadata being written to the database if the DbContext is used to create the database. + This can then be used as a quick check to see if the model has changed since the last time it was + used against the database. + This convention can be removed from the conventions by overriding + the OnModelCreating method on a derived DbContext class. + + + + + This convention uses the name of the derived + class as the container for the conceptual model built by + Code First. + + + + + Applies the convention to the given model. + + The container to apply the convention to. + The model. + + + + This convention uses the namespace of the derived + class as the namespace of the conceptual model built by + Code First. + + + + + Instances of this class are used internally to create constant expressions for + that are inserted into the expression tree to replace references to + and . + + The type of the element. + + + + The public property expected in the LINQ expression tree. + + The query. + + + + Instances of this class are used to create DbConnection objects for + SQL Server Compact Edition based on a given database name or connection string. + + + It is necessary to provide the provider invariant name of the SQL Server Compact + Edition to use when creating an instance of this class. This is because different + versions of SQL Server Compact Editions use different invariant names. + An instance of this class can be set on the class to + cause all DbContexts created with no connection information or just a database + name or connection string to use SQL Server Compact Edition by default. + This class is immutable since multiple threads may access instances simultaneously + when creating connections. + + + + + Creates a new connection factory with empty (default) DatabaseDirectory and BaseConnectionString + properties. + + The provider invariant name that specifies the version of SQL Server Compact Edition that should be used. + + + + Creates a new connection factory with the given DatabaseDirectory and BaseConnectionString properties. + + The provider invariant name that specifies the version of SQL Server Compact Edition that should be used. + The path to prepend to the database name that will form the file name used by SQL Server Compact Edition when it creates or reads the database file. An empty string means that SQL Server Compact Edition will use its default for the database file location. + The connection string to use for options to the database other than the 'Data Source'. The Data Source will be prepended to this string based on the database name when CreateConnection is called. + + + + Creates a connection for SQL Server Compact Edition based on the given database name or connection string. + If the given string contains an '=' character then it is treated as a full connection string, + otherwise it is treated as a database name only. + + The database name or connection string. + An initialized DbConnection. + + + + The path to prepend to the database name that will form the file name used by + SQL Server Compact Edition when it creates or reads the database file. + The default value is "|DataDirectory|", which means the file will be placed + in the designated data directory. + + + + + The connection string to use for options to the database other than the 'Data Source'. + The Data Source will be prepended to this string based on the database name when + CreateConnection is called. + The default is the empty string, which means no other options will be used. + + + + + The provider invariant name that specifies the version of SQL Server Compact Edition + that should be used. + + + + + Instances of this class are used to create DbConnection objects for + SQL Server based on a given database name or connection string. By default, the connection is + made to '.\SQLEXPRESS'. This can be changed by changing the base connection + string when constructing a factory instance. + + + An instance of this class can be set on the class to + cause all DbContexts created with no connection information or just a database + name or connection string to use SQL Server by default. + This class is immutable since multiple threads may access instances simultaneously + when creating connections. + + + + + Creates a new connection factory with a default BaseConnectionString property of + 'Data Source=.\SQLEXPRESS; Integrated Security=True; MultipleActiveResultSets=True;'. + + + + + Creates a new connection factory with the given BaseConnectionString property. + + The connection string to use for options to the database other than the 'Initial Catalog'. The 'Initial Catalog' will be prepended to this string based on the database name when CreateConnection is called. + + + + Creates a connection for SQL Server based on the given database name or connection string. + If the given string contains an '=' character then it is treated as a full connection string, + otherwise it is treated as a database name only. + + The database name or connection string. + An initialized DbConnection. + + + + The connection string to use for options to the database other than the 'Initial Catalog'. + The 'Initial Catalog' will be prepended to this string based on the database name when + CreateConnection is called. + The default is 'Data Source=.\SQLEXPRESS; Integrated Security=True;'. + + + + + This attribute can be applied to either an entire derived class or to + individual or properties on that class. When applied + any discovered or properties will still be included + in the model but will not be automatically initialized. + + + + + Thrown when a context is generated from the templates in Database First or Model + First mode and is then used in Code First mode. + + + Code generated using the T4 templates provided for Database First and Model First use may not work + correctly if used in Code First mode. To use these classes with Code First please add any additional + configuration using attributes or the DbModelBuilder API and then remove the code that throws this + exception. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class. + + The object that holds the serialized object data. + The contextual information about the source or destination. + + + + Initializes a new instance of the class. + + The message. + + + + Initializes a new instance of the class. + + The message. + The inner exception. + + + + Allows configuration to be performed for an complex type in a model. + A ComplexTypeConfiguration can be obtained via the ComplexType method on + or a custom type derived from ComplexTypeConfiguration + can be registered via the Configurations property on . + + The complex type to be configured. + + + + Allows configuration to be performed for a type in a model. + + The type to be configured. + + + + Configures a property that is defined on this type. + + The type of the property being configured. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + The type of the property being configured. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is defined on this type. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Initializes a new instance of ComplexTypeConfiguration + + + + + Excludes a property from the model so that it will not be mapped to the database. + + The type of the property to be ignored. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The same ComplexTypeConfiguration instance so that multiple calls can be chained. + + + + + + + + + + + + + + + + Allows derived configuration classes for entities and complex types to be registered with a + . + + + Derived configuration classes are created by deriving from + or and using a type to be included in the model as the generic + parameter. + Configuration can be performed without creating derived configuration classes via the Entity and ComplexType + methods on . + + + + + Discovers all types that inherit from or + in the given assembly and adds an instance + of each discovered type to this registrar. + + + Note that only types that are abstract or generic type definitions are skipped. Every + type that is discovered and added must provide a parameterless constructor. + + The assembly containing model configurations to add. + The same ConfigurationRegistrar instance so that multiple calls can be chained. + + + + Adds an to the . + Only one can be added for each type in a model. + + The entity type being configured. + The entity type configuration to be added. + The same ConfigurationRegistrar instance so that multiple calls can be chained. + + + + Adds an to the . + Only one can be added for each type in a model. + + The complex type being configured. + The complex type configuration to be added + The same ConfigurationRegistrar instance so that multiple calls can be chained. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Allows the conventions used by a instance to be customized. + The default conventions can be found in the System.Data.Entity.ModelConfiguration.Conventions namespace. + + + + + Discover all conventions in the given assembly and add them to the . + + + This method add all conventions ordered by type name. The order in which conventions are added + can have an impact on how they behave because it governs the order in which they are run. + All conventions found must have a parameterless public constructor. + + The assembly containing conventions to be added. + + + + Enables one or more conventions for the . + + The conventions to be enabled. + + + + Enables a convention for the . + + The type of the convention to be enabled. + + + + Enables a convention for the . This convention + will run after the one specified. + + The type of the convention after which the enabled one will run. + The convention to enable. + + + + Enables a configuration convention for the . This convention + will run before the one specified. + + The type of the convention before which the enabled one will run. + The convention to enable. + + + + Disables one or more conventions for the . + + The conventions to be disabled. + + + + Disables a convention for the . + The default conventions that are available for removal can be found in the + System.Data.Entity.ModelConfiguration.Conventions namespace. + + The type of the convention to be disabled. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Configures the table and column mapping for an entity type or a sub-set of properties from an entity type. + This configuration functionality is available via the Code First Fluent API, see . + + The entity type to be mapped. + + + Initializes a new instance of the class. + + + + Configures the properties that will be included in this mapping fragment. + If this method is not called then all properties that have not yet been + included in a mapping fragment will be configured. + + An anonymous type including the properties to be mapped. + A lambda expression to an anonymous type that contains the properties to be mapped. C#: t => new { t.Id, t.Property1, t.Property2 } VB.Net: Function(t) New With { p.Id, t.Property1, t.Property2 } + + + + Configures a property that is included in this mapping fragment. + + The type of the property being configured. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + The type of the property being configured. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Configures a property that is included in this mapping fragment. + + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to configure the property. + + + + Re-maps all properties inherited from base types. + When configuring a derived type to be mapped to a separate table this will cause all properties to + be included in the table rather than just the non-inherited properties. This is known as + Table per Concrete Type (TPC) mapping. + + The same configuration instance so that multiple calls can be chained. + + + + Configures the table name to be mapped to. + + Name of the table. + The same configuration instance so that multiple calls can be chained. + + + + Configures the table name and schema to be mapped to. + + Name of the table. + Schema of the table. + The same configuration instance so that multiple calls can be chained. + + + + Sets an annotation in the model for the table to which this entity is mapped. The annotation + value can later be used when processing the table such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Passing a null value clears any annotation with + the given name on the column that had been previously set. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same configuration instance so that multiple calls can be chained. + + + + Configures the discriminator column used to differentiate between types in an inheritance hierarchy. + + The name of the discriminator column. + A configuration object to further configure the discriminator column and values. + + + + Configures the discriminator condition used to differentiate between types in an inheritance hierarchy. + + The type of the property being used to discriminate between types. + A lambda expression representing the property being used to discriminate between types. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object to further configure the discriminator condition. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Used to configure a column with length facets for an entity type or complex type. This configuration functionality is exposed by the Code First Fluent API, see . + + + + + Configures a primitive column from an entity type. + + + + Configures the primitive column to be optional. + The same instance so that multiple calls can be chained. + + + Configures the primitive column to be required. + The same instance so that multiple calls can be chained. + + + Configures the data type of the primitive column used to store the property. + The same instance so that multiple calls can be chained. + The name of the database provider specific data type. + + + Configures the order of the primitive column used to store the property. This method is also used to specify key ordering when an entity type has a composite key. + The same instance so that multiple calls can be chained. + The order that this column should appear in the database table. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + Configures the column to allow the maximum length supported by the database provider. + The same instance so that multiple calls can be chained. + + + Configures the column to have the specified maximum length. + The same instance so that multiple calls can be chained. + The maximum length for the column. Setting the value to null will remove any maximum length restriction from the column and a default length will be used for the database column. + + + Configures the column to be fixed length. + The same instance so that multiple calls can be chained. + + + Configures the column to be variable length. + The same instance so that multiple calls can be chained. + + + + + + + + + + + + + + + + Configures a condition used to discriminate between types in an inheritance hierarchy based on the values assigned to a property. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures the condition to require a value in the property. + Rows that do not have a value assigned to column that this property is stored in are + assumed to be of the base type of this entity type. + + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Configures a database column used to store a string values. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures the column to allow the maximum length supported by the database provider. + + The same StringColumnConfiguration instance so that multiple calls can be chained. + + + + Configures the property to have the specified maximum length. + + + The maximum length for the property. Setting 'null' will result in a default length being used for the column. + + The same StringColumnConfiguration instance so that multiple calls can be chained. + + + + Configures the column to be fixed length. + Use HasMaxLength to set the length that the property is fixed to. + + The same StringColumnConfiguration instance so that multiple calls can be chained. + + + + Configures the column to be variable length. + Columns are variable length by default. + + The same StringColumnConfiguration instance so that multiple calls can be chained. + + + + Configures the column to be optional. + + The same StringColumnConfiguration instance so that multiple calls can be chained. + + + + Configures the column to be required. + + The same StringColumnConfiguration instance so that multiple calls can be chained. + + + + Configures the data type of the database column. + + Name of the database provider specific data type. + The same StringColumnConfiguration instance so that multiple calls can be chained. + + + + Configures the order of the database column. + + The order that this column should appear in the database table. + The same StringColumnConfiguration instance so that multiple calls can be chained. + + + + Configures the column to support Unicode string content. + + The same StringColumnConfiguration instance so that multiple calls can be chained. + + + + Configures whether or not the column supports Unicode string content. + + Value indicating if the column supports Unicode string content or not. Specifying 'null' will remove the Unicode facet from the column. Specifying 'null' will cause the same runtime behavior as specifying 'false'. + The same StringColumnConfiguration instance so that multiple calls can be chained. + + + + + + + + + + + + + + + + Configures a discriminator column used to differentiate between types in an inheritance hierarchy. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures the discriminator value used to identify the entity type being + configured from other types in the inheritance hierarchy. + + Type of the discriminator value. + The value to be used to identify the entity type. + A configuration object to configure the column used to store discriminator values. + + + + Configures the discriminator value used to identify the entity type being + configured from other types in the inheritance hierarchy. + + Type of the discriminator value. + The value to be used to identify the entity type. + A configuration object to configure the column used to store discriminator values. + + + + Configures the discriminator value used to identify the entity type being + configured from other types in the inheritance hierarchy. + + The value to be used to identify the entity type. + A configuration object to configure the column used to store discriminator values. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Configures a many relationship from an entity type. + + The entity type that the relationship originates from. + The entity type that the relationship targets. + + + + Configures the relationship to be many:many with a navigation property on the other side of the relationship. + + An lambda expression representing the navigation property on the other end of the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be many:many without a navigation property on the other side of the relationship. + + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be many:required with a navigation property on the other side of the relationship. + + An lambda expression representing the navigation property on the other end of the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be many:required without a navigation property on the other side of the relationship. + + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be many:optional with a navigation property on the other side of the relationship. + + An lambda expression representing the navigation property on the other end of the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be many:optional without a navigation property on the other side of the relationship. + + A configuration object that can be used to further configure the relationship. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Configures an optional relationship from an entity type. + + The entity type that the relationship originates from. + The entity type that the relationship targets. + + + + Configures the relationship to be optional:many with a navigation property on the other side of the relationship. + + An lambda expression representing the navigation property on the other end of the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be optional:many without a navigation property on the other side of the relationship. + + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be optional:required with a navigation property on the other side of the relationship. + + An lambda expression representing the navigation property on the other end of the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be optional:required without a navigation property on the other side of the relationship. + + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be optional:optional with a navigation property on the other side of the relationship. + The entity type being configured will be the dependent and contain a foreign key to the principal. + The entity type that the relationship targets will be the principal in the relationship. + + An lambda expression representing the navigation property on the other end of the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be optional:optional without a navigation property on the other side of the relationship. + The entity type being configured will be the dependent and contain a foreign key to the principal. + The entity type that the relationship targets will be the principal in the relationship. + + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be optional:optional with a navigation property on the other side of the relationship. + The entity type being configured will be the principal in the relationship. + The entity type that the relationship targets will be the dependent and contain a foreign key to the principal. + + A lambda expression representing the navigation property on the other end of the relationship. + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be optional:optional without a navigation property on the other side of the relationship. + The entity type being configured will be the principal in the relationship. + The entity type that the relationship targets will be the dependent and contain a foreign key to the principal. + + A configuration object that can be used to further configure the relationship. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Configures an required relationship from an entity type. + + The entity type that the relationship originates from. + The entity type that the relationship targets. + + + + Configures the relationship to be required:many with a navigation property on the other side of the relationship. + + An lambda expression representing the navigation property on the other end of the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be required:many without a navigation property on the other side of the relationship. + + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be required:optional with a navigation property on the other side of the relationship. + + An lambda expression representing the navigation property on the other end of the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be required:optional without a navigation property on the other side of the relationship. + + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be required:required with a navigation property on the other side of the relationship. + The entity type being configured will be the dependent and contain a foreign key to the principal. + The entity type that the relationship targets will be the principal in the relationship. + + An lambda expression representing the navigation property on the other end of the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be required:required without a navigation property on the other side of the relationship. + The entity type being configured will be the dependent and contain a foreign key to the principal. + The entity type that the relationship targets will be the principal in the relationship. + + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be required:required with a navigation property on the other side of the relationship. + The entity type being configured will be the principal in the relationship. + The entity type that the relationship targets will be the dependent and contain a foreign key to the principal. + + An lambda expression representing the navigation property on the other end of the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures the relationship to be required:required without a navigation property on the other side of the relationship. + The entity type being configured will be the principal in the relationship. + The entity type that the relationship targets will be the dependent and contain a foreign key to the principal. + + A configuration object that can be used to further configure the relationship. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Base class for performing configuration of a relationship. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures a relationship that can support cascade on delete functionality. + + + + + Configures cascade delete to be on for the relationship. + + + + + Configures whether or not cascade delete is on for the relationship. + + Value indicating if cascade delete is on or not. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Configures a relationship that can support foreign key properties that are exposed in the object model. + This configuration functionality is available via the Code First Fluent API, see . + + The dependent entity type. + + + + Configures a relationship that can only support foreign key properties that are not exposed in the object model. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures the relationship to use foreign key property(s) that are not exposed in the object model. + The column(s) and table can be customized by specifying a configuration action. + If an empty configuration action is specified then column name(s) will be generated by convention. + If foreign key properties are exposed in the object model then use the HasForeignKey method. + Not all relationships support exposing foreign key properties in the object model. + + Action that configures the foreign key column(s) and table. + A configuration object that can be used to further configure the relationship. + + + + + + + + + + + + + + + + Configures the relationship to use foreign key property(s) that are exposed in the object model. + If the foreign key property(s) are not exposed in the object model then use the Map method. + + The type of the key. + A lambda expression representing the property to be used as the foreign key. If the foreign key is made up of multiple properties then specify an anonymous type including the properties. When using multiple foreign key properties, the properties must be specified in the same order that the the primary key properties were configured for the principal entity type. + A configuration object that can be used to further configure the relationship. + + + + + + + + + + + + + + + + Configures the table and column mapping of a relationship that does not expose foreign key properties in the object model. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures the name of the column(s) for the foreign key. + + The foreign key column names. When using multiple foreign key properties, the properties must be specified in the same order that the the primary key properties were configured for the target entity type. + The same ForeignKeyAssociationMappingConfiguration instance so that multiple calls can be chained. + + + + Sets an annotation in the model for a database column that has been configured with . + The annotation value can later be used when processing the column such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Passing a null value clears any annotation with + the given name on the column that had been previously set. + + The name of the column that was configured with the HasKey method. + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same ForeignKeyAssociationMappingConfiguration instance so that multiple calls can be chained. + + + + Configures the table name that the foreign key column(s) reside in. + The table that is specified must already be mapped for the entity type. + If you want the foreign key(s) to reside in their own table then use the Map method + on to perform + entity splitting to create the table with just the primary key property. Foreign keys can + then be added to the table via this method. + + Name of the table. + The same ForeignKeyAssociationMappingConfiguration instance so that multiple calls can be chained. + + + + Configures the table name and schema that the foreign key column(s) reside in. + The table that is specified must already be mapped for the entity type. + If you want the foreign key(s) to reside in their own table then use the Map method + on to perform + entity splitting to create the table with just the primary key property. Foreign keys can + then be added to the table via this method. + + Name of the table. + Schema of the table. + The same ForeignKeyAssociationMappingConfiguration instance so that multiple calls can be chained. + + + + + + + + + + + + + + + + + + + Configures the table and column mapping of a many:many relationship. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures the join table name for the relationship. + + Name of the table. + The same ManyToManyAssociationMappingConfiguration instance so that multiple calls can be chained. + + + + Configures the join table name and schema for the relationship. + + Name of the table. + Schema of the table. + The same ManyToManyAssociationMappingConfiguration instance so that multiple calls can be chained. + + + + Sets an annotation in the model for the join table. The annotation value can later be used when + processing the table such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Passing a null value clears any annotation with + the given name on the column that had been previously set. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same configuration instance so that multiple calls can be chained. + + + + Configures the name of the column(s) for the left foreign key. + The left foreign key points to the parent entity of the navigation property specified in the HasMany call. + + The foreign key column names. When using multiple foreign key properties, the properties must be specified in the same order that the the primary key properties were configured for the target entity type. + The same ManyToManyAssociationMappingConfiguration instance so that multiple calls can be chained. + + + + Configures the name of the column(s) for the right foreign key. + The right foreign key points to the parent entity of the the navigation property specified in the WithMany call. + + The foreign key column names. When using multiple foreign key properties, the properties must be specified in the same order that the the primary key properties were configured for the target entity type. + The same ManyToManyAssociationMappingConfiguration instance so that multiple calls can be chained. + + + + + + Determines whether the specified object is equal to the current object. + true if the specified object is equal to the current object; otherwise, false. + The object to compare with the current object. + + + + + + + + + + + + + Configures a many:many relationship. + This configuration functionality is available via the Code First Fluent API, see . + + The type of the parent entity of the navigation property specified in the HasMany call. + The type of the parent entity of the navigation property specified in the WithMany call. + + + + Configures the foreign key column(s) and table used to store the relationship. + + Action that configures the foreign key column(s) and table. + The same instance so that multiple calls can be chained. + + + + Configures stored procedures to be used for modifying this relationship. + The default conventions for procedure and parameter names will be used. + + The same instance so that multiple calls can be chained. + + + + Configures stored procedures to be used for modifying this relationship. + + + Configuration to override the default conventions for procedure and parameter names. + + The same instance so that multiple calls can be chained. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Used to configure a property of an entity type or complex type. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Used to configure a property with length facets for an entity type or complex type. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Used to configure a primitive property of an entity type or complex type. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures the property to be optional. + The database column used to store this property will be nullable. + + The same PrimitivePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be required. + The database column used to store this property will be non-nullable. + + The same PrimitivePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures how values for the property are generated by the database. + + + The pattern used to generate values for the property in the database. + Setting 'null' will cause the default option to be used, which may be 'None', 'Identity', or 'Computed' depending + on the type of the property, its semantics in the model (e.g. primary keys are treated differently), and which + set of conventions are being used. + + The same PrimitivePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be used as an optimistic concurrency token. + + The same PrimitivePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures whether or not the property is to be used as an optimistic concurrency token. + + Value indicating if the property is a concurrency token or not. Specifying 'null' will remove the concurrency token facet from the property. Specifying 'null' will cause the same runtime behavior as specifying 'false'. + The same PrimitivePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the data type of the database column used to store the property. + + Name of the database provider specific data type. + The same PrimitivePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the name of the database column used to store the property. + + The name of the column. + The same PrimitivePropertyConfiguration instance so that multiple calls can be chained. + + + + Sets an annotation in the model for the database column used to store the property. The annotation + value can later be used when processing the column such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Passing a null value clears any annotation with + the given name on the column that had been previously set. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same PrimitivePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the name of the parameter used in stored procedures for this property. + + Name of the parameter. + The same PrimitivePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the order of the database column used to store the property. + This method is also used to specify key ordering when an entity type has a composite key. + + The order that this column should appear in the database table. + The same PrimitivePropertyConfiguration instance so that multiple calls can be chained. + + + + + + + + + + + + + Gets the of the current instance. + + The exact runtime type of the current instance. + + + + Configures the property to allow the maximum length supported by the database provider. + + The same LengthPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to have the specified maximum length. + + The maximum length for the property. Setting 'null' will remove any maximum length restriction from the property and a default length will be used for the database column. + The same LengthPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be fixed length. + Use HasMaxLength to set the length that the property is fixed to. + + The same LengthPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be variable length. + Properties are variable length by default. + + The same LengthPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to allow the maximum length supported by the database provider. + + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to have the specified maximum length. + + The maximum length for the property. Setting 'null' will remove any maximum length restriction from the property. + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be fixed length. + Use HasMaxLength to set the length that the property is fixed to. + + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be variable length. + properties are variable length by default. + + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be optional. + The database column used to store this property will be nullable. + properties are optional by default. + + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be required. + The database column used to store this property will be non-nullable. + + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures how values for the property are generated by the database. + + + The pattern used to generate values for the property in the database. + Setting 'null' will cause the default option to be used, which may be 'None', 'Identity', or 'Computed' depending + on the type of the property, its semantics in the model (e.g. primary keys are treated differently), and which + set of conventions are being used. + + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be used as an optimistic concurrency token. + + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures whether or not the property is to be used as an optimistic concurrency token. + + Value indicating if the property is a concurrency token or not. Specifying 'null' will remove the concurrency token facet from the property. Specifying 'null' will cause the same runtime behavior as specifying 'false'. + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the name of the database column used to store the property. + + The name of the column. + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Sets an annotation in the model for the database column used to store the property. The annotation + value can later be used when processing the column such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Passing a null value clears any annotation with + the given name on the column that had been previously set. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the data type of the database column used to store the property. + + Name of the database provider specific data type. + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the order of the database column used to store the property. + This method is also used to specify key ordering when an entity type has a composite key. + + The order that this column should appear in the database table. + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be a row version in the database. + The actual data type will vary depending on the database provider being used. + Setting the property to be a row version will automatically configure it to be an + optimistic concurrency token. + + The same BinaryPropertyConfiguration instance so that multiple calls can be chained. + + + + Used to configure a property of an entity type or complex type. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures the property to be optional. + The database column used to store this property will be nullable. + + The same DateTimePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be required. + The database column used to store this property will be non-nullable. + properties are required by default. + + The same DateTimePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures how values for the property are generated by the database. + + + The pattern used to generate values for the property in the database. + Setting 'null' will cause the default option to be used, which may be 'None', 'Identity', or 'Computed' depending + on the type of the property, its semantics in the model (e.g. primary keys are treated differently), and which + set of conventions are being used. + + The same DateTimePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be used as an optimistic concurrency token. + + The same DateTimePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures whether or not the property is to be used as an optimistic concurrency token. + + Value indicating if the property is a concurrency token or not. Specifying 'null' will remove the concurrency token facet from the property. Specifying 'null' will cause the same runtime behavior as specifying 'false'. + The same DateTimePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the name of the database column used to store the property. + + The name of the column. + The same DateTimePropertyConfiguration instance so that multiple calls can be chained. + + + + Sets an annotation in the model for the database column used to store the property. The annotation + value can later be used when processing the column such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Passing a null value clears any annotation with + the given name on the column that had been previously set. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same DateTimePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the data type of the database column used to store the property. + + Name of the database provider specific data type. + The same DateTimePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the order of the database column used to store the property. + This method is also used to specify key ordering when an entity type has a composite key. + + The order that this column should appear in the database table. + The same DateTimePropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the precision of the property. + If the database provider does not support precision for the data type of the column then the value is ignored. + + Precision of the property. + The same DateTimePropertyConfiguration instance so that multiple calls can be chained. + + + + Used to configure a property of an entity type or complex type. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures the property to be optional. + The database column used to store this property will be nullable. + + The same DecimalPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be required. + The database column used to store this property will be non-nullable. + properties are required by default. + + The same DecimalPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures how values for the property are generated by the database. + + + The pattern used to generate values for the property in the database. + Setting 'null' will cause the default option to be used, which may be 'None', 'Identity', or 'Computed' depending + on the type of the property, its semantics in the model (e.g. primary keys are treated differently), and which + set of conventions are being used. + + The same DecimalPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be used as an optimistic concurrency token. + + The same DecimalPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures whether or not the property is to be used as an optimistic concurrency token. + + Value indicating if the property is a concurrency token or not. Specifying 'null' will remove the concurrency token facet from the property. Specifying 'null' will cause the same runtime behavior as specifying 'false'. + The same DecimalPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the name of the database column used to store the property. + + The name of the column. + The same DecimalPropertyConfiguration instance so that multiple calls can be chained. + + + + Sets an annotation in the model for the database column used to store the property. The annotation + value can later be used when processing the column such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Passing a null value clears any annotation with + the given name on the column that had been previously set. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same DecimalPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the data type of the database column used to store the property. + + Name of the database provider specific data type. + The same DecimalPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the order of the database column used to store the property. + This method is also used to specify key ordering when an entity type has a composite key. + + The order that this column should appear in the database table. + The same DecimalPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the precision and scale of the property. + + The precision of the property. + The scale of the property. + The same DecimalPropertyConfiguration instance so that multiple calls can be chained. + + + + Used to configure a property of an entity type or complex type. + This configuration functionality is available via the Code First Fluent API, see . + + + + + Configures the property to allow the maximum length supported by the database provider. + + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to have the specified maximum length. + + The maximum length for the property. Setting 'null' will remove any maximum length restriction from the property and a default length will be used for the database column.. + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be fixed length. + Use HasMaxLength to set the length that the property is fixed to. + + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be variable length. + properties are variable length by default. + + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be optional. + The database column used to store this property will be nullable. + properties are optional by default. + + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be required. + The database column used to store this property will be non-nullable. + + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures how values for the property are generated by the database. + + + The pattern used to generate values for the property in the database. + Setting 'null' will cause the default option to be used, which may be 'None', 'Identity', or 'Computed' depending + on the type of the property, its semantics in the model (e.g. primary keys are treated differently), and which + set of conventions are being used. + + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to be used as an optimistic concurrency token. + + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures whether or not the property is to be used as an optimistic concurrency token. + + Value indicating if the property is a concurrency token or not. Specifying 'null' will remove the concurrency token facet from the property. Specifying 'null' will cause the same runtime behavior as specifying 'false'. + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the name of the database column used to store the property. + + The name of the column. + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Sets an annotation in the model for the database column used to store the property. The annotation + value can later be used when processing the column such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Passing a null value clears any annotation with + the given name on the column that had been previously set. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the data type of the database column used to store the property. + + Name of the database provider specific data type. + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the order of the database column used to store the property. + This method is also used to specify key ordering when an entity type has a composite key. + + The order that this column should appear in the database table. + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures the property to support Unicode string content. + + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Configures whether or not the property supports Unicode string content. + + Value indicating if the property supports Unicode string content or not. Specifying 'null' will remove the Unicode facet from the property. Specifying 'null' will cause the same runtime behavior as specifying 'false'. + The same StringPropertyConfiguration instance so that multiple calls can be chained. + + + + Convention to process instances of found on properties in the model + + + + + + + + Convention to process instances of found on properties in the model. + + + + + + + + Convention to process instances of found on properties in the model. + + + + + + + + Convention to process instances of found on foreign key properties in the model. + + + + + + + + Convention to process instances of found on properties in the model. + + + + + + + + Convention to process instances of found on properties in the model. + + + + + Convention to process instances of found on properties in the model. + + + + + + + + Convention to process instances of found on properties in the model. + + + + + + + + Convention to process instances of found on navigation properties in the model. + + + + + Convention to process instances of found on primitive properties in the model. + + + + + + + + Convention to process instances of found on properties in the model. + + + + + + + + Convention to process instances of found on properties in the model. + + + + + + + + Convention to process instances of found on types in the model. + + + + + + + + Convention to process instances of found on types in the model. + + + + + + + + Convention to process instances of found on types in the model. + + + + + + + + Convention to detect navigation properties to be inverses of each other when only one pair + of navigation properties exists between the related types. + + + + + + + + Convention to configure a type as a complex type if it has no primary key, no mapped base type and no navigation properties. + + + + + + + + Convention to add a cascade delete to the join table from both tables involved in a many to many relationship. + + + + + Convention to ensure an invalid/unsupported mapping is not created when mapping inherited properties + + + + + Convention to set the table name to be a pluralized version of the entity type name. + + + + + + + + Convention to set precision to 18 and scale to 2 for decimal properties. + + + + + Initializes a new instance of with the default precision and scale. + + + + + Initializes a new instance of with the specified precision and scale. + + Precision + Scale + + + + + + + Convention to move primary key properties to appear first. + + + + + + + + Convention to distinguish between optional and required relationships based on CLR nullability of the foreign key property. + + + + + + + + Base class for conventions that discover foreign key properties. + + + + + When overriden returns true if should be part of the foreign key. + + The association type being configured. + The dependent end. + The candidate property on the dependent end. + The principal end entity type. + A key property on the principal end that is a candidate target for the foreign key. + true if dependentProperty should be a part of the foreign key; otherwise, false. + + + + + + + Returns true if the convention supports pairs of entity types that have multiple associations defined between them. + + + + + Convention to process instances of found on navigation properties in the model. + + + + + + + + Convention to detect primary key properties. + Recognized naming patterns in order of precedence are: + 1. 'Id' + 2. [type name]Id + Primary key detection is case insensitive. + + + + + Base class for conventions that discover primary key properties. + + + + + + + + When overriden returns the subset of properties that will be part of the primary key. + + The entity type. + The primitive types of the entities + The properties that should be part of the primary key. + + + + + + + Convention to discover foreign key properties whose names are a combination + of the dependent navigation property name and the principal type primary key property name(s). + + + + + + + + + + + Convention to enable cascade delete for any required relationships. + + + + + + + + Convention to configure the primary key(s) of the dependent entity type as foreign key(s) in a one:one relationship. + + + + + + + + Convention to set the entity set name to be a pluralized version of the entity type name. + + + + + + + + Convention to discover foreign key properties whose names match the principal type primary key property name(s). + + + + + + + + Convention to set a maximum length for properties whose type supports length facets. The default value is 128. + + + + + Initializes a new instance of with the default length. + + + + + Initializes a new instance of with the specified length. + + The maximum lenght of properties. + + + + + + + + + + + + + Convention to set a default maximum length of 4000 for properties whose type supports length facets when SqlCe is the provider. + + + + + Initializes a new instance of with the default length. + + + + + Initializes a new instance of with the specified length. + + The default maximum length for properties. + + + + + + + + + + Convention to configure integer primary keys to be identity. + + + + + + + + Convention to discover foreign key properties whose names are a combination + of the principal type name and the principal type primary key property name(s). + + + + + + + + Allows configuration to be performed for an entity type in a model. + An EntityTypeConfiguration can be obtained via the Entity method on + or a custom type derived from EntityTypeConfiguration + can be registered via the Configurations property on . + + The entity type being configured. + + + + Initializes a new instance of EntityTypeConfiguration + + + + + Configures the primary key property(s) for this entity type. + + The type of the key. + A lambda expression representing the property to be used as the primary key. C#: t => t.Id VB.Net: Function(t) t.Id If the primary key is made up of multiple properties then specify an anonymous type including the properties. C#: t => new { t.Id1, t.Id2 } VB.Net: Function(t) New With { t.Id1, t.Id2 } + The same EntityTypeConfiguration instance so that multiple calls can be chained. + + + + Configures the entity set name to be used for this entity type. + The entity set name can only be configured for the base type in each set. + + The name of the entity set. + The same EntityTypeConfiguration instance so that multiple calls can be chained. + + + + Excludes a property from the model so that it will not be mapped to the database. + + The type of the property to be ignored. + A lambda expression representing the property to be configured. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + The same EntityTypeConfiguration instance so that multiple calls can be chained. + + + + Configures the table name that this entity type is mapped to. + + The name of the table. + The same EntityTypeConfiguration instance so that multiple calls can be chained. + + + + Configures the table name that this entity type is mapped to. + + The name of the table. + The database schema of the table. + The same EntityTypeConfiguration instance so that multiple calls can be chained. + + + + Sets an annotation in the model for the table to which this entity is mapped. The annotation + value can later be used when processing the table such as when creating migrations. + + + It will likely be necessary to register a if the type of + the annotation value is anything other than a string. Passing a null value clears any annotation with + the given name on the column that had been previously set. + + The annotation name, which must be a valid C#/EDM identifier. + The annotation value, which may be a string or some other type that + can be serialized with an . + The same configuration instance so that multiple calls can be chained. + + + + Configures this type to use stored procedures for insert, update and delete. + The default conventions for procedure and parameter names will be used. + + The same configuration instance so that multiple calls can be chained. + + + + Configures this type to use stored procedures for insert, update and delete. + + + Configuration to override the default conventions for procedure and parameter names. + + The same configuration instance so that multiple calls can be chained. + + + + Allows advanced configuration related to how this entity type is mapped to the database schema. + By default, any configuration will also apply to any type derived from this entity type. + Derived types can be configured via the overload of Map that configures a derived type or + by using an EntityTypeConfiguration for the derived type. + The properties of an entity can be split between multiple tables using multiple Map calls. + Calls to Map are additive, subsequent calls will not override configuration already preformed via Map. + + + An action that performs configuration against an + + . + + The same EntityTypeConfiguration instance so that multiple calls can be chained. + + + + Allows advanced configuration related to how a derived entity type is mapped to the database schema. + Calls to Map are additive, subsequent calls will not override configuration already preformed via Map. + + The derived entity type to be configured. + + An action that performs configuration against an + + . + + The same EntityTypeConfiguration instance so that multiple calls can be chained. + + + + Configures an optional relationship from this entity type. + Instances of the entity type will be able to be saved to the database without this relationship being specified. + The foreign key in the database will be nullable. + + The type of the entity at the other end of the relationship. + A lambda expression representing the navigation property for the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures a required relationship from this entity type. + Instances of the entity type will not be able to be saved to the database unless this relationship is specified. + The foreign key in the database will be non-nullable. + + The type of the entity at the other end of the relationship. + A lambda expression representing the navigation property for the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + Configures a many relationship from this entity type. + + The type of the entity at the other end of the relationship. + A lambda expression representing the navigation property for the relationship. C#: t => t.MyProperty VB.Net: Function(t) t.MyProperty + A configuration object that can be used to further configure the relationship. + + + + + + + + + + + + + + + + Exception thrown by during model creation when an invalid model is generated. + + + + + Initializes a new instance of ModelValidationException + + + + + Initializes a new instance of ModelValidationException + + The exception message. + + + + Initializes a new instance of ModelValidationException + + The exception message. + The inner exception. + + + Initializes a new instance of class serialization info and streaming context. + The serialization info. + The streaming context. + + + + Exception thrown from when validating entities fails. + + + + + Initializes a new instance of DbEntityValidationException. + + + + + Initializes a new instance of DbEntityValidationException. + + The exception message. + + + + Initializes a new instance of DbEntityValidationException. + + The exception message. + Validation results. + + + + Initializes a new instance of DbEntityValidationException. + + The exception message. + The inner exception. + + + + Initializes a new instance of DbEntityValidationException. + + The exception message. + Validation results. + The inner exception. + + + + Validation results. + + + + + Represents validation results for single entity. + + + + + Creates an instance of class. + + Entity entry the results applies to. Never null. + + List of instances. Never null. Can be empty meaning the entity is valid. + + + + + Gets an instance of the results applies to. + + + + + Gets validation errors. Never null. + + + + + Gets an indicator if the entity is valid. + + + + + Exception thrown from when an exception is thrown from the validation + code. + + + + + Initializes a new instance of DbUnexpectedValidationException. + + + + + Initializes a new instance of DbUnexpectedValidationException. + + The exception message. + + + + Initializes a new instance of DbUnexpectedValidationException. + + The exception message. + The inner exception. + + + + Initializes a new instance of DbUnexpectedValidationException with the specified serialization info and + context. + + The serialization info. + The streaming context. + + + + Validation error. Can be either entity or property level validation error. + + + + + Creates an instance of . + + Name of the invalid property. Can be null. + Validation error message. Can be null. + + + + Gets name of the invalid property. + + + + + Gets validation error message. + + + + diff --git a/HomeCinema.Data/bin/Debug/FluentValidation.dll b/HomeCinema.Data/bin/Debug/FluentValidation.dll new file mode 100644 index 0000000000000000000000000000000000000000..7de57518c148b947f7aef879fd5cdfccb27a9060 GIT binary patch literal 138752 zcmeFad7M>?n_CaAywBOovr`wob-J&yYl z+>IKy2=4nD*SO;vO)xPgZnz{-T;h@#V~mdP^PIZ93=E6;zW4Y2^Nmtf=hUfFr%s)! zI#svs?dc0HP^MDKkAFY@sMJG<`8QU=JqInwF6sVAiMqewm70fq(_X2Wy<(*sU7K{4 zC+pWlm)18nI!)0f4bkMf#^}n%=!8ROMb|jX8u}L(hkJRfXHHaVn$J{EZCEiUQ`>vW zs44UnDph4DWohi=Ly(RlJr=Q2Ws*jca`Vq4Q>q0>AyH`8;?qgW|8ubi5{18I;5&~A z@V%Rg*!gdkJnH5R8?m{~AEMygV&u+srSteat1={Qx*809Mln$leGkGLIy3|nTJnTFMBbwccR zMvx|tm;4c1N($ zFmGU<69w>piML%t-fZI-$PLX#%%tDv$!$8v0<8r>5M=og`yJN zkpw20In%V!P-#B+X?uZaoWo!*FmY|?CfW;BTtI>W5% z+d8KL;~v6b8iID}G*$U7b#Ae2Fpr}$+6}r(Y|lu|01MMO6k#(aqHt}bveh~a3HNXW zEkp@E&ls_4kq!80nE^-KSsJ}wldEK-o^44cIP7apJX1Dm3bamKz&CbYMzfk zgkFGz7Mdu*?<#ag<|4{`BYmnKC}=#rn&Y7WG_6Q{XnQ!6 zutH7)l5a!lzB10alU3+Ynu=1H>177QIR-Q~8Wyi|{zIWC6FO0qu&v9z&Z=PsZ44v&eU9xunKg|R;blFHbd-S(&41UuXQWnx!gSUktZMav zRBWXNaVceK1fF^)6~~Z+*jM9@TJ*oyTq4JXaQY^R|(zrdY{7~3k*S+Y*s%_JuX@@|H65~)WSX4SdqFQ3yw z5a^Q`cWypKN2lrtldhjyfN90CHW>hVIN9UAuhF z%H?-%wpgv$HP_|})K?icoU=iKt_#?sVPS>-glW~9!FXlR>fIWojk@O`sJ3S#w|F}Y z&c>vMlq&G-h1NT85O|>3T`&*9MA)84sn7lyN+v?~AQULtzQAxc0j>?%Lj;~`IOhUJ zGtWcRWpJ54@v`4?&S#ltKp(T53xwWsE+ozmT$N#&evVqCF&agbqU|aKQN(r;srq^? zOJ*E>Xrx|2!xI%cHd4O35S z)XB#3r&-hrq*>My*0BCgpmZ;S(78p}#>~X=>r?%}uPRSJmgpyD$lM?m7jB1Eq-}-U zRWR4KQdP2FM$ej0bsIhyiE;3`7!}*F@VMp!yG3gEe0o8icKKWaK0C4C{J;@k&{4}l zo9hV-#z(}Iehgb(=T9_%%KVFm4AX{f$75CWkqm_?p6jPa-*s@%aDI-OV!Hf(gUjJ5 zUkZeC8H3AnSzQMAFxO$x?t&R65we_LAS+%#6^{cl=v+b4Dj82rsH1b+Ivlk1^Mw$1w*ais8>*jV$LH$(O1NgNcw4)EI+q6sr!2wl$LV`xHEP)dlr)wSr#) z2MD7r-okNTX=8B2Tl82YEpoU=i@4XK8jOa`h%9Fd>+Ek|hp6RxrZeU&^Dc%e=dp;9 z`W;vrsozSt4WWyf7ydX(z}d8KM4YujidzU_LN?5q^NFcufKNBp-PyBkGJ2Xt|I*kHDOjViAgya1y)M45f5E=PKLB1ZMuLqFjJeZN; zYBM8)E@U|mA*;{!GOYAu5_BFGSfQP|KBfBgQ)R4=I-L)`7^@NY5#ea2A4P1rzebpT z3;~zz#}T_vAb|2ql!GA@??e1k#6PX^KIJ@vR39tFQqEQcHf%lD?cI#jvp_-&^rfG= zR+wWV?sGu0_nt>=nBe*X67Gu#Y}h}`%aD#8ZkTXbVcv1~C1%1vsT;Oo5qLqRky6!K z#gV7GaB>zr5AEmS!h4g*u)YxOflXkUSj$U2Qzrs!TcTWqvv}AYfDs1 zqE7&%&M97K0Y#`}1Xj7r%1?^p{4N7#9lRmr#;gMt_r5%>2% z(Z2tH820@dBY*mjj7}6>tMxj7jP663cC!ca#+eDb9t)oQGxc&=ZKU4Bh|Hf$|HMM3 zn0cZ|XFGo;PNyrKHwaMAP2kgq^7ZDt;Ej~wdZZ*UQZ5Cd%+GcY>Pruugk{6N2(cTw z3=Zn4E@rt9B%G!+w52|rGM)w|$~{!ZmYD0j1#GreY|~UW2!FXYy$zB*w29f7Hfhp# zfZ2p;sf%u%wxee7gew_ww<9;xzJq>Z`=Ezkkhz#uC0p*b^j%=t()SR%?<0sxOFuvg zqlUR{TdL=!BO#LwnR0FY3n=s3`d7et{l{!sEzp0O^l!lE)1nWN+FlClV}|8?L=Y2$ zo)-qIj)$nyFzlE6iA|^%K1syg0ir^$ucx=C3yk8tzQzE^_4R&+BbAFT%8*mEeI$Gs zPLoC32Lxq$On;0D4D5?OLF|5tKQ|$eS<6sEWhTJu-h8vZlr$r)OUM z&B{0&<-em;*y>#y>|@xUBdvW54009Uh4$(^T8utSDr|o(Xkj1Vdq46MolSAXjKb}m z!iIeWR@00tR>1iIqaq&5^T|Ry)R8$h!wXBzo_J9uh1-P}EO0lxGV24^t2)R>yD(B; zLOv~A>MJBo8|ZkS?NvxoPD8Mk^AF_pVQ)im=nDRI?yRb`9!-TVQVH;L{|P!yI$tBU zbPxRtNm}kVh-HlWYt5>7Aeui?Nt4}~KyjStDJO)XE@8j_26B6MnBBKXV0D7U`{7MV z9OOn8uKPx>kHI;lx=$5b^sDc|qd$0T3jiV8tmGAb?5qc(d10&4{tjgmGjh51e}$Q4 zqad~>$-6<^971(f=R&zY`v;(l3#!kZ37{ez30DQTM8Y<#Jzn9D_?;h-9dm0jAypJa z3M$hS)W)nHc67iYO)f566o$Su;7j8uT)SO{#G1N}kG2fB{9L7>Se zgqVB^5W8Un;Db)i@nQWyqkh<__`8MlcRjgA0PhFhNMZ8xJB6TZ#*E~b&HhlzRs>WF zQG(B&?o`<@gPcr*DAQoCZDd86hOqoiP$y(U<8v}WLB(Jzu9H5OrG5sJM+xw3S1Drh zC_~(CyD}p%X`~{cNtLressf?I6~(DUO3yWz5!4X!?f?|ma?+y;(xQecM6!k6xxa?8 zOtq9T(;X30o=&9hi~wyyN95YH&`5Ow+SIjgg9tVhuKgn2Z^Ov1D`;5xeu&Ah8)COR z0`P+pbNuu=h>@U%qnwe7g2rQBgJiZNxO-ra2KA-^^cg!r-$vXXpk;kM5wpHth})Ha zDvslk=T*@MNtj5M*GTf}3nY2r#9esxL)=Do&NF^>8p@3Veb(udX?tZByb!ucbj*U6 zvbQdyzF+|HSQdW)P&sGcq6e6lt38-XoC3ulMd9{Jy&>n88mmCShO#+z>-lw=3O7P@ zjMa?Q@EOoz$jLu%J;zx?9IW!!^90~NG3}7m78@tx5l2|>Juq34*y%468Zc4=02wI` zH>ZxlLui8bCl{lh{i(x2z|#f?BZex6F!HB|GSZ&@FeXow>{e?y0GZ|kxoN(&>I^zd z&ycs3B6*&RKd2e4gy%d0=e^PqCbi2abP9aA7$xial3 zAk%9IPsWux5c!6EFtB>FUhDxPSvA$6OKP-Noc1MXpPaA>7M>gHtZt`H%qj6q#iZ%7 z3ytg&HA#!KK$y_&mW z6YX(ldj;*|<27ApUVC@06Js+Y*Ql(GU;z1XSno^+TX!QJjJexrmf8s#0EC?qY_`Nq zP#XU9VTjoG1Q`n~?cta{2<>qXM^@NM{uK_CGYjcH@K{N%cW1K&ll(S6mrOQoqPcpx z9Ru02&KzWFy_=l-=+{Qfbw2|&&h7@-bCIq2TT+WN4~RsyeT3l2*%Be0`AF)sNt5e} z8V^3vC$BAC7moIuGv@|tK^`k-0f>*tX5@G|M@k0Nl~v49z(6ralRXqdkg>qDgPrx# zE!Q?p-9|5q^K;2#pY<|9^m2Y%y-*rUWNNDya<)Xq_Vsf0pFaIvw)tAcWYw--$g3T_ zECd>QS%irCAjnwY_VjXIe#=SSMlaY4GXCiTTISHnM(+Z+6sm9%7i5g}&s}NV(s|h7FWH@U8IgJb)1n%h^*qp~q zxlc6-`f(Sag2Lc7lgr3{Tp1{ck>WJbT!ug#`IAx5T?-a1Ls-qP_4-o_*mZ^mk%nVw1tmlQ+^-o_A*H&eS4(c%JQdWK9!^8Vdnp7>=kzwv z8HA?lye2q5T}4YG8c%`C`AyB>ykD&;%}NIGw%vxGX?ikU>;)Jm~( zc&a}`_#Ohj23-;Q&(WFaZ|X%=*k8I9CDV&3i*3^P%K_HE`sA4Pqz0^?o;J-8RNr;KZn?RPdK z%*j2Ie768azSkkPQViSjy&f3%1_U;SWKM4A;zl5$i<=PTcpgTcHv>hUw;;As4BPU& z6&Uw61U80fjwf_+JCJR4aR)GYx;UKt?*xwg??Q|RYzW)(zZ)3$9tI<_x|r%&rn_l3 zsCz+=F|6&^J!@AgLA9l7-jzyFZK*cyN+l?vLjTf^I3LLPNa8`PcW&q(#Uw^mb-#t6mDAqw*sl#cfA??ua zZeG!RwGjKpw=L~%`JVI>+rL8Kp#`)h-8Q@6|rBx(X3 z&s~T^v7%5__r%qq>hAkr9ddrfN-Y=LR;$dr+Uu7Z3URGMB%$r>Bu86${rf0ymhS(W zyix;wD7eOIF7$z`D-TEmott3FlX&m5o&}9$S)G|FySqO4jh&%MfeWDWhq3B_u;iz~NX-Dsfw~ z>pku!J`90)qMxyyD0DCna=VX+25`RsG0%j5jo5vR)Q=;`d1>JB1Q0eB+_)1EM(lg? zIf8tiL?+jrrx26R(}*>nXON2F@TJnmqN>lpO?h2nKFaxRtctjFY+5#!uiScvufa3WcsZj0nh};*14CiX5Iui2n&*ZZc9AUi3e0U(1(*b(I zjWWQ^zd;~-qnDZc3W64*1aD)OiR;o%1VwPq?zg1+9ReF83k{+khNBMD6>+x#Pd&Vf z7>BvPXOtq4Oa!rb9Y`r4=O2K{Q%|P3nRtnjdJPo$%f0hQAY}i+@pcsJdL0ss%(Y$ncpvQAwGT{Z5%&Y+Qb(kMj{d^B^XvmYw)`2X zzappkZwN#iACgWifhfW6gC%I$hJ0+~6o^|{KXx8yh#HizIMkxZxGedcG{0o?N>cCaxZ;+F_ip;T62i{A_``^eS z?{5)XDTc|9^O^n!8238_em*kKb^cV->BzRF{);^4djul$An;vEzCQqiWvdlY`bPw& zm15-Jv_R%2AL5*_ePpjF+vcfIiNQ=6B|a(xJSj8xN6X0DL^fsiBeqfulhX_G26lkO zckNgz+d`I+3L?~fn$I6=ylNo-5VFa?05S9(W|Sh3e1g@mPc17&bnjZLj|?0k;-pdt zY&&)Hs(cZ$oDRA{nf4sR`ihak`brR6DTc}7a9(>#fyv{E2Lv|8Wv(w4W-JzyW7x)& z9Cs=(P3G%uIqNA$HtRtq>S36?ob_akv=W%SdNKoo=Q7C2&U-7!3-9cKmyxbUjAr9i zwXoZXRM!}ZfN|c++F;eW|HMu^W?((Wtc=%NkZWVkjN6!~;;}w>h=Ui`@bC!rY~U#Y z>gkp_e31kY@U``6j3j`FW)PA9q9%io1Q0zk2uT3ZGlP%>5WO-8NdVD1gOCKChU3)2 zzstLAU3`!QHp0F`?P?|Ua1qYys8eRL|1akG9ae{MnmpJh0CIO-tlPW6Z^hQznA9+Q zFxqiE*j2*)5IXx&iKru>K1UtLq7J-EafzHNnrYGn1AJKR50+SIDeQJbi8O05nr(zK zcXkJJ{ayf3f)|0j!}g%m$jcx+j{AX8Fh#ERk4!iB%kYVkPj^(%LX_a`00l1z*aZ^% zHD7t3!tO+rjS1cgO3QRTnzgjdru`fGZI7Q*RZ;N9JaInIwhTs3Lo;YMSUtSgqA-_x z>yjmN*DC16kkc7lMnmCnp%s)P8^hej10Fd!%bgy&#o*6-l6H{wOP`odji_4sa|m=j zo;407>C~dtv>z22Ypj4n7lvBKD^ZH zLy~AlK_S=NdKg|!@*>P-R84P@!CuTElM`DPa{3~(PYhbh%W`ZWX>#zc{jp>49FYky zW@L|ttm&@I0Yx9im`Ku+0HSXOAqnWjCwFAli0lUM_*l3CDY0`B0NnBo!fsJ2``i)w zQ;ndvYas^4A=){(0|qGK?yZ9hjjA-0MmSzk<^B>4#PpHs2@LN-_>u0-bT6i<(#t`? z`(^=kxuKLJeZ%sF!K(fh!A|=x_2DhJuKSNe=7=>2j1HQ;=IL~1Yx{uSgDU~o;?Xrx zwS`7=f5@owF&_XYZ))bz$^|*0=BdAx?klW>5=T;=M6J^804yR+eB3e!(B`B%b!HBiesF%zWnv#&y zk45W<=qP;SV^J+(C&rvw=2UBOsxt+NOk=qFjZRXgI{XgQtvn81@lBZ6YVR}b&FCB> z#b#9x4&jwdBx=h%x$98HsNp~U_@iN8D`aeTBI@bZFUk`=UW=qN2-G9)kYNG!?7>8K(WM4}h_G(<09}faZfIApq1*TO z3V77g%B_Zd9mUtx4rQY@NTap@TNU0OG;CZjx8Am52XPdj1^hc7mdJlW4dUH2UKH}j zI=jQbVWZspy8wA>v-TXes`c$_l!9}l|Hb2a+!O{o?(}j<0V}5Z-)4deep{0kg*t0K z=roL0{V%5TiVJWDJHwlCT-dOE!iG(HJLbbAXyC-(7@@`IF1^=5nRHqiCuP#hRIjsi zI@7*mvQKekjLQ^|<_v&o$Qzhq)vZa}epaPLt}6fRgeuM~T|wF*mA zwv;vr-B&CnJuIcTHtToKI1hDi%}g_ThB4EeVRG|z#=pV+7x-KjCvDuQXOhoRMuIl; zrZV~ZxjtmxRUU@S)KCNlFZ}pZLnJvIp}Pa+oiYS?+IS1}+U{%2#~P^-Ag&%}VYgyj**K-v@7CM(FrA8mcd(&TEGsI| zGpCg7U2F8Q^n6KOWC&!!j996B9B0egh`of1+fvOH8&Gh~bH38lQN(+5oBdIR-sZ&F z3^z>sIWRH3P__^ycwQTfJEI_TML2#)B<$>uWRc+s6Y}Jcxw9Am`4-3<=>T-6L_Bn+ zSK_{^-i5UVU?nrd?c0kYSpEUh=rH_5BQejecDvlnn@Zj`wL>M;MTQ1KQUn$1XVjId_efQOYSlPi zNG$P}1WGJh{6gR=25P^u2{IWrb~rc>b1;a+uY{u?hhGT?eiy%TEJ$>l{AwHctjlk+ zd~%@BzYfleQ4~r<@Cx2vIXnCo!N}`DZ8;wzxeki!Qe0KxFBo|~kOj^`U|JE1H%3AZ z+#B4Y#{C7chMS-Rj#?RV0cRyZ4~Y1CS07Q~--My$bB-0f;bqCaAL#`4ZX}>@gM5UF zgMM7LX0K@T4{7s08|EE?d3!Hh>pPpgRhD{McRl+Lx=`z>D_l{78(>w3w}<-pt7dOk zRWWulb?oko%Jks~vTL+dk4+ess99ulGzM*c)Ig|m^aop+W&xhjV7sWVsmQ2^g{$#Jg+}1y?Y7T>sX8K^D&U+WXd8Bx^hP% z_Il8Sw~fmzWyv^89}i@q_d*UHJ_fgh>{WU$$=nM&McTE2bi5aK0=eK`*ha+rbT2H^ zi3^Psp5SJl6=22G*AKI2i>I>hP9%5CbZNxsE?ij%yC)&Yn!;2g)dJXi;(&F9&4w-N zXHut;$H~Yik5dqX$Ek?qW>P+n({eoE_qO42I(eM#@i;^CIFmfOBk*3hJ&W+!2<)lo zYW;2;W*2n^b(O*_=f~pWoC5+bE>(DebTDweEBxhnVH((-X#99nx)-(_n~()RSIP&S za{&d5w-<6n_S@$HdOPzS34R6RfWuTFs#N&g$N9)hvy|a-5lXW%Z#~LgSB5+1-FG+D zxh#mkyk(4Uxsn9uw+1fO=hnAGuS`Z&T_>GP4xs5=fLiUlm@Jv} z*rB_G*yC~_xnywJag5VOb*AX?VpI^ul}gjT1gWM9SZox^A0wSE+J=GUJdT{$0vT0a z&J)1cPZB-VkPbB^)Wc0=HTaDiJq~!G90Sgj4Vh>4c!8$a#*4=QRSlh}$n9?XBqtqQ3K}8{H)@B1c~5#ZHxdWZ5qv>?p79LJRm> z0|}bIWJ{>p!jg`?Xsardrs|J8 z8mT`3t8eh5-Q072jTjr`NM%L9eGQovcoKs>C>DT9`;UMVWyw|O>Es;<+}DBF7{PNJ z3YGp7AOr4^>QWf2?UH;36o%yJk4KI`w)8E-JYKDzTsv%X{^}JJ(sJj{R-sT*6TB zAJv6u_y60iERJ_6Xs3;s4=d1z1zN&)wuf_{i__nZFw|kH?*<-=@jG=XZ2k0OH%S07 zA%l|ou2FYdMMg;F=T39 z0J-(+GKua2c=QzUFBGxB6!c*{X7SsU9z);8nXi@S`%Gf%F?BNLSy?z1uH^sHe)y2; z61HC^iU4M)vr!s5I_EUR=_x3K^chSatkb73J()bYwj7S~KWBNFF4tj)J%V<+GA#tT%U!uwT zOV!$KaK^lk3BuX6+)u$IZ1Dq~ej&z-vWKyi-HaBA=h}Cm*5vmnDjCjatkuJIEo%=u zq+RT^cCpEJvDdbX-P$hpn|86iBJD{wrd{k&?PAYr7kgv7*sbki-)k3(caPiAWXHBx z^zPrO=iHV?z+=qh1Q2>}3=w5IWi*P|v1anxY>w&9#fh~2Ir4EUY!voCBz3+(unP#Y z;qp#9vcCjD?8eO4Nq8nyO#7dR(qA)O;!pnzFDQTViok3fH8nE}HxfjoYOn z@i|^b`#0{3EQ|jaS-#szmfC3Yh>AUna=2;u1MYt*e+u&3KOhBlVE*;Xoo!4v-aAr$ z`5GA1VrhC@BO>k23|cjVeJL-bnVA5uRL|y<3F%)vmYoP7#v3+2QnsZ$t|3p%6Y6rv zhVQIX0$NFWCl*p z;x>-Gkc+R)1c1`-jh+frZJ*@5P-Gtef)p#(-efn}k*j+aLjk9wdZv~H4-;sqxI6SF zB$6vh?;xR(rbbRm4y~kvdL;(}clmn#qyPU4+GFz(;3#$sAHR%nQ5!#^Q^daV{QpLK~%*B_kGHq z>8j4nN3x9zjo!7zeW1gSC{&0-3BGglQEjq!WU~d&diA@f=b&DHqS~K-tWZ@K^fpwP z9VNb?&Vd@Mj7pMBkP=l_#oQO;jkvWXTJ*C z%D!jM0&U)#J}Ez!Z1(xR=_^r(xegD%^WU2$e_Sd>*!I0?a>m_K;^))IaU#a`cNAph zToiq+e!vGiy*DjP7Jzu?_w0oWPFawVubM(IhiZxtQ6&T!3%pmokh+atF3#5rdF-=Z zt`fcAk$b*g$lnr~+UkXzEs?Q(y*&BmiyL;*3t6@MJ~?@1-zU$ROfk^VO9>+CgCJvp z_o^3Cx6#XO`FbIbeb&p>q8Hpt$kz+`TOw0iy^u5R3?pn`FLMqWanMeBA**)vB3v@| z!uRVr`MRYbha=~du^5M5@_95(FO&;GM11mNqOed{ZiM7`f4&^C{{9%gMJ&2TjIbdI+NaNCv?L-@#bY2imymfLkgkV?>n7U0h|jDlIN9K3BwPyx zR$Cj~0A5ql{)owUFx4;7uP#22DNlS!Y1n;9e>`Nv>-6~12>d7o5jYHqH^-2Ybu&(U z0znH=g12#OpqtZXvaCfuCWZcpI2jOREHLVCZ(i6R2Af?+SfI_kuqZ#5Z1#CxxK`!` z9O~!K3*>K!SZ(J8a>j39AZ&kLc;}r*?%ru$Aggxg1>usL7o=Y*^(|*~NfEmQqmsR4 z@_Twzkb`k2aUEmo$*=B&zBY3l=DMhP5VEC5@U1%CQ!PXZUiTS3TBj-S^}Db;3_%M~ z%@PdHWR76wNM;h%%)rK32^{d|{gIX`MkC=KfS`pa!8eb|WFE-OvCJe&@HP%M_){Ow zIACyP1>vsNiEnjz)`{(jo^NQETWFUPk;j_|q{(YE>~az?d3HG&polny_=6F&5Y^1U z#*qh_VdLaN-g7hfy+?H&ZNbKlJa_sTNv2_1X5IrBIBJ})ovC1xl^idNe22*tM+m^m z#>bwf^L0;#O+CK+@*Sz`*^cSR=d<(~i1XTklg~qe$+ZK69sYP+Itgj`<#G3LP}uNV z`L+r_>?o!(i;Uda2s2|D&at{-C)=2Ve9_8WB=l${s+oZeCpF%DM22EMDe&nP_`wJS zZ^P}P-r!}#bAF+X@2g-u+xQL)RgyZIF^?f60mQ-#LK6B`#zxF+LL>v({#^66Xj4Sja{LiPi%H3GUb#>XP?(zHd)BqNty=r39AJro`m3AWNY;u1jsCC zJ+`nf!?%ICH^X5TonWUK}F&@jaq@_zz zU@w`IIxkN|_h6j9S)TkJrUy%7&%vjfi_sm~Z{$_mSF;s(vr!sq!vm1Zw z2;E~&3n{RF!*N+P!bCMbcg}>VuK_Ma1$_96^VQ6vw;mf@xczdHh#@LTY4bABX2vD9 zdg^BCbO##E`GsUbO-yBK`@}5sF_qGQk~WsfxP2`G=V*3*8)90Kywc$;L>?BuV=+Fu zQq1HS7>z!!k&BlWe6@gN!T3@%d%ryZgx%kE>1Ld#DJhJzS!~=aoyNd85i~L~B>_Y_gOCJn_Q25n zc4w3!ncXFmVEe>2Xg|&|)b58y<+jJ60ed;1rVbF*UV&7VJW#W-aK-JRAU2cd<+PH< zKATtEQ;fB+x~X^;NS-+4wPKh=XoUx$unp%cjtgF#6Ns1mOy@&dv;aP%oE@K&X^A8< zG$6oEPoHOxfxd5rzVU9+C!QrR&#=d%Chz9kr!;|+Wq+H7zv{N z_F=w1Em->LAtaVw2JaGus9~*T7cm3+e|A%KgGuwT*R1erSyR^n|A8SR5&< zJHX5ROth_kP>e+UMEBpxXe}7=CnT`$WPdTt`!z9;d`^-vIL^V{Wx26gpf6rabK!35 z=FVhuk7IL*YL)=|5xz9(gjbHj+elEG} zvtN2A^}7y7a`}EK`CB4YTfdZ?Es?T)zf?8#x_KwRl&sqIOUWy{kI#${j3SJ5w+VSX zSY3x0pW;ldN30=dIZxE&Tt)x3h1huNcrtqj%J-;llF86}Ele_HwV;>lJ?H0x5YyR! za+@%$^|fov{D4z3lr&2`#lk%~Ao+$OrfvN@A`ifp?xHQ7h#dYVRT?o~&S++oBH&1M zbk)35uBzlW=%OmQlMR_cS74=R}-N#2G}OljDW{pmQdG*s-$0x5y}@uOQP}3$2tU zh<%}-mnyNb^JW&o;P5tY=HL*AgRX7ILVsTLb5uWtcVhP_9GzG_TA*is^Qve`lCsI4(W*!d^2`}e)}GhqAru) z#aAc@--=4s`o(;{003?iK-u_>CHqJ~MSeU!{TUSmW8~>I%NufEh|kXao_Xb2mS6XB z&Zsh~mDcA}ONsDib>+6Z_q;&Kvc~8C=y8P>crvdW?-@pQ%t|&^dxyeuK`EJR1BR;# ztMCz)O=yIDFErqshg5|XAA`rF=ObBMU|)c!Hc(X&*gmD8`@s33TC+Ot>$m_n9PkEJ zQM?rQ6uXCyKBAD(k^E|W)xgg(&+s2^`wTw_LcVqt3B(|;eotevI^-h#JpTi<_ny7C z*GR5M6RO<{Ay*oD_Q$T!JtZDUiWtxRpcb5qD8Ag*?<@slkD!`+_n{ioUdt|h{U?!Q zhQ>C?zwf2e*g?^+YGhsi*w?!9OW~=PR4KMQ0D46~;ynj@6*%JTUhBffjUig^Zrrdl zaK{mHaN=Z~=Z3)pb10hL8U2E7BmR*+}6B)+zVxU{b)!(cG3O# z@IKeH7s~ef5zBeUec2ze@7nHl+uUR0i@S2i2L^Bj zK$yc-i~{yG%tRkwo9Sao0DxY=yUC4v^B1aIHR)wmWFutH2pS~5uh0gp~2B%!BpNWH$7E`(D6M z_}z&79r{=L%>iY}uP{L+|AWArH)T%5#$297=2ls64x590rgIt8f)_7%Bib5Nj>J7k z)J@ZIhyLTesd0FBPK_ke&NC0Cl7|SA1@e%KfXsvY&}7g+%#!!*Ljz?x-HRq3LWQxI zQH2>&l(H{n9?@mY4qh305s&U!9+}z9G`wzq>~pQM!~pMT#C{z7YHKpkV}vR+jgevr zIi%%{THf{7dvjO>_Fbm9c8OB$)!X;OOlXx=u?42MeTgC++rQw_TP2>zulGq%>;dSB z;5M-KM1Df4KpH!WY+>qVp9<)+Mp!QE)Sytzl0 zhYhC7!?>->^8)3kLNxI7exE)V0M=~;#y=-`f9SB`vq)6#0fSYB!Y{!e+ASfk) zKHkMi-EPUsvShL|%+?km9-d>S_Hx46+A9cQmSt7IdhBJl4mJNO(?m%Cfi1Ldvm}6c zFoTc;>X03DXQ-1Ea%(SdQL_`_68mE>87T}Qe{D~^FfOFu^GwK=4Li?f(-=$qP6~;P z6amcrWOV)PO1U=)zGncFn*qTq!uTSi~U%~w$a>AQNtp8zFxz9!A z1qH9XF8cXTtktjgP*QDXf~v!JD^bpJpWJi1 zzoMEj^Zti=nrh(1d^xVoqQ*goJhp9v&{L^b2-Q8p>bMV)1Q3sA5Rw4m*BOK)Fjx2$ zJOhPZ&FqnrIKaAr0bVY*uY~?bp321tX~NB|P-gK-u(Y8A-T`geM7MR>oZjHIo5x&Gv6?*=k<8hHmglJof;@>}u$$ z$%Pj6*~wB!i~);hzTZLCu+{PB_BEiWVMBcQ$1k*m`5Bw`P*(MBsrd;UT&~pl0_d}r z3h=~ykgc!N&%2i`>)w44-g`lx8?ruNdcd>O?uLjs#z%S8B!$sxt?H}A( z$H7i32N4GZdD%<4s{RngDYYC1_VV}=te+QI^!l* z(b%NW}u%`dv4X(2;xwOH}rVekYU)GRJ zMAx`Wo#g73OA^t!4M}&U(|Ev;{sZ}6B07HE>ZWzch65TK)-@&TS0|z~*DYDSa_J!r zC(L$MH8dWuWccvUTl2h+!qIIedE0kE4RJ>&*$g1 zzBO!BYq&#iB|SDw;W%J2IEe+`Yrz9=8VGJ&fii}W0CHOxDNH6 zf_NI@68xKwbTjh!hev1XO~enHc$Z^5K5x>1&rz<#Prr^=^?;VCi3pSUR9RBUs~Yf@ zU_A&{<4dFs*{uDMiLB%BsgU}evK(afYQVQ2>eW)PU4-lgSjcjuSG3^)3swmdE(OUt zyfn8GALD3HOYpA=pV(-SV)>QUK=dBVAwvUrHz7<4&w6mrC))(Ff$fvARqadt1_~us zg44bVgXe#$Eb`OduJIfXg{_y!S1Cy9OPXa(J5^88hm%F3E#!YZ!^Yg zj-b6>c@+emHHSthd-YD8R_cc}tQGCh8kTwr&adJCkW^89%kghRo7!Du#at=HHZ6jH zBwPwk>{Vx{4%z~8-^jkHnMr4DL$c|F8TD%#(tV?i4UNy-5p~xlpV_>=@tIqqThD#w z4tKQ^U6pKDwz7$NtLj1B-#2J4MK?zq*3_?D?W})hbF_Y0vcawI@0&EmS=Q(@)koJl zs~e)bFj#Uzbj{W)SJy|EJo8vnH0i8wtOwC}XU*FB4UC%z=5Jinm(e=;Vu{3&Y{i06|uOIIF4ucJPfIcsVC>V|Z5S%cfqw6d}Bna7r{ARo7B7kgQ@ za{0<8*W*DJu&Z_Tt9Q=;-)If}|NhYbH~!Gj-TOlg`|1zjboryZ9t4-6%YkXnk~j{pyv=qD#dMiY~2BE{isjII{%r+;+5vo6}u zh()mhi)EW-FmJi^9lqNdvJ0>0*>KI3mAzrZ($(wSmFpX@w701wFXnI*r(kV0Dik zU#|z~nuaF&46vfM8=5@~PYjMGaK%{!d<7}JroO2^JdT}tMAy`xAhQ6Pyv9j3XtlTJ zYG`+X!>)frspEWd0;a#Gx}JwAg9i?-8;PY%1+d3dYAv2H^lVn@ZNwKWLV8wH za%JOkmlUf@d}>(@aC2sqC$?Znd+7#Q4Lk@0<6_2MP{0e!$VH>75;U> zza}7wM-ic2jQB(#aJDMHdxg^`$;ausx~|}=0!uwxa4W(O3;uxcAA<3RHzT)H!m2Q7 z4wrD5geOUOwuBEz7%aT1Agtaje7ew5A0ch2f+B`pB^+Kv{kyhPoB&{EHrv((?q$t_sHu!Dp(60WZ#=2QuHRI-*t zhl`5B%IWZQVOT{vF+89nrAl^U?(JPj|9rOxx>@SmZhz?(Ruw&iJuUTlZ|0WtW9~@_ zrcWQh^yziS)LAMzi0O}pzB1HOY8Yj%mT-uK(=-!b*7g7ek!GuW23hZ1wOgj;7a{hEYtN%(<; z|CI1Q5*Ey2>+D&S?J$IvdIcCu{bd$y;2TMInN1nS&VIf4Ivp-2LHpaB96 zQPTvPBG6DZ!^id=jj1(&-#42hd21wZB)-MX`py<;lsZzND+D?~EtC3g#=Bhj7Q9+3 zc@KNgagz6vK;tn}vkjk^oc+hElZ3Lu|E(DSbc*El0;F)m|7^)SK=LN3a|AjP&}+y$ zSD+Rz?|gwS6lk)#SfHB(nyM}r=n*`y58xMouM+5GKs)d|vNsF#o>0zIw@d9G^U*%O z-Sd>>{phDY2~p}|xi>mXy&!o#0;2-`@K)%{0?h>!0Q8Eqc7;Im)bAy)1?BqTw^`os zoeT|L0w{o!{&$7)77zN152Wf5K(*=^^|e6H3AB}ZN08}M;V*v3B$h{?R7N7(y-8NXC1E>~X>m4L{8zt{_K&KIdM}W?K!~ys0;oFTe5OWSt1dEp(K6K|G$a%Nbg4ko1-ePyEL;|%9Pe!2 zAzU2ca*Mi4ppyVy?z>GrAkZZq^q@eudCx>vm;&_XHq5M~ed^a%nzqCPiF%r+Nd z6%VM#;9wE5Mi6>j;RY0-$pSrr2lRwK6zC}x5-12?GJtg2RVola zFA-4Bt8#&Q3-p4j6lkJAFRChmv@9>Fj(N~;RcC>IKAK!!Rb2&oPN3IRH-W|-z`WO0 zjX+lm^e5F*puY+9rs^$FF&@VS@cp{J0u2}FZPibp69jq(KZwZI-YL+#s#YM~hWFF} zfv$s-8c^@6I)R=Q=mRxapsxh_s~RRy#aL4QO^pz!pFkg~Q34$!&<-_PptA(}Sd9_r zR)IcIV+DFypik8}fm#LnLQN2;-$AV5OEt+^B0%^NI|5b|wdPSh`RlPu83G{l>^lcL834uEK&J*Y?>7&lR3k1@3-Nkp2K+~{$3aGBWO9c8+pzgj)1sXq% zc~Rfx0^N5gp&`EO1$thfVZIv#>U0?MM)__PXo5fo_-+?S_w5+podP+MccAZXf%Lc? z?|Vof-47Fej|im4*d*Vt1^VSI)-c)kxInrMQ+!VfR5yot2m78DXpulueOm?UHkWya z_?{E1dr+Whz83`gR-hTa-wHHp9w}$~UXyaVMTh&|l)TI4GjEpfZOPM8&+&aA&^HU1 zH`n)9fwW}vd>;yQr`YFw-wuKHKZ=wKe4hw(pFl_Y@QNMAigh&ej`Dped3t78==;X3 zQQw41eGyes*a?efSA-FD;;2r(I(2MuFQZPKSZo`^)aAt`W}P~zq&vcMN_ru@z9eD# z)V#8$fKM$c+ko&agb{U3*)@S0^Bi&s>fAxLEkhA(BgrlmT zL^!wlS%hviX*N~Ag!E0-uOfW0nzejf{W{VG9p5XCsN)Y|>ux>dC8QV4d~bL}U4^hl zz1?wRNsW5H;{_#rrX}_`>^{u2sorjmrZE5cKd{K=W+4)p_m+g?wn~)po{6<+sJv@8B=o)odm(GzI zbwd{$;jg+3ir~#hY1dg@i_3j#OIJ$%WLI)1-LJU3Ms=6a-j5m^x*zfL5c*U}w=+Or z+wFNsa#**YA-$^G1%hE;{HfbrO1{SHCs^dz71 zUOOr%+X)9&!B6{dMU@)cs{uVYrp_+^w)d>cxh+$A|F>dp%V7vJm}R{e1HZ82V!W_*dGFg$ z%i8%{$I(uz$Fr9H2%nla6X6f@k_bm0aUsGljyQWlM4fabDgQij*hHUtzBlE+y!X46 zHR}03{X6*7pZm}rYWhA@T%)c;=utBgTMs#RQbesh>M?|$PWTAn5A$xB zOg$f7m0y;+U3_pv`4(P^aP-254?e8r7ya0e*Z149A1#p5-rDcR{qm*tsn`4c1DMYw z%%v&YH^3Lg+4h)(Q{uFN6%w8)(}_1)Xn2Sfk!Z z(4JYZmLb3P8gCR_R{JVs`*-an-Fzz4pVrl>KkK@;|AWB1+W$RZC`paVwaBO57{FS- zl(2AMb$1I^hu&9558QyXGxR{5vgq`&1K*5V>ezv?8ip6tK%XOjE$LVf_A=8O2R@H; zlxg-OJu+eIz(3;5prEdoVX5B?dq5QEnI%9b&1o2gMQU zUfVoqab+g`{lS+5f3MV%Pste`Cwzlg*K>6kt)9)O!S~^W=@ZAJ+t@n&0?<^HJ#WI`n1Wwd9{2O8(lm?Gd!7 zej{n^_e?iNQdgr8zTfepk(8YBx0ReUw_&ZJmKeU>k=F8dN80=u1KBT=2eT~=1F3<> zL=T*cYSdeEwQbN6bh_KTTzU!8IM>7os!^}cCuQq=V$PK@#Z`b3zBG|~`&~ACbI9RU zx-D46j%KODj%Fz>+db2xK~1mZ@43Kv;rnsAlYuS^KPuz4vheTtzOnp0 z7q}t(HvEzd^l12lJm|de4xCeF@-7R1sedRDi06u54}Z_EsL0=Q#UF+ZUr5c268x}$ zdH8i{4`N<{x=Nt;eRkpfDy+Wspy`E=;;e9X4T>q|J%`t2ul1nmg}=k^uze!Xb3V#a zqKqD-{Ln{PO4UGtnAZay)}KA-vhV!TyeU<735BjEXv9E&~*h_OUiqgI+b$u2($5*Y6=&ke0imvf>R7HI<&|SVx zYMBT1EPCG8S$*q4@uJ`Qx~kLqYRZ9tx~Y2v`p`GA=q+DVJucAuzC}fU1N4NyRm#!(f3N^Pmn<5DfqrRtud&%v{Y z2fbGGjjxBQ^`Os?*GrA?Agj35*GJWRP(^Xb=&M$HQ1{|8qo2CKgT@qB3=HN=B{Q@p_#tVVm#e~McGUG71?lAjyH)ry!dS6p(7 zF-koo(50$x$rA>)=5d|Zx8wz5teTRA-ZaLkvpnd~k}r)3>LCwW1Za}#n$YDImHc2# zQCA71`)I0qK|`vsq{^JCK5COUp;niBrep~6-p)b?o72^Z{>-~jy;$OyGu6NW8u~-Y zndU5Yvp^TCk4vsL=csqG&>iLx>T8eEDt*FSpng42m+K4YXmwN_p^Me*(m$Gu)#yPP z=v}j3O&P4A`qIzMCF)BLN|*j%E>&HJ=)81k$iGZY@u0IxyZRf{C0VGCe}x*st1*!J zg3^)xRq8bly18_UzfpZQOy|8+dKjQ0oDfl#_e+c>@fdj>RK-^T6RF-a`l>*H?V9<;1_BwPKa1;c-awwtJGG3E>=^^jtN|& z{^)6b;{n6^T&s3yN*Sq}RTSq%N^yjr7}%^X)=+3g*=d36)Rh9A5jw8yY(UoubgGwk zn+Kg#b~*Cy*OcILW8ixAxQ5g%Wp@T{R4;gtKl~t|9UgQK@@`V2VcMJ{? zU#m@7Xp8lDw)XeH<;g6xBl2P%^mXKwJm`nWt9g*W{B`T8Y&n1VU#+LJP^A1{)-zeC zOSuYeRj+0x>m7VneI(F_K7aX$;PdKVS!inT1!YcR(GPu*@}6wgH9+vH~5NrDhq86Zd1SWpqBFcgTGhrWTEGS zuc=S7&|AUR)ps8BNcoq+H&k#kCA(C;QEr6ZR9&-B=g>Q9iU)mwy!X^mS*Ua9FX~zk z+EG3_^r8AX3(X7dP_w6Ko;%8$LZ7JHJ?QK5OG2M1b+FF+y8OP-=W1~ldM$+Kb{^DP z{%zi#U$q2O!vyay#Jz72h&-poQB3cgi;_nC zw%F92H&|Gs$(f(jECuqp@?R`$oXMRB=5^J2v8g8?ZDEb3UVMpW!y#WE{;-9OGkNkh z3u`pNhvAW3?OSZ}&+{$p8&eQpVqt%nLiu^kwmG^wMsNfCbsl?Zn_~<- zNk&-MP{&war`a^ODUO5qS7ZRxIOKd!_R7V#O+PT;oLAaMaMkuY+=7S z-pt!A%*AO8KR>3+Gtw!a``n^fo7+gI2|U`uZg;wscUssQr^!4IzLUkCXmfkQX&Qe@ zGkA)1n$FGn$_7udP9?lpvoGB`oo4YC&3=KJ-OhdC`&x{`-JftO;~O<|bHC_V&QEF< z3T!_AMYF-~j^;{!JA8YKGkd0cka+>m(#&JTgh6-kO~h8S+3o|(ck9p~llL(Pk|?KrP@pJ2Yr!uGh&G%q8DpKSKKFEB5+uxH&**<0Bw?#rz<_*_+M zuI}=*+vZqruCcJU+#fWr;Ek$g#(0kt=33rFtj3t(aT?emZ5!$FzIhdYQQM|^v;#Y? zZPgx^&8zua+P1;tTVU^N+x;FtoA2hIX!eB1HDF&5yJW&z-^0Jv3~PN4|5bawU5V8g|KrgYSYK^3^qgeBmIr9tO+BXpi_kXw#8=1j zG{aAPb$lVQOD62kb^Ix1gLCBHZ5=-_5li37!g~(sb{~J;!bW%7%ifyuI5tUZvS6u_ zxQAwqJ(mOX*6g{SYrE~{!Nh8eCwguL7OiaTBZ#?&e=!xK;OEU+^B&$g4HM z*0bTG&&5B)Lo~Y^*uS{B2ur|c2LEpRxi2y7!LaU+^8#Y63`>8K=M|&pR<^U(i0)5w z+z1=5qlbEp>wbuvOO);LUemfi&!aUv+G}Qa*tUiK9k)BvtGs(N&nMd@j_hSVgP3|^ zd4XuCh5g+9IPWo&JlT3j zbC1_}fM(kqy?VUP&k|E(=?(siVsswf;1g$IK6M^W@D9ze=ilTHQ(bCU!k9GwQ@oPO zt6>wyB>TP1eM&K(dfq+5Jr!f`+~SaUhG!DHkMZ8IJ^sx{Sy)1kHeNt%D|6_b(&If| zYhlBByw4vdR?qxWI~2`-C!e8?M!ZDrGX zukG;>@362vJwE36{#rbn(|SMA;}d=}vDIvK?-M=Rd9j6^?s0*)D@OC+XZ*hwcA>{- z+_?;+sI%F@n~1G89`F52kI#9BW^KT};JxRdC(fcl*e4&K}gXemkkM+6Czvg=_wiM^DdAqjZIQxdfdVTn}mAUsB=KLMc zAy&@<`%H5Fp5H}mHJj9Dqw^1Zt!AZtwmbjGcWAbx&jZds@kY(I_Sx_JGxsgWm^H?I zeVUwq;qk;)8(;486tGmy-tTh=SdQ{!U-x+#*dk@47X8lau44~a*ahd``Ed(NalXop z^Hdv#_5H&68ZRe?{dwB_U%uADmYe_Jjhc<``yDJ;3z(1jjx&5p=OU5VYF60yCuc53 zYc{X%erF-(D`s5L_YHd~E>h|BtTBI54=I+BZ7bWfzJYvUzov}BI zRhr@Fj&5QTv8~3leOI}36FV(zk4tyaq8RJwd&s4S=&Z!LY-Qi}eappFbW|z!d*4eg zu#*S!qHOFtuL{=~k*sX&XRqb1aiUn+ zpncoz28uf^Y@h2Ov0gFbO0QbG!D1`18sko{?Z6%&wvx_!qIj6tR-?PmVb?_Qxn`k0 zF9Z8VvpAnuf&HXen$JnsBw=1eXT_LL%wMx&VhNg65xZHlwZw`w`xmjrnl%&KsM$GU z|I+LVv1ZNee6jR@Yu1a{7n;Qq`>$r%#M~FFdQK!3uG#Ix(llE}Y`kXciIovsZ9M09 z5z4Dl4EpRVU@M8?cLML(CyPB6)?q(HJWuQb|J3h$*A(%ZW^?@wZmHru&G0*cG|LtD zhyQ+OEAtBQa!a?^1_gxKu#o|AZW-cZilWAKruf{##=B*S=(}hvu{#5{+vSL6&F%)4 zD_n@xuq)%9PZ=)uXy!Qn`IHd?U%G|Y*p`5Dw>*(%VQbt*i&D*=23x+Uwy-sB6GfY5 z{|?yaHd!1XR?lu3e>r8EcuBMQ<9|pg5O*%6ni;>g!<-aX?s zU2M0o<8H;Gg;+h~fgib*h{rYCIKCovhHzSjG1WIwGew|tMTG>?T&v+5@BAXNxw?t^%7Y zep!J9!uNGOlilZwSj|>UxSU!c(lpyP!7i;*Owg=pf^S-tDA(+Z2@}#5h^3kZPOMJ5 zL+sM5V4_{xo#JWD_Dp;vZJ{`!*#{Hb(-w)dn%#7(DSfdhsHM8lcd>Vgdx_N=D}qYg z?-HAc)fkrql>^&F498Nr`x0@Q*l~^{a;d0ZjZuzs9FfaJ;@!wDaU7A$#4OElL@pPv z6T^Iq-K$0PJ?Ocb4GLJ}UL$sEwmN8!`wH{|L#T}aMp0pzK9#KT4L(fmD&RQeuyHGAf^fb8|+4`SF8FS&0J9&4x##zR4;?CXUWu^Qt`LCekc zB3Rohf=;+^5|P@rB&ZD-=EBd~p9VEK!|sWS!RP7k-K}h!;~(yuyKLRA2043du`sXT z_sv!|Fu2`@jST+Tyw&1a9DEH}Je7Xjgyn4$iNr3MFv>QOp&3TmCPrw6z*K2gMZaiMB)HPGXl#cvhYji#5Zu@~l`w zOpS@>y4pu$@Hw$u+2|ZSFV<;K921AdX3fTjHaQ;_+lZ;LbXe@v49C)8v74BhOUe-=FbzNl-O$HxUlg( zPl)-%)R{gZs+5h|a6;588`b(vVZINes9K*C3B<70xAikuW{hF9E0 zF-P0*in}Q8AXW?C{EOc(-O^2gwuL&;hm{+t7H)gr1khO~h)9 z$HO{-`Dz>H`$~jr+uLCKO2iRUE$S4H62q9CUSErMEbM^SH{u$x+?%kvh`PA@L)c6LQM z;3Z@fF_q6C(-fn8_A=Ar`MVdqsfw7Yi-W`%UEggRHN)?=g}0-H)w?@+ceAiP?tQ#n z zZ?w%ne6njF`IEK{4FAr#kNiX1a=_MCI_#pJFir$pU+JvbEQskTduetD#PpPYn$?Cs zwx!_{b58nJOcioPFeN+ViV`TyGy) zq!{&!kF2(^<8D6k4r2B2-C_1{U+PbMV!1ow4SPQe+d%9jd0sLpTN|+&;{y@Xy#3@y z+J>I~@}jow2b;hAh8T{lV($RiYj@WOx!pTR<`7foJygDJu}$+1lfT-qaOuCNE8imT zezL!XP4n(A$6MGU??_o_Vc$7N%Z>Hh#mQM20+nMF*^ZYgq@W;na0$Wh9ZX15eM zQQL5KOO*xMhO=9$EG4F9w=}t*820C7o*~~Rrb^GSoUtDLJ-TIfF+2bMXY4cOd6mzI zwk+8}tj3tuzb~+_iK(ZAZ26n=gc9!d&X&#%*dq0GF-&@ChEEs6WIx5|nJ-7)q8Z+q zbLBGaiO&n%peE)Hb}{ZU%9@DwcGUh=nL7l$|at<+dznv%-5K~vqM7iI>-u0d&U$C%`y{F1IE$nvhLU~>> zqi@t3_QkS8v+$^C-o^53&EmjTB7f8@18gPoznYDXy68Pa+V4|spB42DFlS<_o-<_& zu^Lt#RqQ=W&S*r>dbTd=7w_9;m1bL_n9pq4q1oOjlTVp6JcOP#?CB_HpE)v%SUo!e zwz+b%ww(l9xt!vQo@$iOlO>9=#`vr70){^Rwl;soSnq@ypLuerjcvZ%tZkDLe(;$u zU)OAI!tXv6a+PK)5{|o7ND*j_St-qmvELFd`c}&MHnu9cMBDlfPWG#k7j0~JNarAm z!qNvn;CF}omTdJbfAEujcgh{gM%V2^*{VIC9-QXCP&N{)XRm_iVmUI{T9>=zIK`NI zVjBDo>%5I^iR{p}!C+e=XN6evEtT^WW49*$$A75|47b{r$q2>Rqe+(omdPI?Y;9K+ zV{4M13tT4e?{8~+STXi!@+!#J5@~CDT`~4y^1VUJX*sow)A}@-3rIO0yiy*IwdSjp zrxjx(Q+kHf%Jw*`ZI%2&F}5LPW6&zOdZ5*|T5eQ~{Tpnn<&T4`w!7su#n_hA(V=(C z#CWUi9+{ySJDj>S^d7mw#x9pEXCOU5VKA` zYGYd`pVqb($hS^zPqgM+FB=qNpQddLS}#{6S#2BSI>nf4`g4IBAlTRsT^v$fb+ajOWY;xwg@GY`M=fl5AZIOZL4F0K@TV$DL7;~$9nwW~YRlcs6 z(KD;oZo53K*~F}K;oId|oeyJfm&qB{nA>HoW*BpaJV8ud9XsST#n{VP3;XSm?V6p+ z`jqXIv$HXZ^4ujW6=NfZ{t~%M_8e-p?Uvq(!3wf7_Pgah!>qPFa-(AG)1l8q?UCng zY!Ao|ZL=TtZPWuYI>(ytL7AW!3mzuCACy~cY!Asj+BS69s_2L07dE#2@>^}2J?w+% z{W3Y%8uL+^r5LLpmKgJ>TsX>Vdt6p4#@-nAmFwfO*~a#SY}K|8!S;lV7;Vk>q+F;N z^UC?k^+`FJSUro%sfm3`#@TotkjdIJJ!eKZx56J=Ab1y_WB=c^uMtM$dSB!lRQJ$0Yh}E<1xizuR%X}Np!*a6r4A0#adsqgH zwMIE2`zgk1bH8#uA~)FBn&mcadlqcX@&_B+i}H7EJDd9-{}*L$zBT4ca*SfkdH7eZ zFUbdOY%j}4wJjNJFUzYowiam^M^V^xu(imAiqT!|sI1nudaxap@7ma2ksoQ>yI^}o z#*Meu<(N!Xj9nT&X3#M?c!Jf|D$^CCdw;8}zRp&!ZPP}avTv1>Z?(-=tQd36bB%A6 z1(VQrfsf6b691}vQZxJo!mILm&88@KXYxW4Sr!;FNc0#jHh?%EhOm&4Hm+sfG zG{xAJQD@?h%MF^DM&BFsntW6<@6pX}ugfUS28=!qYE#aP6cX16zF_zYWH ztYU21h-AMvomidAIdh(Fy?vLr-s2lJS+2D&dX@UDCWm9L9+!A^JAGtOvU_I zHfn}3KbD=EVa!kDqqSWzFY{02(~7bDTc6GNL`JRZvdwd8m)VLLzrMBB?o&BZGuKJy z!atQ0iK+5FmCc%Ad7nzdYK(H6VR@g)oV&YXUgn?4(TcIwNzZ0{CdEBgTZeR1jG1qH zHlsrhxYugCD3cXqXK!oEz9=7{zgwv5_LAJM82kRVn}%MJE$giLK9{d62H&{+68X72 zx87>|LS9jf9iM#XurFlH2C}gaCO5l%DKBW-Hy(!? zE1YsJyia%byfu^QYwHd@bGURbAFhnUM1h ze6zq=ezX;*kgTx8Mz4HI1JG09-{tx{eVZTVRWWyjp{($BD&3 znt)$Zc10HOE5$#{n`|_@EOJ*(R0L}-*fWfL6h20>!e>c-G1}Q#z%PiMohADS&;Y+9 z#uEPvhM*v~gcz_alG zh28`D{GXQF)$@P$SNiMYa6Q_CA%52wQ=?9u*)CbYSyr;!kgl_!#$MO8sr;>@g0oFF z{jc;}ESfIsbIurTFX`2Fr>@qyS*RbEZN*2yN3iF~({@f!{tA^|`S`h_|1_FCY~|w= zLFpBqAPrvcxW5PH>JP|u-oN%yo?ZU$Lj=h_q&Opby_v(@|)AKMoF-;u9bYAD$M8?tTx{Qp7z=WWEXA?RKvnK`y=%yenuuG8Qd zOpV2>ubjr@|1){jC{-nPjh`GSSF({*x*BQ!S2UajBwDWsPbZY|ekx!G2CF>jPqKua z7OuBS*rnlrX%^a8QNBLH-)Yv^FSz76lCq1*0j^N(%)L*d&&&bHd% zKdoC=t!|8uHNiPYK=1&Q30`Q;r`}ew^^9;fk$S$6P|ZB}4A%7&YFjtk`=fe>oJqNM z_Wob3Q*A6K&nm+2z+b>lP?*cu=dbgs*-X_FpHzi@0#{G1BPdrjMcW7{*bYFceK3Ak zWEBBN0`885xQFD2Y&5C|w)I7;EvlLyAWy`uI;baVbqzjGR)zn8kqvo?SBu)(|FizD)3cdv>1u3X%?0cnh3&OP<*A+t|N4nhuxvUDYJ94z$yTFA z><{qGB4@T(k%=0GwtDrvs!-K!G@aiYdwUA$ebgAE*;1V^D|S7#+P2qf?V88bnN|9e zw_&Z+bvo~cab-J?sk+(X9pEq62Fj)G<`3IMu+95-GDZ{ZRm!z11ZC_!sWrB_l&6~I z{z)Bd^QtFUrBQipt+vrVpqd<@&+lsF*m|NY*q7iV*){TCqzV{ zt?190%BB3z(QKx2sWYf*g--&4EvGnES+WhJ!86X8I`2yJPsWDwvHhOyXDX$EqN#Fk zjAQG6V~;%vc?CUdbv-4jIaYo0Rd+`9nO8-Ak^GNQiB?%MoR z=f?P}qOh0#H>#^%J;!dR`Pn)TU;lJB6Rzv)pZb(WUDwuJoT=|j{y7HIsMwo|@&5_h zMppN-9`Kjnu2G72E5X*&olEr(-lqh+m%d|B8g)nekTmM~&02rKz8-3ADau_}AC3e8 z`?gs%nCt(H|NFx*@;5f9o_JMcRX1h5QLpmesJD%#T5)43H~J{g86&Yi>g?x?M%g+B zY|nm|to*HgrN+bcX#1H+dE%3U(BDg|HY$z!6ltqb&kstY@~Rn3-HDXm_SvA5o&;2% zsQRn>nxOla?Y&Ip-Anqt@X7%rTy6G{@Cfh0fPLkh;e80saCC!rR={3vtT*$9ghzj{ z1VajkG!arH>&s#x1w#slG!arH^JCR4h;0OIHSE8?5iElsb%U+Kg5Vtq8`(g3Z$&(N zoh3jT3~30&9|C!Yutb(Z|NQ|oAbCTY2q}?eL0xj#Rd|;`D9?j5l0`!b31RJd!f_5HZzsVz@ zJHq}8$B}Rhg8s{fzjS6X+%c$%a1F=xnDvA^0GFHh5bp)Ip)nyH{BZ@| z71CU#U*H>{z2)vPx}~_!h9~U+=t(;pn!)-N)Dw3BbmzDigeS-STmxZEc&UpgSTA!= zj%)QIKu$Bq0iNid3_jt0S>Q9vFPVIjIj-5uv-mvSJxtUOKIxYao*VrpQ?z`J`@-gP zT(eh9p81qFpW~XoGE3f{yH{a+|0NW^isKHlRUFsvRgr%c$CZ7x7XJ^s*KyomwvMcI z99Q#gChJv(yAG^@Gkclm!s|>f^W7YGGu=&|jT&*Eg54a~`89Ix@=K2<@;OL#ZX%y1 zjw}5RQcO>VyD(mbQ3^jG2mBDuFYdSPNxLO_(mvdMu9sGH&NauE#oT7gXGyv*h)1&N#(Xd zeeMWu6Sy038`OWH-FdQhkhPQIbdtW4JUhv=Q{d{%D+15&73#?=0?+al^1nhgxeETz z1RErt7qi5XW|pWiOI)Gp4w^KxSqvQVeXu9!yN5(jv_SHYplGOB9uPr!Bb1NC6`XOD zH&9~UWb$7mDpIaVM57@~;@-(wIwtmN9!1C_eIDuaB(C-hW51_dhPw_+U1OIo@w`96 zTv8iD2J-=_O@Ozg9wdAja6;hJnlW?*l~Jv#pp*rn zOCVaUT`iScOPX4VYeDPC=L(JI%_Q#z>$0Fm@@&*HuJ>$`xT7B2oa=- zAZrBqM^JGkCNu7Se9`u9MRCvM7x%h8MbG5_A4`7a|!NOMRFC%Writ@iWnZrb1 z*P{`;$!E6#SEz;wHuQ&xM$$AIaD8bZj8&s(G~mk9-3DCKT4%u3vP~4>AYn6ME8$7P zHUrML=i%&Zw~M2@!x?Dfp2)#8hC2490hi_EKXBYvo!+tV77bV-_?%-JzCz;|T+u@qjJc^KShyIfZi|z3G zDkJ|Y@~qM_u2Wq?{xBs?#P zvlTou2DIAae(kOHxJLFQMQbC^Hu7mBpEi43PkWwfd!DT4?Qz9xhdu7^-eHgXyLZ^* z`q)mgc9Oo+9@o!av0n%~zF)D&9pA5#^(twuY7MTAH8|k2lfeOZf;T(Rc_EEiYjBmU zJ83-0>ZxU1AsYyqG;@Rl?i}C9@yRxhe3A*{NT20E*Ny|On$2^--R1Miny+PCF+14- z>p9s0>sd_JV$u|A4X&ImbHLr)tH@fVWn4A;D_m2{%}X3`fBIUo)@m8o&DJ^Kj`f>K zzgf$;W_CAd(#(y7VIph9oyaQ4{2vSGF64mLY!va3lh8MQOM zx7ar7HFGogG{$$3Plp3O-L+C*HNvxBV|*v+J4x?C_nq?$_jSV0CYR&GAi}rtSE!V$ z4FIBR=iKaol+=%ZPjMmyu@{d1e`lAWk#G zU3l`0_$GloBks+g2i9rcc~rMNBd({-Gvdzuc{E4G!Efu#J>uXu`d&TqjkqsLO)!?@2_b7Bm~9T~^S1dz|Ltg*ckdyBlWr|bvw;;}x7 z_?#1(IN6A2wwQXd%!p&V3fdUzvV`I<(K4>3tp!b*xehch_-`ibW-a4t+TBKcdq5-U z8?}rpX$xgc;2Viel=qUxEf_s)NQ$Bj&l3%J0S=8+4HJ&X;!iza)l< zsQmvD_DpIv;@fZ1MM8eRq#Bu*AD@&i2IchwJ-!>K)kq_m_INu95rUmtp+$}H&D5?| zih0tAZ_YVs#5d~bjwpi(XA(2X?tp1# zcN0BdnZC&1ZWqI=JuNo4(GULoq8sk5{O{lr^FnG(Y99PWFU2 zLtFw)_=cYd6J8gACVbCNpb7Upi_;o>=TD#s_u(AOf6t!;=iOu6vE(rBIqvP`Fwt+^ z4-tVTd?QdY)Mp-e;%Esp;eKZ(S}7YyrDU1#T@ZOxe?NXDyC@lZ#?L#C^mr}9coP%H z%^8w!!m%{jgjZ#r3D-jxoA3=1Wt6u}%eWSLFFfc_W&zM0_;Rn73;p@nvjP>BZs;fWn)u+=GJVCS&=QmRb&#-S<`-e>dR-n88g zpT=SSG~qjlmYDDzM1iKWefPL5G2uHXmYDEOM1dyU;cbZt_dcqHy5V`R>-&1j5)zZa8i`K*rsY>P)zU(qQz@7@pfl zq<4_D!-VUsJ4nBm#osz2-H)f;Iz7FUO20yQmC)dbZ8Q_Q6M7N`5*j$Z8OgwL51=waM)+#@K$5!YeIX-|B6l7ZuXJ;|iWa>RFiWI5uyKJq{_&n3?h*JkHA;+kxD z-yFPW$-r?(9|Om?Eg3lO=aa9a;hUEX9QX8@Od9-t=`?8YT}%d!yZaPtPkb+vf#VK8 zW!m$|q|ht_?M77P_;vn*tR;^4rjaFJz08+5;#zJ4$M-lHIPL^gtK;BaMs;J8Q7Zpzi@h}U})$S*-J;ai~$9QO?BdD)9&>eAh}K-Eq#y@Sf{);=unhk0YNrvc^%aFmZ0moFT~+ zKTI?xya=ASLOhE!aZb2CJdfmjCv4qhl8Xt;2&+Ip%dfX6n%ZM{m?)om(r<|q&KtE( zIB$F>?wlGp{0v;hZ+V|#%cm|*x&UXY&FdV^02gQmsB=8 zFxPVPW~Wc4HaTy0+6iZ^hOdiSGQ5VL?Rz(1oq0WA=hXWEe*tVH&qnQuci|dtn1)to z!YkQFL3T++>^tq~a94JQjdvI9T^8!&%Fcn@oqfS>cXnmhKz3zz9I+c=4B-$!BfK*g zbM4{bK1SBSZv)N4q?FH;L?paJ`ZkaUz^}z3*;;lVXvVUkfJrPGFq3cuVG&yh zn%h_f;B2-G@GiC*a3$N7Qp4VXoJ|oQJ7UD~ zYQmL-`v_YIj}f*Len!Y#Fs3B*B@7@;C(I-)BrGDVAzVqgmvA59QNnh@&j^_-MJ5a& zOmoGvmQHdeVF76hNiHI+cExM9hUArm4W!veatq1FNNy+jGm@nnmgPqnK$uRLNmxi& zL|8+(l5j8KKEk7f#|S?o(j zNKPX;ljH)Di%6~}c_qmWB<~}+h2&!-x0C!C$*ecU?@jSZ4j?&=9|n&g!v zH;}xKa zgv^ut3DXD*2&)Mj2wMo-37Hr96Q*fg=^Q(-faC@*EVt0R((!V54dGtGql6a-xer>? ze9*Iiu$r)eu!XRlkoi*E3DXD*2&)Mj2wMo-37H@H6SnxH+)l^>NKe>K$O1`2m_}GY zSR2?6dar}9B?x_5gHY2>a$qpZX(6aDAZ#FP3Bf*TCuE`2KZFH@4TLR(?Sw20eQLt6 zANCR+CA>h$!%=St$FlrLE+i}_O%2JdBp3HXpPGIYhp?42?ft2Sk%-j_qgFb18&VyG zlPz1uj6v{<%HDLo`E9qNO z(X*Y9rBN=zG{OSHYQhG>7Q%KymX7{ugaw4vgbjr48E9phh%MQO?SyP7%D#jxIix3S z$R$t0c0x9sJPFeXt4E-wfv`o%BPkbQJ0ZK7dky)EA6KtR`$AY$5a=i~2Oe z0>Wy-2ErD?c0!hqp1y=>gaw4vgbjo(N;3{U+X>lt%0-w)*fNoL z_iyvJ3rGvNC18EP!vQA)ehT<+fH}}VFfVXU;Of8~f#(9h3rr3g6Lee93qijJMFj5; zZV5Jo^bg4jnG!NRWO>N$5Vz3s(5BEgL*EbmI@Bj@WZ2fQ7sF15*@Xv%PY<6PzB;@y z{PFPS@b3Kv^~>ouzF%3t`H^cQFGTi_S`@WD>fxw!QNht=(Jx1P#@rS2Ow5}x=VLC% zM8_7ymc_muJ7~bx0Ur;zGQd49E3P=MF79~Tr8xV6!2`1g-8JaNK^F)8JSZtXH~#+k zmiSlWLlcS;N)z@bypYhI@JoW*V4uNb2H!RK@xd1ce>M2pVAsUt#HopE5+6!@Iq}=X zkx7k7Cz9Sta!wwZyePRddBc#mhFl%eHzhQsf69QA)Rc88<5TZTZAg7O_4U+`Qy0!SOOUsGRwI3cfJbrlL@bcjg3~wBM zVECKE-x(fGXP~+F&9Dv>-U<&Z8O*<@A*9&^}KR?eoedEhZ0 zJQlJNwwTReOTfAeEHz+R0hTqa0#+ne!aj6c*k;(h9^P%nw!;d(ov>mL-d4%(XRopb z*!kc=Sf|*?-e&)T@%MtA35KFVgX4NT#+EzY2dLx?E~WO2?Xkg++@CZv7GORM7}o1@ zH^!oSeG53G*ROy%z5W1H*8E;}-5HzOs~cc>FN~u~Q4yB)!U$`7xqO_a4Cg z-dN&VZ|s5ByibGXVc+)vpYlBq*g|-c@GRk1gu)N4?u7jbvk1o!77*S+xQcKy;e&)v z6TU?FoBvI2jD-h&2Y6FZraNO1gii(?1o@*NZ10mnUx0j9FxGQrFs`6&2*#d27>s?c z^h%?wN?&fj5ImQJ;F+om!S>#$QF(3Ss0eq4Vp%Gt^2rFpKJR7B?aA1Nu$6#HKZMSv z!W-jn>iY@&Qs`J1qOGhv75<%Gjg$ZO!ya&o!20(g430oebOer&;So4OI;dyD1M|HZ z+ZKVNWf!5Xd}G~W`s4UiXxk4r_P}%G`FUhB#8>A_)$PYftcfWK>$XO|0#;X&Rc}N` zV@(DTrbYYsFjz5-W2{HU$KecqgN5??OqAzlp?q%^%HQ0)IUZgjISOOu-GVh#@(<(D zrz9GEl>BY1Ro+B;9}o1I7J&Nl0VvO&@^QE`8^s08YBvLNSQ{;2#xoH*!JNlo_Ok=c zY~}!11{Tid!rUid?m=7)Gb3kr0}6Hzypfy3T!Xj~W=r_p72y?FV=dT^%meg45&jM< zuHkpFfE>Ob?hW!)!vDg`YWUR)A?IG8XM}?LfL;>XaX-)-2<>?Q=p6`6JP7ngK+c?a z2*{3vW*!C_58e+n?u0#gf6&}S*qcXzz87I6j{$uYpkRae0KjQ{AYcKH2Q1`+0q620 zz)C&@JgWc&tgcQ4tl{aPS;;d&UO`yPvq7^85PFFZ1Nm-1!RlcpEBvZ}j{w{XtGfl; z#zz6}g!OiU?c!qr?}ydioIL<2SOcu`hTlm53icqZ^5$$G;Y0j3&@>W03ah<2dkj#p z$N4nCCt%GtXHNnO_7pDyJOC@e1$&y$1bl{<0v?3*-}vqN9KdH`&9`9B@%ezy^Gd+O zd;#DK{7%3ld=X$XzYFk1z7+5!z8vsnUIW;|R{|d8s{qgOyP@0<00sMuuK~FOP_T=9 zEy$Mu1-ru6f&3#NoFlOTWG6tl&kA^Z3F`(ZSa)$Bpo`c7=qk2>-VG4Wpx6Pj2cTd* z;oD`wZW4Py1MhPJxwm)#&`azEjW?ixZ}Rs628)LPL&Sc-{^Aj^Mv2EjjwFm0kAo%# zP_S6>Bw(UA0GcE~!IH%@fT`jTV48Ri^cmtX$mxVx;t0su;ziI86EA~2lrUc$1$mq} z1~^^33Rogu11uA70L~F_g8y8?dEyjk$_XpP+aOnpGk^=kJK%E%;X?5)XznCjD&7aV zMw|m&DLw?BT0p^8iH|^D4Jg=J@d@AtaRG3L_zd(r0bz8Biy-d?gul6n&q2PQut9tY zngJr=*9hMb9Oj$X2~P9}~6<572xYDU9ilJbMd1bd&xH@j zmk7TWejtA@0zm%*AdFHG1oDr7g8d{yK>is}uv{4iI9&Dv93}e$j+Rk?uwOCYcsT%Y zmmCOqzl;ZbMh*siRweAs#g~4~5(zW30iGx&{F;Sv33F!#59Q%-rX)OZ-Ye|@>!btV zdWpa4c-C&G-60n3FxGI0#lnX2hgh6LZ}@e`Act|FNpP3|m**WsTj;ygceU?c-xqwp^ZnJ=(XW@^D8C7Q z^Zm~Ib@+Yn*WG`D|1|$9|84#c_#g9s)Bi{RYySNLN&?CP76$AMcrKtd;6DL&fj0$a z1m*@#2%H|cDe%F-mcUbimjb&5c?5X|#RTOBZ4J6V=#ijTgDwS`gWZEYgENAs1|==hTIo&ImABnw$OV*H->HteIWF7 z=trR!LwkhX6c!d16E-7kUfANWrm%xytzjKu--P`h<`SL~o)bPUd|LP&;mg7|hVKdg zA>65-d%wtjdHtsMdm`d+#77Z-M0oa3?!TgcXaD|@OCxI|w?@7hc{cL%$p1z z{vn#jIK>Q$851)-rYz>}m@P5KVt$R0vE5>CiuH+2jvX31I`&ZP%dxM;ei(Z()-<5! zfQSJr2Gk9Ba6r?5wgHz1usFxK=(xnV(Q%XF=EW_JtBq@jdo=D~+>y9{$DNP+KJIFq z>p;(e{RSlsDjGCY;vHtEr% zb4gz(@#N6tq~wg`b;;Y3_a;A)EQd@OGHuB6A$JdXX~^**jVVv0yqxku%GDJ6)Sju4 zsVh?-PJJo0Ej2bhDgBo8S?TN2ccq_6|0UfwV|>QajJGo0%lIVYw~T$6k7qV#8nbT7 znw_;JYfsjfSwCc5%gW0hpS?8u#q3YA|H$?qI&|pOp*@Br4VyCT^;z4mVWeFL3SQYV7(4k5h03TK{o& zp9$IZx@TdJnLq1xlOO8wQ-91f#+*Te@^p}m@XTd`58p?*7{ZabldyI`i;4QUUg z`yo95sR7bn<^`WJz1TiTjerlq@n3-Z;rKA%BXE2a(qoXCAUzK02}n;udJ573NKZ3A z_6($hkPbn57SeN&o`=uehatTH=?J7|NH4;C^b(|(A+^Bo@{Y0?_6nq9FhjitefI{W z6Oi77PvIvaoq~DmEl8&!;jb9&Sv{R2_?tZ)q1AMBWmoCgi^ZPX4qL173afd$cg7bj!cWJ&y^F5mH)p7Q* zc|E`lMw~j2kLly%`glm&59{L*c8UC7gd@g(QR`pU`lDKZRO^rFa*t{LDjYH2t9qQg zsmnQ~k8kVa8GZah*YmPIcIx9d`uMFrey@*L^zkQs{6!ys)yLoTk#W^tp^pZAwCAed z>@|1fYJ8cw>Zk5n@2L*Wq^oAq0+gtnjYQ4YK`)hq59MLZj>H!B9 z1o4muaW(!!G!FreGj9lg*9HATb-lv*fpqi_=P#$DK7zlHfjokLl7T#uKbwg>l7E+`gJq}Jc8^*3w%D6Jo@^`o_Z zjMm?x^|xsKSgp_3`h2Y)r};R|$7?=b^9hPxZ`1rX%_nO< zS@S8HPtkm;=2JDFruj6@3p6j#yioH(&8Gv${w>n_BCRjcyhQVvn$Og{RP$2JXA|$m zW@|o2+vjLruI=TT&jXI-&ewkPwZ1~@E46>6)>mo$0`0#*>+jI|JGK9vTE9^17is@R zTEAHH#hTxx^WCNS5}j|U)-ToiWm>;n>z8YN4RLtyiRLS`-%9PbQtNBAewEg*()!iJ zVb^8N@7DIaHNS_S8jsigJup9Df34B}Yqb4dZNHayr~T5`>ilc9y-wTf_-L}P)An`R zz8*Nn-Jtaww0UUZ()sSw`R>#D&Dw7>SNF#)+P+2Gw`smj z^Bur3{w{soqmTD<&nZ~`{XBdM+8@yR20dTy)qI~mKBSNP_3;rnV*W>TIgb(V1>Z5L z`aiDik8A#Ky?^A|OLS@V}QKdSjr z&5vn*O!HSYe^v9>G=EL=H#C1k^EWkrQ}a`rpVIto&EMAijOJ%Fe@F9oG=Ep~cQt=s z^Y=AB2ORtBLw)>6>%D|J4_-p`yN~8RnrCXBsrd-t7-yx{uhjZAny=A(t@c}|_3N~L zgVxvU<1_krNFOf ze_X2eKB@VWnjg^ofaWg)$M*iJ^E(+-{krMn4ug8$*{6>W>EknS9LJ9OOkf}SyudY;??9T(`uCsB3Lrh-|CHz+Ih&1+tP|zIDu)8b0)a-9?~o1LG&Kf$_7Md%{8BE5y=- zI!MbvzQ$t`1MFOrf*|#?%Ssvn$AeIx+3ZNt1m>EwLNq7uu=^nS8gEZtA!ZJF#%|G& zc!w{jCTauk~2<;*%{ClI4&A8n|+b7!2YMqmG&dDU^kVl3G6`D z3TW?M`z^lvAT6+W%6`)R3-r&Pz#htOW}Vp;?9-sxENW=HVMX9IUNCevyfJ1R8#QdZ zA=LK;=-b)sE0lA7wtpb!LBkeb?yw@T5sr2a@8z5l-{j1O_oF-wzRm0`9&`FSxDP)i zKJWo$T&Re^Wl)-8w`*Q zAj5B9;O{;zkcLBA3V-n#4rwXt4!Z6jcL&)OWLJ<~L3Rh(9b|Wq{ov>a#{kd;fE)mF z5FCTx7y`NwkV8PGf5{`uix-rYq_Cl73rglzjV~-KEiSAoEuR}%Tvo<%H7~EY!ER$K zh+*l|E2}CBi@NfcSAZ_7WM0YKVhDN*6i^9@%F}JXc zPDbBo58mlm_k!ns8yWtoLV zvr3={o2=Ojt4iipLQ5*ar>baH?%WyW8HJVTMf{eM$^~UrR-07_-^Bf3A;>p{!(PVbyh2vhC}+l~p*xXn-*+zp}*I zU`v#I82qzgcv|ZQ^~t^i27gv*<-GDrJQHjr45^Zen+xYy3$p|mSyEY9IJ0DEdBvQ< zD!2|TP0pNESUOi{O)n|}H|il3%c6+2_+u3<-D}&Bu`oF2&Kz65paMqB4dW38HCZZI zm(&#-hL5&&Y4k{AW2@k5F8Vv`(898^>Ch|bcfvXOJEy$D#fz@1SYCM%OhJoFim%hE zlCD!(M+l7es*;6OUDpwe8Lfd+pu4s5x@#bJZfR9%VHu2Y>@1t>#?o(DC6z@LrSov$ zSj)*TsjSLgSX4q+(2YHaW;JVdEblHL|4^dh)mWf;lDXZXfd(jjYK_ zUE4L8LBpth>UIZD7<40mV>UcAv&;pRRpoP(#{kWACFuc_oX3__u?e$E=Kde;eSK_Q zM|R)5M~Zx+q$l!Gv?cqIeva*!ie-kRBwOCnTFat7xY3s-%Dc`=;XaX1Bv<5n^n0W} zHa7a6tRNde1!N$LCO{WRfE3su*57Y%BCygPU1%$YN1&YU^t%-nm;d^ z?<=c-0W}RT@Ez9w@*>w!WZBVeG^0u3oC6kz>FL@$R*~9*ZEvP!C#cBe+=3d*Tmn~W z5I-|F?~GU`tL4>; zICIu{V=vU%LyB5>xxOKt1|Qe%D0gNXNx~mmD4cm%Z34ubg7TYfSVadlB>i`K?>yYY zrX8k}D7#$0)vT_Wlgn^?!B=}t;RNR%!G^Qd<_)h-Tj#H}YR#J*0nXal89K4HRpv;i zTp~t19PP%fnd>L%*Rgs-bOAkW8L-(#aEVuJ-Vq{Y;h(E{J9%!M%gZ7(u+(J2lWC}! zC3}j$M{mr{y{>-L$>rKgI77_oYJEW@iu9Rv5g9NmP~tP3w&JvtiM)htka93 zjogeSBNNo{(!MpWV9KkpX4JYfXBnBn>~|UqM#WglYNAiNSi7yi&i@fZ9P4OP*CSeY zh$?YvLj^abA?9f(VU@HH9^@*2NYc8(IrG>#G7>LA^g*$R&rYpsvmLax*10@HCVZHV z0PH~2j@1`rV!0vp8A?aevZq}X^BQOZS+@oHO-vMXzJ9EJ$Jyjmj@H*TOnW!lWyXVX z0>eN=99VMB->fy8%L_10HRj^MQW;!=Yfzqb)L1{(Y*z1_zpi?&1-+s7PE8|Zx3GX% z&rPg8W=6Vg^^v5H+hBoty|%bqw_qpgSkR?HZ05B@o6vrO9`;4nB71a@yv2- z9ZShgH!)h6LEh4vUD~MMFl)BIv{qNDccj}cPi{2iA|?ju(OYTXCYkG)L|K!vSjL&^ z>a~SxWSU7&f?MjG;FbtOa#$SRv;4gG%UBxSvF!Lpvl#_-p$-U=$|NKw>1@M^tH33) z)JEbcM%v|K4V;>f!cCZ=tBsq%{qdDrwdvt?;2cAQrz9wrL1L`Tx-b)A5?O>wNHn1m zS*L0eeRG4UvgBIxRGBFqzLYYaa-bZ`bZInB>9Syu(uG!9(*=I;(nZNZOGCtmD_tJv zV7ffcyHvRq@sK5fi(!HeLoqq6l%!f5w?NDsHaoo}0_sK`rlVEnVgo~|b1~B_2Ar(+ zK%OpR_8#`7TiUO43RbyMppy~ywvCXPD0ONBp&(+m9n?!SwpOGs*Q*HdUs}T&bAgHj z8x9D{2|?m}A}~mIi%}97yHJTOM2)ez(5NBWI@>tcs5@tUdRgpRphNs|r7?d4ixu#k zZ|VedzKJZnkZEXA*Pmq?anX8DbA1)l5ms7tVPP)1Ysw@HGS1hdLavS=3_&NDQwWPo zbh>6%eP~*JiiiO%8+#U~!~2v*CjL@`I}Vsh8(6|YgoGcfE619PQ1@%x{Xr6;2{fp; zu>rRbVKsqm8Ib|EaxG$FUs`HxtSnq^)zIIt5thZWECS|VplXUyXw_9vz@<{iH=DJP zg*`xE`<`G9D$QW$>oyoX)6zI4qxk2qYtLd_AgRY28zLHy~!NC6+PnZ^8m< znyTG!F-^-8>8QIA2I;g-2*4_g(&}POmUo9-H*(nXcn;a-W__R=37C;hXuoMh7=I&p zthCu35y279I=<4V!)D_zT%UN1-1rqwXic#bz75qH6`EZ=(=4BI^kmeIQIaZ8BZnm0 z-8(mnY`=VrD7j~Kwps_K65ccLJ+~s^@mRLC`>*LfLQu4*zQ#HbAEdkv`5d-iOY;{Y3H7NG+(`2^%87S<6Mn{c>6m8ecDHdv3H~K`7w21& zXCc3`dDWz%r_hO-e~7aVGsPbhnA#l9sVky8kOpJ6HQKCiJ~ey5?;9LFI_8?m3U~X! zfditi{fW?GH+eUuMVND{wk}HC>IeqWv1!$4+}K!yb%s(k2V2%o(4dN}msSD7w}cwC zwjwrIes4Yp9%StUt7zg$dP>hz>rF=c&R3nB*uSV4TiEJSX#&m&1rx;PHL zfGRe#fHeYNBUT|R-yZwO#AVB}s%67x^gxDnZjM0^#+nh5TW_qv0a|V%>}&T+j|IDo zQS3rTLF9#kCW+VOfD1ZrrsO^~2ntRnh}e=%l9=Le3R;Q?JkydO3j(>s8z&fv+{}1i4tW=w*?|;v(4CSN7O?}$Z95|iFw(?^7OY% zjVrHjNTwG|ak(lhRF3VubMs5h^ANw8%Ag>{XyK$p9_g71V^t;SUISb%$wO<{dX?=5 zW+g!q#W!Qn;=-N^9bf?$<|Ywwd=kiPjKepc>H-7P0dcAFAk=BYn+V~?P8}eCW>gpW;o5(y7@-Dla)@QNLEHbZT2Z9KqJL!-;_lCVw@th(hBz@boG^=jfJGFUX=|azobdl;bus+F{M}ww%n5q)fbnzb8lK?uJo<44uVTs5fCsmSa zU3IdqDpnQ4*3!5g;jGh#TUa$|M;ff9G3h{Soq;_Z{7OY}&E5=|+U z)<3lrx;q)m#X8(QoCwA__xj>5*P0Er^=2~i>80T4!~F6pR+&?^_1Bkijt*DE9oCmI zMoeGEDfY!WPQ(fw$k4>Ojn#M?D8VwNZnK#ZpcEsxkSRpED1*KfkT&g+n2b7R*+z*N zWtW4w>)gIp6V1;BiEm%B?iXSq9D_QHSicQt8td4A#yaQ@-1=0D;T;+W65H2Rx(&{RK>6yU1L!ci$D=?x0jlmy z!!m6Vp7s}2cGEeQa@V-_Rg!0q=b<;N(3z{yml6iCTkQ=!`ES;}0SY96$>%vAMV@iy zx7w_(%2sYfp;ZmbpuFV*bk`ZRUT+xee^{@lMho07TIRa*ELw)UGBSd~S|8y9|0KhO zXWceXHF>ld`-|!A=@xgQF>}>F0XuMF5{*C`iJcFQXdVL5xmDqU5as|xr_~JOxC(L=z!g_kdkAZ)dF4TX^=fkw{^9!4a?4=%#m^@pE)l(UJavpw zW0=m8{8m{(o<_BtC$WV6TG!RZwS|(~NH3|l`JgP{bbXQ9)0V^Ar zKhbVOC^W7>dX`n-NeT;nX51r)cK)&Jgl!Qy97CJd9tv~iU`_y_HaC4buuxVdNJDVq z9k#F=c|Q>ncX*o=j zrJ(3|WA#m(bVhJ5!gKu0C1hhXu+~Mn=V}{}PM%~Gv1pyC))zMrOo$*{Gq!)}f|EFV zm@2e7czU^tWw?bS$~WaL#d@?ODPp03Mzp^F%M*PMpL&=sQ6bFmx=*;a=#TL@T4D-?h{ z-b`S`G*e6+cYz%OT+aYF7y?X8n)!8jA1O31J1F1DiNoovm+;EsSCm$qutSsl9H!Gh*n1c2OYn;c*sfmRD~nH zLh>XvTYz@UJS5Jtmthmp)}zJGA1>$4>UT#^ZC;JLLTTZ@CT&0DxH+5Qq6^qi+0T*D&8!%x!v-Nm9$$|PEVYq?BCcOGYfjgirEVGZ-;JMob-D0vDRqdP}{c8NO;_`TBCLIUez1Q6G_<@%@U59#%ibpN9aNsdNLe zx~XFHW>d1!Yb-s>^AWWfeaA;g9@h7XsDlX9!wIf0dUR3I=0r>!jnV%QKr@wYAXYb3 z{E)s+AY7H87SIV-XaUC>YwjQ|Cj<^F=wm!G>0)<>@gb406puD;#R7jNR_Ud!Rf6gX z=%A|FY>4qrjjd1tB^)3;vb9R{T+IAfi=})@<%z7qWWs|_5@y8`cY;T?Oh*LheIf_4p2&gakwi2h!;s45*v0Wc2K4>n-q;96(I@eAhr!2`HY%?qq`pm{3XP|WP>ElB`5-Urk!XJ7V_yW zu0@bXU**u&q@J|P=~Xs)4G}*)gn*|GT8vL{>j6*I1g6T0aHgOL6Yv* zMa#xg2(KO z7|INbCbRf#O(ZXxA6Ho1xIAJA9oUKb&1JkqK^}<;rToedP)#{Uk;$oe4Fc&OCx|p=4wq-kQ>y z%-SrN+@kG0iPzuM*AMb#b#guqr{AUqSo%#~Nu`+~ zpIZ|BM>G=1@K*YfIlCUwgqu2U=N$uT&tgq+tCq%#-cx9)gB|#}> z&=(pu6e~dl>@UR!SGS1-96>hhnWK+*ES9cvdPF8UBEch;N}hcYRcicRQfNLU&s{bG zAJT^G0Ry3kJkXa3L5E3>pS}w<#EtPtjqXFk<%iYI?N6SojqG9cxV<64TptZ zQ=e;`;2|9=gLWF$d|rlcageS>^mt1A^fK{0q8Ot7u-a%b`8udmlrhc^MeQ?{Y?0gu~~=u(({=uLvGN zu}sA5O=LnDq%*hZ7QjGA*WIFS#5_*d-Qwa5+bmu8UkVtGHx1_T3bF~xh4hnQD;XkyW63>@7^PJEKKEDTW)13uO%bWma z${kBWQ$GgeF-l+b@sh+daFkQ{0_gvy#V~^&Rt!(!VZ|_<9#&k1L8lMu2^^Ja^xPeZ zgC|M^83h@74Ur+07^?)s$NB`Bc6GB-?dfKv+EF3IKj0-uw|Yzi@69>YY;3GyF`yK< zUd55ko5kiD-a-Vp*Y9LlIirl*&0%6nJ^hA+g&!5m~~JoJ`&@&dshJ*YTlBjv5J`LB&Zsx&wK ziqDJ+5w!Uy$1&tM3Xd-uteXnHZ(qfC?ORCI@%_UU{H-9rf!{Y#vVu)6y!{0^HGGNB zwEsL_`DOy70&qM_18_Dmk4i+`!09w1y@SSTNIj1aDvsl`1kdy1erDDzp%&rd*cvz& zRsjxTB91zUxs!q-zOA-7VcX2T67R**V0==IHf6U>n z)<2GR$^QmEFK(_L19$4cu_}CDwPh82@REGP`Dt9|!N2SHU&BCG@afAXq{#7k)T20% zyNkGYJ-USQbqd2BVsF}h;(=J?R)C`>*y^aaj{h9D3ffnyKB1P||L!dy-iRS~1mMj> zAc0~9xFvmmNs98J+E z#_6eoDbd^|gBx4}y!bY6gE*hRNxhS8->aI)GoYT=8B<8%{q-`L+r_lyZzUr|?nG zB?KJjAVl!yP=_<6Ds8gA~t(&*wRD{}#>%ujWfF-0<#%2-=7-f;VYX$%3L5s>JVL83olaz+LK@CUU zNjj=Bs{c@3_C=BGC37~0l~ez}90Ms8WZ#Cck&$fllTo0q(KF~YhlWc1YiMC1K?X$^ zCJlba%vS4+no+YKHD1M}sU+}G^PPpp=D-T+ZwsHDAWE`=a?}a}{$l*IO~qnh9gNu+;8WgN|H~ zrMK%BkPpeZb0SkuMW#JX!3KJvo`w1vNtMk(4h@HNpOllj$Z~W*@4njM1z@+pM7vY>m&|RNXlecU%cVJW z5^Zdt1&T*}@SW?BY+sjNU8dA>!E*J~aT$18Xn1ohdWV;0q3?K`q0nd^Cr2pQE3kbz zDWd$h(LRMPmj4{ZlOnW^d@hP)GN(-p>P14$OAlz!+yopsx(++PCUs)a&n%+V8nCKj zB{q&i3}zx5hJ3D>OiEv*0Bo6teVg`W*e(5;biI%)eF#Ovy39n1Bi2J-n%SEtwXUO@Rw2WKfvGT`RO8?|`oTo3~h2=8BHRLM}ss?9*#&CR@vh!$vAX4odP4dF|1GK}F zlFV`_&$m7;+~%sza<%?dNs*7?5~NGKs;fx;sR6)(bJhdHY--_T4UCJ4IH#HTsH4ZA$#c7QnLglo5q~Qt_k5NLVnUBGg`LrLZuW1hT#_CnKAhg-^iF@g&{;ke1{ z^b%$>RvenE8a<&l;oJ)Fy?V^DG_J8i+`9UP{m@t?uuGgrBSj3%35$m~0BWX?cQ*Id zIpH7$gT{&W!iBauv&n1fKbmx;QEdcmTMa_iy9LY?Qgw8l^-$TwexND%qRDk(D*XDs zUxA;@zh6cpFT(r2YThwdK+HSHdD=XK^t0wU^YfT(SIjTq{|os4BL4p(x^=~T9{+y@ ziuo&;l~+*bU3`a_7`}|V4FsRYF$2a0e#1=T`^6{mmnA3h9b=Xf6Yr+6?7Na_q@t3O z=)_5}|6c%=S1|AYanQOS+}aOLkhfPb;FI{fU+$uuag?)c9NZwhLXLy`np;Kge(=~~ zh{L~N%g7IfpAdc$-w~U0&0gp2wPqnEpcPr?Wn6W{N#TSYIi?R<$ivWFZbWaJ!=R00 z#+o&s|4ENDxpoDAvwHT5v_1~1w9l?*5nbA&PeTGZ8ahs&^cb=)Dj{s)HT0Z+v*zR{ zKd)3qe>QDp_31@O-8;}B??88aI+}ws>u1wHjvjT?e(1^M2!0w8`2slhvuP*fAY0Wn zf@8=2(%3v8cG;&plGKIaNPZeT%Qz-2Ko=p=<(E+k93h1sR0l#G z!e~bh%k1`(VzOY%a~tuP9f66_OPBUGS~x4$kJpCA^=N9G6{F$|sBlg$^N2Z?_c+^U z&=HU5hp^9F#NDFwjJ;8dK5o{TXVln>926R2yo=m0^JEg{l6Tw8E;{y$Vxqv=e_S1N zb=w1|9g(AFu15K3lZ)=l8hS$)kWnf1C1_gFjMDL79P`W8oT7pFIlHxg6|!mu)o_i` zUrYDtQ)v0!hxN-j=^EivlP^uF_AKI+>zVUO;^V?ndP~x8^TXTkf6)2+>2rTDa^QPU zGsnP{H(jnD&n(9{`GX`%uYd z^;B}D&VzDaMJQsjAUUP>M>~BUZm@4!YX4+gC6_Nv^a{kF+2H{O4ax^Pdx0&7%eGP8 zYzG5bAvk=M((ZZ`lwjGAvC2V5#m^q5@ff?nP#O>8sdT~|+Os0ZxWmn(N0QySXdp9AK7 z=m4RIO8a;8lT2om_V+Q1-7D?i?X&eh0vj>CMo^UZm~IO`G;lRf+Dk)VTo*GzJ2GwF zkODF<$St5FL!}b~R|ooYs7(^sp%H_6u^cTMxVjU$0IZVMp?-H`i682fUJjaqQa5P2 zdxjx9k~?sK*BaX2L-I%w^=oIK>x#DNuP=6i}>@@Cx?bSTsax$zKtr)uLvTCTM9>3U4)Yry|pv70tS^mSfzfB@452T4;qPVTUHz4N)Ky?A65facYj87)0vu0)To-?cW*h zCv%oWbh%!T`B0DGEg*AG^>=MjD#D%zr38a|E8u^z8|uEi3%#|=MyWF@N?R8ZS>tkG z*&qOFWE3HF1>)ci=JLCMFj})fVCQs6_!?y*OX?9PNgaf09^LEO)Eu^CQ^^9bt9@^< zpQ?Hx==4YqlMq70yrS}FuX8^4-ctB~yAEv(PrmvEsP78Imt&79Hy%NdBqJ!i{dh+W9b#xw;8n%4)unS**AP z;F(MSk6&P*I8$wmyv zVhhPoB-DXaaw^pg0a{u+<>V?PK(XO1Prx(o=wbmGm9(6o{SRE9Ll|d z7l+G`++aGmY*GBC49UzaRN-UYK&TuAlndBcS#@=2P&izM%%o69#kPG2-sV81_79;+ zGs>wa^8=l->RCsYyVgM79xy3Bn_VgEmN9fWh>@g+%R9$&)FJPPeY*{+vAj2?VQ)jN z?yhu|+P^kbV!G7+jhI4i|C(5)SUx(V(AK%4811~h52M{$*i@aG;cVJ6yRdy!7oN^& z*QhCqwf@hDC*M;PYyW+<$KRLL=+%6=tP2!VQvMAs|AyTBKyQA4LnT}c=tZDkNU*ds zDy5y#Cn`PA*YC6Y<#MV04Gt!xjmB~bI$S)TXzEi46Ir&xcCO)_QT*#;d$1il9~R+` zph-4YS{S^$UV+Lv$xn{o41)2o$<{SL^0WEaU&IN0fj8UYHMeQ~m9Mmh2 zfx-^nenT>U(92Br8+jm4K}en?m5irlg=v2s0~#q5S>SLl9D%u*FTGoOx4(c?PE&9z z3QUQ6foop{Fzt2`13d&918>LnabGf*#;Ek(_Bfy60!ex3D@n$a!rNFA9@!qtcXq~S zis(sI>wy6(D7Kl~3?#nD-(s-ZK32vMm4M5Ln(ts;|H?RSin){w#dU3h5ad=G>c2LA+R3w~wvC(2zt!?J(aFv5j96qGRhLlu9Q$*(Bq=c@egD)KHyvdKZqU8e1K{NI3DcU_eGmI za_PC#4pib9<fqxORxz{^#Hhzaxi{Q34aL?YV1FTdZ0Zvr&m?lPvhtsvR_ z{dQLY?f_u#2|4$ahiQ>%~)Q z0@l-I{C}I)M!EF1Uz1@zzh4Xu27&;B7Dk?t0j$CAa&3JVhJ(1{vZ%icT<^jv?tESB z;m+3!aLL6&C|0&1W+O?4Y{Zgj{~7~4MVK{R_@$4T8|KC<7k~O+F1*mWuhEM?rLCh; z14+{2FAzncKw1mf&9#QoE@t{W-z!*5qqNz-D>nN_LZjWu{Vp90aUJf7S^tq3>G}(B zxB$yykqxXCV1A=PY+6X0aB#3~f*?xmYd(M)!?->Fsd`*Hu;q-6%l z?px%vz|eS`9PT_|lYc|&8d(CRMj-d%chDJfZbP3-b@yV!44d&nU}*?}T(JfjbB$;l z$@MB-L%@$MzRm-o=E1IB1hb?)Y}sCAo3hzXBH$mJ9_$anDe3M*Cwlt8&Jn|H{~t@L z*o&Ut^S7vjXw--SFuX(QC2xH>{dD@%=s3b@wi_5AH1)TrAw7`Np5ELrfOaXk1tj+0 zBA5&=D+~Z%5KKZ1Yzuj`0O#lu``_V;V+?WFLM1;4Vg_@2VkNe|w!(_^$4E8pbToko zLtwEFnw`e=goOf&gvFx!?K%kjB{BaAIDO9qrOKACv=igxZw8{qW0Vm~Dqbhp9wQID zOX0dFSzV|~j{`s3{q%qX)EM)UfX339I6~#DaarOtn@~4pfk+GWhSR_Mnbq?NCbjP^KLgN@N`R3Icg#ITW&+D_bWK~JI+C2 zlfo4oJQ(P_0{(K39P?lZYc6--m_&h6+6`!M9%!W10#Za*KsF{6B}Y^-FIs^mJjvtw zBO{=#V%+<@2vCW0h1XEFbQ&A1eG=HFfMSqyP{Mb2idv)=S7<89STQ5vJA|t{r81+G zRcu!1FNX7OzfKo7gnQ5jz(ltqk6g;gngPcIh475v9+;&IfpA(lI3Yt;>;*bB#?wz| zOqjhFu%KO0mIpBJFvI|KJdxH*LxdlaIn9P)c%2}=vSo3ZNTgqqLLG2>e`&w69SNDG zyz*?;W#}5%7M)|Ii9Twd6WCcOUGB#*8c7zRW}tt*$z26nRgk*&H?gc8D{$fFh(nfM zu}NsSQfH=*CE6s$kY#!^)w>g|p&=mdoQP^^RtV{8lC}|tN&^Ql z@DMtgeRrQFn-7Bv7TC$&sE!*;$fr?sBEaF8#cV|Y218ZLu`C#52dG322xi;P0b&`q z*v37#nc{I5jOf4t6#^>ByN4{~5qssmj!%>`!j+v$K_?k8c#$7CpwNdR{0uQu3@PVR zBIlZt&7C-+k(@{5#C=M{-R(T+{Co}AL_o+isBdaFcJnpgJ*HGysuiKLY+70ucE+=# z*)=WA35b=!SLdw)!_oZ1A($1SQBvwu z8MDQujKe>&I8;GhNA}1V43`u`uh2_kIH1I;BSivI3osmda|I&)k|0)frD^8!=#Z8B}xfEHRfb+KoMbsoQp0hps2TiPtGTZ8-p`fOeRYqbwt%zb_BidV}>>)eFueo%E z>5igx9>8FNJ20rV=IYyG&0~XT-Jh7V#I6ZLxdLo-TO88AbwMH(TsE2+w0tGXb*ZT& zX_`Ax@V(F}?2=&{Pp+&@@Y{kAgWw@Fmvq6I4UYOL%G-jTuCsPSkRjgWk=owABX|V^ zo04K;en;wKy89kWks{YZs$bu0DaAgvTqR&eEN#IqSS%ZS18pUcD5A|cMXyDmi4tJX zybVMnZ*z9gZno*&P894tmw)2kw;Ud(t0*f8AI7y5xmVgAkFzYZ+wNog&-b zBdI}C#tt)w4STIJ+@@@&4v!8XE?FKFL9t~Pk_|tQhILXI+UbHro6|Bv-4`fym^K@I zeY7Hg{nS%o2E@1R_jzsPOCYyXCu&L%M!mW(J>J2tsN9uHL1%1MH22ER>9i#Q*57hm zv_;wtpL_Q=rQG_X@#-aZB%Z~N|EAI=?uDkA`#XY1v1^*S|H8G7RMb07lYD9+gg6+M z{UPCh&%^&-0IzA5f6JGDD=61A%m2`q|Dlx2AY#o{x@;cWr5{K5?|As{2)q<|pN@W; z*3?qg_^z+<-GBm3v-|^J{y|W#X_kM_mwzuP*L3@TJ@wes9D3O9%>6?m6_`md;q#~Yq_;lS#MPEy`;+eQms;Fg~oMByVsfn2wyg;OJ0p% zCaA2|T6{zGfyzd!R(YNcvZ3ca*6RE^K4iFZr?QOiP~a`g3v5C^KT)~0v^>95@woZT zq)HR739sA&nG3b~m1-04)kS{KV%@fo_3^RifgGRZtuF9MMlk04!kBFg&6f2(5}5A` ztFW+^5jvJrRa~zm27dQLYwUlB!Lq|$R&R+pn0r`a`2%>kK`x2&!?|I*q8piq0)gd{ znjFzHI{!cDHaO7*1sWV%0fYpzN8z{Qw48)Wcu48)U-tCp8Qt53m0Ztsl74O*z=p?} zK4=^$Pw2%_prC#n<+Cp!%bA!YATP1(QQ+_}cYg>6popHqvgzE%6;@2=zJ$vp#SNGH z5<|nW8^k5y)D3hxfElH_Q(&8=CpA0w5sEBG2mhLA2u;t=)zSnW?dr|v3q8Hv1^fZ# zyMLq6eVkr}$qw}DJ+dF@9d;!2*)1C#Cb6TI*ij6pbQpdnL&BqYh)07{gu4H^-d#oJ z+8#Ro$}QyLZxOh-`!`(gJODd2$|%1qJRc7BB2t0VuiwW%*9#1_a#jN7&e$Oaakb>I zDfTb?NNI^MY|uQ{yB*8AB?RYdzNe)aNA3}^geMs>EI2cmE0iH6yLgPSu!}!^;M=Y~ zDhh}Do{TMCwX1dpX~ z3uFoX5TF&?gEOpz0MR_~h}uJ&)s{uK|n zV$i>h6QzXH!ZH=W?@B^E_kKhH47N}E z^S!;>%4IYsA+SH;12-5h5>7fhe~JX+rSjl{&j(I91iOR0cv}BKGvP24p5@|S8)8Gi zSa&Hnc8nkBFRRPRTU`H8NY}XxhU9sS7_(BQrpi+>&xibM+w2V04MyZW7kF~Bq+EnI z8rg~EqQn`|Qc(u*12)SYTApDX==`}by;o8$?=O7bU+^R?)x$7jnMFV`#{$C)!x3AI zD{(Vm4F+S>AtGSdU*(GM$z9G6`_H^63vk#P;S|QdZHzM)Fj8o!2Mv{nDRaY!)=J|= z2t}JK3`X3hTyfZm7eQ~4y;`%by=hemnKB$d_93NxkVtvznX{1%bVp?ykSFp@CR`E4E zF1=WWFV`7f$9nrj+cC2ZuH6%r zD|#7&4U{^aPyotD3q)@t_PCCi7oiimtV#7$Z9>RmV{1PKl^jCbG6^@oQF?>Z`wg-D za0-~A>^DTR{&EL3`L|IM+CXwXdM#%T+K)6vFZiErG*((;_}W$jpQ5|N4>>KkLi-8y z-a}*K{A=Lo^Cab4g6;QvDR4Nx3$L1o9L4aEEnsmDJKZ9-x=P=-tMq-DHMk*f?X1DD z0+#B8&n#k=@?njMQs<0IoCd^uy8EChf#s(88QhcSXP{8H7UC+>#2U;$ZS!#*N`;?D z!jt6ePh=eIl8LYp+F}b>m~jmBzFU~@7hNBUjFETl7s2XbIrz?~Aol=xC58Rcb5WEw z&D=dfuBMs0H^{YV`X;CcEm>Aw12aqScR>5Qv=+I${649*#}}6_yP~qF0(XaN2n0un zRl+Ri{lqf!0ED)PF{^7z9{M@X2L3CQ8ncH!#A=!OuN zq0yKfVu8{dF6W`S#Kg4>7aLd8vY={GfE@b#ldR(I5^e3H?$=6*66++!D9aB}3&ygt zz>4Ba#=we6BEp`_kb3jc2>o0i-3czDxBi*w?)MHMakP@jr03r6e*!>!mg{Xb-Yg_)zowSU08#m zgFslM3?&WrY2<7KLy;s=Q2SPk68iSHX!_>_Z~Kq1p%X{Vb3e3FM)JG+(6a3Xsg*bt zkBQqn^aJ%-BKv+Y@;OrIJ&t$aSqnFaxaBZDi$ZH!+(VWeb7Df)&9+E{ta27qmX7!N zprRcbpycDHXiW!$TpX3*b}4L=MGOSo4#yOxX`2f?)@rIic>)2K|A-D?_^rxuw^|Iu zHUk}y3i>27d4K|N4r^01C?h-z#2FsPB9kzlC9ba^+(o(sANj+Wm46z6F6IIL=)(t; z&-;1ttVI-X2Y1UQxvac*Ku%zBLHn>+r0Hgp1ckLu<{$tkC~TU}xl3a6u~>R zvOS*XSa$yXKB5R5nY{79kT?Wv5!R(ohK>wewNuzN zfg?m=CrU%Rc{~MtfSezpn=S#__;>^^=q`?OD;zG*MahF1 z1}Bq~(gKymekC|3Ja@MHD1e=@^zHMS_JPgN9$}_*0VfN%B#3zFIAGZ9(=Rp~ z;}Xv(v4&@@)S`azK)%Q?MTmAhaEJdMShTt}@R@yST#og*8+0L!4WS5|36}MCab~tZ z!mjyn7d+rD%;@d%JCo~TZ~&VLy~RSls{mS=)tfJKaYe`+a;~wa$fV8paj1y_en0fX zF2t>H{1)eG&9C#C-VuNG%>dixAhjV7OxW^X- zpB^o-PQ{m006Ua3{mIXu8S_HU{QU98+MVX|;?jC$bbf#33$j^m%*Ub;+RdP-$voj#a1r-$<9;-%?JyD#i|>)rqGS1119-+rs-_G7Po zfi>nocLibVuh!<*TUV0(xYBCQr!yPZzIx?iZKa0KBBu(+))ua@^?zJ{?jKUWl2rdI zrYqU>|4slGLChU*G^bZq&LVVfR$KFpX00~1u(Bcm|K~a2>W^SQOZ~$*fXM~~dyQ$w z@#ua#=1MA`aHsMAORwe4m-u+3{qv>*umr^`vDY^E>UZ!!)0c#ZxxSzz^2>BMj8N7>-FJ|YTXQfv3 z!7jcv(tTM?0L*u~KY$qKKvVQZh%~0(6d1lUS^plw8*sq`d=v}@58j^4*IDyj<$Mbw z-m(Z<9{y5>xW;MCdk(w_Tzq-8z8IW14&%*>FX8_r z{*&%AW(e@)lzvcwFBo6JSm>8J9^K{`-bBpL0P@eec^$4pHa%96q7zexXi z+XmrDzvCtEI2s?XAJZ}(`l^Hlypxk3u!uPFXk4W0kc>kdM{+chV{t_49K(3=3p0Fu ixV~omQT5o~C;DeRkB1zL`M$FF6Gije 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

    <#t*DavHwx2XRuoq@+o`+A0W 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 literal 0 HcmV?d00001 diff --git a/HomeCinema.Data/bin/Debug/FluentValidation.xml b/HomeCinema.Data/bin/Debug/FluentValidation.xml new file mode 100644 index 00000000..9a42560e --- /dev/null +++ b/HomeCinema.Data/bin/Debug/FluentValidation.xml @@ -0,0 +1,2043 @@ + + + + FluentValidation + + + +

    + Base class for entity validator classes. + + The type of the object being validated + + + + Defines a validator for a particualr type. + + + + + + Defines a validator for a particular type. + + + + + Validates the specified instance + + + A ValidationResult containing any validation failures + + + + Validates the specified instance asynchronously + + + A ValidationResult containing any validation failures + + + + Validates the specified instance. + + A ValidationContext + A ValidationResult object containy any validation failures. + + + + Validates the specified instance asynchronously. + + A ValidationContext + A ValidationResult object containy any validation failures. + + + + Creates a hook to access various meta data properties + + A IValidatorDescriptor object which contains methods to access metadata + + + + Checks to see whether the validator can validate objects of the specified type + + + + + Validates the specified instance. + + The instance to validate + A ValidationResult object containing any validation failures. + + + + Validate the specified instance asynchronously + + The instance to validate + A ValidationResult object containing any validation failures. + + + + Sets the cascade mode for all rules within this validator. + + + + + Validates the specified instance + + The object to validate + A ValidationResult object containing any validation failures + + + + Validates the specified instance asynchronously + + The object to validate + A ValidationResult object containing any validation failures + + + + Validates the specified instance. + + Validation Context + A ValidationResult object containing any validation failures. + + + + Validates the specified instance asynchronously. + + Validation Context + A ValidationResult object containing any validation failures. + + + + Adds a rule to the current validator. + + + + + + Creates a that can be used to obtain metadata about the current validator. + + + + + Defines a validation rule for a specify property. + + + RuleFor(x => x.Surname)... + + The type of property being validated + The expression representing the property to validate + an IRuleBuilder instance on which validators can be defined + + + + Defines a custom validation rule using a lambda expression. + If the validation rule fails, it should return a instance of a ValidationFailure + If the validation rule succeeds, it should return null. + + A lambda that executes custom validation rules. + + + + Defines a custom validation rule using a lambda expression. + If the validation rule fails, it should return an instance of ValidationFailure + If the validation rule succeeds, it should return null. + + A lambda that executes custom validation rules + + + + Defines a custom asynchronous validation rule using a lambda expression. + If the validation rule fails, it should asynchronously return a instance of a ValidationFailure + If the validation rule succeeds, it should return null. + + A lambda that executes custom validation rules. + + + + Defines a custom asynchronous validation rule using a lambda expression. + If the validation rule fails, it should asynchronously return an instance of ValidationFailure + If the validation rule succeeds, it should return null. + + A lambda that executes custom validation rules + + + + Defines a RuleSet that can be used to group together several validators. + + The name of the ruleset. + Action that encapsulates the rules in the ruleset. + + + + Defines a condition that applies to several rules + + The condition that should apply to multiple rules + Action that encapsulates the rules. + + + + + Defiles an inverse condition that applies to several rules + + The condition that should be applied to multiple rules + Action that encapsulates the rules + + + + Returns an enumerator that iterates through the collection of validation rules. + + + A that can be used to iterate through the collection. + + 1 + + + + Sets the cascade mode for all rules within this validator. + + + + + Keeps all the conditional compilation in one place. + + + + + Class that can be used to find all the validators from a collection of types. + + + + + Creates a scanner that works on a sequence of types. + + + + + Finds all the validators in the specified assembly. + + + + + Finds all the validators in the assembly containing the specified type. + + + + + Performs the specified action to all of the assembly scan results. + + + + + Returns an enumerator that iterates through the collection. + + + A that can be used to iterate through the collection. + + 1 + + + + Result of performing a scan. + + + + + Creates an instance of an AssemblyScanResult. + + + + + Validator interface type, eg IValidator<Foo> + + + + + Concrete type that implements the InterfaceType, eg FooValidator. + + + + + Implementation of IValidatorFactory that looks for ValidatorAttribute instances on the specified type in order to provide the validator instance. + + + + + Gets validators for a particular type. + + + + + Gets the validator for the specified type. + + + + + Gets the validator for the specified type. + + + + + Gets a validator for the appropriate type. + + + + + Gets a validator for the appropriate type. + + + + + Validator attribute to define the class that will describe the Validation rules + + + + + Creates an instance of the ValidatorAttribute allowing a validator type to be specified. + + + + + The type of the validator used to validate the current type. + + + + + Associates an instance of IValidator with the current property rule and is used to validate each item within the collection. + + The validator to use + + + + Rule builder + + + + + + + Rule builder + + + + + + + Associates a validator with this the property for this rule builder. + + The validator to set + + + + + Associates an instance of IValidator with the current property rule. + + The validator to use + + + + Represents an object that is configurable. + + Type of object being configured + Return type + + + + Configures the current object. + + Action to configure the object. + + + + + Extension methods that provide the default set of validators. + + + + + Defines a 'not null' validator on the current rule builder. + Validation will fail if the property is null. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + + + + + Defines a 'not empty' validator on the current rule builder. + Validation will fail if the property is null, an empty or the default value for the type (for example, 0 for integers) + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + + + + + Defines a length validator on the current rule builder, but only for string properties. + Validation will fail if the length of the string is outside of the specifed range. The range is inclusive. + + Type of object being validated + The rule builder on which the validator should be defined + + + + + Defines a length validator on the current rule builder, but only for string properties. + Validation will fail if the length of the string is not equal to the length specified. + + Type of object being validated + The rule builder on which the validator should be defined + + + + + Defines a regular expression validator on the current rule builder, but only for string properties. + Validation will fail if the value returned by the lambda does not match the regular expression. + + Type of object being validated + The rule builder on which the validator should be defined + The regular expression to check the value against. + + + + + Defines a regular expression validator on the current rule builder, but only for string properties. + Validation will fail if the value returned by the lambda does not match the regular expression. + + Type of object being validated + The rule builder on which the validator should be defined + The regular expression to use + + + + + Defines a regular expression validator on the current rule builder, but only for string properties. + Validation will fail if the value returned by the lambda does not match the regular expression. + + Type of object being validated + The rule builder on which the validator should be defined + The regular expression to check the value against. + Regex options + + + + + Defines a regular expression validator on the current rule builder, but only for string properties. + Validation will fail if the value returned by the lambda is not a valid email address. + + Type of object being validated + The rule builder on which the validator should be defined + + + + + Defines a 'not equal' validator on the current rule builder. + Validation will fail if the specified value is equal to the value of the property. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value to compare + Equality comparer to use + + + + + Defines a 'not equal' validator on the current rule builder using a lambda to specify the value. + Validation will fail if the value returned by the lambda is equal to the value of the property. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda expression to provide the comparison value + Equality Comparer to use + + + + + Defines an 'equals' validator on the current rule builder. + Validation will fail if the specified value is not equal to the value of the property. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value to compare + Equality Comparer to use + + + + + Defines an 'equals' validator on the current rule builder using a lambda to specify the comparison value. + Validation will fail if the value returned by the lambda is not equal to the value of the property. + + The type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda expression to provide the comparison value + Equality comparer to use + + + + + Defines a predicate validator on the current rule builder using a lambda expression to specify the predicate. + Validation will fail if the specified lambda returns false. + Validation will succeed if the specifed lambda returns true. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda expression specifying the predicate + + + + + Defines a predicate validator on the current rule builder using a lambda expression to specify the predicate. + Validation will fail if the specified lambda returns false. + Validation will succeed if the specifed lambda returns true. + This overload accepts the object being validated in addition to the property being validated. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda expression specifying the predicate + + + + + Defines a predicate validator on the current rule builder using a lambda expression to specify the predicate. + Validation will fail if the specified lambda returns false. + Validation will succeed if the specifed lambda returns true. + This overload accepts the object being validated in addition to the property being validated. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda expression specifying the predicate + + + + + Defines an asynchronous predicate validator on the current rule builder using a lambda expression to specify the predicate. + Validation will fail if the specified lambda returns false. + Validation will succeed if the specifed lambda returns true. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda expression specifying the predicate + + + + + Defines an asynchronous predicate validator on the current rule builder using a lambda expression to specify the predicate. + Validation will fail if the specified lambda returns false. + Validation will succeed if the specifed lambda returns true. + This overload accepts the object being validated in addition to the property being validated. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda expression specifying the predicate + + + + + Defines an asynchronous predicate validator on the current rule builder using a lambda expression to specify the predicate. + Validation will fail if the specified lambda returns false. + Validation will succeed if the specifed lambda returns true. + This overload accepts the object being validated in addition to the property being validated. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda expression specifying the predicate + + + + + Defines a 'less than' validator on the current rule builder. + The validation will succeed if the property value is less than the specified value. + The validation will fail if the property value is greater than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'less than' validator on the current rule builder. + The validation will succeed if the property value is less than the specified value. + The validation will fail if the property value is greater than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'less than or equal' validator on the current rule builder. + The validation will succeed if the property value is less than or equal to the specified value. + The validation will fail if the property value is greater than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'less than or equal' validator on the current rule builder. + The validation will succeed if the property value is less than or equal to the specified value. + The validation will fail if the property value is greater than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'greater than' validator on the current rule builder. + The validation will succeed if the property value is greater than the specified value. + The validation will fail if the property value is less than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'greater than' validator on the current rule builder. + The validation will succeed if the property value is greater than the specified value. + The validation will fail if the property value is less than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'greater than or equal' validator on the current rule builder. + The validation will succeed if the property value is greater than or equal the specified value. + The validation will fail if the property value is less than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'greater than or equal' validator on the current rule builder. + The validation will succeed if the property value is greater than or equal the specified value. + The validation will fail if the property value is less than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'less than' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is less than the specified value. + The validation will fail if the property value is greater than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda that should return the value being compared + + + + + Defines a 'less than' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is less than the specified value. + The validation will fail if the property value is greater than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda that should return the value being compared + + + + + Defines a 'less than' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is less than the specified value. + The validation will fail if the property value is greater than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda that should return the value being compared + + + + + Defines a 'less than' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is less than the specified value. + The validation will fail if the property value is greater than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + A lambda that should return the value being compared + + + + + Defines a 'less than or equal' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is less than or equal to the specified value. + The validation will fail if the property value is greater than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'less than or equal' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is less than or equal to the specified value. + The validation will fail if the property value is greater than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'less than or equal' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is less than or equal to the specified value. + The validation will fail if the property value is greater than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'less than or equal' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is less than or equal to the specified value. + The validation will fail if the property value is greater than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'less than' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is greater than the specified value. + The validation will fail if the property value is less than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'less than' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is greater than the specified value. + The validation will fail if the property value is less than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'less than' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is greater than the specified value. + The validation will fail if the property value is less than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'less than' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is greater than the specified value. + The validation will fail if the property value is less than or equal to the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'greater than' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is greater than or equal the specified value. + The validation will fail if the property value is less than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'greater than' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is greater than or equal the specified value. + The validation will fail if the property value is less than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'greater than or equal to' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is greater than or equal the specified value. + The validation will fail if the property value is less than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Defines a 'greater than or equal to' validator on the current rule builder using a lambda expression. + The validation will succeed if the property value is greater than or equal the specified value. + The validation will fail if the property value is less than the specified value. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The value being compared + + + + + Validates certain properties of the specified instance. + + The current validator + The object to validate + Expressions to specify the properties to validate + A ValidationResult object containing any validation failures + + + + Validates certain properties of the specified instance. + + The object to validate + The names of the properties to validate. + A ValidationResult object containing any validation failures. + + + + Validates certain properties of the specified instance asynchronously. + + The current validator + The object to validate + Expressions to specify the properties to validate + A ValidationResult object containing any validation failures + + + + Validates certain properties of the specified instance asynchronously. + + The object to validate + The names of the properties to validate. + A ValidationResult object containing any validation failures. + + + + Performs validation and then throws an exception if validation fails. + + + + + Performs validation asynchronously and then throws an exception if validation fails. + + + + + Defines an 'inclusive between' validator on the current rule builder, but only for properties of types that implement IComparable. + Validation will fail if the value of the property is outside of the specifed range. The range is inclusive. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The lowest allowed value + The highest allowed value + + + + + Defines an 'inclusive between' validator on the current rule builder, but only for properties of types that implement IComparable. + Validation will fail if the value of the property is outside of the specifed range. The range is inclusive. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The lowest allowed value + The highest allowed value + + + + + Defines an 'exclusive between' validator on the current rule builder, but only for properties of types that implement IComparable. + Validation will fail if the value of the property is outside of the specifed range. The range is exclusive. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The lowest allowed value + The highest allowed value + + + + + Defines an 'exclusive between' validator on the current rule builder, but only for properties of types that implement IComparable. + Validation will fail if the value of the property is outside of the specifed range. The range is exclusive. + + Type of object being validated + Type of property being validated + The rule builder on which the validator should be defined + The lowest allowed value + The highest allowed value + + + + + Defines a credit card validator for the current rule builder that ensures that the specified string is a valid credit card number. + + + + + Default options that can be used to configure a validator. + + + + + Specifies the cascade mode for failures. + If set to 'Stop' then execution of the rule will stop once the first validator in the chain fails. + If set to 'Continue' then all validators in the chain will execute regardless of failures. + + + + + Specifies a custom action to be invoked when the validator fails. + + + + + + + + + + Specifies a custom error message to use if validation fails. + + The current rule + The error message to use + + + + + Specifies a custom error message to use if validation fails. + + The current rule + The error message to use + Additional arguments to be specified when formatting the custom error message. + + + + + Specifies a custom error message to use if validation fails. + + The current rule + The error message to use + Additional property values to be included when formatting the custom error message. + + + + + Specifies a custom error message to use if validation fails. + + The current rule + The error message to use + Additional property values to use when formatting the custom error message. + + + + + Specifies a custom error message resource to use when validation fails. + + The current rule + The resource to use as an expression, eg () => Messages.MyResource + + + + + Specifies a custom error message resource to use when validation fails. + + The current rule + The resource to use as an expression, eg () => Messages.MyResource + Custom message format args + + + + + Specifies a custom error message resource to use when validation fails. + + The current rule + The resource to use as an expression, eg () => Messages.MyResource + Custom message format args + + + + + Specifies a custom error message resource to use when validation fails. + + The current rule + The resource to use as an expression, eg () => Messages.MyResource + The resource accessor builder to use. + + + + + Specifies a condition limiting when the validator should run. + The validator will only be executed if the result of the lambda returns true. + + The current rule + A lambda expression that specifies a condition for when the validator should run + Whether the condition should be applied to the current rule or all rules in the chain + + + + + Specifies a condition limiting when the validator should not run. + The validator will only be executed if the result of the lambda returns false. + + The current rule + A lambda expression that specifies a condition for when the validator should not run + Whether the condition should be applied to the current rule or all rules in the chain + + + + + Triggers an action when the rule passes. Typically used to configure dependent rules. This applies to all preceding rules in the chain. + + The current rule + An action to be invoked if the rule is valid + + + + + Specifies a custom property name to use within the error message. + + The current rule + The property name to use + + + + + Specifies a localized name for the error message. + + The current rule + The resource to use as an expression, eg () => Messages.MyResource + Resource accessor builder to use + + + + Overrides the name of the property associated with this rule. + NOTE: This is a considered to be an advanced feature. 99% of the time that you use this, you actually meant to use WithName. + + The current rule + The property name to use + + + + + Overrides the name of the property associated with this rule. + NOTE: This is a considered to be an advanced feature. 99% of the time that you use this, you actually meant to use WithName. + + The current rule + The property name to use + + + + + Specifies custom state that should be stored alongside the validation message when validation fails for this rule. + + + + + + + + + + Validator implementation that allows rules to be defined without inheriting from AbstractValidator. + + + + public class Customer { + public int Id { get; set; } + public string Name { get; set; } + + public static readonly InlineValidator<Customer> Validator = new InlineValidator<Customer> { + v => v.RuleFor(x => x.Name).NotNull(), + v => v.RuleFor(x => x.Id).NotEqual(0), + } + } + + + + + + + Allows configuration of the validator. + + + + + Delegate that specifies configuring an InlineValidator. + + + + + Defines a rule associated with a property. + + + + + Defines a rule associated with a property which can have multiple validators. + + + + + Performs validation using a validation context and returns a collection of Validation Failures. + + Validation Context + A collection of validation failures + + + + Performs validation using a validation context and returns a collection of Validation Failures asynchronoulsy. + + Validation Context + A collection of validation failures + + + + The validators that are grouped under this rule. + + + + + Name of the rule-set to which this rule belongs. + + + + + Creates a new property rule. + + Property + Function to get the property value + Lambda expression used to create the rule + Function to get the cascade mode. + Type to validate + Container type that owns the property + + + + Creates a new property rule from a lambda expression. + + + + + Creates a new property rule from a lambda expression. + + + + + Adds a validator to the rule. + + + + + Replaces a validator in this rule. Used to wrap validators. + + + + + Remove a validator in this rule. + + + + + Clear all validators from this rule. + + + + + Display name for the property. + + + + + Performs validation using a validation context and returns a collection of Validation Failures. + + Validation Context + A collection of validation failures + + + + Performs asynchronous validation using a validation context and returns a collection of Validation Failures. + + Validation Context + A collection of validation failures + + + + Invokes a property validator using the specified validation context. + + + + + Property associated with this rule. + + + + + Function that can be invoked to retrieve the value of the property. + + + + + Expression that was used to create the rule. + + + + + String source that can be used to retrieve the display name (if null, falls back to the property name) + + + + + Rule set that this rule belongs to (if specified) + + + + + Function that will be invoked if any of the validators associated with this rule fail. + + + + + The current validator being configured by this rule. + + + + + Type of the property being validated + + + + + Cascade mode for this rule. + + + + + Validators associated with this rule. + + + + + Returns the property name for the property being validated. + Returns null if it is not a property being validated (eg a method call) + + + + + Allows custom creation of an error message + + + + + Dependent rules + + + + + Creates a new property rule from a lambda expression. + + + + + Tries to compare the two objects. + + The resulting comparison value. + True if all went well, otherwise False. + + + + Tries to do a proper comparison but may fail. + First it tries the default comparison, if this fails, it will see + if the values are fractions. If they are, then it does a double + comparison, otherwise it does a long comparison. + + + + + Tries to compare the two objects, but will throw an exception if it fails. + + True on success, otherwise False. + + + + Tries to compare the two objects, but will throw an exception if it fails. + + True on success, otherwise False. + + + + Default validator selector that will execute all rules that do not belong to a RuleSet. + + + + + Determines whether or not a rule should execute. + + + + + Determines whether or not a rule should execute. + + The rule + Property path (eg Customer.Address.Line1) + Contextual information + Whether or not the validator can execute. + + + + Determines whether or not a rule should execute. + + The rule + Property path (eg Customer.Address.Line1) + Contextual information + Whether or not the validator can execute. + + + + Custom IValidationRule for performing custom logic. + + + + + + Creates a new DelegateValidator using the specified function to perform validation. + + + + + Creates a new DelegateValidator using the specified function to perform validation. + + + + + Creates a new DelegateValidator using the specified async function to perform validation. + + + + + Creates a new DelegateValidator using the specified async function to perform validation. + + + + + Performs validation using a validation context and returns a collection of Validation Failures. + + Validation Context + A collection of validation failures + + + + Performs validation asynchronously using a validation context and returns a collection of Validation Failures. + + Validation Context + A collection of validation failures + + + + Performs validation using a validation context and returns a collection of Validation Failures. + + Validation Context + A collection of validation failures + + + + When overloaded performs validation asynchronously using a validation context and returns a collection of Validation Failures. + + Validation Context + A collection of validation failures + + + + Rule set to which this rule belongs. + + + + + The validators that are grouped under this rule. + + + + + Useful extensions + + + + + Gets a MemberInfo from a member expression. + + + + + Gets a MemberInfo from a member expression. + + + + + Splits pascal case, so "FooBar" would become "Foo Bar" + + + + + Helper method to construct a constant expression from a constant. + + Type of object being validated + Type of property being validated + The value being compared + + + + + Instancace cache. + TODO: This isn't actually completely thread safe. It would be much better to use ConcurrentDictionary, but this isn't available in Silverlight/WP7. + + + + + Gets or creates an instance using Activator.CreateInstance + + The type to instantiate + The instantiated object + + + + Gets or creates an instance using a custom factory + + The type to instantiate + The custom factory + The instantiated object + + + + Selects validators that belong to the specified rulesets. + + + + + Creates a new instance of the RulesetValidatorSelector. + + + + + Determines whether or not a rule should execute. + + The rule + Property path (eg Customer.Address.Line1) + Contextual information + Whether or not the validator can execute. + + + + Selects validators that are associated with a particular property. + + + + + Creates a new instance of MemberNameValidatorSelector. + + + + + Determines whether or not a rule should execute. + + The rule + Property path (eg Customer.Address.Line1) + Contextual information + Whether or not the validator can execute. + + + + Creates a MemberNameValidatorSelector from a collection of expressions. + + + + + Assists in the construction of validation messages. + + + + + Default Property Name placeholder. + + + + + Adds a value for a validation message placeholder. + + + + + + + + Appends a property name to the message. + + The name of the property + + + + + Adds additional arguments to the message for use with standard string placeholders. + + Additional arguments + + + + + Constructs the final message from the specified template. + + Message template + The message with placeholders replaced with their appropriate values + + + + Represents a chain of properties + + + + + Creates a new PropertyChain. + + + + + Creates a new PropertyChain based on another. + + + + + Adds a MemberInfo instance to the chain + + Member to add + + + + Adds a property name to the chain + + Name of the property to add + + + + Adds an indexer to the property chain. For example, if the following chain has been constructed: + Parent.Child + then calling AddIndexer(0) would convert this to: + Parent.Child[0] + + + + + + Creates a string representation of a property chain. + + + + + Checks if the current chain is the child of another chain. + For example, if chain1 were for "Parent.Child" and chain2 were for "Parent.Child.GrandChild" then + chain2.IsChildChainOf(chain1) would be true. + + The parent chain to compare + True if the current chain is the child of the other chain, otherwise false + + + + Builds a property path. + + + + + Replace the first validator of this type and remove all the others. + + + + + Remove all validators of the specifed type. + + + + + Remove all validators for the given property. + + + + + Provides error message templates + + + + + Construct the error message template + + Error message template + + + + The name of the resource if localized. + + + + + The type of the resource provider if localized. + + + + + Builds a delegate for retrieving a localised resource from a resource type and property name. + + + + + Gets a function that can be used to retrieve a message from a resource type and resource name. + + + + + Builds a delegate for retrieving a localised resource from a resource type and property name. + + + + + Builds a function used to retrieve the resource. + + + + + Gets the PropertyInfo for a resource. + ResourceType and ResourceName are ref parameters to allow derived types + to replace the type/name of the resource before the delegate is constructed. + + + + + Implemenetation of IResourceAccessorBuilder that can fall back to the default resource provider. + + + + + Gets the PropertyInfo for a resource. + ResourceType and ResourceName are ref parameters to allow derived types + to replace the type/name of the resource before the delegate is constructed. + + + + + Represents a localized string. + + + + + Creates a new instance of the LocalizedErrorMessageSource class using the specified resource name and resource type. + + The resource type + The resource name + Strategy used to construct the resource accessor + + + + Creates an IErrorMessageSource from an expression: () => MyResources.SomeResourceName + + The expression + Strategy used to construct the resource accessor + Error message source + + + + Construct the error message template + + Error message template + + + + The name of the resource if localized. + + + + + The type of the resource provider if localized. + + + + + Represents a static string. + + + + + Creates a new StringErrorMessageSource using the specified error message as the error template. + + The error message template. + + + + Construct the error message template + + Error message template + + + + The name of the resource if localized. + + + + + The type of the resource provider if localized. + + + + + 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 '{PropertyName}' is not a valid credit card number.. + + + + + Looks up a localized string similar to '{PropertyName}' is not a valid email address.. + + + + + Looks up a localized string similar to '{PropertyName}' should be equal to '{ComparisonValue}'.. + + + + + Looks up a localized string similar to '{PropertyName}' must be {MaxLength} characters in length. You entered {TotalLength} characters.. + + + + + Looks up a localized string similar to '{PropertyName}' must be between {From} and {To} (exclusive). You entered {Value}.. + + + + + Looks up a localized string similar to '{PropertyName}' must be greater than '{ComparisonValue}'.. + + + + + Looks up a localized string similar to '{PropertyName}' must be greater than or equal to '{ComparisonValue}'.. + + + + + Looks up a localized string similar to '{PropertyName}' must be between {From} and {To}. You entered {Value}.. + + + + + Looks up a localized string similar to '{PropertyName}' must be between {MinLength} and {MaxLength} characters. You entered {TotalLength} characters.. + + + + + Looks up a localized string similar to '{PropertyName}' must be less than '{ComparisonValue}'.. + + + + + Looks up a localized string similar to '{PropertyName}' must be less than or equal to '{ComparisonValue}'.. + + + + + Looks up a localized string similar to '{PropertyName}' should not be empty.. + + + + + Looks up a localized string similar to '{PropertyName}' should not be equal to '{ComparisonValue}'.. + + + + + Looks up a localized string similar to '{PropertyName}' must not be empty.. + + + + + Looks up a localized string similar to The specified condition was not met for '{PropertyName}'.. + + + + + Looks up a localized string similar to '{PropertyName}' is not in the correct format.. + + + + + Looks up a localized string similar to '{PropertyName}' may not be more than {expectedPrecision} digits in total, with allowance for {expectedScale} decimals. {digits} digits and {actualScale} decimals were found.. + + + + + Rule builder that starts the chain + + + + + + + Builds a validation rule and constructs a validator. + + Type of object being validated + Type of property being validated + + + + Creates a new instance of the RuleBuilder class. + + + + + Sets the validator associated with the rule. + + The validator to set + + + + + Sets the validator associated with the rule. Use with complex properties where an IValidator instance is already declared for the property type. + + The validator to set + + + + The rule being created by this RuleBuilder. + + + + + Provides metadata about a validator. + + + + + Gets the name display name for a property. + + + + + Gets a collection of validators grouped by property. + + + + + Gets validators for a particular property. + + + + + Gets rules for a property. + + + + + Specifies how rules should cascade when one fails. + + + + + When a rule fails, execution continues to the next rule. + + + + + When a rule fails, validation is stopped and all other rules in the chain will not be executed. + + + + + Specifies where a When/Unless condition should be applied + + + + + Applies the condition to all validators declared so far in the chain. + + + + + Applies the condition to the current validator only. + + + + + Used for providing metadata about a validator. + + + + + A custom property validator. + This interface should not be implemented directly in your code as it is subject to change. + Please inherit from PropertyValidator instead. + + + + + Custom message arguments. + Arg 1: Instance being validated + Arg 2: Property value + + + + + Creates an error validation result for this validator. + + The validator context + Returns an error validation result. + + + + Ensures that the property value is a valid credit card number. + + + + + Creates a new validation failure. + + + + + Creates a new ValidationFailure. + + + + + Creates a textual representation of the failure. + + + + + The name of the property. + + + + + The error message + + + + + The property value that caused the failure. + + + + + Custom state associated with the failure. + + + + + Gets or sets the error code. + + + + + Gets or sets the formatted message arguments. + These are values for custom formatted message in validator resource files + Same formatted message can be reused in UI and with same number of format placeholders + Like "Value {0} that you entered should be {1}" + + + + + Gets or sets the formatted message placeholder values. + Similar placeholders are defined in fluent validation library (check documentation) + + + + + Allows a decimal to be validated for scale and precision. + Scale would be the number of digits to the right of the decimal point. + Precision would be the number of digits. + + It can be configured to use the effective scale and precision + (i.e. ignore trailing zeros) if required. + + 123.4500 has an scale of 4 and a precision of 7, but an effective scale + and precision of 2 and 5 respectively. + + + + diff --git a/HomeCinema.Data/bin/Debug/HomeCinema.Data.dll b/HomeCinema.Data/bin/Debug/HomeCinema.Data.dll new file mode 100644 index 0000000000000000000000000000000000000000..ec96c820ba33f690a5ae6aaad98c53167192abca GIT binary patch literal 94208 zcmce931C#!_4j#iCU3GYlgUOBk^o7D01*(WC@NtSltmyYC<-ANAR00-6Ob4{5b9QN zsZ_;M3yAyP+N#yIpj3<1igl~43#m(MYwK=ltN8uSx%a(!lT46?f4|W=_ndRjJ?GqW z*LUxmF!k(f$U{V4e82vh=n&kE%YK$g52ZX;@rW_yxr+KF&C&8@k?`V3 z!_xA`hSt__TlvCJd1OUvd2?&|`02CCmxh}{wHX4F=;<)vXrvJg z@eMvoL!FP*^%;Zas*QwN!VnZ+;j_e`wVT{nS200bIIj4xZzd(tlIw_8JxyenJaD!_ z<%2}zh(KSnqYqJP4boyx&oqMwTdL_c$@@{Hz(_XT@gH8rExOde^XCGc#!o>oqg2HLTan^sQmNW@hpl z)@x>_tkHTs^bvGon4rx9@IKWV)d_|UJe#mO7)rB^dWy4D@Y$@@!BARm)ZLs_3)1Xh zS1f_yV}OpjhO>rB7JFxPFbod^7`!StT=?v*)xj`)Eb|uxM+l$2w>lVxk7NF%;7H+f zZLAK4;cqd2Xz+O9bM34ShT&1nFASa_e6Fq4!7zLx0QWQQuP?(h{*))3-+4h?my2g{+R^u=_ztcfuwGE%-V#g{QKH0^N)ir#Iiyf^~?`_;YNIF3xOK+?mbBK?kn{ z<8?YgrxQ8-t}`{U7^Wtc!qmhDh)g zSz=XY8;o}~@L09g!BD0ejCVEi*p$`5Q05tXyf1`Z{*-@bQE*?}co&n1motLVa+u24 zu3BQ^#=96C?UIgJRpT8q7OzK^A^RANy+sBs>*EYPw${s`#~$@^=&{#FG4wc^y&QT@ z|2Y*pxc^MzG`5pqHu{Tj?R|t#`o{p(KkR)33tAlv6rA4xORtH11+gPA?8(e3r zgQ41OOwzjzj)B#|P<9)bt?GfB9UK!&V0boA%vNU#pJQZoFbtmsz`a-Pr#%P}f6ALj z*Zn)LD@&}pcV&)Ng87Ogm0*7&@i_^3_P#n6p#=LAiOVT2X|+F*u#9oB)&4}HQs-i; z{fPu+tcx9sOc;-gjwi9egy%B5M&{EeOrjLo%k(#~mq~LbR1QZk2PTKC7Xy>`G91>U zm{2+Vy_`@hv6ta4d=z^bZqB3F%W$(F#a@QH$5HHMxEu9yFH>2TqDEq_AD`Sqc|lA^ zIk}rS!Cr`y++2UI&Cz=yX6vm~8AdXX)!cwT;LkghH;~KcZQ=ywImylQ=h+-xp4naY zQfEU4&**MAoG1+}?V!H|ECNVe~dG;hU6u7DEoy2TZ zD}FDv*5lqwv9(?fefFrAL!Z4qilNWZ?B&pRb_C}^2lt=(I$faC2AyKFEBTF_{?6H( zb20QME`|QYg}6U)Azt3O5HIgiNcz_gi6~9_*C6R%YQZdJxenH42~=Hdm0q-2xh0ON zF1A2#*V&rY!BBOvNqV_v>sALtbu2Jc9}BQIRtH0MEKsPA1=u^QgP|8j*!^V1buP=v%B|6aZviC)~(h{@$Y05v3s!EO^AD^FdO?UA8j<` zEDz5D9xp8`ah5Ljte5?lz3*lJQ-sxHNzappq zvDRMpKdxCX`yYGP%l_vy;bQ3ECS0P^W}Tj|(+hOkqSK|Ee&RGS7e^CwX*4kx=82FC z^F+vnc_QS({G20&x&42JIA%%v4^i{s-C*c0z$&c{hUz(n=Of(<*o-Bvs$Q^4_X4(S zbud&@;sQM-vL99lLp3E%(o-V)WpyxAQ{qrPC9yuAhnj-TN8WAVEJ9*SpV^;(7PEQXKC-SBl>SM@&TIm+^Rv+E3Yc0bI`NV5s&}_FVugvc#wwiS}IpYqmNVs*z~l z1+XQngJI(5*Mj=F1LMYznCw1&*lvRHBL=&#e_~I@Pfge7*N@QmV|M{;t(SeDJ?drO zXRnWX+4r64za2Wb`&^{c4o+h`aLz`z;aqeZ$#nMLxzb;T#_zwmfYre;e*euH zEU}{ci@pD5l~xDC#QX2(PWrP{tv>huo3-|`{n>Ia+n>Gb zW&1k~xEeaR0oUkstxhl2={lXR*XboX-JsKroT5z=yxYL4(fF(xjn9gC&S1s7wzFbh z+gUNM?W~yZAXqWqL5O0WTRy_v5|F+!Os(~uVCcO%o3J_a2Ckje z!7%>a2Cl8u!7%Z=4JjLn?vLxoQs)ZD$3I7MuoLuSsq1K$G=?2wB=wZ}P3s;mY^mnS zF6j}%mRg?TVviKIRC0`qeY~)xj&&~f3Br~tj%7BcRP-Ak#olfB9mbUF-3G2=F9#Ke zp_hY-L)FVc#Sa7=(q2xge5k^qKZ*?nH_=gSD7YzmxuK}UyA9mrM{ys(U89%x0nT*x zZRp_X>{6XxrqjzgjcsRG3{w+JVQOL_o|;5R)+gT2@ z{CR_07KNC3Px3|ZQcQM(0ytCZ|<6R7PAMavM#(TH@%*V;@{R~^{ z<!TQYT)SQlJ*WR%0Ug|buGHywbh=5Wn>qcFvn^(E^dpu=KVo6-M=Z=s zoCr&QLf58z=}*V1{lLE+a~y6>50BqNoU z1+Ri4Y?*?H?I7aLJOeKe*7U>6zJh=;(`E<)#w?p52pIJ?Ll7`#+YCX#IMZeb0>)W3 zLl7|L*bG6ym}@fx0po0&AqW`f*bG6ym}fHt0pnboAqW`f*$hFzm~S%#slq!k*B~HO z@}A7~y5Ey0d@Yz^lSAYQUk5yT2(NjCJz!L6##hYnx)}dvMv{y1A7)rC#=n^1b20wO zjAR$%OJ=0F7zdew_8L@GQ)7C9-;>7UR)epp(rSXJdy4_^zYybv%#It7T{$GL$~1#F z0u8?hJ(a0zm~EvEB45o!HA~@TV^44^xP(DhJk(1VAXLOU*4_keDysi|F24;RZO~c1 z@DG5bQ*!ub=Kc^MW6_V@GdZX(YpaJvRGF(YcMD)o3feY@};rz;d>z1Ls6$}YFeyp zHOdxuwH-|F(E;0jATOq45_F)7UHm6cT7LQtvp{ue9P z`(|!#5}7$kQpcPmRmmK0jcsGtaLVO6<_=9_AGx0B8{zv=#R5HZf)-gqLmZ(06R8$`SCi+y2jrlt|aUVJ?SX#t^;j)X_D6u+6Us-uf-_XP9>)W$B+qb@DF*csfi!dg=7?WN#CcUcna-3uiE2U$msCf$< zntOJvEgIn$=5MDhWDe8)7)yY1t0a+IeZ#+&cxr!M@8VClp;V)NDWTx_m@hMC#$v?t zX{GW-7LxEaFu?7fN~R?hvtsqq?Vp{a%I6MMzrCvB@@lS;$%Xl-9J%()< zWJQ02f|ctyClJho-Thkdn&`M^&G@h)^CBu<}-VmvUUdZQ94i%2tN;jDl>8g zTWpE9n9COTi$%@}1Pj>WxP%s8V2hH~qeZOgV)1v%;t$y3(s+vjw)mo0_OFQN2aPE5D5Rl5tS9o-ONX*C6J#V2>%gk(9XZ&7=+_vkk2uA9r=~(I48i5 zZG-ktNf?7S*c-{}F$P$7B?fOoG{Q0OLDgGFrix>5z!B{hgCo=;G3bOE#NaiK!Ls-m z;2m!(`X}U9uH&2lKcWuWKRsa#-ezwktH&6W>lnNPQHgmEs@^>^RUCu&9MNtuI6^HF zgFizJV(=lyV0nBD3S*;>bN-JTgG;ilhDkt15=;J*fKof2Zo`v`7Q~!?D<{9~@!595v_%T(z~) z_*Ut|t@0tvRIcNkK(Ifz%It)#@)3I@Sv|H2_5;!?A49aNhSxfamK#_k`C~@7Uqps5 zU|#~kPatNqPh>WCRfo-EH!_*oJd-(WCL(j0%@dBpW+KweY@Ul9Hk&NiJPn(d%KQl1 z*ck|Z8Z+x;u~)GyHtl4w3$ZLV?_{wXu`G7M$zoSxS*pID#S906now2N1lx6TRIPQ6 zs;eec4K=~bxl@LB6PiHy5r0EAOapnZ5ow1@YWKo?AM%ACuz4n*=_#JcFS2?gccMi2 zb9gNxE6x1@eq!a$82ti(-^lfv!GChKwPQq5fGeD}!>akU@ zua!B#fG8|}%@!|=w^+s&P2^XuRFCxx2PYX z7KwT`)FA4O9D|GEW6+Odkc0fnb(|9j9>XzMoG=D>3QJX4J;q?DjsYH@bPN)!!o$vy zsNxvlDMgERi@_0Ukr-g3FK5ISofcbvIU)(xU+ydk*gSG&$&6o?d16l>E$k~;6VEZu z`pYJrH8FmXWwSkGv1unOe${3>PFB3axGZ)hw*Imk&LYW%9fHTEL$FK`ZI^TJ+@Z~45Io@< zaaO*+FZMX~Sk(xn>L%c35Kq!p@HoZUBAnkdXQbj>1AKoU$K0nbbJ#2##`AB9IXo3x{JU57 z{3=#eAgC@&%i@WMzI7OH*oPKh6+N+UOSrEom7Bm!u2P(-EmEtu$ zN82Bo4W70?n(;37r!i047hKzKWxmUPNm;SmejnTZr7WlI|0D;vwqL02XZXR>_WLug z>=)YguVbFJKbLWBU-&NjrDZv8`^C0>{52uR{w2AH0sP2VC3lW4C`kc-sCj#=F=b$2@KS9LBZ%6^y&=7xxhV z>sU_P-(CP*+b`Dk4>C{NKe-Tim-sJXp0>Y^ac%!5#$EP{%8C-!|EDac?cY)iT-z_v z_W#2?Z9lC9co+K>%+vNqF|O^;V%%lFr}mGsoVGuuFK}(YRNLRhJZ=98#=F>mk9pd@ zRR&z!FJatezoaZZVf{z5oVM?)0Iu!#)%NEzPupL^co+LSn5XSO%(%AyBI7RmeM{Zu z3+?XzE{kdNPxJ?_&6lNU`+Ww0sqK$pyo>!anWyawuI)#d@3LQ9mgRQ9nSVC1oOWPt z6>!^uRPDfn%+wA%&$x1+#GU{?WuA5*ry96+;26excEA~cr?Z@PU}X@v?LeA#;J3`w z4t&J8a-cYo1Nj4yuN@f8c+U2gfqNKt zInXzL4tAR036|3iRMY~u9mv!Uv@=sXa0TOC9N57;?ZCr~YX_cZ+~q)7THGS!MBwi% zrybZo6u5Fguh9HX^7+_D;0ZE^q9~TJQ+#&6u}F^ zV>r#QQo?nNsEhuhL*86(j(5mYOBcKnaPq3C!}l|j5sl^UK1K$XE$8K0zZ_5y$A?od9qLWcYSgYe{7 zP8bh7T;g;j;VFWb@4*(KEVV2k9fV(r@&%_NhcO&@@@K%9;505UT?)uXPUKn?`wU@6 zg2NEK8H}e}$>Eud=!!O>;;7{bW4`|SYb!hpId(<)43zID@w}Wv1)F)Zi|tQ6Bq}2( zv%cA^W~Z}X;(Km94(Jay{kX2N=*?u4Z^-cK2|_1#&L-g*1TVI*;6ySDl$;qnlhsLl zO{zd1o^bhoGK5D8G=*nAZje)O&-n&xMKS(4v9|^#`sw#;YR1N1wBa8adqtOr?|SWb zb?}gji#2{%hkq*UwcpiYwt83R1e_8cfB}97!-6y1$FM=Q%P*1gSyg6qGxG744>MFr z?iZ%K`=R~jtiT};yiS*2)q2BcNd@8Vo1(lJ{pfP&#5K_&vdMfCc9Pcs7N(OD zkvG$l2m6xsyFYkur;g>+8$f)IZ{pT|O4xqq$08i55T3Vs@^Sw(G^=`kI}N=ecpf}S zcR8MM{GF&|iujHTd%rh09}=-r;RPVW4FKE^2Twrtys_#f7i>OFI-aYZJA(@$-L;~Y zFUQgq9W*LliK}eF82Rvb?sQQ&dK;p6!W0aLxEH7FI3;5iNS610Ogf$(`&7j#7w>c7 z35M`6niFk=cd4!xO|$k(8}YfwnkHoW!XZHGkhKU&bTL41EZSggGca|V4&;z^0q3?b zZyo2XUCO9jwgWk2wF2sF&Iyi#igaIi8E~jx&bblhk7w0UV6L)loV$W~>o{la%J}RH zW7(V&oB$OW$tl5!tg1a;_9B+;VBR{;S-Uzudrd5xbAqQr1<$n3D`zsFqN@@f#NB-? zGLL)HLx@>w0rzo(gQz;1yyw)V{nbkfJU1U+SN?yYOPz_}Q~>jkeNN)#clJo}Jb^>j zTCU&4T(e22nUdnUpsU=v9^_1!UvSRA?{KVVJ(mEaT4s0y6O*CTdH=#oI4~icK;%Tf zEkd3(mm)<$mPMmqh9r79KoEmw(Aq13Nuz%U$RTSJ=Wb@+I?h>p6{FmrRQA=eY|aUu z&Zd2MnI44l43EB6x>vcG9KHs8?d24RVvCc4yA+FVfR8xk$cf^S*5dctFv;OXo$$4g z-(P08VPuKjyy?mNzsvT1il&ae24d|;J=K+sdaaGM1g~SkpFvQ@aq|8x-3tb}MeNRz zyfZizz6CKyp)TSg+Qy=T@Dax^IZ-@ri;q|EL@qCodnrH741W(w_Ln%$wz!e)GxZ?6!-+!U<%I+$I+}&J3n9e~sBNhZ+*RXFQ93k27 zpPHWVRuoF}g>OO!ry1dZsjp(r4OQHY2OZ%!x>Rdbd-+WcVHjwyA86gb1e63 zi$7pBUE3G&cL#>GbP0@I0pHHx46eXT0C7Xw5JN-G5zXMuP!DCUcP88H_QFZxPq@3p z8@CnX9iv&SxE`RYrpgR%7frnGTXeRge}~r3M^*prN#$(TzY_|=w*Zt4kM3gpRsj2+ z8HZ`Q9=CzZ^(c4jxX%@DM{dvcIFs$11rWZIb@!y?uKx=qcOO>C9QNcMh^QK;x@z2$ zSN9%P;apaDA1k~cfWs#3^F5Cpw+F!Hxb^1v7p*)f_#i8n_GyaqHnGAVLAvLLIENL^ z1F#z+v66=ltE3lR{p7z<=(Q~;y&-=#qeB`i7 z;@h))KOXCjprbu{WID@#jS+DK>V9@ub@REN3%H(-LoU%mjkz?zLhYJM8@TjB0B4NG z=Fne2DUZ=U&fK=jHAj~o)-}AXF(~*;i1avzR+;u(uv^=St=;Ym6<*qU9=c6zXOCki zelAF?P!`A@7nfcrOt2MjMYxN?_+gyb!zT_~WjsU=3gTJVnXO_m0ahOd`F>FFDQ?%N0qk`bdq=(Q{u*5Fn+Z0jN7Uzo zOI!g=tmK))I@rt(p8t(X66|(ek&}(?1>dOTH;474g*{mc(8DI=xx9Ot5s`*Bj6z2B=h~|p}ec$WU{#S zR?Id2cUrDSMvC8iDDN5|IbIPtz#@)9J?T5NgLJcWIDOGhD8;x>r|lT`qYocr$AlCA z7{`vd%X%!+Zmt+7fw*d0jtW;knZ4%9r#N+w{z>_oMyJ8olMe5z(xx|}hqD`fo3-+@ zO@J^_ep3vz-Xrd3u}$aUoQO5+k%d-yfq&-b=*Phkci1C{r5=TcX+td`onM++TKAo} zo_%BkF8Z$BZmEQolW=7J&GSRg5zFW1;o;~LkKDr%J(4FAHBR4y)##s2-<=)v ze;%vo`|Nt|&`h~A`Gz^{zaGENQ{G|6uTpztJy(x`|4P^~F1?dG;Wv-9=wCT5wb2q@ zOtHLr5uf2Qbg^GeJQdo0B`-93x`O?o@8dwg#G4QokE z(~;=z-CXY2a2h!Jf#V|{RKCf_o>v4%^AWXK^zUMo*F!(y7VMkW!~afu?_!gv1F8BR zS&!&>OYz_O^FOU^^dB60?vt1N|7&l18gY-2uq<*Ps*b?(>eK%p{rTU9_#>{=X`b-M zNX?E<0E3@u)@NN%y0;z+cQ3F%ReAv>+SgBUW#xT zMY!IQJyjZT_(_GJ5eIq4h4*=D@WnZ<%-dYn!WUxlLI6&j2n!wmTY>m&DBygSXb8Mf zZqaiB7w0klSnlTXTnblk?xEb{`dIWpfZ??Qr{yvJcfl>e^928E?k`aGdVy`i85;O! zo<$wGtg|9-GvJ`g?FAOifPRaf7dSbvxjdD21&_gNGsl_7)MQd;+3gjXbVoMBT>|$A zXIB<;{+YvYXFkJM1=f}`-YEFbC3jRIbIuXYB*7oayuBio&Mjm8SNR!V-RG=Ai>l3; zRw`u%&nisCzhHY-p&t<~E4Ju_yzO|7t~3Vsx5)2d{Jny~`13Y-H4T1?QjM8bKJCiA zvn-WX6wU{KxHSU&tz}=KF70K*2jCT;0t+?$nz+70k{Moh$b(-MsLDHh>g1;sFuL1p(QON%MLj36u+)pdY*{d^*VMP{w1+OeB&F8YC z%h=XUevWE3qMAxui`Ju#r}p^>@@Zx3QTN}7{Forik0^fw{E?8f=&C+k-{kDF;#7L9 zA9F@!v&;rRdsqqFPcI`He)=~c;v<|=_=5=*bWfkhtX zZ1LEcpStEd<&$Sc8+n2IqT5b8^j1Xrjq zbWFv3)K93%B3a7s9--V9LRIjMH7Ne~ey8FuSd0^Didd-Or*Y&h6lxgZ<`q9c?!WUsNo_xiB=2sL!qY7M${vlE(sP{=h6(?EYxoYURhy5<9$L+ zG_S0f3hI6`pk;6V`2Md^BUUP=>V;~e=R{|9pYdqP5WOhnzRJq;PX+Y{q3+CQY7xCf zI}n9CKoPwBljJ=*FwZ{^)Z3D`4HQu`y+`X|;jZ#$%BF()vrtpY6!ll3-s-o#ALo56 z)bnxFN1FOX@;v>Of-)qwi9P-j817Sw-)N(D6>)R#j28j>SHeI?XVSQFKDJL!&8w>(=Y)~rSmDldZ6<{Lz_D*L9$Y!Mm7IZbn&9 zlLI;TK9OW-(J{$M)=1ivbVZ+hGO(uP)1~w<;8ODizNiE^B14{5dZ_dj(EMM)<$FI0b0N0xg zU-MiI81*uI#`_9jdD1KX3MweBL#bhzx8-uFl0ZH^Mah8on#lo+a(ziynVJjsp%zV< z44ZTIdCw@vK%+~OpUnFdHJziW%gPU?8ni%Bh11G!!G>&=P*2hPe$z@kv|CeivrhDS z>7b@^@=wA(Y!h}^tn=lhPm#ApQ<*sjQ@ylJQ=esDmgc2hnwnium*J&*G&MGJ1|%P{ z%MF}`h3s)nt|; zsXFA->zcY3I`iorP2Je%vb22qKvPSz>N4`_GffTi&4A>WnmVU^7WyI{UBu7N%jSSe z*Hpiqo!P)C;IlKYB`0(klJv1EG|?Dry?4 zEO4t-(@UCSd)4$Fwm`PMYWjz!X8R7NR?`=nn(VtQt(p#L>SKRhMm1T(Rk_{%8Ia7> z)XM{Al~hx{qTtKOqH3BVl=5W=9n=*2QcGKoRi3dgwKU+km@l<7SW{v6QcEK=RSaKh zX|$qXVR}(5%@ayl7)Fn4iY*MMz{r?|;q+&rRCI^ahnhMOBXv0aQ&Y1GE=wCuUu$Z4 zW?jZ`^5IQOj#6j!3`k~a>U!U-lHpXKsYAXwpvn{l&*l~lr+Gpt&qmPze*Dv;@dWz4 zrnv4W(CsHE3p|IMK=*6v^`wKTC(y&1`ZMN`6X=(k3S%^$Ku>FGL~sTqpV!pBq*)~= z(5sqye83z~Zz)PVJAq1Y)yTf^JW)sQXo_PtmTnxa^4PPnv>2BTb`Kd#{O`>&bwlRC z)UkA-ruM+Iv2?Mf9)M?K=`uyZ-sOd3=^mk!y@@mc&)aq+PNglHVtc33ZDTl3wb7|` zpQeh@3r?kF4NQ(17<+-YEAtGeg1U1K~o2Ub3px2Q@;zI3+i@F z-PmU#s0S1UuV)vYPRZkxpWF`hsP%27u=`&5Sy|bxllCsYB&Zd=G|}PrhZ#_3Mgx;YQOfX(@HO(Oif)~RS&8_Q(srkFKr<_$Z4Vxw6ru4#T`J`wG)Lvp^5E2@ zD5XzlEl(L27R*a(qbZ6?2@7?(&YKfF(c4DPYHDBJt)*==^bA$*+rFQduAn(Wy=QF9 zekib#l4q#Ae*~W_y^y8|#d&`yT}9VuYR$k8O55orC-1A$i)j2zRc^EIob1)KO;gWQ zpOd|YKG0NK?m5|O>G)YnvMsl?@5QuVQ-8||_FYHw>Qx>`a6N5PRLX-{^ODxnLz;Re zkExf0+MDuN#Y>>lXG=K>6mz+Q=P2rz*z>QaRd~mgs59ju>m*RuXeu*{sa={nznZD1 zgyL9pxp#zmO6y$J=+?=91Sh8RFPc(1ztoh{**COJET zKT~Z&t*1x)d7ySENdp(lw1IXBrTpAL_d3*O?*`hfsATSu8|fpV-jiOwk&WT=R1&us zs0dT<8Lw2cV&#MQ_l>@D!Yz;ze?r3m|aqKJ!Q8mYIaVr>_)m# zC{@3k=5 z78h08cb7x)tZ}PD@yu|WLvcU5J+8OjPG5hUv#%|zFF&rVYhL=LoVNiNG^3EW>@r1N zP3M)}K_!DbAQ?0bcd#vcz;!P53S}44Cwr&x2^16 zdP!4xNu6c)(TGhdZ++5dW%tvR%}goJ9*Fb$0h%Lu>{)L41GMBSRqkpUUj87ZU#+N> z=A`l;(MC;$Jm-}En7+J5<^9&PuKXd|bgiP6c&{)2Nt}hB(){nLylK>#^HYjwYME!1 z|6%&JP|CAM;>tZj*J{aIXt@6o+N!B5&Eft>oxDGJZu0+(Zqs?Iy*K$EqaSPPMen=* z$LVoR4NQ91|8x44Q0pd_CWmL>r@0I*Rt1VaoKwzk6-B~cg-CM zo$}H+)@zA-5f4o;L@1dK}c3!#;coO{^ znl1VO&`0mUVluq~m?9C5FRN|s!8F++vBIf}nWWE3nANrw0f2ZG1SnzT(?L2*ip{qz8C@UUXw z^fEwi;I{k?{L4ayQAkbr*CSf+HH>0>2SX->cpsYsn1o+dGhP9hiW|Ra<=MFDV^}9} zvcMSv=L&2P*bJCQ%LQ*2xL)8DfChGCtl>_;KJ=h)+70I43HU8~)c6eh?MIDi*k?a# z+=c!1R@sxTmiwF4a(}Z`N^PW1tAC08;rxF4Xp`WZ1mB1=+tWx%Ih6G~Xkd9}@f_!5%}tZR_fjpwX)*X-s>R@YsTPCprCJQWmufNiUaAE(tuWd|vd!RosWyY} zrP`n;50LMr+6=yzYBTs=YPCqNHuzp@H6oJ(4&O^{6#hooy#wza@O{!I;cSxVZ8G>? zYLmhDQkx9Em)d0Tz0@Xy@1-^wd@r>LQ5|S(ky2Zv7F$Hm7K87lwh4cm@V6O!FSQMt zna}r9k4kS}Z|0WQcps&;6(@S@jD7=7@m_1*oi_paw*F^$cbJ=fXL{2ix!JqR;CrTB z2H!dDGWa=vmm$yh=8T$s-WkS@0nd8xF~*c1@IGWr34ZErFg6W1=zUx`dxg_%)a0B* z&BkVoAny5jNe`MEa!Qhxo8HRuq({vq!RjQ#*@}`k8{2UxMtv!!twbYrP7*G z-|NONs)zgDF*f^7^=&my&7I~O=;3+e1F7j}Qq$Lk|C;&NyqkTy48EEB625)pd(e0+ z>kFUP04uA|-@J@8Dx zXM@XA=ZQ>{$h3$|lgalCEh5t*GHoKWT4Xkg%xaTw12&4xMv>VhGFwDuo5*Z2`ILT} z$ZRqB#BiHP?h?s+MDih#e9)*FcuD$$#;=1{0zRGf-Sj<1pZslr)5>>%!!zpRQfjZ1 zdR9v9HThipS<$~2`s*^D75y)X>wrEorjZwFJql(Jt+DKA>&BVW3Q z;~emCgiC}oKsbYiGr+^O80_Kb4fb&KMu^O4kr^*CqeW)C$cz`60W!mn@;vU#qmOA% z_DNLd8Ik))*86m?#^20(LHPSI6wl|uhU|Kg?-cpTo^p)hPAWm|CVL`+8^Akh7HSGUG|ccc7O)J*;eF$n zewSvyZyXq~IlGfKS(w=;hevmHPK9}V=Ej^h&y{%xQyVlDjUIjy-KAythI@;LpDORs9KP+|;^8OD>?y&k?b-|OM$ z%4en2a?kL}mvUe7@D2J)s6`1NKTEzYxi5M6PW>ehKTkgHxhw0Oz&jqEUH?V@u}<{z z+_)j|FM1)XIw?TR@09+GdAs~1wCUK)ldxaoQn{n^L9X{InOXA zgJT#k55T=V__^Th_IKnlzBTVo&$IbI&YL1-(+{~HbKvd!^m!S>egbRr zUj_fhKFs+fiQ%Yzf6WVc*AL9dFY*4-_pST^-cbYV^Xo^%3;^}gyP=GW)#qeH$s@)>_Dzs1Y(+-Fn= z?=IM9l;%GJI3)QH;6*vd6nZgp&Mqtgyu5G(;4OvwjBn@NT{s2!Gr(^z_)lSz!!e!q0@Cj<%a!H~{eS!qI>i6b&=C<+K-V@~Sb_zvhafQRZ{t zY=KvJSH;WYXfDbcv`sj3%|BM(U$o7;CGUx%xh9{L?DBFSzQ=n*!9#(EAahIM<0APu z%9en`?{qxm<@Y=)aKv&;zgnCSJX%qUr-xqv7Sq#!{pmfxLG&TuvE+r!i2}z7JYD#+ zC>8v3gwrVS0_q1&l%@c7(A<7?qJJFD#2&2}hxdE$>9>Hs54=J6jlypP|E+%Oguh<+ z8-%|B{5Se<7yb_6-y-~5z&~@qZsG3{{*%Ig68viibPDHf;k*sb<&}oPb@bp}vqvjD z#&_uJ$_nB17fye0?y9O2&N$(W1Lw=C2H`XcrxBb-s@Dr=gK##0vpTp#IJXGr7I6NK zKV!hQo)pfL;7lFZDV(>3^ENog){w~&Fii2v6tB$h&>c19!mkki7{TiVUm$pc;Ohl$ zFz=>8gLVjhi{N_%?-WQL(eGjX<$_lTK1T35!50YLAozNL8$8?xb_jlp;JZa;k8lnM z-YNLol1n%hMlHNj3on-~7fyw6`U|H{@CJeF1?~{IM_{KwBZ)Os2&@y>AaK3F?Kp{s zSAy>re2?HyCUM*j2&YpxZwrSk@yZgfES9MdyuaXef{zotLGbkgHwb6Dl-(hmTZFS) zID3Tiq;L)hr&Bm@3x|AS(I*ytVo~rqfeixJ3)~@akH7;`s#9=E77fX)pRadjxh0G*YEhDr=}nmAVLL zjBx6NQzx7S!f6mrgK*XfXT5ON3ulMmI|Sb&_#VMK1@9ExNMkET8r!W9yh89g!RrKX z5WGR~b!qI|df}`W&UWGK5Y7(a>=w=*;p`F40pWBCr&Bl;=~BCNw!1E!b#529Ti^kK z3o@9$PT+Qdy9I8{yajy9;@on9V+1Y`*pwx?*^(=8jKBqolf(Qm0v8BeCvbNT`*T1b z`57-4I7Z+Cf$Icr7r0yC0fCe&@&d;Q9G}ZRED(I1!0iHe3*0NY2Lz{plodEe-~xf` z1a23&Ti^kKlqd26#|T^?@PI(d=iCD&JR49c!|eih3p^l@`pR4(aE!nO0@n$=2XA5z zG1eMS8?P9j80F?v^J?>c^9l1W=I3UCXRzly&pOXdo?m$0@tF9_u{V3~^A1W{l+>Q| zeA3^N9?<&!8Ir^9}n4VU6%xB_Qq z)i^<`!Fo9ixyMrmejk^K-~VROBuGxdsoD(6#akHxyi=Zscccq(_BKR*pZs**?{GH% z-hfvDKTKl0Jcse5oYw&x3pxSM%6t#7eBj>zugU)i@CVtS0~Y1}8&H+HK8s7;o5`j8 z$(;^=q-awzk7cvWJ$+cFBa3C~e5|>poHcvPS@W@FtodC(Yd$IeYrrH6+W~DQ&Bq$b z2eO8DMT62jSNKzX%>Ufq3AoqKnqM2hnw892k*N_G#aSS}H5PEG%QHIx|544QZufC1 ze=_@{Bo8F9-M?kCJ-3m)g-_^)iVJ{RLukYUF9Oc>#CLk`l~Ji{AJZf zz*&`70X{nLM!;Rc9{^rduoLh%Sq%S>$MBaG{I2YB>nDIuXEN+x&9FNsra|>^6X(kK z=atd7eSpd6+a|vFH>J_T@y`2R~E> zSb|Z)|KfCizgfTL&};0ZJV@I<^BXJQ;q2IP0xO#Cf?set2XI^cMW zNE33i08hiaVkRWc0-Qo~0jJVAfYaz)!09v}@C<4IoQ>a-m~9q zyo`PbcscC=yozqYEOs@ZN!QS=z^?@~>ASciH=yfw;9GD;Z$RUnz^|vff!_dV;;)_F z3w$e}iFeKK2mXCP+&JJg-+-kDf!|C&2L3}p-2Tu{fbRe_X(v4l{1!kH=kbpMzZKA= z+vqXiw*#7V2mKuQoq#6YMZW}oH=qd{dw@RxXu`&mfIq=60ZrWhJ`MOQJgu2{Yw

    @E~{yJPaNIzXGelqu?>{Yp@194xRu{g0);LW2k<8NBiIby0&jzN zz!vZ)@Gkf>*b3eQ?}HD(hu|;ZBk(cU20j6wg1>_8;BVkF@HzMb{2hD=z5+YI*WerQ zE!YYE0lowO1mA-nz`wwcKm*?}s0ZqU2xtH@KtqrP%ORivN3&>HLuIuggBpbfwG14H>e9PH2U13+7FAUFsd3^GAG&>qZzuLCp-90EFm zLqR9d8FT@Mfv(_i&TU^RFYJO+LZ)_})Bf5IFKp5XVB zU@dqGJPm#W)`4e0Aw0i@J`2`^-+@isdlfv#@8`iE`Mnvu3pQ~5d+-8y5o`o6ftSH6 zU=w&1yarweZ-765H^CplX7CpHl(_y1wu8Tc&%o#43-EXFCHM-w4evYPU;N$z{S$Z> z{26Qo?|~oj3t=m&;|AndE=Q{q zCe8DouYrGk{x3C!Q1dSQ$>}$3LUG|4(VWtfX~Xm9MGHz#%FfTr%`VL=ESOeOoU`jq z&%dy^WZI;h?EL72;%H7@3GBW{x116aagmF7mWgG><-5=C6(BKAELajgWN z7@a*YKf8F?0^%;&MP{N-UgTmMb<~eKby8D6MbYBYg(q1B78VaFEGUgGDD~8lyv&3& z5&NR%l#7^jldKp+qxsR<)S-gezRa~2HrJ2S7q`~+VO(M9xOw^csS~oGu(W^(Q!3%G zv*u-|R>Y`cOs$M_ivsnt)@6+vqlz(gGLDHB%r2dix`NI(@zqkkiP4gI`50bLENrN~ zlbrrAX(l#LC}OjBl4~Wq$~HVZFMnQfG*!aQDi>Yywub&EH!ml}WKF z+Rbw@&$Kb8PRk>Tqg2-7)K-SsHqzAAhk&FhuMz=)Q(h~EE!bVPBI;sJd96rsi%W4k z8#WhX?OU_tdH}x#l}w8&I{!Mk{>hi7WZDp!>(U|F#ku~?T8o%t;>;n=6v{a#FFz*Y z;N0w@(!%1}OR89XA+yWHntZQ1M6nJj%+F_L7@XUsRO%c*{*=o)mqmD z#99rD3hyw=a9GYeVX5ZK`YR&}d0cab60HS8jYn$(Hu` zA{nWYTDI@PaU%W&#kVe!HgG>cg_rdqcKRKt)cYI0XA6%i35pmGt_P)n1eC8Z;y z`Iu!l=`AeQyAG|7IuLOET0wU!SZT7{M` zry{qOx687t7I}BMxvQMSYZY2P-Wtj~ib#qJvh$}+oR=RxZXRQdWHp)RVk#!4ndM@t zp-ilF6wWKoiIz+o%al5McC@4$7A|jgL9(K;?BYc@*F}h>3r1K&2~YA@&Qr1SOG(yh zoj0bhNu{ju=1eLrW}$bI$#Qb$C8n?v6C)irFp|YG`*p6Q ze9XzpJei5nnV8tv1izM|YNn+KV>5a$!ek{>^DT+GhtY+_DN?B#Fwv%3pQ8%sxC(Nj zL$Y(`Bsm%OTTY%AS56?VWVKjZyXOm4TU+P1W$(#wtgY0t;(1SnV=bhX^=@c%RyI%3 z{GKC4^)A;&o9cRJ*EVWx5$!UDA5F5gEoM!K!S94?S->%iQWWTfYgx)ElrI%h<>wXD zzCkDwzkVgBpZLmOt7Vn=DqpMBm3YZ&YuMt2tF3*DRej%b)KWhCbxpvBc%th&o>EBDP7WxvEO!I%{`fBx-*J>@TFJ!JSx3}Jwq|_xPjK%X8 zvL~(}>6L?QFB0~@1tP&()nwc}IlJUcyT(>BE%3Xx^|6#_?Gjtbw7~D$*2#c`L1~jK z-+){}8Ivnff6QWf+0wk3dHH#z3zHMfA4r+5HZHCjmaluT;WvroL~_qC{OYf0^e&{{ z32Dh5;|n^o7aMeK$o_Y5R~z1?0B5vi4>;()C;Q&Pii6q13@&KI9%^v>0ql1NRk=1T z*~<@JgZCif+q*sc_(AEu>?sFwi`%ge9NgBNcR7G_7iX}~8wA~_d+=UEQ+sDXEB4R> zxe1-vm(Tqz;8uQ{d;76>9&ByQUiK#TUS)rqlD{dSH7|uUitx??$kPiV6}TmPvsZsF z_HcvO_#N+#BHb&1+(|9irw=xvWa)#h3#b=gb1#uwi!M$l z%|}7Ajxmlly!>(+_!PabLTBHDqo`AI6Fb=Vr(bK$y9t!{&$*6w^{8)?!Dp1^fPHw+ zfco(TV`GQK)k& zcgOqSqPKn}UeyQj$}h;P_U3pS@4fmA@v1$FSAIcW)qlsk`K>b#6|dTbc;y%5l^t-r zSqs;U5bp%;iC2C>UezndJK~XBKN7F%n|S3HJS9ag=wm#&^>mJSACG^-z7((eDDlcK$g44#R*0FUYGgmE)Z_`>&hDtFe}NfkXK^@$J^j%2beO}SV6q< z3-W5*<#_j)`m|}s8jp!renDQ1sT}WtCHtCsrm>cI$TidTL?UX4W^@1oD9HT5EZY+!{U`+kXK_t$GdLeC{q?1BZ^mkL0-)@9Pf8aM?I=|H3t!|{DQoizc}6( zZ#dcX$C}rOSAIcW&3hbg&nCz0uXr^d60iJ%yqdfCyyx9fCSJ{H#4EobujX}*w|QjW zrsCCnPrULA@@fv_c>A_|ccyqXw-K-Wg1nmNIo>;$+;y>dHUAT@{DQoigF4;=?(RBV zyqcSeSAIcW%?TavqsJ^a_Ca$+@yajAt9g&(z3%Uy7@cW8BwqOic{TTOyq(VYq_t$& zpL^n!UyxVx9mo69hsWM5Ud@BVE59JG=E;utvAJIsidXYz@yajA%dM0+ikP#tx=Qrac$QcFOpL!oZC?L-V-@*KkY+!x z9P`nE+(1jr-*w2f!KE3WBpfQ!jl|iPunOmRTZb}@=r;zkkX>AC$|4yVza;Mdz}A_t zsXttX=-SQMZu-q|vW)Il=fsuK^mJBSS$$4Si%?Sa`Rn4awiw^Iu_%Bwd^lzE);u8pcXnVT;S|R4)x-`YYUe@Qp|;;G_KLPl17``wY|G?1yzG?AW`k~8J1(ifuDI1( z)g{6vvO9K@Ud8^NU22^uZDgvcZK`i-MtB$7bi7vbGRz9ITA@UHV>MP@6P#PLLe!+jrYYBV$bY z{-!o*^p#P-b+E+ztOZ!K38v@4O`m4inh=a^OrMUGTx4t(X(Qba|1F?Bb>rGKFKL_ zcvl5-w)gT8^Ji^tQda)~eWy=18$wHZ);cfWdwF3P>N^hW$e1+NYagRZjK-ZoPNto> z`m~Mlu-p}vn7^EllQF}k#d~$J*Q(hyZ0fTuXNFXv)j(k#zthj%zWx}$YLH{b9?@bY zu)n9{U3fe{nTMdC_mX(hdUfNY&0a%Q-|HOb0A(~9=jpZF_(%=b=5srF)WAgH9Ix`A zI9A5zlY7#E>QKuJ5sl2qWU~D*y(`tv1p3ITjk;W}q!1l{w?pY_9+IYY5FKfa{ zy^h!RFJa%71$ny|-u8xfB;jpe5cbDFG$S*%Q`DL8?g2ds{<$!cw0*w{bV@r#w?XP^J8O!K4hp-`FZ^91M#(23q-tysJbO?=XmwNGJlPBfQh zZO7HO(+D5o)Mll<7+8A|_U%q%?kxavv*2Yep!1Q-6mK4s^3hqzWzzAPP|c0=q1@BC z$z{dR0_bJXv!D^UB8 zZlJ8CtFn`z=RhIwHUtwv3xC|N^$xiiU=!F5G*9de#()`M0noU61<-k@IuA`}iZ-XQ zYA&WTz~+E5a0}4cj+=naL~KeW$^t`GnUZwMqw71@dvOHE6hEa|mhR`-#Swu$xbV91 zf0_Bs^A?Y9m+}8D+4RGpl3TXD15~#C5GeMcEW+vU4N#eFW5;^G z$Cz|vKWzTOe!f+jl2wi+E)&0OPJMHtyFClL5q?^CmXrL`sP7Aa&QH|Xdp*!ue`!~9 z4XFLQ@qMXRCvUJ#%tSVqwW{Ax@WyLw;r!@0_ITmr+Wv?97Qf?h?WWLgH)ed_!;SCV zxH`_?jQ@Lh@%DwT2akih7<4FYrMDEi4y**f_U@}q3G!FCtzZFIOC?n}=YM$xW2SQJ zh6HFzn19j^Bh;s9{B8o|bcSz5^kY13C+yBRs&g^V1v(G9l<>VkHjqrmd2=c^KULnG zD?;ZdclC5`*HgQV8k$#9R9KQdGe6qR{*0PDtN&O@oC@#4xH2dzUk3gh%auVQf0cp! ziBjJl@N8dfj@HxjS943`&v?wpwHCQ9C6e}BmwI_o8BONi;<)>+jO4FyD?I-vy>QOI zwqoMns*8!_SHijuf&U z8bGi-=8=yB66K?3_d1)8De8oA!Sa|-K6)q2N6$K!4~;D}mbHCD*z^<1590}Q7O#G* zuh-aN3w^)p=)2I-(5=vupdUidhi-$)?r(=a4gDMRchE1O??4rg?69t7hyM;efV97Y zwugQV?FAK|?6R)MLcf9PIncMzQ=x<{n++A;BB=N-^RBOk{=oHesM2}JyRYvV)C(gQ zly+ODZwx5>yU>PQ@9?hG59oR?+IJ&p7pVBuFX(zGv@uj;e%+tx-7oa6=Rpa2z-U9E=^8rrCpK=6qw}Ign>79n8JG7)fPNvoZ|jAvSJ5uckF% z9&>=PB#OT^;pj|p9n6<^^z9$TeXP0HjJO+`ullH-%G!jGq`jdk|14nprLgIvyA!&Z)j$E`HAG z#&EI&a{F3h{_>5Ij1f+6T8pnhZ#7x7Rar(cdJ468uZW?ZVVWq;yP z94?&duD&UuvAFVdo)@26+r8W$2Xm6OUSWsFjY+FlexvI*B}}{?br!tb-j3XNHds&jK0(HoO496I%QV+`X$E!6_Yg9^swB-LYnf)(469Vz``X`6 zk){@cjcH0yo*HY_Mz_noG=t^I_Z~71tR&4owM?^BLz}l?dGdXUj9!(b*|(NyUh1V8 zEYEeMd3+^l9$m{czxUD%mgh61d2%IbW+$1Zo5QYaWOX~u>&tY-H?=ZKU7F=hg0ZFA z!mtD=jN{YVfx_Mvu$lh4X-VvvU(jENS}2TcYBF`w?O)5%A|;OHD&O(Fk&I0vy>`$o z$82CrCJi?}wc{ETVwefy;4CxtAM}Mu;_WxmjT%c|<%i}#1UbP+3CVT~G1W#*R z8n*vVoQBq3n=rl?ug09V&rO^LeVj={v&#m?+guQMHZEn)k+Pdx6Vr#!j zLwS&6HeuG7Mfc!(090|bWe(Gj5|!N2o$aF%KU*3`m;(vvcx~U3c>S9>CTrM7`MkDI zi0Ls{u4CYBj`m!<)|MxhVXTQa)91A|IPA@g%Fj{8!P}Crl)8AW?My81Ca;)Bd?MZ2~!s8yX6oe+0iU zA7xroJf5l0I_N~MUxZHL`V^FWD%TOdyc(gEM36bcEVBW=uHMjeL$>{f{dTRPgzA&r z!J$x@+G2aC`h^bAPEgG&>mzG@zLr|we4#4#EJ5$&$XyCFM#u+?!78vGYzGk{RlhnE z6oE^D_Bd<=Uw}q57`-zz6wCo-U8{7X`&9v;i$E77ZI8rdOhyD5;Z$~=9lSxxP9NG@5ah&W)ecrN;a3?~I4enR5 zWtup?LkOq%Kv_@dp-{!w30mLm!#Fe~n-`4FmS5O>w;ERbV|I>y*2Jg&U-GF>SKH$^ z@fC%veBH~%XUi&aeCp#f36E_ydn%C8$jAJrEW#J9WrG_qGj(=23tn3$iTA%S&StF8 z*5CW^2>f#7H#7nJmJ1evrC=pk3*G?RL4-j@7D&5)zXnvt+}wE?zWc4TNPd!}}&dS&BJJeFas%Ghgvzh3EmBRRTH z^Nv(*y51OlB>P9@@A{QeFA|!h@BYlN?qH0UDgVK_x$>wYAHV7g6>Vwf~ir`KENa2TH5vKUMy2eO>z+T;$(pu8uf%iJoYmVZ_LmD&FrDE}o@*nhlhG%pLWVJ*w9=QQ{B88|x-91G5&J}gbw2{ctRr}B5>Kkb2*>tu=fdpra6JEwT< zKkof+m4kSle{lUL*=P6vjx{08J!&$Br3n~aRJ7)Ei>J5FhRgmLO(HMF>8&RHqx3F0 z-Fi&K8%Vbdq%j7DZ(JHRUXQW;uuI3S#}s+#c*LZ}H_9^_Pxb16)?>^Wh~_IwHEQ=R zEzSGX?rpsZ`}Hl@?%UGt)em9zS>MR>*EJN*>NU0=91O?w@O;(Db|%~yKb+Q!t**kn z@nK!?`2%AR(y{Mxv;1q;YqW>Tu7M2o=c-l@iQlCDJJxnTS6PuX{1;ons8xc2{$$Lsuq?LXPQIaRIas!i0a?J9@6 z?%i=VZ%Tr;dn}2Jj>~gR+OBjaIbGXb=cVE5o#Yt+L#az6$+qj#ac#G2g0?%5bS`n} z)S~UWv|QV@WuCb0@{G{5-2+UUD)if++OE}W;FkMn{?o`rZvTW~s5id64XueiiBH2l{|Tm1k2IR3APr}; z^uCH*uzJ@gjlEqON!l!z7q|9n>rCP{N&aY)txex6+hNNo@me8W>iNx*m4tY9}}*VA5QUF9VK4NXaj$Q9@dQ! zbOxwgCjsGyf@z=#TncUhtHB1a73>75biww&-0P=gZ=HLeGG9)EF<$+LWS8d5aZ`V- z$eKOB>O&RA@g?rVWBYGA2A&NM&C8x$P*}p3!%8?ODmOZqmt+=};4|d%d#n zP7K(8f6XuU4&Wv)jN_}w{wF#IEYbNtmGudU>sIXCFzLN!eTGI1yXxHaiDjNnf_>rv zB=T@jCxJe(CU#xAmAtO+_|Qu$SX6Cc_?1hmM*Wk0-tN+H`O&*2azQh)g9+|4E{*=~ z5Et9blgW?kL)Lg{b+JjBzXy_^mt9&eDSVPi$L(kCYP)^&?xsuX8}hW%rQ_$xoRp%B z^%7rg(%j;u+1n)u{hBl*lbo$|ne)@^DOTCc?u1LgAM$m_SrOicvnCh1jKyqvkZ->Inx>95^lf_3zaVE(mBB_Y&q4c|NuIBCc^*;ze1&AvI>~!iVwqjC(p<=Q?MQ2xOUs_;GcJ0zryq{= z@iNM%^~yipQ3R^Dn~;A7@hVOikE^%W2XvnbojIGh)5`~QO5c4;JA2&aBZ)n|u5Elt zj9I|;TZ#9zG^bx}!ah{TYwdpG@hbheKVH>%$lC2N@5@;ylhNJ#y)V4Vn#O~&#rr|) zn{!zXE;p96b~*7_@*u*rV5Q2*X6_KgVlrW7xNuLEetU+nt@8 zj@R0#u(4MXKc2S*?;Sc`Yflo(fUbQR77&kZzhU17XsnX21aMuELG7d)RF8O%fXc4* zgraB3V)lD#FEYC0v_*S<4|}4@BAg0j_mQ@N>itNad86N_gFe2jw%sKzcf0?1AH%D% zwDmpgx2IrP9v8A@I0V`O-l5P)=%i4DQL*+dNH>bZ*4Z%9SQm_g`HRUXb;0Dv?q8in zUAW9J@8GZWqqDo^W`LnotQlYdSO!*sbzn2t37Rvv=mZ9VT(Af%2W!9^U^{3^1O1O36I)*XmasFyYz3*o>16DK>UuU{Mg^l zvF7`IL;15nG#;qgSlvjm%X^q^yt&wV>l`TGF{jD+&dKkD$5;K?dguhgh~M$J{_O1X zGVgMBMk0UB3zesu^xM*})q_13sJl02W?jK|`@l0B!)LO`7$Nrf#m;-gsQg?C!}ma8 z9lv{r5!>XAD?_1TbINk^vbr(cW=~ev#~3+~bx}apVQ0jG1MAL zo%`kX@-Bwo)~B#v7q#Z7K2MH%Ql@Lgtw%wO9i9#igU;qDkG%YoPt%S37t9I=fTCF%I-=WB&oOr%%r- z$SWOFn3J8~y~eiQ>B7ml3>zpn!V>eBcAoKoFXNozLOL4BSc-f+gEPF&U-wsVUuUc^ zp9pR6!a3OoRw#Q9BfAUVmv{*p`g0&WQRjXN|Ib=GwOT5nC>7wFt?3GkGR+SHl9n43T8XAsgqP}avJhmyqD$len z)3{V7GYGs9h}Zd7osZtTB_9%7`A|R59avkC_!&&^`t})2pZc21cJTYdEW+9L&ESCF za>}zCHw=W|&6C7y+hA-zSde#=;f?i6wk?GHHYB}EPPr4{)m&>5v+ge9|FPcJyzh}2(nuH1 zU51VNfdQ(qQ3=j}EP_$|j>pZPhWLF)`R8iZCRTqP8$)91kK3c#)(GOs;|aM0o)*2m zdzGA*Sd;qX(p7!R^79w_)=1DMsl7`S$7^K?Tb*$~5$_J}Yu<5GCVz0MADPsNzF-1a z1pXaP{%{R_b)5 z?=Z!xe@*&5=}&Sx8{+oypKGHxf9J!n&ZQBs zA+ob`kZBVTzvD@?R+=9zm|Z%@%{i+-zH;)ZU+xZUSys3|x2zL9*gu9xQ+*pVgL_s- zVfqs5WG*Iqzcb<2m_oLS$5O^tX^xS_wT8#CL5D*Rh1Tbr8xfwET4?|MWIr8^Ppl5Y zMju?7vC0hnz_GW%tmTR};kqkSb7*8LW2~=dh!>s>?alQ;^l^QNrkHw`l5 z&YrIP{qets9%fxq;dcOqaeNi^1OJZwe~J4QZ;wl1aS39Y^{krp8+Py$-*33OZ1bJ? z%q$dDHjuC8NJpx_Zoa4ATdBw2|3BAdm7g2`=ki-Fxc+lBYpr7$AeyR?#QOh5gjfIP zY|JK`M97=cnX9Gn%yel?N`4Pid|F!5mkXwK4QUmoFfG@wYaL!LXgjYZtwk;^HdoEc zn?0{MTC;U6mnT<7`C53wsXue>XQZ>-rE~I}sM65bLGL28f?vGO->oAb@2}6qf48pY z-z1Za)m;x)n;8jgol3ku*PAw@7N>POm7Uh<)J$xDy_Ehr3&hsvvhcI@C-FY1euURE zTi0G~`6uS(IYBvITYicAspAaqnf|=Z>NxC|joOx*w`q+?c^OU^*-D=Il#x&Aq6|WQ zdVzr;_Wh{VhsekDhoM$9%1&Sqm5G?-{UX(%gKEt@JA(hsc zx48YOZXIX_;S|R41^a)Mc}@D-dfp^7zOVJ`sAp%hJXuA4i;M?WBI8PUG`3L~$ES5_ zMRk*J2g|QhyLIfCKl>=`x63ClEQ;3nS)242tp8S5u{|l0#f^WVW$xQtnv+?XW8YZ} zK6_xz#;n_5QwXE)*&XV)n>MV^$TbIjDWJ(9A6%-!@|?=w?V~UC?hW#&$Y%)sYE#$# zhh&$OPA(ij^NeUtsU`tE%s8+ncECLYmmOFDY~10{Ab!iKy*oSf9(mIB2T-lK$%eB2 z75WR;%oRf)LwkDnF;Stva?LYq!>4auWO&xM3C|++oeQ}P%|3C?wz%hVN@qEGSs&1i zVf-)uqw@FLmX}wG+jl!D|1(>-@}E2>TA*_0qdB-_%U$iz#+i8kG0zGp?_&~{(H6>Q z=l@t4`Gv6?ek5xD6u0m8q~Cs_m0$ja=53af3iEQce@0cIclV_0fhv)WJItuZx}a^l zhkBrWW%oiGuqLE7ov7V5-xvD^(yrzjNL2m}1JSVmA)`0OR{c|`zdr0iACQxs8`XDP zl2`}&Cnh-958AjBKL?zQJ?{|MKj^--BU?Rz@-9u6d7z|{`x&(VE4?VRcIw;@6xPOF z?SCKnyYXKszZJ&uxv^7^3dU9{|77|O*H3BBwp?FJ%-`>c^vzx6JW8IDa}`v32NcHf zIXTgRXMW0$0h5)}&2g+g!bUfeLt@)e2xnDb(~e{o=yEdMs@d~wpdb2-dg9%B*1G`WdUJ|&eCoj5O_6{cAG{}4}waeQi5>O)vN z47RHygWrIa4Uh9bO8z~#ukej`_3tBpjrU!xA@tO!5Z(i;=m+ z3#)9F^RwB?o9X0~V$=RagpR{sGxat%7lzuzjab&)1gWl3vCZX-#M=0v19$9BXwene|*g7*;ZK%Y@N><}E<; zpQsl`dQkZV!xR?h&DMuT6;Afcp(ghBR@%J6xwXyiN(A?gCFU>BN;B4aa)c&E=kjG> zQ!Qj`d1u{xk6HYVN3u#cODm}psxxu^S8c#u*`Ge-vqQCm+OU*9#v0*VNzA* zRjuJlN5OhAQW?ixXo>k7rC$8plQlFXKbl>vYEfcz(3=Qa5k~xu$K~gmO6r9oj`=4p z*Py>ESJlNiq}iM_42`f`m;tQ`#dc9f<0&`=dPPHPw% zD|MicYXQxI%3rh#^blwtC|zzD;+kingQ41&GYxt;^mM46Y3uz3#W&Zxo(DaG`_gZB z=)Io*gWmOH&>q}>9Eu$+`z@4pld|C<=AG3Bw9WwQ8I&>KK zXF^YaN)MB~YvKsyaDNUIsmi1m@y&;d?*iy-uB)534Ce2_a@CkYHhsAo08YcYPW%}P zrhx@uDOd&4Zue*)LbUGL;w@ehsz=Vv$DVIwQPr5Qxc#3~U=pwMug$uDeVf8Ad$Zga zB;wgm*<0t%Mz*(|Y&@HoR9c)@K!vQySV#Gj&3Es#>OCvDdX|{K3*h<4r8Ao)5Vr+Q zdtuA{a{@wl`&m5aTUsD%nj7!}9RTkoP{=xQN)&9?l&SguyeDh%&o}7poH)JJ#7;=>!Lhd9{ghK1cJ5nv zmbx_J_Khw_rbdJjzvIz-Lt*dn$J(I~=O4|J4O3dl$mi_lDo?({lz``UBHuj&j`nQX8I`7_%;m|ahYH#N?QTef=yr>P=jv+`m5om-G96WRL|p||En%K_YubL zya}HD-}M|lrUx|}kGS{1T$+rnjH3lUrml@;*AKyu3BBlgh8P=l1*&*FRCGe0L>0Z@M&wdO|1PRD5~rIK9KQREzhoTdQp2+ z|6$8KasNR(JYNE6&062Ob>r;G+_Pm9)|lM52K?3dTTbKR3}{!V>eb;;4LLPV&V*`h zyMAb4D8k4%0++sd>*B@+glw54{+<|X>SYnW_$~RxYjqVidgIdAH}x@c$8Zi;g!z!O z8*ZOTCVsuK86&|APzsiSE5~57>As8yw{%kGl?^gbEu1B zqjP6Qi_Iob)rXqY|M+*oZ2YmhM0NJ}NoXvwCo?Zs7QuJHcB1dhV54zDr)jk{pz?Qf z_#!V6No{>L$KR+)tQpPW}ZXKb{jBzv~m`_;E*<$f%2$+o&SXyZ*>?s`5khNl&- z+_!YF!m01>OPNnem%CL+E&rcRd%3EVkg;kx&1dhjzJx>mdJna#CF=Cle$LD07QlYFhe-~1+R<(~tYbNRkU4Gm%K<#;R z?q%}R+2tqD?aIG4y1TTVO`*9<2>J?X^{gN*mGd_AHkoh=ihYd`}I?SiUZ1*Z8?db;?(Bm|*#KRYSoA^YbeC zxsovrsttwW%2ztqxtH26rZA4redpq|3iHzgYh3eZIn~LN)`XNN*HO5VJB-RRRUb_ zdDt7sIx#Cy<_Yv8StlT;zO|vSj^CC2^oq+qTj{BcYO3R^?3JEt2FpI8MP6L6KL3Hd z-BgXdbww|$fWkU{m$w-e=FPruwmb565OUaf?Rt;Yvk7oi^IekJskq77dtjJuESQ|43fCAL7-)6ARdy zY4>KnK|Y4UFJ9;G@-nmHyd0%ScSpIPZWFKTBa6Jw(HJ--irY+HN?cxsMvI~axzPf< zKw-*fIr(WrIE8V1E>AfX=jmw0y*u)Bs28srZw=DJUtD)f%-^@j)305g)Gv5@j8xxB z$;&n%e#hhTlUs3q$m;INPZuvxO52a-GPTC**eVhFJ7|f4v^K8bHuc7E+9T)?@ z<8}FpR-CU{N@RDG6YGv9UT4d9c=-yJ(>vsAN=L69jh`PaF3!u1PVinr2$We{!rlTD z*73W%k%0WhxH1I6j$Q9D`6y=`&#oi657 ztP9_sRllv+=hW(R6lS8A*Nt9YWyhR*m$KXG@>Ji;Cy?JZKc{=m*_!v46cKKEQZQl46I&0Mxjah(zh zT?`@o1Yq;0IP6@a@;J`);+UHt4#jQ9_=(r<&LeCjG|kVe9cw4f>t*mNua}!J%Bww- zU3s$O-q>EIppIPmT^|Zv1S{bh`8u*=%F6S1H|Z%K_xR;_9dX2TWXE!q$MLuq$CG{> zBg@5M$54s)NjUj`PaIlndjSd|{3vjY$;)J}?U*HO#xL@307mKuPH|*FnNyg(8jQb9 zT#QvOkp37)ltGA3=fP%zhM>8xCp&%!`}HTjE~$Nd5VCQ8=;!fN6OZbn@VtTjzW92f1!&atxP^A;$+j9}5kxWX*_FJ)U zHix~G3rFVdz-e}UBZ{m=it$mK|Lrhdp+k0W#dG%ZE(Avz{ zv&x|U4~Ad;aVE4GRN*67%m%E9M}m7}I^c<04z{)>PSBhR)fEf{Gr$6{46Fhhz*g`* zXvM^*FPH#I!4mKg*Z{VJ$ie6hbO$5B44{pJH-Lx02Cxmtz-EE|U>Ya|OTY^7A^0Bj zZWl_sI;sJ+SvStrS+jDg!_GCNQ$1_EH_p|&55tO!_3+m`1Ds?I;x%Iy#gj#Ng?0SF z{XoI};EB$G4Em4BD>$p$umweYr>um>3|dlTER@yaMDJ|>$#aUM*}1&x(M^Ytl(0t+ zzv1jCE-3X5dL&f0*uIm*{_Z7?io)Zc^nP*mYP6xabB3Ls^&YRBN6ha==()t{S;uT7 z&~r`3Oe!~xhur*mq*tiHvTY1QsY_F3o8)(_v~aFhY1z9lH=E)3?0IvkFsfY1=+&ja+DkvE z*F8!9vS9j?<`oqc7MGSVuPMmQ)`p>2Jxwxww`aqxEeF%zi}bGurf>6aW>rk(<}*_* zmadY?w@X*+sdB+O+>CUubm^L-VvOEXlCJCDt!+vCju71z`|0iXRy7u|?J4nhIOw|I z-NPR@*mjUOUbCpmd-J!CVN(U#Sh8;=}r;_c`2+B%b12G-@u z$zaPjF)#Cza(b|3l2{MSn~WY9mzgzyTf8~mAg;%>qdx~rz-q7&Yy*0cqAlnRa={|7 z3akg)K?H?$1!-6JHK1nf_EWC+#62`1c6-|N>yx~89=HFu3_kHX|Gfi!wEA#GQ&rzf z^o&2MSO>4CalUT zUsEyf5cCM1U!wLL=Wot8p`9{TvHLG${;~J06nD5>Sl%<36U{lZWZqnEoA(Wrg<#m| z{Aj^Yj`b+zzSe=hhi1Yw06Ju{EgPk&t|%BTHxT9_64kjJS|=Ipg^?`M>n>sFop?P9 zP1p4NkXOw2#8qb$RyI&`BwIgXa~%?FX&-V?4j99Is&SB=_v2|1ZX$>r$Uc_o(}B^&4&`U z>@2AGOQ5oo=R$ebW8Qn0jlG0x+3=+v-)+!ixV{U@9Iq@w?(JC!Eug)@KHvcU^@T(G ztoCJ2cMzIt3GD}%z~OX8Wrp!PfVrz(S=1a}x^Z^;Qe__391O+QP60*WQcx48@^|h3 z3ooG81(>UWbX_@!Yt$as{#U^vUguwv@qUH2!W-i!nggg#)y!5Xce{?movpaRt4ox< z?*@_I8(e;eWETuu5Y3s#VzkTzPeC^n=u3 zaGGvAHyEDhot(pq3+Kkomn82k$jVsQgmb*kHeD8wcdpsWTavV#ZeFw9lQYw{|A#^ub(&MV-T^plKEWs_)|UY$++K1utK-G@$7 zGV8>$F|th&)?b``l3lZPAZ+Rbm&g>eYqA@f|6q&CAcQ^3w}-YY!hU%M!=b9OHt@4( zUlw6yO?E>vj|5gPF*~Z-t-Qz`3x7lCKxi}QAZR9Z2sA=$k=@e@TDpxAo`(_49VT z6udt(yCgbnK~A(tn^1{EwxIgkFKlEbN;4PII6#i~Gs`sIQ=4ui%5`Jt z7f{3x{T-?{`xTUNNQig$%VfvI-;lmtE(6=qkkNzQg=}Q#0p`Bz&x7Ysmu4}a0{;%D zGIIU@3NOKNfrJMm`W7;4%6~|9Y0jKj*%rYkUgz)nLdw-I!??XKH7FZ-DFv-_u^)3ddz2Tqwj^E32LM zqv(>;h1I&D>iT9ctlBA2mJ6$P8Vs|DFdD0W8VJL!a$!o@DXK6+_4@Jh?beMs`1Y%D z8pAs`6g^I0&xPa+nK~;y@^HE|uV7xbH5$sF#v58cR9MIF>PH7(r}5*tqiY~@tPWRI zKV)B|i{ak7X1*FGjhL@7hR>Y-vTv*rs z>9agLUH*&&$x+k%DU90_)88x90Rh=ZBKyxU=(bH(Qnb4^Rg;e~o$zemQA|YBy?`a@t0I*3t?Ydlb#wq(EgY@ObDQi4^1=k+Nps(IcGL625^GTQ! z3(hXiE;71m1OH+me#hhT(#6*m-x)0^h!)%7MpES-lyMq1Q7$OsSY(`3fsAXBuM=U! z?|7VyhwUaAdt>|L4!6YoWn7w3?8~TAoAVdSL$+at@owxR7EMMmoZW-ae z2U-KT$cx*}tzzLgL)sg&NsraD_2tK3u6{Jd7RUwjHJ*IkUO~S4lBdmHz8sIs7j-Y# zANlL;%2z&N-T=ziBXRkPg{ytO-1ANCzmz-967zQg`T8L)UkSP^Q+~|}zYHk63*+oy zS3jS-*n}JRmfuDF}zk@unG=|U=Ee}KJcpf|Iwk+mZkA||rc=EI7&dklW z`c~bQj6;!aDSWScGAfU<_rY-G=gK{1;caaJ`5Q#InOuJs2(KY*FudPC1Tw007&evT zV`EJbyC8IGJ2Rr$CMQ~J)vzrXpUa2*G!zK>>0Li=nL4F zL9#eEkvf~heN$)0W*497FASB8pIH(uo*zwap5WFSwt8u{cL_o#k>=ShO??uJdn)HP z+`ANr*ZI4;e1zW?;@f=Bo{GBq`m27M&-CN9?*pycTPa!j>@VKyBro?S$jgV^n+(75 z;{07+x>uYRJ!;!6dFkNCYxA&l&0K?Wab?hYa(mz377LkwbUS6EP%S*3{^J47f?#Rnw$Zg}bd1;11uO7O)JMw~kE0>oo3Gy<9yu6hlFZw>~ zVxYV@f0q{~Hx=atFPCN&dmyOP5x@}0tcg}NKke-=3_`c|Bm-PT_EAV;u{x$~HUdEtGBj4287vWk4PWq>GN=kM}@z!jB?-?vq7 zY+U_v>F4Feji1M`2qU-H67%;|@^VfvFM;)(1>~g-VZ`rv-1wQez5MJtFIYvmR)o`- z;}b7#H!p~VOJ@8W>(5n2uCMO2pUuz=OU&PCL?2 zR8(eWytF&)0?$@W{d4Og%e=g)Ejo7^d3!pRH=dAYLFkVwO8(3 z&l8oP=cbeI`q(C0e+td&K~3AI>W9w9rbgF7q6?Iz1u1!#ysY){gX|;Uh(r)ywFVV^vDPAWOV4p$8UIP zu}mELr2*K#0U=dU`cfIWP@m9LY@=u2U~Bum*9N31+P8i|RoH&pS_$;ZWa zwux^Ye)d^j*#GA7Uff#^3ZlkXfNm;&_U2&LXU&q1)TuB7kU!(0jSme ze(3pduqQYS{bhyp?xxa|4(v0JuzCK$C3d8|4pfgH<@HYax&7zJ;yqUg`_Cn`?y^)& zIO#3}x)B*v?_P#7TncT1vQ{5@4a&ULykmGI^i8e@KsQ6Fi=i!0<>k*DS2_p!IoFVo z%}*QZ$r$pXI@A@a`qK};xwyPX9XMQTjJRmHtgorO&=elm2Z`rGGnA>9d!@ zq<<$gar)ZtJJGj`BMD>Ie#8Dca)f*Rft<5l_Yt3L&HYrbqo7Z64IwV=|C3`XSfbz3b1QoF8^|gx*Ouy#cvz zz*o{5pr;1dH+|Dvt^s?ZGECnylKPtq&IH;srSs#J8}T&pXzYD`yY?4*-#2I%d8e+d zAt89rtxRD;E}s%j6ef<<+%=dt0b)s65>Mez-IJaCY6P@^HMT zaK25in;*`u@l+n}a6diUpQ)YO^_0rP_4UIQ`{~)Wi^{_d@xzt);p{p=<>AKp;d1<{jouWd%?D^ zKKp#)?g+iGUg#?IS3lz#V(Of2`>}D5onOYjn-HwCw-Zh}SZ-wP?8~9LVCR3ay^X@@+c^@7AhO`G*tOo2kis> zEtI)YXgzc|^f{=;rY}PEUW6TII~|YZS~@-)s&RwP`tEAVUV622uCPCEi`T1c;%mfv zF!YUjq06Q7tz1KhM>aJ!{!l%z^P+GlQw+G^*p)p=WsSMV-gc9(zd>0_34H-o-TFJ! z&J*_c@^BFGxA0}P^PI4m^T3W@tPboIvSmhHHE}hEcEVp}QlB?T>N9GqADXLR{+?~O zPqYnv!TKz0HTVKV4qf5fGr*-_IoJfYf#yu4I)VORGMEE28CnKbfpuUr*bX9Hh!1oJ zL%}pq1TF>3!5Xjy>;SFk_`8BJAQvnG%fK4232X*#(CAo{Jx&Dc|TA# z!{!#1F2qM|a=FTdFyePSZmn%}iq_gxH|+YHU9(-`$wA^##p@v!AH$;HCa1#d2#7%PLR$` zq?486bOx!B5g{>NP*1T*PtJ%AdHfgN((g^BcIcZ!Imxl7+7Tz)-Ugy6%^FO5_3E}8p zefJAwd)mo1mNQ83k!)*_D+_+{I)Cj0Q$Xe-hU$0u{RTBZuimwDS4NrYfQBaF(=@wmK9 zs4y=xcS~L*dN3~>-eO#^Zrw>VHi%qXHxiGnWx%Av1 zFPN`;NpE3_({tmOd~Z-0Oz%F@yTYY6f^+BCKI|1)Qf21S+MFP*Rit%m3e$3XamIK9 zzhJ)ZC#?q)q!lQ-r1Iy|T$dot2T1do-H@hh2Q$eCDv0IQbqzz8@-(FBjQ1dh$6QC*P!ieXH$Q(#hxE2?*-%VdOiMg-&CC zO-wI@FN*M7w9w%Qa_2=x>HcvjSJ3IF) z16D*&#p4ALB`eyU~EtV881b?9iEJi&&jwu z^tdsBjE^JZk(J2Ul`uB|>Cy2y8Fz;si(2oh$0v|+awRfuLcacllZ=kf$(Tw#x-o+G zWy>i&=bl8yk_0jaOs1L3mm=pjPgck8WKE?$ova%Y$hsC;udRlxnS@;iluyU+WZfNl zEp2198Pw}j$ogN`n)!e1y#bt+#d+`l9{2145flk3D%C|+MMVOL zN|fj#s1Q*RSH* zZE0gu+Hmj3rryTea&M{S{;#*CH~0ISndg1y9A040Sx92C1J8N(oOfoPnP;AP=9y>a zozVsxLR{A0p{)CdQPz!=^H3-o?ozEMqh@CynRN9id=x`Sw!2Gh2f0tSR3<$~Ke8if?gFYx(eZDNy$` z{71?+y(PbV-4tvlX%ye$XbnTl3=gFItKKiH@@t&Pp0f`m@K z{}HDd*w9AJdA7%Vv%klZRoAT){1f{Wf zBbB8$RB!T>Ed61ieY$1IZ1{F;Hif_n_xJC?gKxFe@}RGq^YYg}MGVRR9ul;WR_QFR zwbg@ZpR)6y8uOD$=ItD#{h^$(e!rPL1yf;~`f0Mjl+wabP$&HE9J#qXZp1HUWA@HK zbh_w-@cZ!SW}}@;+Vkl(%Ds&AN^9|L{gh>{Fw?8nJ;T=ze$8C^;bcB|P1TgIwfp22 zUy(4xyDxu0K95+PmiBe^ZW!!&vV2>4=&7=MH@OiW8okXq^j?A9lc$N^ksNw|2)!RM zdc5C#D(lxxz6vov{|I_tIK}kLhR_-63gbO;pMMO!-!XcN2Fl#7y{L1bzW3H`ta*zZ zTLHfxBik!j;5Vz|H7wEDeN>9;_XlKm*u-&fbaC%>``HxNujOawrp9q^b8#1?as8Tn z{yF)qw^4?>(zt$YJwNWlF0OwULS^vlXqQjk{f3 z(eP`n`80kj(D-eaMl?3KbPGu5*FjHw2NM0SqVWPbt$;|c_Y3BydH8k86X)^QA&;+D z<>B9{Q91k?VIf`nY2r84OTqT2{(Z>fAFA^Ba#{|*Hh1E3{GX7=zgFe(-ZT%tCU)XH z#uYq2&H}4^o*(Z|^YCj?C$7syA&=}{De?4WmxpA-uMy?%CDVH)ao_RlJo#~Nu8Hf{ zYVza0&&6Glmcg&H*iinT!d# zROR%(%lve=gmi5wz3i-R?@!E6w>+d>j59xj?C!O~V<){0VknW2PUqd^5ET!lDH2LZD?tt1| z?+)l4$T*$%pJX;lJcj-u@g>`T1TON1UXk~}-r~FJ=lvS_>3BE5rTYt)?x{50X3|Y> z(fp*4&N10Gfi(H>SH#zzlD`IPBJf|plfnNL%v3%38?dH5-vDDjC4URP75sN#{8Gs` z!A19uXBnDPl4eejFS`34X7l&W{H=HIvO4&Ae|{a_A}`hbpIx4+yMIqYb^oyzUkA<0 z6=I(KTS)hRT{_j>r&Hbi{5ZevXEgb`H-T065?FN~16JL~fmQdjz^eOrup-=>*dlfDqud(0@!4tt3fv19}IvUJ+T)uO8 zhob1@LF1~QcV_Yz+ik5bAFtmP*U$S3ZVt#-H(xay`m(0v*<#Y4=IiHQh1AB5^PTI; z<83wN>*r4SaocL*`gu=&+;PT_UIpF&jslaf#a{<3237$>z!qR9@G@`!I1G%Pl_V{|d|)}y4Qv9o0=s~hf!BaH z0mLJj49o-;1FL``U<2ry+1x&dehdV$Tr z4&X)LRp1TaC@^_0bb)0+H?SGl0lW;n1{?v#Uxz;tXaiOOL%>#G7qAaF2ylf%G6h%w zv;!M~t-y=GtH2w;QDE}*&;u3&tALHbR$w=<4|pAT8<=tf?Bp_qIyo`678v7Pw2@ItRNtyUTa4?=FXTK6QabAeym0-1+P|wlA06|qs`mGJ=g;MTp7y_iQ}K^b9_jg)FY^V{-?~Dn6&MX8 z6D~+KRuAu$@`2uVIa2t}^9X(V}zkedMyU{uj2*_5ja5=QjVSx3r7STdC zHbTpEj4yv7+^*&Ghl~q1BV*SmPp9L!r(Z~{Tq;W(_pIc@sXR`((&sS|v|v8E7U&1I z0PmEb_BUT|e<<{%sPI2WoBYaqtxbIYU%}d#M1W?gt6lUip?ulaEVO} ze)sQW@Ax%x|6BY%;fnHOz2z={mq-4)p#GTNLCSYJ-q&klcB)YOzMkV-_z#rh*W#T&$_q*q^Fm|<_Pt! zL#d6G#?HQOl~54&d*nVR5oa<56y0QL-;?Vd)B# z$(v->$M+A0{FR2+!m83xJY7NUWq|l^0A=Dl7Sf1k@-xJA`pQokJ6xS5g*DHuuxUKC zZ4AR3OaGg*%}q9>v(-+%uNQ19Gx=s~8Q2Z(+zsaHm8RsPg3Y@%U-xoda5BzU=Hxy< z{XL!dsz)pMZ15G}B8Lrl*yhHIqx|k=sgTO$yZG%epl~&5^#(_r$b{4!Yf z!qcO>n$1KYvVLI5afSvzq%_HSE*J zIA`Dvt}^Z$3IhN)WX;OXh>%XK?><>+<73Bs>p#15`1gwt`Oh)`mi7$}b@p{h&)3s` z)DFJ9{$2YPDPDrNLj2!fAi`h8wC?8pvd%SS&iY^1Ipps>XoRNC54HxH=*~3!5;R|r zX_|b%aor(35_)csfRgmNg|rgJIZ?)iQ+je+B^uvCU6fN!sY#y}U;Z#70M zXx!5{qj67V(74B#>c+cfMkKvOTcT$*Gj1tArSt7kNZTnM+j(A*j539EWBV;&<)d@o zihL@M4#4v`yW3VhtsPL9N*czGWFh!m@NM8J;6>m|!HdDz4DNi?CeE2_;_SF0^(|th z6qD+EvssIFLAJ~u#*qWSVPO1Cv=6WZ=m3~}Cfk9Rfc?N5!1rQM+nfHH8F&-AxvMUl zZA&_s%srC+Upg3er+Qmg>E8sD#^S{~Ki1#TSub8UhcjHF-_tW-^5%#2pXrj#0jb6* z(e>sleteh>>a!g85r(eQrA)HU92W#qAkN!0pCgXd9j=$Ilfd2-+ z)IS-G8XH&h#WyLJ?ip1Yi>KdP`0e>)e)l~7V#MRFp^eD9=U@E$lbyXi-JLoe+t1mD z&p*GvytZyL)fru09_#ZP)NTCo(0{Ayc0)t5XnforXx)*KN?wQ7*}1glHAKtyOtvb0rFzmx61RW;Qv*6-WB38*u+)9_8|{hzHYDUZ{A%$$yZW?>XJl<-3-Ab?!=>ulx->j?&>T;tnhs#`2Y@FK2lM zJ&^Y0?B2|g%B1e>REXPd3YlI)VO562+AfSL_4e(Pwcj{Ms17#A(fKM0LDjgw|B3cn zV&zHO&*ll5>-sYz>MdJL_q9M*wv~mqp!>cP({(0VBXrGXKO6{t$%uk4q+ow-bdCR3 zU7kx;4^ZCiq*XeLD_K-Fzn;pf-mNhoSvE$*&$+Q}-C+BAqvB*wypQ8lpSLpylhe0Z zz4bnsEU55m6B|$4#3$zW1srclJoXZb0e zA2SPX{NyXoGT)#4a_SoI2Fv$18(hNTFHu^Z`)YjjV^}^P=aA+H@FH4VKL! z&apic=uXS&bznYiwl-`r+RDf4r~LXq0F5j0d|LgzPRY*1j_dR=aWA2L6n8V=`*y+g zbH2L!fi~(7g6gEUy^A!GpJm|N!1sdh2j2&N5WE7s60C9zfghsmzXmSz9h7JfXLF)G zW;*|0bH6FzYk{%AY*!Y^iSKvWKDSs-CMJ@9r+6wCf>pMr2VMa70SAG%fr(6F=L5@ujlfo5 z5AX``I`B>mMG9>;UAqK@Apf0(A4i$}>jzIf|6`57rLlPN{I8L9!20KT+2ED$^J5;k ze#1Z)Zo%U|4`+Kych~0=^aK0x)&XA%JT+Y^zH-KQX^i>I8t^HpO?)}MFOYrDF2wD& zjR;eXhUV?J4-Bm5?o{Uxyx%dSE}OiT<_m#l=x&bwXP`O5Xv#NtifGzAz|Q_;>`B9C zp?SU0Os$Oi{Ek*P>jy(pJOuQA8a@Y|57g3Wz-BdCb`S57Kr3!L_Fb1gVYJkCi#Yde z{kke|?!tjJ8?<;Rd%hm~q?Z1W6aXPKr~CUSq5tDC{rflc_pcuq8oVFRb$4g)`aatN zhCiJYjnFrH{7|4D*Ps37rEM{NUw^0%Y0>$~o^E%A?}+Gj%U~kJ^83@!eZlCut&WcG zr-W`_;`{1Y83_chHT>T@p!=&v_n7sHAk>^$J!@%j$iyq!vz${-x2dNQm1`qylFEN5 zW6YbMp^PtD85gZBcYTQEWnNU21T;d+Y!yFd9f#OzYyCtg41(`LSky>XqRjZK<(y_T(4s=p`?1@uHk@+&+J z5Bl|tsHz_(L*jK)LFI8FwrOPZzKdUF^R|HJg1xOI+sNB!%ERlOLaLAAJeVxGJg^sC z9=NhA%4000C?-o?IaE%sPx9-E=|Z{vJ8+8Y`+mNyxzNSEAkEkJ)BJpIcX8*XJoJ4l zpNDr4S3DFR=Qwy{O2hY!{CUy)T>O?au9wk_Mu9wSzI6|AB?o3J@}7|k9elnG6DHrn zz5$>OSP4{s?Z95(0B{%>%ffyuumI=0&G#NZtM-}He@3y|RXj00<=d>_+D~u-^s}!^!PSeeJj?tBny*POOCMhao&jdw&Q6%50%9B<1l|pFr~UJMl(~Z1 z<8T}OcpRFHO?% zXVu7_&%cm%+F16cAs><(VaeWfu-+fL*7*`9rn2(279JAD0{zIx7GN}-oC9iq^A-1p z=r&&J>r(uoVtPSe7Ch85v^GpboLhW$UAEtQ$;)(3tMYUC=D)A@1ns;mS)aD=LE7(CfxmNqzddSPJWYu%ipFsaFq)Y`pi}n{NoyH5<1@=5{_xv`>?74dR-xNF)wfr}G zY_lt%+lNbueAq_Wmsr^~O*Rp^yR(mNaRZ7a8Qu$CPWtP>7GJ-s(t0PNh2I}o=y_mv z+UFuWjU_IpI#nmZ@aDsQ4PX3K8ta3Hp{L-b&Hv5W6{U{^`ib`k^$u+qDC_C)XnFr^ zEv;2y{-ZXu@L6a*W3;>vWJI*Aef9@hu^;qv(0blzxq78%A34vV%G5~xY&>gg^0kU- zZinX2#5BvgljhN~yrUzfwO4L#cH zZe9vx8{w(>>vpK)6JnY_4b6kqG{YHPtNj^dBcN+_o!ERVUG6I@{ZmYLjX$4%h$|J0 z!;RF{&aT^%L-S{#S-LIgL&Pt-hroZm*^{I2bkRNcd{|KVo`6554#2(W`0DM(7$}Ukyq& zru%v5u8-;Vt=CX8^z;b&i_u#kLzxiM`vvH2uB8`A>`3ajJBJ>75KBK7{!sv>ed{ZUx4O+ifIm%*OWJojGpO$v0CsZ#BKOX z&^r**<1mKa@}tzWt7i~ryisnXEzOqo_FU#~J%ci|x{^3s=ozVq%dlzBWS_>F$+*=2 z<87ycv!fJULxud;3i79Gjvya7_AoQ}q;f5I7WiD=mO3x_3NQm7fZyXHdfw)t!u+jJ z0Bmk5Kli!Bw=#R1CBMv+p`twG=ROyY(}d(~mrgXi{gJIH#58Vq@gGd%db=S%u6)bq zM(3gVF+V@zc%2`&!^O?cDD>lOe%u}x_k(G9{n(fv7h{L=u1w?lF)cstM_k-T z)3|;N%8$FbrVM`E$dCJJ7uVleuD0+xKR@ngUEJ)fH?Obr8Y}bz6Si-*R!=(=vFylpps$xwx5}d3}-}_f;1+J9p3Pg8aCD;o`1J=bC?h zK1?Q1=VUTEWCqX%bOW1!?Z6)3Rp1R^>>~O*&<3moHUe9Lmw^4iQDE|7_QU|ofla_R zU@ve0cpI2VCz=N=1BQStz#iZg;1E!}1Kk2F06Kt;z;<8{Z~zz$rOOx7I*g>zeXId!NaT z?$;vc&PXX_QLO}HT6nuSkO-hZ_6E**3WgnCwwJ)}CzCu6pSuV40VS}dm*Ag5Q5 zKXyr_i8V3XUm&~3mm^ynZ{jz}y~4%Bm&rU8EHm#Cu-4O>lSzr*TQgbzT@fQp1ZE=V zZNN&PA2<~uZvT0KpJzuIa|UVY|11gpzoz{U6HjsN`7!>#I^XYd@)OcD;urpQ`hCq` z_d?*=n22Y;ht9lksp-r+{Vfu1y`(-l6z?U6Chu#5EZiT_`cvYx7_C4`kLAB){*}xl zjpAFJOTr$0Y@~FVua8SE9vJjzhg=rk4T+yuuQkte{kWd~Wc4t=ioNHh`GAF2;n|?o zV*wSpyS#37d0+lEHlqaNpV_kZrmiECwJFfSi zK>LS=MSK2;Xs=X9uc`N+LVMe=XuoGfv|r1iy&u{?JuKRt4biqa^sZ)K?_cxCeeS2v zeBNjuPt=I1K6HSxFDDPBw=}i}@bgh0dSXL);A!Hhzt-C~PWIl4s-S$$_n~*a6k<90 zGwQUQ%}`E;sZ-Wxc>CY?rMk-{n#RX%fo4!aj{a9^!}Uf}{YD3a4W{&*#+yUTdif!` zW|KZ2I%=%*I0w7*gwZ{QtZ%pNly^31mCoW?yL~>V-RzyX_*u2yn=?<9J{|3=v0eF^ zo}VGZfH2D=_xV-oyf3P=E+*0g$>BzyaEc_+3Ck}`9{KjZozdIUe-UksWbuyhIpQ7@${yj8Kl&Z(Y1Mu}>t6SQ?Z+qHx z^YV~u&ef!8q&FjNr ztF-dFw^uX&sm2lWwO&OU_HnrRkmz|^vfy+pU&$w%P$+_3-5z@Kd|cIZK?cx=Mwj9=4j%Z;(FUBKVOtRXNz2$ z#`U(!@#D_Jhi&skZzmL-%>Wsvt3*$MJ>So*11tX`y-)intvr7G&M!Nvi}>05kbd0F z-=oboW$NkQhg5s{@$ba#MZ9O15x0%BphSDfi{XqHrhj2vDWqdkk>8ZJ!eY{BEVu)# zu?!toLGBWUtBT(5^Jm-t1UTEL?Z=9Iej+!#&zaTL>-PM*t|0CtX4A%duUiXF&r*ac z-kWUROB?7}k=eKL-s`#i@~ni$yVy5walLNJZ>RSYcYKf=^+B&A3VJ8f1&v!K3;g!n za=x!3O;K7De%rkNU);!mFO=uc!_XbTi@<*1O+XuNrvOWU4qz*=3pfBA2GmFA18V{G zpIyLS;7vdcGXrP?I)IJ9R$v$K8gK}hf*za=tOWXj?Z6)30B{(XC}9~5?|2TVAKRGt zYN!oc*wb(uV{to!hxGF?`#-VeWZNhY$*Iy=T>ak0_iZ)5%fG-+3H>BUcN8Cw8>;)Bnsg=`S-M);@V=+v z+rxg3U4=UMH2xht`Nb5dRvM;a`@L=TjQpI3h|y1c#kJ=*1sP_(UoFEYJ4cC3hF^BS zXRo&GoPX!Sl^(gzAE4|vUKiRZDm(XAB|7U?aqYR4{loQ^od#C>h;_%LP0x*)-%$Nd zHditKhso(=brQn6JaV6#Y2!zX2Mba;)hjl2_3K)G+xxk(tXu-WpDg9K5W3qBGUY<$W;=b^<6aXQXr%S2do}Bu(`aZ(=lmN zc`Bb4c{+>oiwEX!>5zaCVtHzT2Y+ci2)+zCTD82CYdsEP__6B0KPO zr>FUaWTSbzAzS-q2uOWPqN8{6mRg)oURbL>W}C#}ohV|Mh8^obBm!?uqMlN2nLm>5yOb`2l`>$gkIO z(iC}*UG)+VypGS0`>>1a?-qtu&~=4WPZs%2Wmf1R?v>!j!PkQEB~_TN>#l)HFg%3hMu${Tli@>YE>%iN<_`7K*pbc0F^a7iK?Z6)372tK?C@}dR#z9~i z&<$(?wgY>B{lJ?*5hhLr=82i##i2;q%nsTY%E>U12Idf@|8ZMnGsyYRQ;jD|TLBc` z;>3GEPRD+Xo~hhVP{Z|wNix5kr$cp$sN#wp$_b3yWL z;a3!AQQ#BjB&4Pl5r#+0&-ZF+xdDMZq~9!j5n30YLRw!6XVV-~XCj>Kk^AIK`_lDB z>zK1??0vpjOR+Q_>shm5pmTL^dBO4H*=g;PqM64=)6chU;Lzmqz`gEjfx!jsGutiE zEw{`vG7`at_-b`!ZOetYuD?oM7kww{y0njjbUJ%abzN=j@qIJjw>_OMY-dnvjPd;> ze=X@M;>ymr8ax4vUPsUBo|f}ceXcxwKPa%m&|k=sASyt=gb#5xxL66 z{@VAZGAj=+-msQqpHUmNP8zHMPP?f)B0LfnwI;BF2? z^X}hz+Ws@qc^~S3KEM3+vp=R^%|Ifpz3uK{wfAn?`jyf4wx&5HIPU+uLXONE)4*QM z($(Xv{TFo(b*+^EpvE&BaEQN^#^RapcpQ0@Ph9;iotV%;J6@pKA~CSRRwY8+6& zOxa zyb-B1JWYfxr+|iyExx=3EE6B%vE?@8Lqo`7@R_{-X74X*O!8$Y@J8dY>EsKL%Shw? znRq&s&SY%2m`IoiOkRPH4QK<}f$#R9qSxyG*e0Hf{{NrH=>PiO`>ECcKEKSq(%54C z_v`TYHg*;nZ)5%63qPNK2k`W}z0KqDsr}9VGyQLEp?I&-H_yWO_T#@lh*blC3_$Y% zNdGI1#WVds_7v%VZ2i=BY)$FppBwdC$j{a6L^An_?+$zc*?DlUwY00 zbAr;9Ow?TaH=zG*>^2=U-eu&^i8LDPpfTHMEa8aZaF4CzYb}uu0GcaW9NQ<5*%!IEGhA^2sQ@%6k0t{ywSUx1-Q%gFa5y zHOXf)J+U<&J@@@8JNr}ZVq?IQ#4j=j7Y)Vr@}0f28^cVm*)Z%l1<)&7xG-o2@^C{9apuA0E&q3bme$&d8jN+=$!(j zt7l#}i#}%ZE7|gNvh!nO+4?f$`dP`R(zaf%MkYw6U!)!17;Q_(k9t4U{`P*0>^Ozk z|MLnB^v5)W+9FBs#&Vk<)aFi9>S=Sc<%}kKD_jW8>HhwGXlg7v4$b+Bq;X{<_%NWf z7T;`7>UAzZ6GrBHs4egIP+qMIS@;79G0OHh5m&JO$LcdU1JKlalN%B47UOUG+Hbv##%5mG(Wesg>7J`dv#qd(DAWz!0z< z7!B_X4ygaz{LlRVasU4svi(a$^0KYC|D3sA2P^#$pfncGbTDmnN_DX5HBTp7 zUyOCt?;$&L*g2CYFK;3%#Rn+pXh=Dr_Oo|uH-%s0{{MHh|CtPezW+P_zpOvj;fH$q zHgxL#7ik0B?)8mv<`*#9n;ijne_kj>l6(`|=bxPRjY=SUpaNb_J~!!mNT=Ul;rkSR zzcTvWWc0FBMw4WqJjg9zeqs-4m#5O|3}Er3EzQ&KgOAgeF-DX|FubvTYC+?+@xf%< z^E%UuVvCL0J;?U-q|J@*kPCGzxcc(d=||Jy%wL^d@C5iAo(+PvhvZ4H_#k`XDlqxr zFLQhPD`KR6FEL9iaXY`!&-U#HTqmH-{V7GN~IGdQ6B zZ$7UU2^%5y|06%8FXQZRkD_-SlA49dxI;!c33c=LYJ~f}!c;fMaHE@9bKu2dcwX%0G`Zif?f=#w+ffX&sy| z;QH3tgph6@>1LBoI`68Gx79sMXSP9OW4zVPS?upcL~bzgM}wSz({ zc8H34IavMi3UCuE(>gmK_EmdboA0Nf?JGqni5~eSUO(oajf$EgZg%IL*Jb&37xpB+ z$Lu@;uZ!}1;M9}2ng81BlKgzNk1;;y!s~);Pn=|zF6)B!I-VWMyM$kSKP|XEs|bj3 z`i_9N;oN%}mGk-iJxTKMFM-?014P_+1B{GxZSkrX@O>uR(?5paIsgUwK}Fw{uhtgy zT{a)(s4xV$@2q{e=huMW$L|*fTX8(Svzc>0F2H_Nh}+W3dwyFoRjU+{25U<%ulaje zSGu?tr*pn3S2|Mc?%-@4Y|)p1{lMG6#0Oai09FATfvv!9U?1>0@HQ~{A@m5a7+3`i z0b77wz+T`e@VycwH)j9s36+ZNKhA_K-Faia{U^CmTzekde|h)*$fl{s9y{J%e;Xq- zr&IW}NAB}_%KLzoH@dH^9v!MWtE{HCeEstE7WH>}i#e9lTl5R`mi9BhJC*g#l+2f@ zkd{^bXk#ch^D@_ugw;#fZc|Yo7p5<{GeS26{1o^H`2B|i{uG$LS1BgTlDm_KlVbAO zi^cCoH50Buc?!GsEqoCIYpmp zf3r)a&lTR~k^4MA!<~)2>f8Sz+y9UGRG(dn>nxQ4*?d0F?0ra0`y?9*N0EU^VA&g& zCcG>`FrQQG|KEiy>>HH_$Dc+&)c$s6&hC(jcyHm)X#X!@sQdQ!`~T9_-#It9xtH?T z2q>M!HUH|^>bci!n|nzg)H5cV{8(96hOr;pHVxb{R(k2UWxd{&RW^>+oR!YvT3M+_ znCqUJHDlQil4;MA{Q1IuWc^Owy|%c%O!<2t6!&U4UE3EXLgS$N!NbfKfCa#CgW9gP z|0_QWe+^Fu)BgWJ9|yb+%FQ$PhQ|B9c;fRcI2%N?)SOfF2cfy3xlU%!$9=w?y7kvl zKcD01=kYk8_BZ?Ack(1?T%Tew?SF{*j_YnU{@<60BJFI?WBWh<-QR^nLjyglHw={r zm3#hu0h#|c|M^Jn6HslB_3xVf!@IXGJnoVETuS|Krf<1N(R~8)ITiVF2vB^BV|xLA zIn^b|>%jW{^1#s3yc4{kOkA?8OZTY_ltwzD1MvJVr0pcX3G-zaG>5=<;^q$5f-&8A zhtA(GfDggV7489F#_vt63Kf&_z(nAB=IQsRa~9bGzD@;KKfXF2QiuK^%pm=E@Jz7Q zmxQG}XMx`hp3N)&kAbh}yX;D)WR+rab5f+$FLh@CY=GVkK=pkG&oW>rNC!PnKi>ho z2)sJl=N(^8^~cHj{|yM<3J{2!vqV>ID{dSPGg}(AYPZuLV>$wj^ z_r56KI8EMNFvnXHz9`CzZTscUZdN~MX-~)CaqNxEo;a?(!LAS)EcrG~deVopY1B{a z^Kr@(c&trgZNk{^LW@W4llgJ!W@{67N3*|{J#G`NRZk?X(pg;7O+ArqQoU~H-`S{V zUMBfaoox=WCzN+gRNj9h&Ihc#lA(xYBcU~wxt@aT9}AD+uUc)ivU4Eo_E*%_i}w{= zaQz?$YE2zmvU_BlgB}Wam=GZMznJ4`Fz^HdwI8UG}WG=xWk7 zB1gvW3iDfqcX{MKzeSlpY_vS7x@nxO&iFI}Fa5jG3qob*MCG8erBBzCLvxSKlzA-i z71y5Iy7h;mcDFk}Y%M%~rWZJR!n=0jeIq=ye!nY}eR5Rx0%iXlEBnIkY--IQ@EX_e068qXF*JYyG+w(~V4 z=i;N4vtz6;9Mk7CG*QlXT@_?_MS0!&C##C-%GpjC$C6g*EUxwG-l&{Tcb}|JcV~V2 zn6zo1eypLoo=m=F55)Y~ANUdXGv?5x$BiG0ddr;yX{)*Mba-;&ZI4yt&I|a-e#kxvAQ98)&0QwTzjyUFN^4%1-+j!dTicU z+%rgDc-qxYec(mP*g`s`v3S-8)yafYtMn7o6bFsLg>f@e8-f3eyFGNCwW!+ z?x-K=x%d(1|5)eX(Cr(0hLlcrvgSqc^UlGi`?@04q&#Fc#BrYN?Ct4xTjB>@9W*4y z&#P_i>u{0zap`54ahN*X#rMl_o~dlgU(Fb&5BY0Lm>Vaw;ouO!*p*xz(y1@YmWtE) zzU=Q`Rlg8O7l?N=XnVEQ3Q8lo=aXJC8>g>-Z@YgNdpLIA<({%ITH!zdgMOO zMus~=`I4o5Pp z7KGIvxzBSb_Y+p`ob#C5DCZFAl*Zzz-PL{!exa<#?pfSOx|yVtPW_>fztV|lmX5vt zULI3<*+aS+q~m|`qamI8n%X^1_tZdVe}B2kTyy*}xe@(-GQroJycFdlc^z&(!y9Ka zITG!+$iEfvK8E~#WB23N!uOEw-SKnZLefGy1@V?5yP)-Dx{rM4tTTJ82jkc=b9H!+ zUG)6iHGl8f2OPcZ9w9&Xq~VnjLAjG0Isz{M@nNb#qNzm5rZV+`V8ww=1}L zo_N-g z_26Fz_k;foOx()<0MmaeAb5Bma2N2UM0a`>;jZpd(w$=d-l%KAbAVOAlf)~gb@ubO zeEwi_S6UPQevA0-=U>?#ftZ(ytNXLW%LRa+0~OqSh_BGh+WBL|l}@YhUwnHOtbI`) zK9=U;=PCtiYgBOE$f^lUhzX%2;MM~N1_Nuj{d5f3c9?$q5^Wlr66(4qkCxL$z?AyM2pRTvD z^ZU$;q#4HuXKm;0<7_`rOz%s?6}>Nm)sJ2RH=}u)nPnCER306Gw`B{?uH|bL-~W&_ zXYkt}gJrk83O*nFr(oIY`@t>XuY$b{PbKFo674;1CdVQkO3`Tryv>-M5f;nj>_Sqx zKHLMRxZc*w=K=Q<@t&eT^Ls6sc-yOx+HO-xze<@C)Sg#@&nL|+F#8@W?*U&}NIovN z_+@ficT1T2sdE5@zdu!M7 z?7e(H6BtYTDc?I%8J|sjZyOYBkY#-H?W?@jP_8qz>~q^m*h;}Rm%0?E5Q9=wWEH&5v+K3f>}$hsBdoocY>b+Yt8ghH~X== z-$mW#MfJXqy4~dJc7!ytn_s?+4}xT%4FTx@HUis$J-~k8O`yo&H5Hf-EC+OM-X>r> zum^YrcpZ2fn79g?16T}n1Dk*yz>C0Zz#(A#2jL;G7+3{t0=5CWfqlT609Rint-u0c zCD0FS2lfE_fzj~of7=2ytBgUTeDFw zr@m+ScX-hOZVklv_;TQ*#u^I)@bS|*e6)#-;tkIx_WlO7i`m53Z-M89wCyxzb^r=3 zi9atJwczy9bg=XgP;(i~m;|_Q2S8{zS`lIT?nbdOZ8+Xn{L4-D4T2gMte z)z*=A20D|B2)LIB=NO%^ZdXq~HyYMPTGLg~IB(%?{EE|zMz-cDGiOBg;p|=)+B|Zf z>!{CFMr#E1F&*M%rr_j91jItw`3je!L&hHQ~10A^u*aqwYUI7jQM}UbP!~qrnjRcj`&fwS-GPoeh zXeP4tZ|H6(+6y@QC+ozi?@ep4;%z;0{qZnn8m~Q#{B!=)K1-Pw7;nzM+!s)NpuK~K zz-VZU18RTMU;9HA$Y~m0#LjqlQE2~Y-+|I?0TkDs$9lh!Jw4K;r$XOTl_J#sAmsNA;ZdnnNCOerSGzbDSm8qLsa%7LV!$!{&&`z1i> zEUvA~kyL8Rg|77*`iA&RG#e?W@unl__Lw(64{yF@$$K4%(pbDx&6ks{W78~--_lhohnM$)lYPF@650OiOHfDp zekoYKz83Ig@H8-g%Rg0-PM;2LN>}|c|9x=j#1ACTxbd!? z{JhK*oc!<=dp+|9YMh(IccobX);QD#);QDw#@??K`7Clvn|xi($q!PNtQ=k@^2>qV zuPTRcqk`iTSyz?g-NaQnlt$&43%(V69hjla?G?|;A>ZdFR}Rzr|5J=4h=1EV@GAiO zfHwhEyakvKtOACBt-xqFF$bi_O(zV6sFGU?o6rdxueI^tI%xU^*xdO<9G*_7-os!t zTMM2NqMnAQq51I>(3He8q9wp)oc2Kx)tXy5b*Kri3Oyg0aZSui^H*m1Ft@v9@X<%P*Wg3#ogXUq&362rNcm)Iq5_h`p-$!tjni^BcAC9- zJbb&+uf41NeHy<<_4&ZpA5djNV7;hxHAVQr0uME{Z>E$zE>uK=Yl7Jy}t5xhV&0?tIPva^oqu@o4{@0o56R3u~91b zft79*_!hqV_vC!-_1;`FsdX-5GiTK_WA!zMlA8S_JIC{;pmRH1h;`Rg@>H35RyiLm zT1}kg(G>Km>8|mY`n2N1_SLNM0IvaW0~5Q@y+9*DGHdg{?vR1(D+?c{@juJ@Por%+ zoco_X0*&7}1vDfR8WVhZvvaS{;5W6m0`2P7Qtt)V-v8vwkomLYbjZOoXOh0%rMn3) zc>euQ3uuSsz*=BagKgpp`fd7%+kdQUWdEM0k!MUT?V>}tM|TXYU&jN}_xt#J3}DY= zec#CZztJ@!>8E=924~Pq6>8USBtMc9U!QzGBYm|JuWP*TV&&xhvD;|xUGIQ4_a*k9 zar<|N2ePj%tfc*a-P*qa-7fj@?c>Lfjv!-Z$B7R1TIuhMhBq&8G~T|kpN)%y95Adn zlDV~D?MqNvi?1Ym>S);YS|4|*R-P7gwAdiHW-Um~NX|0CV z&zwS9(v=;6*9`^PP%f1CWQ=rSGP+XV&jU;5v2Wads|&#Ro>*N@D%fC}OJnmaO^SG^ zbmm_XOH6;qHk9x0`SU;7PU__N-kyCgcpBe}oJv@vRN9+ndfoT4Y)-2_XLjY4F3m+Q zu51Y3U$QgbB#s&z6s{qz>f`-p^4n#;GT#TXb*Gqy{9me<%F_#YSuP|d<7%%CKtVn+ z*&D*L59fj5r^B)nb*_SZ@4}SF*|J5vimh(nrSR;;pZ#_Ncz((QFWdQhXJ!8ula@5D zm(Bcf(A&b7rg6P&<;T6v<(u8R~x7Yk`^WatKcwPH$#~i(SU@L`c;r6s zAkN(5)dyLsNADUv^=Ih}U-!(P73&Pm>!dTDK%_zF!hY9xP|1lePa!R56Tc}x1&p7H z`g=dR?fqco)6BldX5B*J!cnvsFQ2W~$C7q;TI#GYGfM0*s znzp~4|29X@M#3wfXLg5Y%&V8FGh;-k>)j%COg&ZSL)2|7GB_F<=YZP3cKu&+Y5^Om zbk`Nu{`Wpv9vJB9PG7&#YlTt-{#~Y#$b+Ymjm@zEa?UYLT&%hI6iqzlC%LUfz3c|DDs2t z#TW_?m$4^&kSH_;lM!W)Av4h@9M|7 zifgcaefYk(+*@9Qao_~wx*Hpoi&p4+n)&{u%dib@V()dWyh|1iAO};{Mim(S^Mo9T z`~RL0Q~pE?U#I2F;oWnSkq1KwBqOttkM>a+5z7*_zn#6Y(f#7~B80z^bCHnG#Ds<4+C2%KLKB(2;$>1(< zk<$&DQ6tTqiJ`73>4$AS*f z=Hq)p;YU$j98mk4|NqsH5_2yN1@!-inGksW-){c@vLe{H&s;?B(j^v8zpGDgtNGpL zd-GCzpmx4@of}Ie6N2H*EBx9|EK4#-+%F$ns@$uzM0QI9{2y1{(dbx zF|EJH_du%t4jcCj+sb)_lX~ zUBCwMLF0LE`1@>RK;PNxUSV&K^8;xc^d!D(_@4}(8-CZoF@^6-!}n%(RF{HfsdvbA zwvd8G6$R5Pu^sUWGIi+tOs>@a?+^YT8~>L$4*8EmwEtb>)Am1s{ioe)I!&>sZ-YAn zQ}R)+vJsT8DBTIH1Z24cBtPw5oWGtrv)&Fb}K#uijs^4s96z%PTZ2LA`}o#4IT zW~_oSyg4u?nE>eAlL@&pQ+%9!fp=<9`_)zrWk$B-a1d|Kt5qZ_)mDvza*4|9S}^8UgVC z$MXQCwfOpdG2gcVsF36*Lq68`XQX{!??QEz`!$&)9wh6q|NqqG9n04a^6+KI_Ea&2 zP2USz#5ggQ?>eV09#`(`z><) ze_1Y{_QRt?-vK^(ZhY^3#_j(~sGi0|3u9>ie?7MS>GfH^SN~QTi)a0tNV#LXo~ym{ zp3mWT_5YE`mM=$kK0_>9_c+;Fk}F%q4<$(p@ck6j{+4q>nV+t=$R zrCKX*9@apk?bQw?pMQZyje5La5j(zVmT2l+lLd~ar#d`Ty65K4)( zOTLbsPuq5UpS7=J#tA;u{^tLA-Zioxt1Zb{VkyBr(m81-x&O=J#_s~g@AYNJM}_;i z!o6S7?<2Ywtp5AI;ixyOS1CIV;hCaHpS zp0xvhNf%l?a-Y~wrFZd{YX{vUlG6@bcvvK@(pg-4|BXkfSzo=!rv5v>Boiv{Jz?JX zawzX|S5p6h%b@Z~**r%MBW*AL9HC1v8)qeH9=D?%9-H+i~o8PFT0=jtg#xEG_5 zau_d`sY4NXKPC<5P>!$i&9&Vyc_G_*33WOGC@)KIV=F9A+mmskeyVPAM5Pt-N1Xl%GP8#eqOD+ZagjRr{+@o8DD2;vPk%lNA7bn zb=A2%RF@4@{-TX?B(J(>Y(Jnh7SHTn@(=Z`-VdYaQl)v%=kUAf^6Yu-`dQa$;fJap z%k$R2k9eI36S4G^@q@eGv_X($4e4|n2gA_l=J(1=fj!}+%|^$+E55iq*fr48?~Wa5 zh~6V%4B6&~Vrv{nkG@peYV=N|yBBr#nHboCD}(nw*8X&VxuG(d>~YM53!%HYzyFZN z_<1YS0&)6|^#gLZb~nav>(g%pTC%Gx;FBxuGFpL@o~ch4iN6IAQK0Od* z!Q{X8ncG#wi};eUddJ?AjZ2bIOI>N@MYiuax_^e64+UI{A7wW%KRj&vh6Zl!5nl zsU~g@cxgJy+v&(fEFE)ti0an{Pxb(cYtL9<>l`H^;u3jrLlNcC(3ZVI?WfI(^04MLcUg~O=>VgTqn)|C=FnEMY2{^r`^=2 zm2^sD@vKhp_IPzdqn@5R>HP@t%5<;YAEtMFEnGsKUbH$%PlU5O)Q5Dz&vFcE#kV+S zKhS)kKF+?l&hG8I3Hw5MXU~KEaI!l@=gxNLmx;H>q)qP-ojX@~pN{sIXUFI3biB0&z;yFpOOLKg2dAeixs1!=noE71y4NPl&(HNXg}s*;(21?9K@_gN#!f%i=ie z`}7p!r`+xMg^G`8)Y@w9ipkT$uj$Z@`L$C@fiTS@_t^r!o-=;=*E$`)4#JUT#8+H< zZv6z23;a5!E~l;UUqLxk7wh{InPezPA6lTSrJYt6&TP58Z^OFsKxf_O&`H0F)`P(w z+!1KSw!&q^*<-YFd{;{Y@zuR${8&{*8Ic_^mI;Rfwo@ALftJ2(W#Qa^oxCTLWiC6j z>b0X{dD$9hNscUhoe2M*(ek9~rg1V`O=}2oIgW&Kpxe_xnM$u`kgLvE zHhGf%z~*(~T2#k4{K|^E0FXE+ZVOmJI%Kx{%loC#jk4J)(pSQIgda4y9BrUHmH^iQ z%40cL0rj5lf1XPkWYC@YqCHp`3G8|G=M(C#Hr>h6ocsZJTAJT;JU?E3H;4QvyE}J> zvvFL0ZD60@GV*&Ru`_8@$FGL`%x@Fd@pjUwe0TEhncl{_%jJW&6REUwW0Z&Y&lFPM zPn^fSA&>h)9uHLIae4Y~hxd)-uMa-r(yUA4K1QR72j=&P+i;DGJCO3r`yL9;4?$6r znEzT^P#gA>Ml$yV_$KfG7(`svbp>#BnxCKB7gFCqUVa}Tz4F@xo&o+rwmoI}>7GRY zPK#v8&!MwDks3o<6`AlU(o0UafOT$oeD08+6X(nEkGuHU89;tMTS%38%&*V7xc-bH z(e?Ap{5{z_iFOJVP18L$zd&5cj?!S)xH||h2Y-R@Gr_+E_A+@} zqBF?-8BiCbZS3b~`Q_M6+V>?7xVS2ZpEKo`sZx4;v$SgY?p&{|$UK_?zH6!Eb`^1}omf;J@cPDABtiMeZam;xK9sC*N7$ z*vNBl_Z6HCsQ6<6l|{kY?4QX?`u%@_TfqMtd@cBGuynTK-3mU+cXU_sZ(va3Wp)8L zqph+SeaVKmqYA1073)Kz&%N}HZVBx3y*$mMl^?u)li$C!KT_xBYm8A`Z=dA%744ZU za)+YD_4WfV>4+#H)&*B2+6Qxwi!0sa$Nxgu#iFq~(@lztZRGgWl%VAaqM`cx@j83I zE3W@^(y2dQ3C6b<(yycLbNH66<320nfPf4n8$ZOkQotTyKkz0nl?I&$^a7iKmw^4i z*mX(L0?Y@N1HHgzU<*ahqbUIV@zp$HN4jZq{Q z&JI{;KI{Kqp6cZySx~kAze~^Su`@pt?CVtaT)x>Ed$H`Dg`D1*tW5W5#QXmb!JF{| zqCOf%$^o^%?f-r?WF{Ypg&|bK=TLlVn}i7stKsf#ulU|V&9jxyc0g$@zJ6cK_icdm z`Oc7!=FWW8J;)C0@Aytf%>n#8U^u=p|NhSt(R+p+(Rg!&_!>v-UPJxeicBtfhskB!|94Xd zg-IT{&(~;(D~ROUe}Q-6I>(wOnsZh=pMmnwIIDCP*V-7qgf^~T>l%LhX1-6QFY3<=|{!2 z=kcB&w^t_kN7~C9huB85WrjRnOVs42O<8wP%N$A9r`)A@)!ju7Jqbjfc_wne~jFY6q3o{9sdLd=Y$U z{NGm+q3}RxEA7?Fm|fR6ZM5DZTiI{EeY10FoA_Navu2{bq|TPa_OGb_TnjGZL%9;qh}XxOA5KjBjIVRP z4LgUl<2VD@^!4ALMTUeazybQnA)tt)O$Fuw?M~`kl<$iV_5a%apO|H7_(ueO#eJs# zvlVU*PVejNb%Vflid>H@v&q59ve8`|`V8iJ8V*CZ@5FTHDY9&gP2hRtq4btUzwhPy z?3&+A*MBk9^`wdRPwBae6F+~_Z|`uIU8@fYhF4#2n^=9-pCr$opZWKxy&ri!H<{;T zTm8n@r;yH9<9@S>xbk^@5Ih$wznJ<|2e=!&8eGEKk%lYLcS@X`Ut(Tmec_;tAcDpZ zj%!c00lR_MfYI>%!2$Ju8~^8remEnlI{W2IXW?vdk7~w$$&upP^LYG^?|WL-)Az)z zY%Frp74HdNQGTqKgQVQcKi>|UK>hbrjQPg59f5DbMd7%2FGQ}Z;oIR(J{NCKhO!tk-85$y+%iNg^vE{9OxP3ZLLP?Bt0nm!OKnl zJw1#;73=}t;*~w|fz*~zI?vba{SK8?dR2jW<};GXX)fLEX}Sgc=6RK!IUCzCq=!zz zT8-ZQ^tOn6?9I*>y(qOcJRb_q_eHcS`}`Wxj-zI#UuTX{j3j9R4oT{VuseX6z+zw( zFa&G^zEdIY|GYo#Lfrq`X!{?2D8K)|Mr_5k=W+jkXZ3HjICkI}Qw!t4n24_LS^wUY z)4vzOm*1%2OFex-eC2=IzuyQn;{JUb5&qg}G}yn5j`eSJh6{23=6$=;-y59~^lzhO z{oBh$e*eChzM}rEe%{21Pc~Oj|Mq;%@87K1xc=SZ(k)5TsegN3<@awtFL8Rp^>5}Z zmAwA#`HwPsDU?&t5ujgqCD_E8zK4NQ`gtVQdBznwtEXb|tW;Tf9%}&Yn0EEZ>>d|K0;W zi|DXq`E6iR$f zRC3NrC`~{>UH@O$uj8K=4y<8+UEfgZ`)9aIl*Z!4bHBXzI%W6NH~;d+QLTMuYXLL- zW9>~%1HSCi)ar8El9etksY|zr2P(7qt6m87!tn2Ca+XBts%m;{1ntqJwzJnb#vGs? zJ!5pOeRc$+4L?sB?trfL`?(^y4gcX}R$|Bpwvz{INvAXxPd+YX^{Lbc=GJDew|&C) zu0i&kJy7n{N1x|G^6Vx9Y_a6FKwD{4hB!@sXU_mXCE}f6cy;$SxYgaxZ%1Fbfcj1Y z=XI2}THQ5n+`o4HhTiT62DJw_W4-e?43D;-dmC+Q@2!D$JeDkh_7`H>RU}>iXqc|8 z#}?H&2{B#HCMo@DOm}&2XIFXc`rhvH0N&XRS~Y2;uEyt=15M_^X?PzrUo@I4%Kf4k zk=3Ojj9dpTbqGU2@-i>94HZ4cIOw z2O1+aFY)@V;B*~dDRbs`xB!z>`iC*GQe*`qUZ3!KDBIJgexk8cVVa9S%Zgq4|eo;To4Fqaho__wDQ+?AQjmp7<*3jbQEVkj*hMd{;T<^ZTsuojC6Ko#31K zowaeT0Y&#;w^DY+Ry$0_=2*i0j?|vu=Tq7XH7T_#eE%#U7e2&wzm0syB@d@@eSgZg zLGEyIv;CpI59G&vpNl&q<*Ap!f|Ey;B5t>Ph^s|k?E&!ZwjxdEWhYy=jngp?ar>6U z%cf+NtDMbM9-r#Iy7jFY*g{Ky4q!8|1K0-~1l|TFJ_Ub)c3=~*4R{II4;%$1Z^Xv} zoUWkmZhdI18iz2+Blo$CKJ*VYeMo&=>Gp-V_B{6goXiF|mG?u}Z%>@q-_slTpmj|P zcf*H&tKmaEdRBb&W1xSBWq+WdG1S66#F@^<1ox-`ePuLk{8%i3CA7Ft|MAnTt1UDd z3v`xO=9t%No^((n^)ee}b{H#h8Ki-|+@(&VSxwT77fUGTQ9x-do{bk{2UYDZWo0riMZK0aU7qAk1%|j#E&_~U+XX1LR~LTYs%h1>iV+P6`Meh z8sVqWcstNIFQRcDH2(4w(6BlA0d;1AGg$ne$qHy3ifAn5+Lw*IqpQAulrrrkjpADz z@mg~G>9oD7_xo5|vW+8BPTj@~-IM>(O z*Wb^clfE@PYox7A_IKylAnnlEV04xaE?Ub43X9fu_VnHRSVOdI&eLA<6^Z5I0cib@ z(Qw5R&WzLteUui+WgM#{O=e0=@PB&8<%UgaOuh$E1&cs*Z_;TxS%lqBrq4H5~_x=F=B9v3_BV3c_ zr}}ywUPyI&T;Cf>CqJp|x(mUuy3&mGQ{pD6W^7aOOeTfbwb>boO4AD{%p;AO?gm^# z@QeAn_MUm$@H+59zApyf2EGs61{M!*2kZTqBC{5~FQd>5cbdsjcX8XhGpd8vlLdC8 z`w-XR?!@1JE&J>u9((&te7&rS4_*&u_esQgJV;vA=^?P%Y9&~FY-X2|wM_@VdmUCt z^`Gjkx+ttB%>-~4cnbJ2u=s$kaDKWT@BrT*2N!9{W;j^HH&>)(ijfS6hhE?0+rkW3 zl_F~kY8%D%IwO;3=_%1y_=t=99v4@9^!+%W2hS2$bB5=@XM;Dpv@;Ul7TMkCzCY%_ zU+_F>bcXT~(u<#e9vZBJzuOR`cAyui0Na7xz&_wjAbA>n1I!1O0o}kxU@Nd2*asX0 zjsTNC%-Sfh4Cn?n0i)sca-c}|W@~7#l)@~J+~*7ifH4nL+oWdy9}02pd2Ij3>%Wl? z5Y5Pb&9E=@oxbm5Tj1CA5x=g2U)R_0s~(#|{Ptt6pC`PXL*r^9JbnsktUAM2K)S@j zHPHCEQ$WLPuofw10%KenWEmJeUiH-vD?DCUsr~KxI{IIDi*lEu0 z^5yjT#%1l`x$g_vS*fwD65D;}6ZajtQ<+RyHX_Tz}bMMHei;hed zJdNxf@mLmq1zDI%{$3WIcV)|yg-ujomsP^W8vQsK2h{$y&aLUX!W56(=lf~@Z&vmH zwEa^>&`r#d=mDR9A*CC){r{rvFCc&4_FhBfwf$b&{ms#~k6Lbcf2#d${{MDJ@}4MZ zGYb1soNw{?Z}a~biKn>sJf8obmUGzMo9BKWSKt02)e@g;&HiqiXLY;EC3u6gpn+eXkdtMbB-$YF%TcAG(n5k}VfS=C!7|#LE=l6-=Cg)R?&0c-( zk1u2X9eR^VCwtiX%MvnFAipH}DE>BJCa?q;4d0&}ko?t-|I)V>{sR5~*86Py$H9SH zqo-SE>kV?~uwQOfujR<`x%kvgj^jI@JCNNiqw;IbRX0}q zoBr<(sbl;9M_H@8aACFnuSfqqM|$Z$qwz|hp?SQ8t;D(J6wr__VK(5)n?J8Ww%xn} zU5`$ECiMeJ2m3N)>oZLuKakd_p3(Y=*6K7rmanQQX-nj1kT1z(b0~Bk>DZmfM5jQ{{Oh$pMyr>gVpWcNIlHI+@j7znCp@IoyL&jYS-`d0b11HP~2``Vedy8Pt( zSAH|V%1?VZZU$=)N0#s9Nu0O(wC`j2YZa^mxV-6?F7J1zd1dGJslL7s<=2-r0GEe+ z|0*A4bLFEShH|M)Eopr_h~xW0A?-)8|DU;n^OG|tOa1;+Nkd&K(jV^yYkX`2d;kC9 z-dPvrma4!Wm}xJN(A{O1Re1z-Wt4y*+#z&2nvun#y0Bp<^U0?Y@N z18afrwGfa02SeqM%QXBtI^aDW)#HGT|J#YBxb{3A|Kt6?dFMa4=XvKcH9W`nja)m& zH@mZ~;HxyrBlo$7x;@@eUAKD1IPr%6scpM6(2(tC;Wvn|spHhq7%S%(A*S)0(Ad&3 zavC-kj1B$e^Ny1L_zE<37>$~-T4x}0PF$k+7RScw7o)ZM?s8Ypy3XFJcSYJrw;y