text:
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="EnumerableExtensions.cs" company="OBeautifulCode">
//   Copyright (c) OBeautifulCode 2018. All rights reserved.
// </copyright>
// <auto-generated>
//   Sourced from NuGet package. Will be overwritten with package update except in OBeautifulCode.Collection source.
// </auto-generated>
// --------------------------------------------------------------------------------------------------------------------

namespace OBeautifulCode.Collection.Recipes
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;

    using OBeautifulCode.String.Recipes;
    using OBeautifulCode.Validation.Recipes;

    using static System.FormattableString;

    ///
    /// Helper methods for operating on objects of type <see cref="IEnumerable"/> and <see cref="IEnumerable{T}"/>.
    ///
#if !OBeautifulCodeCollectionRecipesProject
    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
    [System.CodeDom.Compiler.GeneratedCode("OBeautifulCode.Collection", "See package version number")]
    internal
#else
    public
#endif
    static class EnumerableExtensions
    {
        ///
        /// Gets all combinations of items in a specified set of items.
        ///
        /// <remarks>
        /// Adapted from .
        /// </remarks>
        /// <typeparam name="T">The type of items in the set.</typeparam>
        /// <param name="values">The set of values.</param>
        /// <param name="minimumItems">Optional minimum number of items in each combination.  Default is 1.</param>
        /// <param name="maximumItems">Optional maximum number of items in each combination.  Default is no maximum limit.</param>
        /// <returns>
        /// All possible combinations for the input set, constrained by the specified <paramref name="maximumItems"/> and <paramref name="minimumItems"/>.
        /// </returns>
        /// <exception cref="ArgumentNullException"><paramref name="values"/> is null.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="minimumItems"/> is less than 1.</exception>
        /// <exception cref="ArgumentOutOfRangeException"><paramref name="maximumItems"/> is less than <paramref name="minimumItems"/>"/>.</exception>
        public static IReadOnlyCollection<IReadOnlyCollection<T>> GetCombinations<T>(
            this IEnumerable<T> values,
            int minimumItems = 1,
            int maximumItems = int.MaxValue)
        {
            // ReSharper disable once PossibleMultipleEnumeration
            new { values }.Must().NotBeNull();
            new { minimumItems }.Must().BeGreaterThanOrEqualTo(1);
            new { maximumItems }.Must().BeGreaterThanOrEqualTo(minimumItems, Invariant($"{nameof(maximumItems)} < {nameof(minimumItems)}."));

            // ReSharper disable once PossibleMultipleEnumeration
            var valuesList = values.Distinct().ToList();

            var nonEmptyCombinations = (int)Math.Pow(2, valuesList.Count) - 1;
            var result = new List<List<T>>(nonEmptyCombinations + 1);

            // Optimize generation of empty combination, if empty combination is wanted
            if (minimumItems == 0)
            {
                result.Add(new List<T>());
            }

            if ((minimumItems <= 1) && (maximumItems >= valuesList.Count))
            {
                // Simple case, generate all possible non-empty combinations
                for (var bitPattern = 1; bitPattern <= nonEmptyCombinations; bitPattern++)
                {
                    result.Add(GenerateCombination(valuesList, bitPattern));
                }
            }
            else
            {
                // Not-so-simple case, avoid generating the unwanted combinations
                for (var bitPattern = 1; bitPattern <= nonEmptyCombinations; bitPattern++)
                {
                    var bitCount = CountBits(bitPattern);
                    if (bitCount >= minimumItems && bitCount <= maximumItems)
                    {
                        result.Add(GenerateCombination(valuesList, bitPattern));
                    }
                }
            }

            return result;
        }

        ///
        /// Gets the symmetric difference of two sets using the default equality comparer.
        /// The symmetric difference is defined as the set of elements which are in one of the sets, but not in both.
        ///
        /// <remarks>
        /// If one set has duplicate items when evaluated using the comparer, then the resulting symmetric difference will only
        /// contain one copy of the the duplicate item and only if it doesn't appear in the other set.
        /// </remarks>
        /// <param name="value">The first enumerable.</param>
        /// <param name="secondSet">The second enumerable to compare against the first.</param>
        /// <returns>IEnumerable(T) with the symmetric difference of the two sets.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
        /// <exception cref="ArgumentNullException"><paramref name="secondSet"/> is null.</exception>
        public static IEnumerable SymmetricDifference(
            this IEnumerable value,
            IEnumerable secondSet)
        {
            var result = SymmetricDifference(value.OfType<object>(), secondSet.OfType<object>());
            return result;
        }

        ///
        /// Gets the symmetric difference of two sets using the default equality comparer.
        /// The symmetric difference is defined as the set of elements which are in one of the sets, but not in both.
        ///
        /// <remarks>
        /// If one set has duplicate items when evaluated using the comparer, then the resulting symmetric difference will only
        /// contain one copy of the the duplicate item and only if it doesn't appear in the other set.
        /// </remarks>
        /// <typeparam name="TSource">The type of elements in the collection.</typeparam>
        /// <param name="value">The first enumerable.</param>
        /// <param name="secondSet">The second enumerable to compare against the first.</param>
        /// <returns>IEnumerable(T) with the symmetric difference of the two sets.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
        /// <exception cref="ArgumentNullException"><paramref name="secondSet"/> is null.</exception>
        public static IEnumerable<TSource> SymmetricDifference<TSource>(
            this IEnumerable<TSource> value,
            IEnumerable<TSource> secondSet)
        {
            var result = SymmetricDifference(value, secondSet, null);
            return result;
        }

        ///
        /// Gets the symmetric difference of two sets using an equality comparer.
        /// The symmetric difference is defined as the set of elements which are in one of the sets, but not in both.
        ///
        /// <remarks>
        /// If one set has duplicate items when evaluated using the comparer, then the resulting symmetric difference will only
        /// contain one copy of the the duplicate item and only if it doesn't appear in the other set.
        /// </remarks>
        /// <typeparam name="TSource">The type of elements in the collection.</typeparam>
        /// <param name="value">The first enumerable.</param>
        /// <param name="secondSet">The second enumerable to compare against the first.</param>
        /// <param name="comparer">The comparer object to use to compare each item in the collection.  If null uses EqualityComparer(T).Default.</param>
        /// <returns>Returns an <see cref="IEnumerable{T}"/> with the symmetric difference of the two sets.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
        /// <exception cref="ArgumentNullException"><paramref name="secondSet"/> is null.</exception>
        public static IEnumerable<TSource> SymmetricDifference<TSource>(
            this IEnumerable<TSource> value,
            IEnumerable<TSource> secondSet,
            IEqualityComparer<TSource> comparer)
        {
            // ReSharper disable PossibleMultipleEnumeration
            new { value }.Must().NotBeNull();
            new { secondSet }.Must().NotBeNull();

            if (comparer == null)
            {
                comparer = EqualityComparer<TSource>.Default;
            }

            var result = value.Except(secondSet, comparer).Union(secondSet.Except(value, comparer), comparer);
            return result;

            // ReSharper restore PossibleMultipleEnumeration
        }

        ///
        /// Creates a common separated values (CSV) string from the individual strings in an <see cref="IEnumerable"/>,
        /// making CSV treatments where needed (double quotes around strings with commas, etc.).
        ///
        /// <param name="value">The enumerable to transform into a CSV string.</param>
        /// <param name="nullValueEncoding">Optional value to use when encoding null elements.  Defaults to the empty string.</param>
        /// <remarks>
        /// CSV treatments: .
        /// </remarks>
        /// <returns>
        /// Returns a string that contains each element in the input enumerable,
        /// separated by a comma and with the proper escaping.
        /// If the enumerable is empty, returns null.
        /// </returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
        public static string ToCsv(
            this IEnumerable<string> value,
            string nullValueEncoding = "")
        {
            // ReSharper disable once PossibleMultipleEnumeration
            new { value }.Must().NotBeNull();

            // ReSharper disable once PossibleMultipleEnumeration
            var result = value.Select(item => item == null ? nullValueEncoding : item.ToCsvSafe()).ToDelimitedString(",");
            return result;
        }

        ///
        /// Concatenates the individual values in an <see cref="IEnumerable"/> with a given delimiter
        /// separating the individual values.
        ///
        /// <param name="value">The enumerable to concatenate.</param>
        /// <param name="delimiter">The delimiter to use between elements in the enumerable.</param>
        /// <remarks>
        /// If an element of the IEnumerable is null, then its treated like an empty string.
        /// </remarks>
        /// <returns>
        /// Returns a string that contains each element in the input enumerable, separated by the given delimiter.
        /// If the enumerable is empty, then this method returns null.
        /// </returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
        /// <exception cref="ArgumentNullException"><paramref name="delimiter"/> is null.</exception>
        public static string ToDelimitedString(
            this IEnumerable<string> value,
            string delimiter)
        {
            // ReSharper disable once PossibleMultipleEnumeration
            new { value }.Must().NotBeNull();
            new { delimiter }.Must().NotBeNull();

            // ReSharper disable once PossibleMultipleEnumeration
            var valueAsList = value.ToList();
            if (valueAsList.Count == 0)
            {
                return null;
            }

            // ReSharper disable once PossibleMultipleEnumeration
            var result = string.Join(delimiter, value);
            return result;
        }

        ///
        /// Creates a string with the values in a given <see cref="IEnumerable"/>, separated by a newline.
        ///
        /// <param name="value">The enumerable to concatenate.</param>
        /// <remarks>
        /// If an element of the IEnumerable is null, then its treated like an empty string.
        /// </remarks>
        /// <returns>
        /// Returns a string that contains each element in the input enumerable, separated by a newline.
        /// If the enumerable is empty, then this method returns null.
        /// </returns>
        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
        public static string ToNewLineDelimited(
            this IEnumerable<string> value)
        {
            var result = value.ToDelimitedString(Environment.NewLine);
            return result;
        }

        ///
        /// Compares two dictionaries for equality.
        ///
        /// <typeparam name="TKey">The type of keys in the dictionaries.</typeparam>
        /// <typeparam name="TValue">The type of values in the dictionaries.</typeparam>
        /// <param name="first">The first <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="second">The second <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="keyComparer">Optional equality comparer to use to compare keys.  Default is to use <see cref="EqualityComparer{TKey}.Default"/>.</param>
        /// <param name="valueComparer">Optional equality comparer to use to compare values.  Default is to use <see cref="EqualityComparer{TValue}.Default"/>.</param>
        /// <returns>
        /// - true if the two source dictionaries are null.
        /// - false if one or the other is null.
        /// - true if the two dictionaries are of equal length and their corresponding elements are equal according to the specified equality comparer for their type (both keys and values, ordered by key).
        /// - otherwise, false.
        /// </returns>
        public static bool DictionaryEqual<TKey, TValue>(
            this IReadOnlyDictionary<TKey, TValue> first,
            IReadOnlyDictionary<TKey, TValue> second,
            IEqualityComparer<TKey> keyComparer = null,
            IEqualityComparer<TValue> valueComparer = null)
        {
            if ((first == null) && (second == null))
            {
                return true;
            }

            if ((first == null) || (second == null))
            {
                return false;
            }

            if (keyComparer == null)
            {
                keyComparer = EqualityComparer<TKey>.Default;
            }

            if (valueComparer == null)
            {
                valueComparer = EqualityComparer<TValue>.Default;
            }

            var firstKeys = first.OrderBy(_ => _.Key).Select(_ => _.Key).ToList();
            var secondKeys = second.OrderBy(_ => _.Key).Select(_ => _.Key).ToList();
            var resultKeys = firstKeys.SequenceEqualHandlingNulls(secondKeys, keyComparer);

            if (!resultKeys)
            {
                return false;
            }

            var firstValues = first.OrderBy(_ => _.Key).Select(_ => _.Value).ToList();
            var secondValues = second.OrderBy(_ => _.Key).Select(_ => _.Value).ToList();
            var result = firstValues.SequenceEqualHandlingNulls(secondValues, valueComparer);

            return result;
        }

        ///
        /// Compares two dictionaries for equality.
        /// This method should be used when the dictionary values are enumerable and where the elements
        /// should be compared given a <see cref="EnumerableEqualityComparerStrategy"/>.
        ///
        /// <typeparam name="TKey">The type of keys in the dictionaries.</typeparam>
        /// <typeparam name="TElementValue">The dictionaries values' element type.</typeparam>
        /// <param name="first">The first <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="second">The second <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="keyComparer">Optional equality comparer to use to compare keys.  Default is to use <see cref="EqualityComparer{TKey}.Default"/>.</param>
        /// <param name="enumerableEqualityComparerStrategy">The strategy to use when comparing the elements of the dictionaries enumerable values.</param>
        /// <returns>
        /// - true if the two source dictionaries are null.
        /// - false if one or the other is null.
        /// - true if the two dictionaries are of equal length and their corresponding elements are equal according to the specified equality comparer for their type (both keys and values, ordered by key).
        /// - otherwise, false.
        /// </returns>
        public static bool DictionaryEqualHavingEnumerableValues<TKey, TElementValue>(
            this IReadOnlyDictionary<TKey, TElementValue[]> first,
            IReadOnlyDictionary<TKey, TElementValue[]> second,
            IEqualityComparer<TKey> keyComparer = null,
            EnumerableEqualityComparerStrategy enumerableEqualityComparerStrategy = EnumerableEqualityComparerStrategy.SequenceEqual)
        {
            var result = DictionaryEqualHavingEnumerableValues<TKey, TElementValue[], TElementValue>(first, second, keyComparer, enumerableEqualityComparerStrategy);

            return result;
        }

        ///
        /// Compares two dictionaries for equality.
        /// This method should be used when the dictionary values are enumerable and where the elements
        /// should be compared given a <see cref="EnumerableEqualityComparerStrategy"/>.
        ///
        /// <typeparam name="TKey">The type of keys in the dictionaries.</typeparam>
        /// <typeparam name="TElementValue">The dictionaries values' element type.</typeparam>
        /// <param name="first">The first <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="second">The second <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="keyComparer">Optional equality comparer to use to compare keys.  Default is to use <see cref="EqualityComparer{TKey}.Default"/>.</param>
        /// <param name="enumerableEqualityComparerStrategy">The strategy to use when comparing the elements of the dictionaries enumerable values.</param>
        /// <returns>
        /// - true if the two source dictionaries are null.
        /// - false if one or the other is null.
        /// - true if the two dictionaries are of equal length and their corresponding elements are equal according to the specified equality comparer for their type (both keys and values, ordered by key).
        /// - otherwise, false.
        /// </returns>
        public static bool DictionaryEqualHavingEnumerableValues<TKey, TElementValue>(
            this IReadOnlyDictionary<TKey, IEnumerable<TElementValue>> first,
            IReadOnlyDictionary<TKey, IEnumerable<TElementValue>> second,
            IEqualityComparer<TKey> keyComparer = null,
            EnumerableEqualityComparerStrategy enumerableEqualityComparerStrategy = EnumerableEqualityComparerStrategy.SequenceEqual)
        {
            var result = DictionaryEqualHavingEnumerableValues<TKey, IEnumerable<TElementValue>, TElementValue>(first, second, keyComparer, enumerableEqualityComparerStrategy);

            return result;
        }

        ///
        /// Compares two dictionaries for equality.
        /// This method should be used when the dictionary values are enumerable and where the elements
        /// should be compared given a <see cref="EnumerableEqualityComparerStrategy"/>.
        ///
        /// <typeparam name="TKey">The type of keys in the dictionaries.</typeparam>
        /// <typeparam name="TElementValue">The dictionaries values' element type.</typeparam>
        /// <param name="first">The first <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="second">The second <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="keyComparer">Optional equality comparer to use to compare keys.  Default is to use <see cref="EqualityComparer{TKey}.Default"/>.</param>
        /// <param name="enumerableEqualityComparerStrategy">The strategy to use when comparing the elements of the dictionaries enumerable values.</param>
        /// <returns>
        /// - true if the two source dictionaries are null.
        /// - false if one or the other is null.
        /// - true if the two dictionaries are of equal length and their corresponding elements are equal according to the specified equality comparer for their type (both keys and values, ordered by key).
        /// - otherwise, false.
        /// </returns>
        public static bool DictionaryEqualHavingEnumerableValues<TKey, TElementValue>(
            this IReadOnlyDictionary<TKey, ICollection<TElementValue>> first,
            IReadOnlyDictionary<TKey, ICollection<TElementValue>> second,
            IEqualityComparer<TKey> keyComparer = null,
            EnumerableEqualityComparerStrategy enumerableEqualityComparerStrategy = EnumerableEqualityComparerStrategy.SequenceEqual)
        {
            var result = DictionaryEqualHavingEnumerableValues<TKey, ICollection<TElementValue>, TElementValue>(first, second, keyComparer, enumerableEqualityComparerStrategy);

            return result;
        }

        ///
        /// Compares two dictionaries for equality.
        /// This method should be used when the dictionary values are enumerable and where the elements
        /// should be compared given a <see cref="EnumerableEqualityComparerStrategy"/>.
        ///
        /// <typeparam name="TKey">The type of keys in the dictionaries.</typeparam>
        /// <typeparam name="TElementValue">The dictionaries values' element type.</typeparam>
        /// <param name="first">The first <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="second">The second <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="keyComparer">Optional equality comparer to use to compare keys.  Default is to use <see cref="EqualityComparer{TKey}.Default"/>.</param>
        /// <param name="enumerableEqualityComparerStrategy">The strategy to use when comparing the elements of the dictionaries enumerable values.</param>
        /// <returns>
        /// - true if the two source dictionaries are null.
        /// - false if one or the other is null.
        /// - true if the two dictionaries are of equal length and their corresponding elements are equal according to the specified equality comparer for their type (both keys and values, ordered by key).
        /// - otherwise, false.
        /// </returns>
        public static bool DictionaryEqualHavingEnumerableValues<TKey, TElementValue>(
            this IReadOnlyDictionary<TKey, IReadOnlyCollection<TElementValue>> first,
            IReadOnlyDictionary<TKey, IReadOnlyCollection<TElementValue>> second,
            IEqualityComparer<TKey> keyComparer = null,
            EnumerableEqualityComparerStrategy enumerableEqualityComparerStrategy = EnumerableEqualityComparerStrategy.SequenceEqual)
        {
            var result = DictionaryEqualHavingEnumerableValues<TKey, IReadOnlyCollection<TElementValue>, TElementValue>(first, second, keyComparer, enumerableEqualityComparerStrategy);

            return result;
        }

        ///
        /// Compares two dictionaries for equality.
        /// This method should be used when the dictionary values are enumerable and where the elements
        /// should be compared given a <see cref="EnumerableEqualityComparerStrategy"/>.
        ///
        /// <typeparam name="TKey">The type of keys in the dictionaries.</typeparam>
        /// <typeparam name="TElementValue">The dictionaries values' element type.</typeparam>
        /// <param name="first">The first <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="second">The second <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="keyComparer">Optional equality comparer to use to compare keys.  Default is to use <see cref="EqualityComparer{TKey}.Default"/>.</param>
        /// <param name="enumerableEqualityComparerStrategy">The strategy to use when comparing the elements of the dictionaries enumerable values.</param>
        /// <returns>
        /// - true if the two source dictionaries are null.
        /// - false if one or the other is null.
        /// - true if the two dictionaries are of equal length and their corresponding elements are equal according to the specified equality comparer for their type (both keys and values, ordered by key).
        /// - otherwise, false.
        /// </returns>
        public static bool DictionaryEqualHavingEnumerableValues<TKey, TElementValue>(
            this IReadOnlyDictionary<TKey, List<TElementValue>> first,
            IReadOnlyDictionary<TKey, List<TElementValue>> second,
            IEqualityComparer<TKey> keyComparer = null,
            EnumerableEqualityComparerStrategy enumerableEqualityComparerStrategy = EnumerableEqualityComparerStrategy.SequenceEqual)
        {
            var result = DictionaryEqualHavingEnumerableValues<TKey, List<TElementValue>, TElementValue>(first, second, keyComparer, enumerableEqualityComparerStrategy);

            return result;
        }

        ///
        /// Compares two dictionaries for equality.
        /// This method should be used when the dictionary values are enumerable and where the elements
        /// should be compared given a <see cref="EnumerableEqualityComparerStrategy"/>.
        ///
        /// <typeparam name="TKey">The type of keys in the dictionaries.</typeparam>
        /// <typeparam name="TElementValue">The dictionaries values' element type.</typeparam>
        /// <param name="first">The first <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="second">The second <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="keyComparer">Optional equality comparer to use to compare keys.  Default is to use <see cref="EqualityComparer{TKey}.Default"/>.</param>
        /// <param name="enumerableEqualityComparerStrategy">The strategy to use when comparing the elements of the dictionaries enumerable values.</param>
        /// <returns>
        /// - true if the two source dictionaries are null.
        /// - false if one or the other is null.
        /// - true if the two dictionaries are of equal length and their corresponding elements are equal according to the specified equality comparer for their type (both keys and values, ordered by key).
        /// - otherwise, false.
        /// </returns>
        public static bool DictionaryEqualHavingEnumerableValues<TKey, TElementValue>(
            this IReadOnlyDictionary<TKey, IList<TElementValue>> first,
            IReadOnlyDictionary<TKey, IList<TElementValue>> second,
            IEqualityComparer<TKey> keyComparer = null,
            EnumerableEqualityComparerStrategy enumerableEqualityComparerStrategy = EnumerableEqualityComparerStrategy.SequenceEqual)
        {
            var result = DictionaryEqualHavingEnumerableValues<TKey, IList<TElementValue>, TElementValue>(first, second, keyComparer, enumerableEqualityComparerStrategy);

            return result;
        }

        ///
        /// Compares two dictionaries for equality.
        /// This method should be used when the dictionary values are enumerable and where the elements
        /// should be compared given a <see cref="EnumerableEqualityComparerStrategy"/>.
        ///
        /// <typeparam name="TKey">The type of keys in the dictionaries.</typeparam>
        /// <typeparam name="TElementValue">The dictionaries values' element type.</typeparam>
        /// <param name="first">The first <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="second">The second <see cref="IReadOnlyDictionary{TKey, TValue}"/> to compare.</param>
        /// <param name="keyComparer">Optional equality comparer to use to compare keys.  Default is to use <see cref="EqualityComparer{TKey}.Default"/>.</param>
        /// <param name="enumerableEqualityComparerStrategy">The strategy to use when comparing the elements of the dictionaries enumerable values.</param>
        /// <returns>
        /// - true if the two source dictionaries are null.
        /// - false if one or the other is null.
        /// - true if the two dictionaries are of equal length and their corresponding elements are equal according to the specified equality comparer for their type (both keys and values, ordered by key).
        /// - otherwise, false.
        /// </returns>
        public static bool DictionaryEqualHavingEnumerableValues<TKey, TElementValue>(
            this IReadOnlyDictionary<TKey, IReadOnlyList<TElementValue>> first,
            IReadOnlyDictionary<TKey, IReadOnlyList<TElementValue>> second,
            IEqualityComparer<TKey> keyComparer = null,
            EnumerableEqualityComparerStrategy enumerableEqualityComparerStrategy = EnumerableEqualityComparerStrategy.SequenceEqual)
        {
            var result = DictionaryEqualHavingEnumerableValues<TKey, IReadOnlyList<TElementValue>, TElementValue>(first, second, keyComparer, enumerableEqualityComparerStrategy);

            return result;
        }

        ///
        /// The same as <see cref="Enumerable.SequenceEqual{TSource}(IEnumerable{TSource}, IEnumerable{TSource})"/>,
        /// except that it handles cases where one or both sets are null.
        ///
        /// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam>
        /// <param name="first">An <see cref="IEnumerable{T}"/> to compare to <paramref name="second"/>.</param>
        /// <param name="second">An <see cref="IEnumerable{T}"/> to compare to the first sequence.</param>
        /// <returns>
        /// - true if the two source sequences are null.
        /// - false if one or the other is null.
        /// - true if the two sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type.
        /// - otherwise, false.
        /// </returns>
        public static bool SequenceEqualHandlingNulls<TSource>(
            this IEnumerable<TSource> first,
            IEnumerable<TSource> second)
        {
            var result = SequenceEqualHandlingNulls(first, second, null);

            return result;
        }

        ///
        /// The same as <see cref="Enumerable.SequenceEqual{TSource}(IEnumerable{TSource}, IEnumerable{TSource}, IEqualityComparer{TSource})" />,
        /// except that it handles cases where one or both sets are null.
        ///
        /// <typeparam name="TSource">The type of the elements of the input sequences.</typeparam>
        /// <param name="first">An <see cref="IEnumerable{T}"/> to compare to <paramref name="second"/>.</param>
        /// <param name="second">An <see cref="IEnumerable{T}"/> to compare to the first sequence.</param>
        /// <param name="comparer">An <see cref="IEqualityComparer{T}"/> to use to compare elements.</param>
        /// <returns>
        /// - true if the two source sequences are null.
        /// - false if one or the other is null.
        /// - true if the two sequences are of equal length and their corresponding elements are equal according to <paramref name="comparer"/>.
        /// - otherwise, false.
        /// </returns>
        public static bool SequenceEqualHandlingNulls<TSource>(
            this IEnumerable<TSource> first,
            IEnumerable<TSource> second,
            IEqualityComparer<TSource> comparer)
        {
            if ((first == null) && (second == null))
            {
                return true;
            }

            if ((first == null) || (second == null))
            {
                return false;
            }

            if (comparer == null)
            {
                comparer = EqualityComparer<TSource>.Default;
            }

            var result = first.SequenceEqual(second, comparer);

            return result;
        }

        private static List<T> GenerateCombination<T>(
            IReadOnlyList<T> inputList,
            int bitPattern)
        {
            var result = new List<T>(inputList.Count);
            for (var j = 0; j < inputList.Count; j++)
            {
                if ((bitPattern >> j & 1) == 1)
                {
                    result.Add(inputList[j]);
                }
            }

            return result;
        }

        private static int CountBits(
            int bitPattern)
        {
            var result = 0;
            while (bitPattern != 0)
            {
                result++;
                bitPattern &= bitPattern - 1;
            }

            return result;
        }

        private static bool DictionaryEqualHavingEnumerableValues<TKey, TValue, TElementValue>(
            this IReadOnlyDictionary<TKey, TValue> first,
            IReadOnlyDictionary<TKey, TValue> second,
            IEqualityComparer<TKey> keyComparer = null,
            EnumerableEqualityComparerStrategy enumerableEqualityComparerStrategy = EnumerableEqualityComparerStrategy.SequenceEqual)
        {
            if (keyComparer == null)
            {
                keyComparer = EqualityComparer<TKey>.Default;
            }

            var valueComparer = (IEqualityComparer<TValue>)new EnumerableEqualityComparer<TElementValue>(enumerableEqualityComparerStrategy);

            var result = DictionaryEqual(first, second, keyComparer, valueComparer);

            return result;
        }
    }
}


text:
Umithyala - Mahbubnagar
Umithyala Population - Mahbubnagar, Andhra Pradesh
Umithyala is a large village located in Dharur Mandal of Mahbubnagar district, Andhra Pradesh with total 581 families residing. The Umithyala village has population of 2789 of which 1374 are males while 1415 are females as per Population Census 2011.
In Umithyala village population of children with age 0-6 is 475 which makes up 17.03 % of total population of village. Average Sex Ratio of Umithyala village is 1030 which is higher than Andhra Pradesh state average of 993. Child Sex Ratio for the Umithyala as per census is 841, lower than Andhra Pradesh average of 939.
Umithyala village has lower literacy rate compared to Andhra Pradesh. In 2011, literacy rate of Umithyala village was 29.56 % compared to 67.02 % of Andhra Pradesh. In Umithyala Male literacy stands at 42.29 % while female literacy rate was 17.70 %.
As per constitution of India and Panchyati Raaj Act, Umithyala village is administrated by Sarpanch (Head of Village) who is elected representative of village. Our website, don't have information about schools and hospital in Umithyala village.
Umithyala Data
Schedule Tribe 706 328 378
Umithyala village of Mahbubnagar has substantial population of Schedule Tribe (ST). Schedule Tribe (ST) constitutes 25.31 % while Schedule Caste (SC) were 16.57 % of total population in Umithyala village.
In Umithyala village out of total population, 1647 were engaged in work activities. 66.73 % of workers describe their work as Main Work (Employment or Earning more than 6 Months) while 33.27 % were involved in Marginal activity providing livelihood for less than 6 months. Of 1647 workers engaged in Main Work, 378 were cultivators (owner or co-owner) while 688 were Agricultural labourer.

redpajama_set_name: RedPajamaCommonCrawl


You probably know all about the benefits of clean living and the dangers of food additives, high fructose corn syrup and vegetables treated with pesticides. You want to eat clean.
There's just one problem: Clean eating can be expensive. Can you really afford to spend money on organic, fresh foods when you can buy processed foods at discount prices? After all, you have other expenses too.
Should you be buying organic whole grain bread when processed white bread is on sale — two loaves for the price of one? Do your children really need organic strawberries in their packed lunches? Can't they do with cheaper processed fruit snacks instead? I mean, you have a coupon.
Is eating fresh, wholesome, unprocessed food a luxury you can't afford? It doesn't have to be.
Here are some ways for you and your family to enjoy healthy, fresh, clean foods without overspending.
Nowadays, we're used to eating whatever we want, whenever we want it. That means buying food exported from around the globe. We eat grapes from Chile, bananas from Costa Rica, asparagus from Peru, oranges from Israel and lamb from New Zealand.
Shipping food around the world wasn't always so simple. When transportation and food storage methods were less advanced, people had to eat whatever was available locally. That mean they could only eat certain foods at certain times of year.
Seasonal eating from local producers saves you money, because you don't have to pay for transportation and storage costs.
It can also be healthier. Food may lose nutrients when it has been in transit for a long time. Local, seasonal food is not just nutrient rich; it tastes better. In addition, food produced for export may contain extra preservatives to ensure that it survives the trip from the farm to the supermarket shelf.
When you purchase packaged items made by large food manufacturers, even those labeled organic, you pay for the packaging as well as the company's profits. You could even be helping support company activities you find unethical, such as the use of low-paid labor subject to poor working conditions.
If you buy fruit from your local greengrocer or meat from your local butcher, you will only be given enough packaging to carry your food home, and you will know where your money is going.
An advantage of buying food that's not prepackaged is that you can choose how much you want to purchase. You don't have to buy large packages of food that you have to force yourself to finish.
In fact, you may think you need to buy more food than you do. Nowadays, people eat much larger portions than they used to, and it hasn't done anything for their health. Larger portions have been a major contributor to the obesity epidemic.
Training yourself to buy less and eat less can improve the health of your body, as well as your wallet.
Once, eating meat was a luxury. Being able to have meat with your dinner at least once a week was a sign that you were comfortable financially.
Today, modern factory farming methods have made meat production much cheaper. Because of this, meat consumption is rapidly increasing. Meat does provide essential nutrients, such as iron, zinc and B vitamins. However, livestock are often raised in overcrowded conditions, making them more susceptible to disease. Most of the beef we eat today comes from grain-fed cows that may have been given growth hormones.
Excessive meat consumption can be unhealthy. It is associated with an increased risk of colon cancer.
You don't have to stop eating meat altogether. However, you can reduce your shopping budget and improve your health by treating meat eating as the luxury it once was. Instead of buying the cheapest cuts when you do your regular shopping at your local supermarket, save your meat purchases for special occasions. Look for organic, free-range products and grass-fed beef.
You can save money by buying in bulk without wasting food or overeating, if you know how to store and cook leftovers. Learn how to safely freeze and refrigerate foods. Experiment with different spices and different methods of food preparation.
If you have decided to cut down on meat, this is an opportunity to try vegetarian cooking. Perhaps you can try recipes from cultures where meat is not such an integral part of the diet.
Cooking has emotional benefits as well. The smell of exotic spices or of a tasty meal bubbling on the stove can enhance your mood. Knowing you can create new, delicious recipes can increase your self-confidence. You can even take a cooking class and enjoy the emotional rewards of making new friends.


text:
Opinion November 27, 2018 by Brigid Horneman-Wren
Women in Film – Lifting Hollywood's Act
Image by Mariam Rizvi
"It's not rocket science darling. We're just asking you to be thin and curvy, sexy and innocent!"
The would-be director Catherine Tate yells as she looks to cast her female lead in LEADING LADY PARTS – the first in a series of short films that will centre on gender inequality in the workplace. It's a clever and funny skit, which in seven minutes covers female objectification, sexism, ageism and racism in the arts. As women front the audition room for the Leading Lady Part – a "thin, sexy hooker virgin with boobs and hips, but not big ones" – they are asked to smile more, act with more makeup and fewer clothes, and to read it again, "but more white".
The timing of the skit's release is excellent. It has been almost a year since #MeToo spread virally across social media, and the setbacks faced by women in acting are more in the open now than they have ever been.
This has been a fantastic year for quality roles and on-screen diversity. We've had Ruth Bader-Ginsberg's biographical drama On the Basis of Sex, the all-female heist of Ocean's 8, and the new comedy Crazy Rich Asians is the first major studio movie in 25 years to feature a predominantly Asian-American and Asian cast.
As a young woman, I've been particularly impressed with the recent quality of teen movies. Watching Greta Gerwig's Lady Bird at the beginning of this year, I was moved by the smallest of details, like the undisguised acne dotting the skin of the titular character. It was a small way of revealing a hint of truth about the teenage experience, and it says a lot about the traditional portrayal of young women on screen that this makeup choice – or lack thereof – made headlines.
In the same genre, it's clear that Netflix is also deliberately trying to diversify the stories and actresses it showcases. Aside from the way To All the Boys I've Loved Before manages to pull off just about every romantic trope in the book, it's impressive for turning away from the blindingly white casts of most teen movies by revolving around a Korean-American heroine. It's being followed up with Sierra Burgess is a Loser, which stars Stranger Things' Shannon Purser as a teenage girl struggling with college applications, falling in love, and the impossibility of living up to modern beauty standards.
The actresses starring in these roles are aware of how important they are, and the impact they can have on changing the expectations society holds for women. The latest photo on Purser's Instagram is an untouched ad for the lingerie and swimwear brand, Aerie. She captions it, "So yeah. I don't have an airbrushed body. I have stretch marks and cellulite and curves. And I'm beautiful." To All The Boys' lead, Lana Condor, has commented on the effects of a lack of on-screen diversity. "I just thought it was normal," she said. "My whole reason for doing this is so girls who look like me feel seen."
That said, Netflix's fat-shaming series, Insatiable, has been panned by critics with a backlash that apparently caught its lead by surprise, so the streaming giant isn't doing everything right. The setbacks and misrepresentation of women across the acting profession are by no means disappearing.
Last week, over 3,000 people signed an open letter calling for the end of Hollywood's "egregious" pay gap. The petition is supported by the American Civil Liberties Union (ACLU), the American Association of University Women, and Women in Hollywood. While it is pay discrepancies between leading male and female actors that have been the attention of public outcry, the pay gap covers every aspect of the acting industry. A study commissioned by Local 871 found those in production fields commonly populated by women receive less pay than those in similar but male-heavy fields like assistant directors and location managers.
Time's Up has brought huge attention to the difficulties faced by survivors of sexual assault and harassment in the workplace and aims to provide those survivors with support in pursuing their claims. It's difficult, however, to foresee those difficulties fading any time soon.
#MeToo in Hollywood has demonstrated time and time again how power dynamics dominate the entertainment industry. Women who simply want to pursue a career are manipulated and silenced.
"Me too" are the final words in Leading Lady Parts – it's fitting for the Time's Up inspired work. It can only be hoped that the next workplaces depicted in the series are depicted with just as much hard-hitting hilarity.
MyHealth Memories


Yield, yield, yield – and more yield… That's what most of the world wants from dividend stocks. Big, fat yields.
Nine times out of ten, plus-sized yields are a sucker's bet. Because they're unsustainable.
Remember, we want income and safety. We want to do better than Treasuries. We want to do better than inflation. We want to achieve wealth. What we don't want is to start gambling.
The good news is, you don't have to play dice to get a steady and increasing stream of cash into your account. And you don't have to fall victim to the yield trap, because there's a far, far more important number out there.
And for income investors, this number puts everything else to shame. It's called yield on cost (YOC).
It's dead simple. Take a stock's dividend payout at any given point in time – say, three years after your purchase – and compare it to how much you paid initially (and not whatever the current share price is). That's your yield on cost.
If you find a stock that grows its dividend aggressively over time, it barely matters what the initial yield is. As the dividends grow over time, so will your yield on the initial cost of those shares.
Let's take Wal-Mart (WMT), for example. Many dividend investors would take one look at its 2.3% yield and never give it a second thought.
And they'd be missing out on a great long-term income opportunity because of it.
Why? For one simple reason: Wal-Mart's five-year annual dividend growth rate clocks in at 16.87%.
Forget that its initial yield is just over the S&P 500 average. The dividend growth means your yield on cost is going to skyrocket.
If you bought 1,000 shares of WMT at yesterday's closing price of $69, given a 2.3% yield, you'd net $1,587 in income for the first year.
Yeah, yeah, big deal, right? Chump change.
Wrong. Don't miss the forest for the trees.
The huge amount of growth that Wal-Mart puts into its dividends means that in five years, the yield on the initial cost of your investment hits a healthy 4.29%, and your annual income clocks in at $2,960. In 10 years, you'll be sitting even prettier with an enormous YOC of 9.36% and an income of $6,455.
And if you're able to reinvest those dividends back into the stock, the story gets even better. Then you're looking at a YOC of 14.06% and an income of $9,701 at the 10-year mark.
All that from a measly 2.30% yield.
Bottom line: There's absolutely no good reason to go chasing yield. Fill your portfolio with stable companies that are committed to growing their dividends in the long term.
Remember, if you have patience and discipline, you'll be reaping the benefits while the yield-chasers sit around wondering why their incomes went up in smoke.
Who in the Obama Administration is Going to Jail?


ULtra HD flatscreen and projector installations.
Whether you are upgrading your basic HD TV with Smart TV Addon Modules or interested in creating you personal media heaven, our experts will guide you through possible designs and insure that your home theatre will be amazing and enjoyable for years to come.
We pride ourselves on our custom design installs and look forward to helping you maximize your available space to fit your needs and guide you through component purchases and flush wiring installs and retractable panel controls.


text:
Q: Want to create a generic AsyncTask - how? In my Apps I usually have lots of AsyncTasks. They all look the same thus share the same design. So I would like to optimize this a little bit further and create a generic MyAsyncTask from which my AsyncTasks extend. But I don't know how to do that.
Here's one of my AsyncTasks. They all differ only on the methods/vars surrounded with *:
public class OneOfMyAsyncTasks extends AsyncTask<Void, Void, ***Cursor***> {

    private Context                      context;
    private MyProgressDialog             dialog;
    private OnAsyncTaskCompletedListener listener;
    private String                       search;
    private int                          task_id;

    public OneOfMyAsyncTasks(int task_id, Context context, OnAsyncTaskCompletedListener listener) {
        super();

        this.context = context;
        this.listener = listener;
        this.task_id = task_id;
    }

    public OneOfMyAsyncTasks(int task_id, Context context, OnAsyncTaskCompletedListener,
                        ***String search***) {
        super(task_id, context, listener);

        ***this.search = search;***
    }

    protected void attach(Context context, OnAsyncTaskCompletedListener listener) {
        this.context = context;
        this.listener = listener;

        processCreateDialog();
    }

    protected void detach() {
        processDismissDialog();

        if (context != null) {
            context = null;
        }

        if (listener != null) {
            listener = null;
        }
    }

    @Override
    protected ***Cursor*** doInBackground(Void... voids) {
        ***return MyApplication.getSqliteOpenHelper().fetchSomething(search);***
    }

    @Override
    protected void onPostExecute(***Cursor cursor***) {
        if (listener != null) {
            listener.onAsyncTaskCompleted(task_id, ***cursor***);
        }

        detach();
    }

    @Override
    protected void onPreExecute() {
        processCreateDialog();
    }

    private void processCreateDialog() {
        if (context != null) {
            dialog = MyProgressDialog.show(context, null, null, true, false);
        }
    }

    private void processDismissDialog() {
        if (dialog != null) {
            try {
                dialog.dismiss();
            } catch (Exception exception) {
            }

            dialog = null;
        }
    }
}

My idea is to create a MyAsyncTask that does contain all shown above with the exception of:

*

*The method doInBackground

*The method onPostExecute

*The second constructor

*... and the signature of the AsyncTask itself (the third parameter)

These must be set from the specific AsyncTasks that do extend from this generic MyAsyncTask.
Any help is highly appreciated.
EDIT: Here's what I did so far - without success. The extending class throws two errors that are written in the code below. First the Abstract Class:
public abstract class MyAsyncTask<A, B, C> extends AsyncTask<A, B, C> {

        protected Context                      context;
        protected MyProgressDialog             dialog;
        protected OnAsyncTaskCompletedListener listener;
        protected int                          task_id;

        public MyAsyncTask(int task_id, Context context, OnAsyncTaskCompletedListener listener) {
            super();

            this.context = context;
            this.listener = listener;
            this.task_id = task_id;
        }

        protected void attach(Context context, OnAsyncTaskCompletedListener listener) {
            this.context = context;
            this.listener = listener;

            processCreateDialog();
        }

        protected void detach() {
            processDismissDialog();

            if (context != null) {
                context = null;
            }

            if (listener != null) {
                listener = null;
            }
        }

        @Override
        protected void onPostExecute(C result) {
            if (listener != null) {
                listener.onAsyncTaskCompleted(task_id, result);
            }

            detach();
        }

        @Override
        protected void onPreExecute() {
            processCreateDialog();
        }

        private void processCreateDialog() {
            if (context != null) {
                dialog = MyProgressDialog.show(context, null, null, true, false);
            }
        }

        private void processDismissDialog() {
            if (dialog != null) {
                try {
                    dialog.dismiss();
                } catch (Exception exception) {
                }

                dialog = null;
            }
        }
    }

And here's the idea of a class extending that Abstract class. The two errors are written within the code:
public class MyAsyncTaskImpl extends MyAsyncTask<Void, Void, Cursor> {
    // --> Error: MyAsyncTask cannot be resolved to a type - Create class 'MyAsyncTask<T1, T2, T3>'

    private String search;

    public MyAsyncTaskImpl(int task_id, Context context, OnAsyncTaskCompletedListener listener, String search) {
        super(task_id, context, listener);

        this.search = search;
    }

    @Override
    protected Cursor doInBackground(Void... voids) {
        // --> Error: The method doInBackground(Void...) of type MyAsyncTaskImpl must override or implement a supertype method - Remove '@Override' annotation

        return MyApplication.getSqliteOpenHelper().fetchSomething(search);
    }
}

A: You can create an abstract base class with two generic type arguments - R - for result type and T for the search argument.
public abstract class MyAsyncTask<R, T> extends AsyncTask<Void, Void, R> {
    private Context context;
    private MyProgressDialog dialog;
    private OnAsyncTaskCompletedListener listener;
    private T search;
    private int task_id;

    public MyAsyncTask(int task_id, Context context,
            OnAsyncTaskCompletedListener listener) {
        super();

        this.context = context;
        this.listener = listener;
        this.task_id = task_id;
    }

    public MyAsyncTask(int task_id, Context context,
            OnAsyncTaskCompletedListener listener, T search) {
        this(task_id, context, listener);

        this.search = search;
    }

    protected void attach(Context context, OnAsyncTaskCompletedListener listener) {
        this.context = context;
        this.listener = listener;

        processCreateDialog();
    }

    protected void detach() {
        processDismissDialog();

        if (context != null) {
            context = null;
        }

        if (listener != null) {
            listener = null;
        }
    }

    @Override
    protected void onPostExecute(R result) {
        if (listener != null) {
            listener.onAsyncTaskCompleted(task_id, result);
        }

        detach();
    }

    @Override
    protected void onPreExecute() {
        processCreateDialog();
    }

    private void processCreateDialog() {
        if (context != null) {
            dialog = MyProgressDialog.show(context, null, null, true, false);
        }
    }

    private void processDismissDialog() {
        if (dialog != null) {
            try {
                dialog.dismiss();
            } catch (Exception exception) {
            }

            dialog = null;
        }
    }
}

Then you can extend this class with specific implementations as follows:
public class MyAsyncTaskimpl extends MyAsyncTask<Cursor, String> {

    public MyAsyncTaskimpl(int task_id, Context context,
            OnAsyncTaskCompletedListener listener, String search) {
        super(task_id, context, listener, search);
        // TODO Auto-generated constructor stub
    }

    @Override
    protected Cursor doInBackground(Void... params) {
        // TODO Auto-generated method stub
        return null;
    }

}

A: You could create an Abstract Class. This will allow you to implement all your methods and leave the ones which are task dependent as Abstract. This will allow anyone to extend your own  (abstract) class and force them to implement these specific methods.

redpajama_set_name: RedPajamaStackExchange


Freshman Duncan Campbell brings it around the side.
Freshman Aaron Klett defends his man.
Junior Daniel Schmidt jogs down field.
Freshman Josh Bouck brings the ball into the middle of the field.
Senior Ryan Agadoni carries the ball upfield.
Senior Sean Connally slap checks his man.


text:
My book collection of mainly New Brunswick Genealogical and Historical books needs a new home.
The time has come to say goodby to them.
Quite a few are listed at http://www.rubycusack.com/Bookshelf.html
My book collection of several hundred books is going very very cheap.
If interested contact Ruby at rmcusack@nbnet.nb.ca
Vital Statistics from New Brunswick Newspapers by Daniel Johnson
on the Provincial Archives of New Brunswick website
In 1888, Mrs. Frank Hazen presented a fine cabinet organ
to St. Barnabas chapel of Ease, Sandy Point Road, Saint John
Provincial Archives of New Brunswick Anglican Diocese of Fredericton fonds: MC223/SSH-17z6
I wanted to finish reading my Anne book so I told Mum a little fib by saying I had hardly any lessons to do.
When it was almost bedtime, she asked to see what I needed to do.
Then it hit me. The teacher had written twenty words on the blackboard that I had neatly copied into my scribbler in my best cursive writing, leaving four blank lines between each word. The assignment was to find two different meanings for each word and write a sentence for each meaning.
Trouble was ahead of me, as I had forgotten to bring home my Winston School dictionary. But as usual, Mum came to my rescue with an old dictionary she had. I was speeding right along as I first did the ones that I knew. Then I came to "chesterfield" which meant a couch but I certainly was surprised to see the dictionary said it also meant "a fitted overcoat with a velvet collar".
It seems these days, I'm reading more and dusting less. So instead of doing housework, I was playing around with searching the Vital Statistics from New Brunswick Newspapers by Daniel Johnson on the Provincial Archives of New Brunswick website at http://archives.gnb.ca/ I put in the word "presented" in the "full-text search" section. I couldn't believe my eyes when up came a hit of 49 pages. Greater still was my excitement when I read some of the entries.
"In 1853, Captain Joseph Prichard, when captain of the ship, "Joseph Tarratt" of St. John and Liverpool packet line, was presented with a silver trumpet for making the fastest trip across the Atlantic."
I just had to keep on reading and found out that, "Among the vessels in which Captain Prichard was interested were the "Cambrian", "James Edwards", "Express", "Robert Parker" and many others." After the Great St. John Fire of 1877, he built several fine houses on Wentworth and Orange Streets.
In 1888, Mrs. Frank Hazen presented a fine cabinet organ to St. Barnabas chapel of Ease, Sandy Point Road (St. John).
1893 - "Wm. McCarthy left last night for New York where he will make his home for the future. At a large gathering in the hall of the City Cornet Band last night, Alderman McKelvey presented Mr. McCarthy with a handsome gold ring with bloodstone setting. And Wilkins then took the floor and representing the band and friends and the Courtenay Bay Boat Club presented Mr. McCarthy with a cigar case well loaded."
1895 - "Albert H. Dunbrack, who leaves here to take a position on the staff of the Buenos Ayres Real Estate Co., will be the third St. John boy who has settled there. J.H.M. Robertson, secretary of the Bicycle Club presented Mr. Dunbrack, who was a leading member, with a handsome gold ring. Mr. Dunbrack, who leaves for Buenos Ayres in the barquentine "Buteshire", will be accompanied by Kenneth Wade who will also make his home there."
1875 - "On Saturday eve., J. C. Eckert was presented with a handsome pair of oars by members of the Neptune Rowing Assoc. of (St. John) city. Mr. E. is to leave here this week for New York where he is to settle permanently."
1895 - "Another case of triplets was reported last week. Mrs. Carrigan wife of Alex. Carrigan, engineer of T. W. Flett's mill, Nelson (Northumberland Co.) on Friday night, 10th inst., presented her husband with two girls and a boy. Mr. and Mrs. Carrigan have been married about 13 years and have now a family of eleven children, five being the result of two accouchements."
1870 - "The Congregation of Salt Springs presented their pastor, Rev. J. E. Beairsto, with a handsome sleigh a few days ago. It is only a little over 4 months since he was settled at Salt Springs (Kings County)."
1893 - "On Monday evening the friends and well wishers of Miss Maud Weir, Titusville (Kings Co.), met in her father's house and presented her with a well filled purse in recognition of her services as organist in Salina Presbyterian church. Miss Weir took her departure the next day for Providence, R.I."
The Full-Text Search of Vital Statistics from New Brunswick Newspapers also has the capability to find information on a business, such as "Jewett's Mill". In 1895 "Bert Nichols, age 19 years, employed at Jewett's Mill, Millidgeville, son of James Nichols who lives at Spar Cove, opposite Stetson's mill, was drowned at Millidgeville yesterday morn. He was working on some logs, one of which rolled over while he was standing upon it and threw him into the water which was quite deep at that place."
Morning Telegraph of May 16, 1868 reported that between 2 and 3 o'clock Thursday morn., Mr. Jewett's mill on the Kennebecasis was destroyed by fire and Mr. H. Littlehale, Surveyor, son of Mr. Littlehale of Sussex, while attempting to save some of the belting perished in the flames.
Searches can also be done by using the Surname Index.
Many an adult has told a child they should learn something new every day. This certainly applies to genealogical researchers as quite often the information is right in front of us, but "how to find it" is often overlooked.
Query 1873
Thompson - Brown: I am looking for information on Cecil Enoch Thompson, born 1919, the son of Enoch Thompson and Bessie Brown, who was in the Protestant Orphanage in Saint John for a period of time.
Contact oscarb1@bellaliant.net
Wright: William Wright came to New Brunswick in 1783 and lived on the Kennebekacis in Queens County per his claim of 12 Nov 1786. I am interested in finding where he was before 1775, possibly in New York. He was in "Amboy" in 1775 and was in Middlesex County, New Jersey in 1779. He was granted lot 41 in the Millstream area of Kings County ca 1809, adjacent to lot 40, which was granted to his son Benjamin Wright, who was born 1 January 1796. Contact Sandy Neal by email sos_hr@localaccess.com
Kay: Looking for the parents of Abigail Kay, who was born 2 Dec 1805, Hillsborough, Albert County. She had two or three children with a Geldart man before she became the third wife of Robert Mitton. She had 10 siblings - James Kay (18 Sept, 1804 m Elizabeth Babcock), Jane Kay (2 Dec 1807 m Lewis Steeves Sr. 18 Oct 1825), Judith Kay (7 Apr 1808 m Enoch Stiles 1 Oct 1840), Margaret Kay (18 Dec 1809), John Kay (15 Aug 1813 m Eunice Lutes 22 Jan 1836), Robert Kay (15 July 1815), William Brian Kay (4 Aug 1818 m Mary Ann Steeves 30 June 1840), Alexander Kay (18 Aug 1823 - 7 May 1896), Early Kay (18 Aug 1823 - Oct 1905), Mary A. Kay (b ca 1829). The parents are not William Kay and Charity Wheaton.
Contact Sandy Neal by email sos_hr@localaccess.com
My book collection of mainly New Brunswick Genealogical and Historical books needs a new home. The time has come to say goodby to them. Quite a few are listed at http://www.rubycusack.com/Bookshelf.html My book collection of several hundred books is going very very cheap.
Visit Ruby's Bookshelf
New and Used Genealogical and Historical books of
New Brunswick for sale.


In the 21st century having a website has become a imperative need from startup business to mayor companies. Make the right choice between custom website build and website template is one of the main concern when taking your business online.
Before having your first website designed, get yourself familiar with the term "template" or "theme", consider its pros and cons to save yourself some headache down the road.
TL;DR: use template if you need low budget, quick turn around solution for a simple website. Use a more custom (bespoke) website design solution if you need brand focus design, complex features and can afford higher budget and longer deadline.
Before we get started, lets define the term "template" or "theme": in the design word, a template is a pre-designed, pre-coded website. By using a template, in theory you can save your time (and cost) from the design and development process which is the major cost factor of a website design project. Because they are pre-designed and pre-coded (and hopefully pre-tested).
Cheap - The template authors make profits by selling to the mass, instead of selling to 1 single client they can sell the same template to a thousand or more clients. A normal template goes around 50 USD; even the premium goes around 200 USD or less. A great template can be sold to 1000 clients or more, giving the authors at least 50000 USD in return.
Generic - A template is not designed for any specific business, it's designed to be used for as many businesses as possible. There is nothing unique, brand focus, or "wow" factor in a template.
Bloated features - Since the authors of templates need to cover most requirements, they usually try to add as many features as possible. In real-world usage most of these features are not used and in turn weigh down the website performance instead.
Hidden cost & time: Templates usually look really pretty and awesome, because they use 1 hidden trick: they always use the ideal content, ideal graphics, ideal amount of items etc... It's like buying clothes that look good on models, you will soon realize you don't have a model's body. Once you start making the template your own, you will realize you still need the help of designers and developers to make the changes and customize the template for you.
Maintenance nightmare: If you website is complex and constantly needs new features, you will run into problems down the road because the website was not designed and developed with that in mind. In addition, in most cases you buy the template from one author, and get the additional development from another 3rd party source, this will soon turn into a nightmare due to the conflicts in coding style and logical thinking. If you plan to buy a template then do a major re-design of layout or features on it, don't, you will soon find out it may cost the same with building things from scratch.
Low conversion rate: Conversion rate is the percentage of visitors coming to your website and perform the desired action (such as contacting you). This last point is NOT always true, but since web template approach goes against the core concept of High Conversion website design in the Content First Web Design Approach, it tends to yield low conversion rate.
If you really have to use templates, you should check my article above regarding the Content First Approach, then use our Website Questionnaire to plan out what you need on your website. Once you have the website content, user flow and site map ready, you can pick and choose the template that fits your goals instead of simply choosing based on the design.
Low quality - Many people point out that templates usually have low quality code which hinder performance, but custom build can also have low quality code. It depends on the authors (developers), a template website can have very good code base.
Non responsive - Some believe that a template website does not display well on multiple devices, again this is false. It all depends on how the template was designed and coded.
Framework = template - Some online resources claim that websites built on frameworks such as WordPress, Joomla are template websites. Again, this is false. Framework can be customized to build any type of custom website.
In contrast to template website, custom build website service offers tailor-fit service that make a website from scratch. A custom build website usually consists of a lengthy process of design, revisions, development, testing, and revisions again.
Tailor-fit - A custom build website requires the creative team to take the client's requirements, do thorough research, then brain-storm and come up with several proposals. These proposals will go through a lengthy process of revisions before reaching an acceptable state where the final design can be approved and sent to development team. The development team will then have to code everything from scratch using the approved design and features, ensuring the website runs smoothly cross browsers, cross devices.
Extendable - If planned carefully, a custom build project can be extended easily in the future with new designs and features.
No hidden cost - Once you sign a contract with the agency regarding the exact design and features you want, you don't have to pay any additional fee unless there are new features or requirements that you want to add afterward.
Taking the Custom/Bespoke approach requires the agency to actually understand your business. You should notice if they start asking lots of detailed questions and show interest in your business operation.
Designs made by the Custom approach should be specific for your business. You can question each design element and the agency should be able to tell you the reasons behind the elements and the purposes they serve.
Even with all the best tools, one cannot become a good designer without years of training and some talent. Despite the beautiful demo websites that are shown, in reality most of the sites built by end-users have much lower quality.
Many end-users, after much frustration, end up using the generic pre-built templates available on these builders with some minor customization.
No matter how easy these builders claim to be, end-users must take time (usually weeks) to learn the in and out of the tools to build a website. In the end the hidden cost can be much greater than what it appears to be at first.
By making these tools extremely to use for end-users, these builders usually have to trade for flexibly and . Most of the website builders are limited in term of features and can never offer the same customization level a custom build website has.
I have written another article, dedicated to website builders pros and cons, if you are interested in this topic please check it out. Using website builders can save your money especially if you are a start-up, just make sure you understand all the advantages and disadvantages.
Sometimes you want something uniquely designed for you to promote your brand and offers but cannot afford the time and cost of the custom website design approach. The hybrid approach allows you to pick and choose the readily designed and developed elements from a library then arrange and customize them to create something unique. Think of it as playing Lego, you take the blocks and build the objects you desire. This approach is sometimes called the Atomic Website Design Approach as described by Brad Frost in his article dated back from 2013. This design approach is more difficult than it sounds because the designers and developers have to work together to build system with all the elements that can be re-used in different scenarios while still allowing high level of customization for each project.
Nilead is one of the very few service providers that offer a real atomic website design approach, we spent months and years to create a widget platform that can actually be re-used. For every project, our developers will analyze your requirements and preferences, hand pick the best elements, arrange and customize them before sending to your for approval. Utilizing this approach, we could offer more than 50% cost saving for clients who have limited budget but still do not want to settle with using the boring and generic templates available on the market.
One added bonus of utilizing the Nilead platform and our hybrid web design approach is that we are extremely careful when we design and develop each element because we may use the same elements on multiple websites. Our system also allows us to mass update the widgets on every website when we discover a bug or add an improvement on the widget. This kind of improvement is impossible if you utilize the template approach and then customize it for your needs because subsequent updates of that same template may require lots of time of a skilled developer to compare the code bases of the old and new versions.
Depending on your requirements, budget, deadline, technical level, you can decide which option best fits you. For a hybrid option that can offer high-end, low-cost, fast turn-around website project, check our web design packages.
Vu Nguyen is an entrepreneur, a developer, and a founder of nilead.com. While his love is in the backend website development work, his experience covers eCommerce (being both a real online store owner and a developer), Search Engine Optimization, UX Design and Content Strategy.
Since 2005, Vu Nguyen has led and directed UX design, full-stack development teams on projects large and small for corporations, start-ups, individuals and more. He was involved in every task of each project, from idea to concept and vision, prototype, detailed design, build and deployment.


Well maintained & nicely updated 3 Bedroom Townhouse/Condo with Fabulous Lower Level Family Room* Updated Kitchen with Spacious eating area* Living Room w/Hardwood Floors & Updated Baths. Home is located off "Main Street" area within walking distance of Downtown Bel Air, shops, restaurants and Nature Trail* Condo Fee covers exterior maintenance* Home Warranty Included* Move-In Condition!
I am interested in 77 Ellendale Street, Bel Air, MD 21014.


Have you ever wondered if you have a crazy-big or wildly small foot? For men, it's pretty easy to determine, as there are many studies analyzing the average size of a male foot.
In 2014, the American Academy of Orthopaedic Surgeons reported that the worldwide average shoe size for men is between 9 and 12, while the American average male shoe size is a 10.5.
A mother measures her son's shoe size.
To determine your shoe size, make sure to measure your feet at the end of the day when they're the largest. The best method is to use a Brannock device or a ruler to determine your foot's length and width, but every shoe has its own shape and fit that could affect the size you'll need.
Robert Wadlow (R) sweeps with two members of the Doll family while on tour with the Ringling Brothers/Barnum & Bailey Circus, 1938.
The largest shoe size ever was 37AA, worn by Robert Wadlow, an American who lived from 1918 to 1940; Wadlow was 8 feet 11 inches tall and still holds the Guinness World Record for largest feet ever.
Nowadays, the largest shoe size that most brands offer for men is a 13 or 14, but athletic brands like Nike or Adidas offer up to an 18 or 19.
Backstage at Sacai spring '19.
While there is always the option to shop kids shoes for men with smaller feet, the smallest size most adult shoe brands offer is on average a 5.
Do Your Feet Ever Stop Growing?
A splurgeworthy Gucci leather sneaker option of Chrissy Tiegen and John Legend's new baby boy.
For most, feet will stop growing a few years after puberty or adolescence — for men, that's around age 16. Your feet may continue to go up in shoe sizes, though, due to weight gain and loss of ligament and tendon mobility across a lifetime, according to Harvard Health Publishing.


Flip Diving Hack, You Can Get Free Tickets Right Here - FlopHack!
Do you need a lot of Coins for this game? Well, you are lucky, because you can use our Flip Diving Hack to generate Coins as much as you need for the game. Our hack tool is 100% real and working. Our team of hackers has been working hard to create this tool. And now you can use it for free. We let you this hack tool for free because we love to help fellow mobile gamers to ease their gaming experience. So that is the reason we come up with this Flip Diving Hack Tool.
Flip Diving is a game where you must do a flip jump into the water from some heights. In this game, you can use tricks and customize your diver with crazy customization stuff like an outfit to make your character stand out from other players. In order you can customize the character, you will need lots of Tickets, and Tickets is rather hard to get. If you want some easy way to get Tickets, you should use our Flip Diving Cheats where you can generate tons of Tickets without paying a single buck. Get them now, this is your chance.
Many people have already used our Flip Diving Hack, and they really happy when get they get the free Tickets to their account. Now, we know that you probably need proof for the legit of our hack tool. You can see the picture below for the proof of our hack tool.
See the image above? That is the legit proof of our hack tool. Those people are really happy after they received the Flip Diving free Tickets to their game account. Do you want those free Tickets? This is your chance, use the hack tool now or never.
If you are looking for a great hack tool, flophack is the right place for you. Why is it the right place? It is because we give you the real and working tool, like this hack tool. Our team of hackers has been working hard to create this hack. The way our Flip Diving hack tool works is simple. First, our tool is connecting to the server of the game, in which every game has its own server to make their game keep on going. When our hack tool is connected to the game server, the hacking stuff begin.
Our Flip Diving Hack starts to hack the game server with the anonymous username. Then our specialized program will crack the game server to find the value code to the currency system, which in Flip Diving is the Tickets system. Our hack tool will manipulate the value of the Tickets and direct them to the anonymous username, so the account can receive the Tickets for free.
That is the way our Flip Diving Cheats work. But you don't need to think about the complexities of the process. All you have to do is just follow the instructions on how to use our tool to get the Tickets. Leave the hacking process to our tool. So sit back and wait for the Flip Diving free Tickets to your account.
1). Free To Use: Use our hack tool as you pleased and you will not spend a single dollar for using our tool.
2). No download: That is right, you don't need to download any third-party app if you want to use our Flip Diving Hack.
3). Totally secured: We build this tool with high-tech encryption system to make sure the security of your game account.
4). Free from the virus: Our tool is 100% free from any malicious virus that can harm your device.
In the game of Flip Diving, you will always need Tickets. The ticket is the main currency to get some cool stuff for your character. Tickets are hard to get. To get it, either you wait it out, or if you rich enough you buy the Tickets with real money you have through the in-game microtransaction. There is some package of Tickets you can buy with real money.
But if you are a casual gamer that doesn't want to spend a single dollar to buy Tickets, you can use our Flip Diving hack and generate as many Tickets as you want. Our hack tool is the easy and cheapest way to get Tickets because we will not cost you anything for using our tool. So go ahead use the tool. It is 100% real and working, and no survey needed!
If you already use our tool, don't forget to tell your friends about this amazing Flip Diving hack because who knows that your friends might need this hack tool too right? Always remember that sharing is caring. If you are looking for other game hack tool, explore our site to get more hack tool for your game.
When you already use our Flip Diving hack, your gameplay experience will become whole new ones. Because with the tons of Tickets that you generate from our tool, you can use it to buy all the stuff you want. Buy all the characters in the game and buy all the tricks that you can showed off to your friends.
An easier gameplay experience awaits you in the game. We even already tried the Flip Diving Hack for ourselves and it really offers you tons of fun when you have lots of Tickets. Now, you use the tool, what are you waiting for? Use it while it lasts.


Rarely does the University close because of low temperatures alone.
School districts close for cold weather much more frequently than we do. We serve adults, and most businesses that serve adults remain open even when school districts close because of cold weather.
We recognize that some of you walk long distances between classes. Our police and safety professionals monitor campus conditions continuously, and we will follow our closing procedures if necessary.
Our job is to keep the University open. We offer a service for which you pay directly.
If we close, we temporarily deny that service to you — including the many who live on or near campus. So, if our observations and consultations indicate that conditions do not present an undue threat to the campus community, we are obliged to provide the service that we have promised to you.
We welcome your comments. Send them to web@uakron.edu.
Buchtel Hall on a winter morning. Photo by @steveekaufman on Twitter.


View by pictures by scrolling. Scrolling is faster than the slideshow. You may have to scroll to the top of the page to see that enlarged version. Click directly on a picture to see an enlarged version. Enjoy!


Here are the comments we've received when asking our customers "Are there any other comments you would like to make ?". There some fabulous comments in here !
"I would prefer a much later check out time on the last morning - 10am is early - more like a hotel than apartment. During Goth weekend people stay out until 2am etc. Some hotels recognise this and extend checkout times..." - Customer had not requested this upon booking and our Terms & Conditions state arrival and departure time, so requirement not known until feedback form. Customer advised to request this next time and we can price accordingly.
"Everything was 1st class, we love it. There is nothing that I can suggest that could be improved on. The double bed is so comfortable I would like to know the name of it" - Mattress is Acacia by Times beds - we have them at home !
"The apartment was wonderful. Everything worked..." - glad to hear it !
"Thank you for providing Tea & Sugar" - and lots more besides !!


text:
Q Design & Communication Since 1981
Q LTD Celebrates 35 Years of Branding and Design
December 1, 2016 July 5, 2018 q crew, q news
Ann Arbor-based branding and design firm Q LTD celebrates 35 years of developing visual identities, brand strategies, and marketing communications for a broad range of local, regional, and global clients.
To mark the occasion and share a look back at the firm's history and people, the Q crew developed a custom anniversary website, www.q35.qltd.com.
The site features the Q story, milestones, photos, alumni and interns, and a retrospective of the firm's own brand history.
Founded in 1981 by partners Tom Rieke, Jim Frenza, and Doug Hesseltine as Quorum Communications, the company changed its name and brand mark to Q LTD in 1994. Today, the firm is owned by Christine Golus and Jeffrey Callender, both longtime Q operatives.
Q managing director Christine Golus is a graduate of the University of Michigan School of Art & Design (BFA Graphic Design) and has served as an industry advisor to the Penny W. Stamps School of Art & Design.
"Q is the world's smallest global branding and design firm," says Tom Rieke. With headquarters in Ann Arbor, Michigan, the firm also has satellite offices in Palm Springs, California and Toronto, Ontario. On international projects, Q collaborates with its European partner agency, Q GmbH in Wiesbaden, Germany.
Over the past 35 years, notable Q clients have included the annual SIGGRAPH conference on computer graphics; the University of Michigan's Ross School of Business, School of Nursing, and Wallace House; Yale University's C2; The Kresge Foundation; Bosch; NuStep; and North Star Reach. Q also designed and developed the first website for Borders Books and Music.
"We're proud of the history we have as an independent design firm, and the work we do to help clients. We're consistently delivering fresh ideas and cutting edge work. That will always be part of Q's culture," says Golus.
About Q
Q LTD's expertise includes brand strategy, visual identity, website design and development, print collateral, marketing, advertising, video/animation, naming, content strategy, and tradeshows/exhibits.
1st December, 2016q crew, q news
Q news and updates four times a year.
Your info is safe with us. Read Privacy Policy.
See past Q newsletters.
© 2020 Q LTD. All rights reserved.


text:
Q: How to constrain the results to a specific post_type on tag archive page? I registered three custom post types to a single taxonomy( the default post_tag taxonomy).
When I access example.com/tag/foo, I got the posts that have a foo tag, and the posts were taken from all the three custom post types.
I want to constrain the posts to one specific post type.
Say when I access example.com/tag/foo/?post_type=BAR or example.com/tag/foo/post_type/BAR, then I should get all the posts that have a foo tag AND the post_type of the posts is BAR.
I've tried to set the main-query's query_var to post_type => BAR in pre_get_posts but that won't work.. Because I have to paginate the posts, so I can't just simply use the WP_Query to query and show them all. So please help!

A: This works for me:
function namespace_add_custom_types( $query ) {
  if( is_tag() && empty( $query->query_vars['suppress_filters'] ) ) {
    $query->set( 'post_type', array(
     'YOUR_CUSTOM_POST_TYPE', 'nav_menu_item'));
      return $query;
    }
}
add_filter( 'pre_get_posts', 'namespace_add_custom_types' );

A: You can use WP_Query for this. By default it will paginate unless you tell it not to by passing it the 'nopaging' parameter and set it to true.
$query = new WP_Query( array(
                         // Your CPT parameters
                         'nopaging' => true,
                     )
);

In your case, you would simply rewrite the query to tell WordPress how many posts you want, etc.
$query = new WP_Query( array(
                              'post_type' => 'review',
                              'posts_per_page' => 15,
                            )
);

So this query would grab all post types with the slug of review and show 15 posts per page.


I think when I take you late at night.
I can not stand still like puberty.
That's the billions of billions.
In the universe you are.
You can not get upset.
Knock on the door of your heart.
Do not try to trick you.
It's all in my eyes.
I can only get into it.
Give me a little break.
I'll only be on your side.


Gift set consisting of a metal pen shaped screwdriver, four flat headed and four Philips screwdriver bits, matching pocket torch with three LED lights and key holder. Batteries included.
Steel, Friday afternoon hammer with bottle opener and PVC handle.
Multi-functional emergency hammer in black or white. Included in the tool is a LED torch, four COB lights and a magnet.
Stubby Hammer. Compact claw hammer with a comfortable grip, ideal for usage in tight spaces where movement is limited. Packed in a STAC gift box. Metal and ABS plastic.
Septa 7 function multi tool. The Septa 7in1 handheld screwdriver and flashlight comes with Philips, flat and hex key styles screws and bolts. The slide out bits make it simple to switch and restore bits. It includes a 3 LED flashlight with on/off power switch for better visibility. Batteries included. ABS plastic.
Small 7 piece tool set in case with bottle opener and screwdriver.
Tool set with 9 LED aluminium torch and aluminium multi tool in pen shape. Includes 3 slotted and 3 Phillips screwdriver heads. 3 AAA batteries excluded. Presented in box.


JTL plumbing apprentice Jonathan Caisley, who is learning at Tyne Metropolitan College (TyneMet) TMC Campus, has been pipped at the post in his bid to win a prestigious national skills competition.
Talented Jonathan, 21, who studies plumbing and heating during day release from a first year Level 3 apprenticeship, competed in the HIP Heating Apprentice of the Year contest after winning his regional round in January.
In the final, which took place on April 25 and 26 at ADEY Training and Conference Centre, in Cheltenham, Gloucestershire, he performed highly against seven competitors but was unable to clinch the coveted title.
Alyn Carr, Deputy Head of Construction at TyneMet, said: "Jonathan displayed great ability in winning the North East heat.
"He carried his skills through to the final, where he did very well over two tough days of competition. Unfortunately, he narrowly lost out in what was a hard-fought battle for first place.
Jonathan is employed by NU-Heat, the UK's largest supplier of warm water underfloor heating and integrated renewable solutions, and is an apprentice with JTL, a charity whose services include advanced apprenticeships, other training courses and NVQ assessments, within the Building Services sector.
The HIP annual competition was launched in 2009 by the national magazine for heating and plumbing students. It is designed to give learners the chance to gain recognition for their hard work and skills.
The contest also gives lecturers and leading industry manufacturers the opportunity to get involved and to support the next generation of installers.
Alongside the prestige for both student and college of winning a nationwide competition, £9,000 of prizes - donated by leading industry names – are on offer.
Colleges can enter one level 2 or level 3 student into one of seven regional heats – learners must be aged 24 or under and have successfully completed the previous year's test paper.
At each regional heat, the winner plus the student who has received the highest overall regional score, go forward to the final.


text:
Welcome to Brentwood Liberal Democrats
Our borough councillors
Our county councillors
MEPs serving Brentwoood
LOCAL NEWS & CAMPAIGNS
Featured / Latest ▾
Cllr Karen Chilvers to run for fourth term in Brentwood West Jan 15, 2020
Lib Dems call for noisy fireworks review Jan 12, 2020
Lib Dems call for celebration of notable Brentwood citizens Jan 12, 2020
Liberal Democrat News 02 November 2012
Originally published by UK Liberal Democrats
More cities free for growth
The Deputy Prime Minister announced this week that 20 more cities and their wider areas will be given the opportunity to bid for radical new powers to boost local growth under the 'City Deals' programme.
Cities from the successful first wave of deals, with England's
eight largest cities, secured groundbreaking powers including the ability to 'earn back' tax from the Treasury, devolved transport budgets and control of the skills budget for their city.
The second group includes: the Black Country; Bournemouth; Brighton and Hove; Hull and Humber; Ipswich; Leicester and Leicestershire; Greater Norwich; Oxford; Reading; Plymouth; Southampton and Portsmouth; Stoke and Staffordshire; Sunderland and the North East; Swindon and Wiltshire and the Tees Valley.
"In the best English tradition we have witnessed a quiet revolution across the nation's eight largest cities," said Nick. "From control over buses and trains and the freedom to plug skills gaps, to powers to 'earn back' tax and
set up local investment funds to spend on local projects - the deals are unlocking the huge potential of our cities so they can go for growth.
"Now it's time to free even more places from Whitehall control. I want these 20 cities and their wider areas to come up with ambitious and innovative proposals to help them make changes that will be felt by everyone across their region."
City Deals are a key part of the government's objectives of rebalancing the economy and boosting private sector growth. The Deals will accelerate the pace of decentralisation and unlock new and innovative ways to drive growth.
MP Julian Huppert has welcomed the chance for Cambridge - was one of the cities announced this week - to bid for more government funding. "This is an excellent opportunity for Cambridge to demonstrate what it is capable of - freeing us to do what we want with less interference from Whitehall," he said.
"Cambridge has always struggled because of the lack of government funding for major infrastructure. Despite this, the City has proved it is one of the strongest economic centres in the UK; but it could do so much more with the right financial support. If our bid is successful, it will open up a whole range of new opportunities for our City; the possibilities are endless," added Julian.
Brentwood Lib Dems Twitter
Brentwood Liberal Democrats Facebook
NATIONAL NEWS & CAMPAIGNS
If you enter your details on this website, the Liberal Democrats, locally and nationally, may use information in it, including your political views, to further our objectives, share it with our elected representatives and/or contact you in future using any of the means provided. Some contacts may be automated. You may opt out of some or all contacts or exercise your other legal rights by contacting us. Further details are in our Privacy Policy at brentwoodlibdems.org.uk/en/privacy
Published and promoted by Brentwood Liberal Democrats, The Blue House, Doddinghurst Road, Brentwood, Essex, CM15 0SJ
Website designed and developed by Prater Raines Ltd, with modifications by Brentwood Liberal Democrats


The flamboyant Victorian British Prime Minister, Benjamin Disraeli, once noted that; "There can be economy, only where there is efficiency".
Zimbabwe's economy has been full of inefficiencies for far too long. Waste in the economy, has led to want amongst the people. Our people deserve better. And as the Minister of Finance, I have a duty to set things right.
The Government's Transitional Stabilisation Programme is at the heart of our reform programme. It outlines the State Enterprise Reform initiative as one of the most important areas to ensure sustainable economic growth and improved service delivery.
We therefore cannot allow for inefficiencies and mismanagement to waste our taxpayers' money anymore; especially in an era of austerity. The people of Zimbabwe deserve better.
But this is how innovation begins. This is how we will rebuild Zimbabwe's economy, from the bottom up.


Today we're posting 30+ fresh business card designs. In last business card post which was (60+ High-Qty Business Card Designs Part – 1) is really popular and this collection also inspiring you.
Business cards are representing company or individual bearing business information like company's or individual's name, address, e-mail, telephone number etc. Usually business cards are simple – black text on white background – including just main information and company's logotype, but there are many other creative business cards standing out and really taking attention.
I took a special interest in these kind of business cards, so here is my list about the most awesome and creative business cards, I've ever seen.
There are several thousands known collections of business cards, especially antique cards, celebrity cards, or cards made of unusual materials. But we collected some Unusual, High-Qty, Inspiring Business Card Designs with good quality printing to inspire you which is not easy to forgot.