text:
#include "unit_test_framework.h"

#include "data.h"

#include "etl/forward_list.h"

#include <algorithm>
#include <array>
#include <forward_list>
#include <vector>
#include <string>
#include <list>
#include <functional>

namespace
{
  SUITE(test_forward_list)
  {
    const size_t SIZE = 10UL;

    typedef TestDataDC<std::string>  ItemDC;
    typedef TestDataNDC<std::string> ItemNDC;
    typedef TestDataM<uint32_t>      ItemM;

    typedef etl::forward_list<ItemDC, SIZE>  DataDC;
    typedef etl::forward_list<ItemNDC, SIZE> DataNDC;
    typedef etl::iforward_list<ItemNDC>      IDataNDC;

    typedef etl::forward_list<ItemM, SIZE>  DataM;
    typedef etl::iforward_list<ItemM>       IDataM;

    typedef etl::forward_list<int, SIZE> DataInt;

    typedef std::forward_list<ItemDC> CompareDataDC;
    typedef std::forward_list<ItemNDC> CompareDataNDC;
    typedef std::vector<ItemNDC> InitialDataNDC;

    InitialDataNDC stable_sort_data;
    InitialDataNDC unsorted_data;
    InitialDataNDC sorted_data;
    InitialDataNDC non_unique_data;
    InitialDataNDC small_data;

    bool are_equal;

    //*************************************************************************
    struct SetupFixture
    {
      SetupFixture()
      {
        stable_sort_data = { ItemNDC("1", 1), ItemNDC("2", 2), ItemNDC("3", 3), ItemNDC("2", 4), ItemNDC("0", 5), ItemNDC("2", 6), ItemNDC("7", 7), ItemNDC("4", 8), ItemNDC("4", 9), ItemNDC("8", 10) };
        unsorted_data    = { ItemNDC("1"), ItemNDC("0"), ItemNDC("3"), ItemNDC("2"), ItemNDC("5"), ItemNDC("4"), ItemNDC("7"), ItemNDC("6"), ItemNDC("9"), ItemNDC("8") };
        sorted_data      = { ItemNDC("0"), ItemNDC("1"), ItemNDC("2"), ItemNDC("3"), ItemNDC("4"), ItemNDC("5"), ItemNDC("6"), ItemNDC("7"), ItemNDC("8"), ItemNDC("9") };
        non_unique_data  = { ItemNDC("0"), ItemNDC("0"), ItemNDC("1"), ItemNDC("1"), ItemNDC("2"), ItemNDC("3"), ItemNDC("3"), ItemNDC("3"), ItemNDC("4"), ItemNDC("5") };
        small_data       = { ItemNDC("0"), ItemNDC("1"), ItemNDC("2"), ItemNDC("3"), ItemNDC("4"), ItemNDC("5") };
      }
    };

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_default_constructor)
    {
      DataDC data;

      CHECK(data.empty());
      CHECK_EQUAL(data.max_size(), SIZE);
      CHECK(data.begin() == data.end());
    }

#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST && !defined(ETL_TEMPLATE_DEDUCTION_GUIDE_TESTS_DISABLED)
    //*************************************************************************
    TEST(test_cpp17_deduced_constructor)
    {
      etl::forward_list data{ ItemNDC("1", 1), ItemNDC("2", 2), ItemNDC("3", 3), ItemNDC("2", 4), ItemNDC("0", 5), ItemNDC("2", 6), ItemNDC("7", 7), ItemNDC("4", 8), ItemNDC("4", 9), ItemNDC("8", 10) };
      etl::forward_list< ItemNDC, 10> check = { ItemNDC("1", 1), ItemNDC("2", 2), ItemNDC("3", 3), ItemNDC("2", 4), ItemNDC("0", 5), ItemNDC("2", 6), ItemNDC("7", 7), ItemNDC("4", 8), ItemNDC("4", 9), ItemNDC("8", 10) };

      CHECK(!data.empty());
      CHECK(data.full());
      CHECK(data.begin() != data.end());
      CHECK_EQUAL(0U, data.available());
      CHECK_EQUAL(10U, data.capacity());
      CHECK_EQUAL(10U, data.size());
      CHECK_EQUAL(10U, data.max_size());
      CHECK(data == check);
    }
#endif

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_constructor_size)
    {
      const size_t INITIAL_SIZE = 4UL;
      DataDC data(INITIAL_SIZE);

      CHECK(!data.empty());
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_constructor_size_excess)
    {
      CHECK_THROW(DataDC data(SIZE + 1), etl::forward_list_full);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_constructor_size_value)
    {
      const size_t INITIAL_SIZE = 4UL;
      const ItemNDC INITIAL_VALUE("1");

      std::array<ItemNDC, INITIAL_SIZE> compare_data = { ItemNDC("1"), ItemNDC("1"), ItemNDC("1"), ItemNDC("1") };

      DataNDC data(INITIAL_SIZE, INITIAL_VALUE);

      CHECK(!data.empty());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());

      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_constructor_range)
    {
      CompareDataNDC compare(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());

      CHECK(!data.empty());

      are_equal = std::equal(data.begin(), data.end(), compare.begin());

      CHECK(are_equal);
    }

#if ETL_HAS_INITIALIZER_LIST
    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_constructor_initializer_list)
    {
      CompareDataNDC compare = { ItemNDC("0"), ItemNDC("1"), ItemNDC("2"), ItemNDC("3") };
      DataNDC data = { ItemNDC("0"), ItemNDC("1"), ItemNDC("2"), ItemNDC("3") };

      CHECK(!data.empty());

      are_equal = std::equal(data.begin(), data.end(), compare.begin());
      CHECK(are_equal);
    }
#endif

    //*************************************************************************
    TEST(test_destruct_via_iforward_list)
    {
      int current_count = ItemNDC::get_instance_count();

      DataNDC* pdata = new DataNDC(sorted_data.begin(), sorted_data.end());
      CHECK_EQUAL(int(current_count + sorted_data.size()), ItemNDC::get_instance_count());

      IDataNDC* pidata = pdata;
      delete pidata;
      CHECK_EQUAL(current_count, ItemNDC::get_instance_count());
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_copy_constructor)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());
      DataNDC other_data(data);

      CHECK(std::equal(data.begin(), data.end(), other_data.begin()));
    }

    //*************************************************************************
    TEST(test_move_constructor)
    {
      ItemM p1(1U);
      ItemM p2(2U);
      ItemM p3(3U);
      ItemM p4(4U);

      DataM data1;
      data1.push_front(std::move(p1));
      data1.push_front(std::move(p2));
      data1.push_front(std::move(p3));
      data1.push_front(std::move(p4));

      CHECK(!bool(p1));
      CHECK(!bool(p2));
      CHECK(!bool(p3));
      CHECK(!bool(p4));

      DataM data2(std::move(data1));

      CHECK_EQUAL(0U, data1.size());
      CHECK_EQUAL(4U, data2.size());

      DataM::const_iterator itr = data2.begin();

      CHECK_EQUAL(4U, (*itr++).value);
      CHECK_EQUAL(3U, (*itr++).value);
      CHECK_EQUAL(2U, (*itr++).value);
      CHECK_EQUAL(1U, (*itr++).value);
    }

    //*************************************************************************
    TEST(test_move_assignment)
    {
      ItemM p1(1U);
      ItemM p2(2U);
      ItemM p3(3U);
      ItemM p4(4U);

      DataM data1;
      data1.push_front(std::move(p1));
      data1.push_front(std::move(p2));
      data1.push_front(std::move(p3));
      data1.push_front(std::move(p4));

      DataM data2;
      data2 = std::move(data1);

      CHECK_EQUAL(0U, data1.size());
      CHECK_EQUAL(4U, data2.size());

      DataM::const_iterator itr = data2.begin();

      CHECK_EQUAL(4U, (*itr++).value);
      CHECK_EQUAL(3U, (*itr++).value);
      CHECK_EQUAL(2U, (*itr++).value);
      CHECK_EQUAL(1U, (*itr++).value);
    }

    //*************************************************************************
    TEST(test_move_assignment_interface)
    {
      ItemM p1(1U);
      ItemM p2(2U);
      ItemM p3(3U);
      ItemM p4(4U);

      DataM data1;
      data1.push_front(std::move(p1));
      data1.push_front(std::move(p2));
      data1.push_front(std::move(p3));
      data1.push_front(std::move(p4));

      DataM data2;

      IDataM& idata1 = data1;
      IDataM& idata2 = data2;

      idata2 = std::move(idata1);

      CHECK_EQUAL(0U, data1.size());
      CHECK_EQUAL(4U, data2.size());

      DataM::const_iterator itr = data2.begin();

      CHECK_EQUAL(4U, (*itr++).value);
      CHECK_EQUAL(3U, (*itr++).value);
      CHECK_EQUAL(2U, (*itr++).value);
      CHECK_EQUAL(1U, (*itr++).value);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_iterator)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(compare_data.begin(), compare_data.end());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());

      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_const_iterator)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      const DataNDC data(compare_data.begin(), compare_data.end());

      are_equal = std::equal(data.cbegin(), data.cend(), compare_data.cbegin());

      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_resize_up)
    {
      const size_t INITIAL_SIZE = 4UL;
      const size_t NEW_SIZE = 8UL;
      const ItemDC VALUE("1");

      DataDC data(INITIAL_SIZE, VALUE);
      data.resize(NEW_SIZE);

      CompareDataDC compare_data(INITIAL_SIZE, VALUE);
      compare_data.resize(NEW_SIZE);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_resize_up_value)
    {
      const size_t INITIAL_SIZE = 4UL;
      const size_t NEW_SIZE     = 8UL;
      const ItemNDC VALUE("1");

      DataNDC data(INITIAL_SIZE, VALUE);
      data.resize(NEW_SIZE, VALUE);

      CompareDataNDC compare_data(INITIAL_SIZE, VALUE);
      compare_data.resize(NEW_SIZE, VALUE);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_resize_excess)
    {
      const size_t INITIAL_SIZE = 4UL;
      DataDC data(INITIAL_SIZE);

      CHECK_THROW(data.resize(data.max_size() + 1), etl::forward_list_full);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_resize_down)
    {
      const size_t INITIAL_SIZE = 4UL;
      const size_t NEW_SIZE = 2UL;
      const ItemDC VALUE("1");

      DataDC data(INITIAL_SIZE, VALUE);
      data.resize(NEW_SIZE);

      CompareDataDC compare_data(INITIAL_SIZE, VALUE);
      compare_data.resize(NEW_SIZE);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_resize_down_value)
    {
      const size_t INITIAL_SIZE = 4UL;
      const size_t NEW_SIZE = 2UL;
      const ItemNDC VALUE("1");

      DataNDC data(INITIAL_SIZE, VALUE);
      data.resize(NEW_SIZE, VALUE);

      CompareDataNDC compare_data(INITIAL_SIZE, VALUE);
      compare_data.resize(NEW_SIZE, VALUE);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_resize_zero)
    {
      const size_t INITIAL_SIZE = 4UL;
      const size_t NEW_SIZE = 0UL;
      const ItemDC VALUE("1");

      DataDC data(INITIAL_SIZE, VALUE);
      data.resize(NEW_SIZE);

      CompareDataDC compare_data(INITIAL_SIZE, VALUE);
      compare_data.resize(NEW_SIZE);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_clear)
    {
      DataNDC data(sorted_data.begin(), sorted_data.end());
      data.clear();
      CHECK(data.empty());

      // Do it again to check that clear() didn't screw up the internals.
      data.assign(sorted_data.begin(), sorted_data.end());
      CHECK_EQUAL(SIZE, data.size());
      data.clear();
      CHECK_EQUAL(size_t(0UL), data.size());
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_clear_pod)
    {
      DataInt data(SIZE, 1);

      data.clear();
      CHECK(data.empty());

      // Do it again to check that clear() didn't screw up the internals.
      data.resize(SIZE);
      CHECK_EQUAL(SIZE, data.size());
      data.clear();
      CHECK_EQUAL(size_t(0UL), data.size());
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_assign_range)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data;

      // Do it twice. We should only get one copy.
      data.assign(compare_data.begin(), compare_data.end());
      data.assign(compare_data.begin(), compare_data.end());

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_assign_size_value)
    {
      const size_t INITIAL_SIZE = 4UL;
      const ItemNDC VALUE("1");

      CompareDataNDC compare_data(INITIAL_SIZE, VALUE);
      DataNDC data;

      // Do it twice. We should only get one copy.
      data.assign(INITIAL_SIZE, VALUE);
      data.assign(INITIAL_SIZE, VALUE);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_assign_size_value_excess)
    {
      const ItemNDC VALUE("1");

      DataNDC data;

      CHECK_THROW(data.assign(data.max_size() + 1, VALUE), etl::forward_list_full);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_insert_after_position_value)
    {
      const size_t INITIAL_SIZE = 4UL;
      const ItemNDC VALUE("1");
      const ItemNDC INSERT_VALUE("2");

      CompareDataNDC compare_data(INITIAL_SIZE, VALUE);
      DataNDC data(INITIAL_SIZE, VALUE);

      size_t offset = 2UL;

      DataNDC::iterator i_data = data.begin();
      std::advance(i_data, offset);

      CompareDataNDC::iterator i_compare_data = compare_data.begin();
      std::advance(i_compare_data, offset);

      data.insert_after(i_data, INSERT_VALUE);
      compare_data.insert_after(i_compare_data, INSERT_VALUE);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);

      offset = 0;

      i_data = data.begin();
      std::advance(i_data, offset);

      i_compare_data = compare_data.begin();
      std::advance(i_compare_data, offset);

      data.insert_after(i_data, INSERT_VALUE);
      compare_data.insert_after(i_compare_data, INSERT_VALUE);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_insert_after_position_size_value)
    {
      const size_t INITIAL_SIZE = 4UL;
      const ItemNDC VALUE("1");
      const ItemNDC INSERT_VALUE("2");

      CompareDataNDC compare_data(INITIAL_SIZE, VALUE);
      DataNDC data(INITIAL_SIZE, VALUE);

      size_t offset = 2UL;

      DataNDC::iterator i_data = data.begin();
      std::advance(i_data, offset);

      CompareDataNDC::iterator i_compare_data = compare_data.begin();
      std::advance(i_compare_data, offset);

      data.insert_after(i_data, 2, INSERT_VALUE);
      compare_data.insert_after(i_compare_data, 2, INSERT_VALUE);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);

      offset = 0;

      i_data = data.begin();
      std::advance(i_data, offset);

      i_compare_data = compare_data.begin();
      std::advance(i_compare_data, offset);

      data.insert_after(i_data, 2, INSERT_VALUE);
      compare_data.insert_after(i_compare_data, 2, INSERT_VALUE);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_insert_after_range)
    {
      std::vector<ItemNDC> test1 = { ItemNDC("0"), ItemNDC("1"), ItemNDC("2"), ItemNDC("3"), ItemNDC("4") };
      std::vector<ItemNDC> test2 = { ItemNDC("5"), ItemNDC("6"), ItemNDC("7"), ItemNDC("8"), ItemNDC("9") };

      CompareDataNDC compare_data(test1.begin(), test1.end());
      DataNDC data(test1.begin(), test1.end());

      compare_data.insert_after(compare_data.before_begin(), test2.begin(), test2.end());
      data.insert_after(data.before_begin(), test2.begin(), test2.end());

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);

      compare_data.assign(test1.begin(), test1.end());
      data.assign(test1.begin(), test1.end());

      CompareDataNDC::iterator icd = compare_data.begin();
      DataNDC::iterator         id = data.begin();

      std::advance(icd, 3);
      std::advance(id, 3);

      compare_data.insert_after(icd, test2.begin(), test2.end());
      data.insert_after(id, test2.begin(), test2.end());

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_push_front)
    {
      CompareDataNDC compare_data;
      DataNDC data;

      compare_data.push_front(ItemNDC("1"));
      compare_data.push_front(ItemNDC("2"));
      compare_data.push_front(ItemNDC("3"));
      compare_data.push_front(ItemNDC("4"));
      compare_data.push_front(ItemNDC("5"));
      compare_data.push_front(ItemNDC("6"));

      CHECK_NO_THROW(data.push_front(ItemNDC("1")));
      CHECK_NO_THROW(data.push_front(ItemNDC("2")));
      CHECK_NO_THROW(data.push_front(ItemNDC("3")));
      CHECK_NO_THROW(data.push_front(ItemNDC("4")));
      CHECK_NO_THROW(data.push_front(ItemNDC("5")));
      CHECK_NO_THROW(data.push_front(ItemNDC("6")));

      CHECK_EQUAL(6U, data.size());
      CHECK_EQUAL(6, std::distance(data.begin(), data.end()));

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_push_front_move)
    {
      ItemM p1(1U);
      ItemM p2(2U);
      ItemM p3(3U);
      ItemM p4(4U);

      DataM data;
      data.push_front(std::move(p1));
      data.push_front(std::move(p2));
      data.push_front(std::move(p3));
      data.push_front(std::move(p4));

      CHECK_EQUAL(4U, data.size());

      CHECK(!bool(p1));
      CHECK(!bool(p2));
      CHECK(!bool(p3));
      CHECK(!bool(p4));

      DataM::const_iterator itr = data.begin();

      CHECK_EQUAL(4U, (*itr++).value);
      CHECK_EQUAL(3U, (*itr++).value);
      CHECK_EQUAL(2U, (*itr++).value);
      CHECK_EQUAL(1U, (*itr++).value);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_emplace_front)
    {
      CompareDataNDC compare_data;
      DataNDC data;

      compare_data.emplace_front("1");
      compare_data.emplace_front("2");
      compare_data.emplace_front("3");
      compare_data.emplace_front("4");
      compare_data.emplace_front("5");
      compare_data.emplace_front("6");

      CHECK_NO_THROW(data.emplace_front("1"));
      CHECK_NO_THROW(data.emplace_front("2"));
      CHECK_NO_THROW(data.emplace_front("3"));
      CHECK_NO_THROW(data.emplace_front("4"));
      CHECK_NO_THROW(data.emplace_front("5"));
      CHECK_NO_THROW(data.emplace_front("6"));

      CHECK_EQUAL(6U, data.size());
      CHECK_EQUAL(6, std::distance(data.begin(), data.end()));

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_emplace_after)
    {
      CompareDataNDC compare_data;
      DataNDC data;

      CompareDataNDC::iterator itc;

      itc = compare_data.before_begin();
      compare_data.emplace_after(itc, "1");
      compare_data.emplace_after(itc, "2");

      ++itc;
      compare_data.emplace_after(itc, "3");
      compare_data.emplace_after(itc, "4");

      ++itc;
      compare_data.emplace_after(itc, "5");
      compare_data.emplace_after(itc, "6");

      DataNDC::iterator itd;

      itd = data.before_begin();
      CHECK_NO_THROW(data.emplace_after(itd, "1"));
      CHECK_NO_THROW(data.emplace_after(itd, "2"));

      ++itd;
      CHECK_NO_THROW(data.emplace_after(itd, "3"));
      CHECK_NO_THROW(data.emplace_after(itd, "4"));

      ++itd;
      CHECK_NO_THROW(data.emplace_after(itd, "5"));
      CHECK_NO_THROW(data.emplace_after(itd, "6"));

      CHECK_EQUAL(6U, data.size());
      CHECK_EQUAL(6, std::distance(data.begin(), data.end()));

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_front_const)
    {
      const DataNDC data(sorted_data.begin(), sorted_data.end());

      CHECK_EQUAL(ItemNDC("0"), data.front());
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_before_begin_const)
    {
      const DataNDC data(sorted_data.begin(), sorted_data.end());

      DataNDC::const_iterator itr = data.before_begin();
      ++itr;

      are_equal = std::equal(data.begin(), data.end(), itr);

      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_push_front_excess)
    {
      DataNDC data;

      CHECK_NO_THROW(data.push_front(ItemNDC("0")));
      CHECK_NO_THROW(data.push_front(ItemNDC("1")));
      CHECK_NO_THROW(data.push_front(ItemNDC("2")));
      CHECK_NO_THROW(data.push_front(ItemNDC("3")));
      CHECK_NO_THROW(data.push_front(ItemNDC("4")));
      CHECK_NO_THROW(data.push_front(ItemNDC("5")));
      CHECK_NO_THROW(data.push_front(ItemNDC("6")));
      CHECK_NO_THROW(data.push_front(ItemNDC("7")));
      CHECK_NO_THROW(data.push_front(ItemNDC("8")));
      CHECK_NO_THROW(data.push_front(ItemNDC("9")));

      CHECK_THROW(data.push_front(ItemNDC("10")) , etl::forward_list_full);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_push_front_pop_front)
    {
      DataNDC data;

      for (size_t i = 0UL; i < 2UL * data.max_size(); ++i)
      {
        CHECK_NO_THROW(data.push_front(ItemNDC("1")));
        data.pop_front();
      }

      CHECK(data.empty());
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_pop_front_empty)
    {
      DataNDC data;

      CHECK_NO_THROW(data.push_front(ItemNDC("0")));
      CHECK_NO_THROW(data.push_front(ItemNDC("1")));
      CHECK_NO_THROW(data.push_front(ItemNDC("2")));
      CHECK_NO_THROW(data.push_front(ItemNDC("3")));

      data.pop_front();
      data.pop_front();
      data.pop_front();
      data.pop_front();

      CHECK_THROW(data.pop_front(), etl::forward_list_empty);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_erase_after_single)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());

      DataNDC::iterator i_data = data.begin();
      std::advance(i_data, 2);

      CompareDataNDC::iterator i_compare_data = compare_data.begin();
      std::advance(i_compare_data, 2);

      i_compare_data = compare_data.erase_after(i_compare_data);
      i_data         = data.erase_after(i_data);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
      CHECK(*i_compare_data == *i_data);

      i_compare_data = compare_data.erase_after(compare_data.begin());
      i_data         = data.erase_after(data.begin());

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);

      are_equal = *i_data == *i_compare_data;
      CHECK(are_equal);

      // Move to the last value and erase.
      i_compare_data = compare_data.begin();
      //std::advance(i_compare_data, compare_data.size() - 1);
      i_compare_data = compare_data.erase_after(i_compare_data);

      i_data = data.begin();
      //std::advance(i_data, data.size() - 1);
      i_data = data.erase_after(i_data);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());

      CHECK(are_equal);
      are_equal = *i_data == *i_compare_data;
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_erase_after_range)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());

      DataNDC::iterator i_data_1 = data.begin();
      std::advance(i_data_1, 2);

      DataNDC::iterator i_data_2 = data.begin();
      std::advance(i_data_2, 4);

      CompareDataNDC::iterator i_compare_data_1 = compare_data.begin();
      std::advance(i_compare_data_1, 2);

      CompareDataNDC::iterator i_compare_data_2 = compare_data.begin();
      std::advance(i_compare_data_2, 4);

      CompareDataNDC::iterator i_compare_result = compare_data.erase_after(i_compare_data_1, i_compare_data_2);

      DataNDC::iterator i_result = data.erase_after(i_data_1, i_data_2);

      CHECK_EQUAL(*i_compare_result, *i_result);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_erase_after_range_end)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());

      DataNDC::iterator i_data = data.begin();
      std::advance(i_data, 4);

      CompareDataNDC::iterator i_compare_data = compare_data.begin();
      std::advance(i_compare_data, 4);

      compare_data.erase_after(i_compare_data, compare_data.end());

      DataNDC::iterator i_result = data.erase_after(i_data, data.end());

      CHECK(i_result == data.end());

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_erase_after_all)
    {
      DataNDC data(sorted_data.begin(), sorted_data.end());

      data.erase_after(data.before_begin(), data.end());

      CHECK(data.empty());
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_front)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());

      CHECK_EQUAL(compare_data.front(), data.front());
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_assignment)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());
      DataNDC other_data;

      other_data = data;

      CHECK_EQUAL(data.size(), other_data.size());

      are_equal = std::equal(data.begin(), data.end(), other_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_assignment_interface)
    {
      DataNDC data1(sorted_data.begin(), sorted_data.end());
      DataNDC data2;

      IDataNDC& idata1 = data1;
      IDataNDC& idata2 = data2;

      idata2 = idata1;

      bool isEqual = std::equal(data1.begin(), data1.end(), data2.begin());
      CHECK(isEqual);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_self_assignment)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());
      DataNDC other_data(data);

#include "etl/private/diagnostic_self_assign_overloaded_push.h"
      other_data = other_data;
#include "etl/private/diagnostic_pop.h"

      CHECK_EQUAL(data.size(), other_data.size());

      are_equal = std::equal(data.begin(), data.end(), other_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_unique_empty)
    {
      CompareDataNDC compare_data;
      DataNDC data;

      compare_data.unique();
      data.unique();

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_unique)
    {
      CompareDataNDC compare_data(non_unique_data.begin(), non_unique_data.end());
      DataNDC data(non_unique_data.begin(), non_unique_data.end());

      compare_data.unique();
      data.unique();

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_remove)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());

      compare_data.remove(ItemNDC("7"));
      data.remove(ItemNDC("7"));

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_remove_if)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());

      compare_data.remove_if(std::bind(std::equal_to<ItemNDC>(), std::placeholders::_1, ItemNDC("7")));
      data.remove_if(std::bind(std::equal_to<ItemNDC>(), std::placeholders::_1, ItemNDC("7")));

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_reverse)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());

      compare_data.reverse();
      data.reverse();

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());
      CHECK_EQUAL(data.size(), size_t(std::distance(data.begin(), data.end())));

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_reverse_empty)
    {
      CompareDataNDC compare_data;
      DataNDC data;

      compare_data.reverse();
      data.reverse();

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_sort)
    {
      CompareDataNDC compare_data(unsorted_data.begin(), unsorted_data.end());
      DataNDC data(unsorted_data.begin(), unsorted_data.end());

      compare_data.sort();
      data.sort();

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_stable_sort)
    {
      std::list<ItemNDC> compare_data(stable_sort_data.begin(), stable_sort_data.end());
      DataNDC data(stable_sort_data.begin(), stable_sort_data.end());

      compare_data.sort();
      data.sort();

      std::list<ItemNDC>::const_iterator citr = compare_data.begin();
      DataNDC::const_iterator        ditr = data.begin();

      while (ditr != data.end())
      {
        CHECK_EQUAL(citr->index, ditr->index);

        ++citr;
        ++ditr;
      }
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_sort_empty)
    {
      CompareDataNDC compare_data;
      DataNDC data;

      compare_data.sort();
      data.sort();

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_move)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());

      DataNDC::const_iterator i_from_before;
      DataNDC::const_iterator i_to_before;
      CompareDataNDC::const_iterator i_compare_from_before;
      CompareDataNDC::const_iterator i_compare_to_before;

      // Move to the beginning.
      i_from_before = data.begin();
      std::advance(i_from_before, 5);

      i_to_before = data.before_begin();

      i_compare_from_before = compare_data.begin();
      std::advance(i_compare_from_before, 5);

      i_compare_to_before = compare_data.before_begin();

      compare_data.splice_after(i_compare_to_before, compare_data, i_compare_from_before);
      data.move_after(i_from_before, i_to_before);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);

      // Move to the end.
      i_from_before = data.begin();
      std::advance(i_from_before, 5);

      i_to_before = data.begin();
      std::advance(i_to_before, 9);

      i_compare_from_before = compare_data.begin();
      std::advance(i_compare_from_before, 5);

      i_compare_to_before = compare_data.begin();
      std::advance(i_compare_to_before, 9);

      compare_data.splice_after(i_compare_to_before, compare_data, i_compare_from_before);
      data.move_after(i_from_before, i_to_before);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);

      // Move to nearby.
      i_from_before = data.begin();
      std::advance(i_from_before, 3);

      i_to_before = data.begin();
      std::advance(i_to_before, 7);

      i_compare_from_before = compare_data.begin();
      std::advance(i_compare_from_before, 3);

      i_compare_to_before = compare_data.begin();
      std::advance(i_compare_to_before, 7);

      compare_data.splice_after(i_compare_to_before, compare_data, i_compare_from_before);
      data.move_after(i_from_before, i_to_before);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);

      // Move to same.
      i_from_before = data.begin();
      std::advance(i_from_before, 3);

      i_to_before = data.begin();
      std::advance(i_to_before, 3);

      i_compare_from_before = compare_data.begin();
      std::advance(i_compare_from_before, 3);

      i_compare_to_before = compare_data.begin();
      std::advance(i_compare_to_before, 3);

      compare_data.splice_after(i_compare_to_before, compare_data, i_compare_from_before);
      data.move_after(i_from_before, i_to_before);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_move_range)
    {
      CompareDataNDC compare_data(sorted_data.begin(), sorted_data.end());
      DataNDC data(sorted_data.begin(), sorted_data.end());

      DataNDC::const_iterator i_first_before;
      DataNDC::const_iterator i_last;
      DataNDC::const_iterator i_to_before;
      CompareDataNDC::const_iterator i_compare_first_before;
      CompareDataNDC::const_iterator i_compare_last;
      CompareDataNDC::const_iterator i_compare_to_before;

      // Move to the beginning.
      i_first_before = data.begin();
      std::advance(i_first_before, 4);

      i_last = i_first_before;
      std::advance(i_last, 4);

      i_to_before = data.before_begin();

      i_compare_first_before = compare_data.begin();
      std::advance(i_compare_first_before, 4);

      i_compare_last = i_compare_first_before;
      std::advance(i_compare_last, 4);

      i_compare_to_before = compare_data.before_begin();

      compare_data.splice_after(i_compare_to_before, compare_data, i_compare_first_before, i_compare_last);
      data.move_after(i_first_before, i_last, i_to_before);

      CHECK_EQUAL(size_t(std::distance(compare_data.begin(), compare_data.end())), data.size());

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);

      // Move to the end.
      i_first_before = data.begin();
      std::advance(i_first_before, 4);

      i_last = i_first_before;
      std::advance(i_last, 4);

      i_to_before = data.begin();
      std::advance(i_to_before, 9);

      i_compare_first_before = compare_data.begin();
      std::advance(i_compare_first_before, 4);

      i_compare_last = i_compare_first_before;
      std::advance(i_compare_last, 4);

      i_compare_to_before = compare_data.begin();
      std::advance(i_compare_to_before, 9);

      compare_data.splice_after(i_compare_to_before, compare_data, i_compare_first_before, i_compare_last);
      data.move_after(i_first_before, i_last, i_to_before);

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);

      // Move to nearby.
      i_first_before = data.begin();
      std::advance(i_first_before, 4);

      i_last = i_first_before;
      std::advance(i_last, 4);

      i_to_before = data.begin();
      std::advance(i_to_before, 2);

      i_compare_first_before = compare_data.begin();
      std::advance(i_compare_first_before, 4);

      i_compare_last = i_compare_first_before;
      std::advance(i_compare_last, 4);

      i_compare_to_before = compare_data.begin();
      std::advance(i_compare_to_before, 2);

      compare_data.splice_after(i_compare_to_before, compare_data, i_compare_first_before, i_compare_last);
      data.move_after(i_first_before, i_last, i_to_before);

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);

      // Move to same.
      i_first_before = data.begin();
      std::advance(i_first_before, 4);

      i_last = i_first_before;
      std::advance(i_last, 4);

      i_to_before = data.begin();
      std::advance(i_to_before, 4);

      i_compare_first_before = compare_data.begin();
      std::advance(i_compare_first_before, 4);

      i_compare_last = i_compare_first_before;
      std::advance(i_compare_last, 4);

      i_compare_to_before = compare_data.begin();
      std::advance(i_compare_to_before, 4);

      compare_data.splice_after(i_compare_to_before, compare_data, i_compare_first_before, i_compare_last);
      data.move_after(i_first_before, i_last, i_to_before);

      are_equal = std::equal(data.begin(), data.end(), compare_data.begin());
      CHECK(are_equal);

      // Move to illegal place.
      i_first_before = data.begin();
      std::advance(i_first_before, 2);
      i_last = i_first_before;
      std::advance(i_last, 3);
      i_to_before = i_first_before;
      std::advance(i_to_before, 2);

      CHECK_THROW(data.move_after(i_first_before, i_last, i_to_before), etl::forward_list_iterator);
    }

    //*************************************************************************
    TEST_FIXTURE(SetupFixture, test_binary_comparisons)
    {
      DataNDC data1(sorted_data.begin(), sorted_data.end());
      DataNDC data2(sorted_data.begin(), sorted_data.end());
      DataNDC data3(unsorted_data.begin(), unsorted_data.end());

      CHECK(data1 == data2);
      CHECK(data1 != data3);
      CHECK(data1 < data3);
      CHECK(data3 > data1);
    }

    //*************************************************************************
    TEST(test_two_parameter_same_type_non_iterator)
    {
      // No compile error.
      etl::forward_list<int, 10> fl(10, 1);
      CHECK(fl.size() == 10);
      fl.assign(5, 2);
      CHECK(fl.size() == 5);
      fl.insert_after(fl.before_begin(), 5, 3);
      CHECK(fl.size() == fl.max_size());
    }

    //*************************************************************************
#if ETL_USING_CPP17 && ETL_HAS_INITIALIZER_LIST && !defined(ETL_TEMPLATE_DEDUCTION_GUIDE_TESTS_DISABLED)
    TEST(test_forward_list_template_deduction)
    {
      etl::forward_list data{ ItemNDC("A"), ItemNDC("B"), ItemNDC("C"), ItemNDC("D"), ItemNDC("E"), ItemNDC("F") };

      auto v = *data.begin();
      using Type = decltype(v);
      CHECK((std::is_same_v<ItemNDC, Type>));

      decltype(data)::const_iterator itr = data.begin();

      CHECK_EQUAL(ItemNDC("A"), *itr++);
      CHECK_EQUAL(ItemNDC("B"), *itr++);
      CHECK_EQUAL(ItemNDC("C"), *itr++);
      CHECK_EQUAL(ItemNDC("D"), *itr++);
      CHECK_EQUAL(ItemNDC("E"), *itr++);
      CHECK_EQUAL(ItemNDC("F"), *itr++);
    }
#endif

    //*************************************************************************
#if ETL_HAS_INITIALIZER_LIST
    TEST(test_make_forward_list)
    {
      auto data = etl::make_forward_list<ItemNDC>(ItemNDC("A"), ItemNDC("B"), ItemNDC("C"), ItemNDC("D"), ItemNDC("E"), ItemNDC("F"));

      auto v = *data.begin();
      using Type = decltype(v);
      CHECK((std::is_same_v<ItemNDC, Type>));

      decltype(data)::const_iterator itr = data.begin();

      CHECK_EQUAL(ItemNDC("A"), *itr++);
      CHECK_EQUAL(ItemNDC("B"), *itr++);
      CHECK_EQUAL(ItemNDC("C"), *itr++);
      CHECK_EQUAL(ItemNDC("D"), *itr++);
      CHECK_EQUAL(ItemNDC("E"), *itr++);
      CHECK_EQUAL(ItemNDC("F"), *itr++);
    }
#endif
  };
}


If you read this blog, or follow technology you have likely heard of Klout. Klout maps out social media around the web to measure your influence in the form of a score. The accuracy and importance of this score has been much debated, but a new website offers a similar system to measure something a little different.
Klouchebag.com allows you to measure how much of an @$$ hole you are on the web. The patented formula measures your tweets to give you a score of how annoying you are based on a few weighted factors. For example, major web publisher Mashable (@Mashable) scored an 8 (nice person) while Kim Kardashian (@KimKardashian) scored a 75 (mostly noise). This may seem like one big joke, but this is actually an effective tool for optimizing your Twitter. If this tool finds you annoying, chances are you possess elements on your Twitter that frustrates people (and it gives a nice breakdown) so check out Klouchebag today.


Forget gilded mansions and super yachts. Among the tech elite, space exploration is now the ultimate status symbol.
Dan Tynan reports: The explosion could be felt 30 miles away. At 9.07am on 1 September, a SpaceX rocket containing 75,000 gallons of liquid oxygen and rocket-grade kerosene ignited into a fireball that could be seen from orbit, billowing black smoke into the gray sky around its Cape Canaveral launch pad.


I'm gonna be away from my desk for the next handful of days. Fret not, I will be back doing all this stuff ASAP. I'm doing this thing that needs to be done. Hang tight!
Wanna Go See Brains in Jars and Underground Crypts?


text:
Business Insider | Life
Runners in South African ultra-marathons run at the fastest pace in the world, report shows
James de Villiers , Business Insider SA
Zola Budd (left) and Bruce Fordyce at the Comrades ultra-marathon in 2012. Photo: Michael Hammond
Participants in South African ultra-marathons run an average pace of 10:36 minutes per mile (roughly 1.6km) - the fastest pace in the world.
This is according to a new international report, using data from more than 5 million race results.
Female ultrarunners who compete in South Africa are faster than the men from all other countries rated in the report, apart from South Africa.
For more stories, visit Business Insider South Africa.
On average, South African races feature the fastest ultra-marathon runners in the world. Participants in South African ultra-marathons run an average pace of 10:36 minutes per mile (roughly 1.6km), a new report found.
The State of Ultra Running 2020, a report released by athletic shoe brand Runpeat in collaboration with International Association of Ultrarunners (IAU), used data compiled from more than 5 million race results from over 15,000 races between the years of 1996 and 2018.
Ultra runners are those competing in races longer than a marathon (42.2 km). Some of the ultra-marathons in South Africa include the Comrades, Old Mutual Two Oceans, Om Die Dam in Hartbeespoort, the South Coast Ultra and the Bay Ultra.
On average, competitors in South African races were the fastest in the world, followed by Sweden with an average pace of 11.56 minutes per mile, and Germany with 12:09 minutes per mile.
For male ultrarunners, those who participated in South Africa ran an average of 10:23 minute per mile, followed by Sweden with 11:43 minute per mile and Germany with 11:53 minute per mile
South Africa also saw the fastest female ultra-runners in its races with an average pace of 11:11 minute per mile, followed by Sweden with 12:27 minute per mile and Germany with 12:33 min per mile.
The slowest ultra running speeds are in Argentina with an average of 15:20 minute per mile (male and female), Mexico with an average of 15:30 minutes per mile and Malaysia with an average of 15:55 per mile.
The report found that ultra race participation has increased by 1,676% globally in the last 23 years from 34,401 to 611,098 participants yearly. South Africa saw the largest group of ultra-runners, apart from the US and France.
Female ultra runners were also found to be faster than male ultra runners at distances over 195 miles (roughly 313 km), while men were 17.9% faster than women in 5 km distances.
Overall, the global female pace has declined from 12:25 to 13:23 minutes per mile, and the male pace from 11:24 to 13:21 minutes per mile.
17 jobs paying more than R2 million in SA right now
The definitive guide to what to do if you lost your ID, passport, credit card or cell phone
South African and Chinese scientists have just made an exciting breakthrough to allow internet users to transfer secure quantum data via normal optical fibre
Checkers has a 'secret' online shop that's up to 40% cheaper than its other stores - but there are a few catches
Here's where - and when - your car is most likely to be stolen or hijacked
running south africa run ultramarathons runner

redpajama_set_name: RedPajamaCommonCrawl


Grillmaster pumice stones have been used in the food service trades for generations to clean griddles without removing the cure and grills without leaving odors and unpleasant after taste. The professional answer to cleaning charcoal, gas and electric BBQ grills. Grooves itself to grill grids. Cleans faster, more efficiently than brushes and scrappers. Removes carbonized food, grease and soot from porcelain and metal grill surfaces. ready to use. Reusable. No gloves or applicators are needed. Works through gentle abrasive action. Shapes to any flat or curved surface. Contains no chemicals or hazardous substances. Safe for hands. Safe to store and use on food equipment.


text:
The Organelle That Controls the Cell's Activities & Contains DNA
By Susan Sherwood
What Happens at the S-Phase of Interphase?
Does Mitosis Occur in Prokaryotes, Eukaryotes, or Both?
Three Ways that Genetic Diversity Occurs During Meiosis
Approximately What Percentage of Human DNA Is Noncoding DNA?
What Molecule Is the Result of DNA Translation?
The boss of a company is tasked with determining which employees fill certain positions and when specific actions are taken. Each of your cells has a boss, too: the nucleus. This control center runs the show, instructing the cell to carry out basic functions, such as growth, development and division. Most of your body's genetic material -- its deoxyribonucleic acid, or DNA -- is located inside the nucleus. This organelle has only a few types of components, but it has major responsibilities.
The cells of eukaryotes -- plants, animals, fungi and protists -- contain nuclei. Most of these cells have one nucleus each, but slime mold and certain algae cells have multiples. The parts of the nucleus reflect its functions. Most of the time, the entire nucleus is separated from the rest of the cell by a double-layered nuclear envelope. This membrane is covered with pores that regulate the movement of molecules in and out of the nucleus. Inside the nucleus, the nucleolus produces ribosomes, which make proteins for the cell. Hereditary material is found within the semi-fluid nucleoplasm.
Running the Show
The nucleus holds all the cell's directions, which come in the form of genes. Genes are made of DNA and are organized into structures called chromosomes. The DNA for each gene is arranged in a specific order that determines the gene's function. Some genes instruct cells to manufacture specific proteins required to carry out certain functions. Genes can also control the amount of proteins produced. Not all genes work around the clock. While some function continuously, overseeing the production of essential proteins, other genes are turned off until they are needed.
Chromosome Home
Although human cells are microscopic, each has about 6 feet of DNA inside its nucleus. To accommodate this tight squeeze, proteins fold DNA into tiny packages. This combination of DNA and protein is "chromatin." Sections of chromatin form chromosomes. Rather than spreading randomly, chromosomes seem to settle in specific sections of the nucleus, which are called "chromosome territories." This appears to be connected to gene expression; certain genes always seem to be neighbors. Each nuclei has a different, though internally consistent, arrangement of genes.
As if the nucleus does not have enough to do while controlling cell functions, it also undergoes a complex process during cell division, or mitosis. In most cells, the nucleus breaks up, then rebuilds. Mitosis is essential, because genetic information in the nucleus is passed along to daughter cells. To make this possible, chromosomes replicate before cell division begins. During mitosis, the nucleolus is not visible. In most cases, the nuclear envelope comes apart. Most of the contents of the nucleus spill into the cell's cytoplasm. The chromosomes separate into two equivalent groups, and a new envelope encircles each set. Finally, the entire cell separates into two identical cells.
NLM: Genetics Home Reference -- Cells and DNA
Florida State University: Molecular Expressions -- The Cell Nucleus
American Cancer Society: How Do Cells Know What to Do?
Nature: Scitable -- Chromosomes
National Center for Biotechnology Information: The Cell -- The Nucleus During Mitosis
Nature: Scitable -- Replication and Distribution of DNA During Mitosis
University of California, Berkeley: Molecular and Cell Biology -- Scientists Find Signals That Make Cell Nucleus Blow up Like a Balloon
Living in upstate New York, Susan Sherwood is a researcher who has been writing within educational settings for more than 10 years. She has co-authored papers for Horizons Research, Inc. and the Capital Region Science Education Partnership. Sherwood has a Ph.D. in curriculum and instruction from the University at Albany.
Explain the Significance of Meiosis in Sexual Reproduction
The Difference Between Prokaryote & Eukaryote Nuclear Material
Relationships Between Mitosis in Eukaryotic Cells & Binary Fission in Prokaryotes
The Location of Ribosomes in a Cell
At Which Stage Does the DNA Make a Copy of Itself?
What Is the Main Site of Lipid Synthesis in Many Cells?
Does the Nuclear Envelope Disappear in Metaphase?
What Happens to Nuclear Material in Late Telophase?
Similarities of Mitosis and Meiosis
1 Explain the Significance of Meiosis in Sexual Reproduction
2 The Difference Between Prokaryote & Eukaryote Nuclear Material
3 Relationships Between Mitosis in Eukaryotic Cells & Binary Fission in Prokaryotes
4 The Location of Ribosomes in a Cell


Resources for Valves 1998 "GOLDSRC" engine (Half-Life, Counter-Strike 1.6, Sven Co-Op, Day Of Defeat, Team Fortress Classic, and others.
A quick reference for GoldSource model compiling and decompiling. Includes links.
A collection of quick short tutorials, methods, and models I have created.
A collection of links and archived texturing methods from years past. If you want to match the old style of 1998~2005 texturing this is your resource list.
Give playermodels the ability to have adjustable colors!
An exhaustive 5-part tutorial on how to create almost any type of spraylogo.
Ever wanted to use custom particle effects in your maps? This 2 part Video shows how to compile your own "Spritesheet" VTF and make it into a working particle system.
Isolate multiplayer voices from your game and have them automatically saved as WAV files.
A quick reference for source model compiling and decompiling. Includes links.


These terms constitute a binding contract between Nest Seekers LLC, its owners, predecessors, affiliates, officers, directors, employees, agents, contractors, investors, successors and/or assigns ("Nest Seekers", "us", or "we") and you. These Terms comprise the entire agreement between Nest Seekers and you with respect to the use of the Site and supersede all contemporaneous and prior agreements concerning the subject matter contained herein. The clauses herein are severable in that if a court of competent jurisdiction holds that any part of these terms is invalid or unenforceable the remainder of these Terms remains in full force and effect.
By entering this site you hereby acknowledge and agree that this website will only be construed and evaluated according to United States law. If you use this site from other locations you are responsible for compliance with any and all applicable local laws. We make no representations that the materials contained within this site are appropriate for locations outside the United States.
You represent that you are a prospective purchaser, seller, lessee or lessor of real property in the geographic areas of Nest Seekers licensed operation with a bona fide interest in the purchase, sale or lease of such real property.
You must register your use and/or intended use of the Site by creating an account with a user name and password that will not be used by or shared with anyone else. Your account is non-transferrable and non-assignable. You must be eighteen (18) years of age or older to register for an account.
You must provide accurate and correct information, and you must maintain the currency of your information. Nest Seekers is entitled to rely on the accuracy, correctness and currency of the information you provide. By registering for an account, you consent to be contacted by Nest Seekers , and to receive personalized emails, telephone calls, and/or faxes from us. The Site and all related transactions are intended to be accessed and conducted electronically. If we are ever required to communicate or transact with you non-electronically, for legal or other reasons, we reserve the right to charge you increased fees.
We will not give, sell or otherwise transfer your address or Account information to any other party for the purposes of initiating, or enabling other to initiate, electronic mail messages except as authorized by law or appropriate personnel or policies. Anyone who engages in the aforementioned activity may be found in violation of Federal Law.
By agreeing to these terms, you acknowledge that you are entering into a lawful broker-consumer relationship between us and you, albeit not an exclusive one, as may be defined under state law. You represent that you have not signed any agreement with any other real estate agent, broker, salesperson, or similar state licensed real estate professional ("Real Estate Agent") that would prevent you from using Nest Seekers as your agent, nor do you have any contract agreement with a third party that would hinder or interfere with our relationship. You agree to notify us immediately in the event that you enter into a listing agreement, or any other agreement or contract with a Real Estate Agent.
In our capacity as your broker, you authorize us to review and provide you with copies of various documents related to any potential real estate transactions, such as but not limited to home inspection reports. You agree that we may represent other prospective buyers interested in the same properties as you are interested in, and that may meet your purchase criteria. You also agree not to contact the owner, seller, and/or lessee of any property using information gained through the Site. You represent that you will not attempt to enter the property or speak with an owner, seller, and/or lessee without an appointment arranged by Nest Seekers.
The Site is for personal use only. You may not reproduce, copy, sell, repost to other sites or otherwise exploit the Site or any part thereof, or access or use the Site for any commercial purposes. If you are a Real Estate Agent and wish to access the Site for your customers, you must first enter into a co-brokerage agreement with Nest Seekers. No person, including without any Real Estate Agent, may make any commercial use of any content of this Site, including without limitation marketing, advertising or copying of any listings on the Site, or contacting or engaging in any sort of outreach to sellers or owners of any properties listed on the Site. You agree that we have the right to terminate or deny access to any Real Estate Agent or any person as we may deem appropriate.
The Registrant acknowledges each other RLS Broker's ownership of, and the validity of their respective copyright in, the Exclusive Listings that are transmitted over the RLS.
Nest Seekers authorizes the Real Estate Board of New York ("REBNY") and/or REBNY Listing Service ("RLS") brokers and their representative to access the Site for the purposes of verifying compliance with the provisions of these Terms, the Co-Brokerage Agreement between Nest Seekers and REBNY, and any other applicable RLS rules or policies or any other multiple listing system or real estate board that Nest Seekers subscribes to.
You may not take any action which might impose a significant burden (as determined by us) on the Site"s infrastructure or computer systems, or otherwise interfere with the ordinary operation of the Site. You are prohibited from accessing or using the Site in any way that is not in compliance with any applicable local, state, national or international law, agency rules or regulations, contract, intellectual property rights or constitutes the commission of a tort, other than in full compliance with these terms. Access or use the Site in any way that is not in compliance with any applicable local, state, national or international law (including export laws), contracts, intellectual property rights or constitutes the commission of a tort, or for any purpose that is harmful or unintended (by us), or other than in full compliance with these Terms. Nest Seekers reserves the right to make such determinations regarding the conduct of any individual.
You are prohibited to use any content in violation of any applicable laws, rules or regulations, including without limitation the rules of Real Estate Board of the City of New York, the New York State Department of State, the New York State Department of Banking, or any listing agency. You are forbidden to access, tamper with, or use services or areas of the Site that you are not authorized to access. You may not alter or tamper with information on or obtained from the Site.
You may not use any robot, spider, scraper or other automated means or interface not provided by us to access the Site or extract data or gather or use information, such as email addresses, available from the Site or transmit any unsolicited advertising, "junk mail," "spam," or "chain letters." You may not frame any part of the Site, or link to the Site, or otherwise make it look like you have a relationship to us or that we have endorsed you or your Content for any purpose. You may not impersonate or misrepresent your affiliation with any person or entity. You may not reverse engineer any licensed software, application, games or any other aspect of the Site or do anything that might discover source code, or bypass or circumvent measures employed to prevent or limit access to any area, content or code of the Site. You may not send to or otherwise impact us or the Site (or anything or anyone else) with harmful, illegal, deceptive or disruptive code such as a virus, "spyware," "adware" or other code that could adversely impact the Site or any recipient.
As set forth in the Privacy section of this Site, you are bound by the intellectual property laws that protect the Site. Nest Seekers reserves all rights in the content of its website, including software, not expressly granted in this document. All rights in all material and content including, but not limited to, text, images, web pages, sounds, software (including code, interface, and website structure), and video, and the look and feel, design, and compilation thereof on the website are owned or licensed by us.
You may not reproduce distribute, modify, publicly display, or prepare derivative works of any content, including software, without prior, express, written permission from Nest Seekers. Nest Seekers grants you a limited, revocable, non-transferable, non-exclusive, non-sublicensable license to privately display the content of this Site on your computer and to download and print a single copy thereof, subject to the restrictions set forth herein.
You shall not copy, redistribute, or retransmit any of the Site's information or data, except in connection with your consideration of the purchase, sale or lease of an individual exclusive property.
These terms shall remain in full force and effect until terminated in accordance with this Section. Nest Seekers may, at any time, terminate your access to the Site and/or your Account for any reason, consistent with local, state and federal, and/or relevant agency laws and/or rules. We reserve the right to use our discretion to determine whether or not you have violated any clause herein or have otherwise engaged in any activities that may harm or damage the reputation, rights, person, or property of Nest Seekers, our users, or any other person. Nest Seekers will not be liable to you or any third party for any termination of your Account or your access to the Site.
Nest Seekers, its owners, affiliates, officers, directors, employees, agents, contractors, content or service providers (including listing service providers), investors, successors and assigns specifically disclaim any and all warranties, express or implied by statute or otherwise, including but not limited to: (1) any warranties concerning the availability, accuracy, usefulness, or content of or uninterrupted access to information, products or services and (2) any warranties of title, non-infringement, merchantability or fitness for a particular purpose. This disclaimer of liability applies to any damages or injury caused by any failure of performance, error, omission, interruption, deletion, defect, delay in operation or transmission, computer virus, communication line failure, theft, or destruction or unauthorized access or alteration of or use of record in connection with the use or operation of the Site, whether for breach of contract, tort, negligence or any other cause of action.
All information, content and service available on the Site are for information purposes, and are not intended to be comprehensive, and may not be accurate, exact or up to date. Such information, content and service may be updated, changed, withdrawn and modified at any time and without notice. Square footage and dimension information is approximate. Any representations of furnishings or decorations are for illustrative effects only. Any listing may be sold or rented at any time without notice. Nest Seekers is not responsible and does not accept any liability for omissions or inaccuracies on the Site. If you rely on any information, content or service on the Site, you expressly agree that you do so at your own risk. You agree that you are solely responsible for any damage or loss you may incur as a result of you reliance or usage of any information, content or service on the Site. If you are dissatisfied with any of the information, content, and/or service of this site, or with any of these terms, your sole remedy is to discontinue your use of the Site.
You agree to indemnify, defend and hold harmless Nest Seekers from any and all claims or damage, including attorney"s fees, arising out of or related to your use of or connection to the Site, your violation of these Terms or your violation of the any rights of another. To the extent permitted by applicable law, Nest Seekers shall not be liable to you or any other third party for any direct, indirect, incidental, special, punitive or consequential damages arising out of your access to or use of or connection to the Site. Nest Seekers shall not be liable to you or any other third party for your inability to gain access to or use the Site. Even if Nest Seekers has been advised or notified of damages or potential damages, Nest Seekers shall not be liable for any of the foregoing or for any breach of any warranty.
This site may contain links to other websites. These links are provided as a convenience to you and as an additional avenue of access to the information contained therein. We have not necessarily reviewed all the information on those other sites and are not responsible for the content of those or any other sites or any products or services that may be offered through those or any other sites. Inclusion of links to other sites should not be viewed as an endorsement of the content of linked sites. Different terms and conditions may apply to your use of any linked sites. We are not responsible for any losses, damages or other liabilities incurred as a result of your use of any linked sites.
These Terms are for the sole benefit of Nest Seekers. No other person, including any user of the site shall have the right to assert a claim under these Terms. These Terms and all performances and claims between us are governed by the laws of the State of New York and the United States of America. You and Nest Seekers submit to the personal jurisdiction and venue of the State Courts and Federal Courts located within the City of New York. The parties hereto waive the right to trial by jury.
Any action concerning any dispute with respect to the Site must be commenced within two years after the cause of the dispute arises, or the action is barred. The failure of Nest Seekers to exercise or enforce any right or provision of these Terms, including any failure to act with respect to a breach, will not constitute a waiver of such right or provision or the right to act with respect to subsequent or similar breaches.
It is our policy to terminate any Account or user for infringement of intellectual property rights, including trademark rights and copyrights. Nest Seekers may disclose any of your information or data related to a complaint of copyright infringement if we believe in our sole discretion that such action is necessary or useful to address an alleged infringement.
This site includes certain trademarks, logos and service marks owned by Nest Seekers. Nothing on this website shall be construed as granting, by implication, estoppel, or otherwise, any license or right to use any trademark, logo or service mark displayed on the website without the owner's prior written permission, except as otherwise described herein. We reserve all rights not expressly granted in and to the website and its content. This website and all of its content, including but not limited to text, design, graphics, interfaces and code, and the selection and arrangement thereof, is protected as a compilation under the copyright laws of the United States and other countries. You are prohibited from using any trademarks or service marks in any manner without the express written permission of Nest Seekers. You further agree that you will not alter or remove any copyright, trademark or other legal notice from any content on the Site.
These terms constitute the final and binding agreement between the parties regarding the subject matter hereof, and supersedes all prior agreement, oral or written. The failure or delay of Nest Seekers to insist upon strict performance of any terms, conditions or covenants herein shall not be deemed a waiver of any rights or remedies that Nest Seekers may have, nor shall it be deemed a waiver of any subsequent breach or default in any of the terms, conditions, covenants herein.
Thank you for your interest in registering to use www.nestseekers.com. If you have any questions or comments about these Terms and Conditions of Use, the Privacy Notice, or this website, please contact us by email at info@nestseekers.com.


Interested in going on a GO Journey? Visit our Global Outreach page for details about all of our upcoming trips.
Participants need to have a willingness to help advance the gospel around the world by "going."


Vyacheslav Potapov (VP) Great music! Anything from Post-Rock, something Progressive. A mixture of "Azigza", "Cocteau Twins"... a bit of jazz. Overall a very beautiful music and very pleasant discovery for me! Favorite track: Sundown.
Comes in a nice digipak.
Includes unlimited streaming of Race via the free Bandcamp app, plus high-quality download in MP3, FLAC and more.
Since their first album "Chaos Theory" in 2010, the group Dee Day Dub has developed from a large collective into a guerrilla-type and precisely operating working band. The quartet worked on their new songs for two years, sharpening and reducing their aesthetics to some essential features: unique, dark grooves, off-beat melodies, dirty guitar sounds and wildly intelligent lyrics. The CD "Race" features 11 partially linked songs, which the band produced with Ronin leader Nik Bärtsch.
The album creates a sound that remains direct and raw despite its new depth and precision. "Urban voodoo grunge" is what co-producer Bärtsch calls the band's music with a smirk. "This group sounds like a bunch of archaic space pirates playing to an audience of freaky creatures in some underground club on Mars", he adds.
The band Dee Day Dub originates from a series of jam sessions under the name "Dee Day", which drummer Singha Dee launched at Bazillus Club (Zurich, Switzerland) in 2005. Alongside bands like Nik Bärtsch's Ronin or Jean-Paul Bourelly's CutMotion, Dee Day Dub is yet another example of the rich groove community culture that developed over the years in the legendary Bazillus basement.
Dee Day Dub is Singha Dee on drums, Manu Baker on bass and Maze Koon on guitar. Soul princess B.D. Butler (alias Brandy Butler) molds the sound with her unmistakable and versatile voice.
Album produced by Singha Dee & Nik Bärtsch.
All songs and lyrics written by Dee Day Dub.
All songs published by Ronin Rhythm Productions.
Recorded at Saraswati Studios, Poland by Janek Busse.
Additional recordings at Dee Day Spacelab, Switzerland.
Mixed by Reto Muggli. Mastered by Dan Suter.
Graphic design by Ralph Sonderegger. Photo by Tabea Hüberli.
Nik Bärtsch: Additional percussion on 3, 6, 7 & 11.
Rykka: Additional vocal writing on 3 & 9.


text:
Агриппина Сергеевна Щербина (; 10 июня 1913 год, село Гнилище, Царичанская волость, Кобеляцкий уезд, Полтавская губерния — 7 сентября 1986 год, посёлок Голобородьковское, Карловский район, Полтавская область, Украинская ССР) — колхозница, звеньевая полеводческой бригады Голобородьковского свеклосовхоза Министерства пищевой промышленности СССР, Карловский район Полтавской области, Украинская ССР. Герой Социалистического Труда (1948).

Биография
Родилась 10 июня 1913 года в крестьянской семье в селе Гнилище (сегодня — часть посёлка Царичанка Днепропетровской области). Получила начальное образование, окончив два класса церковно-приходской школы в родном селе. С 1929 года работала разнорабочей в отделении Тагамлык колхоза имени Голобородько Карловского района. В 1937 году переведена в центральное отделение колхоза, где после войны была назначена звеньевой полеводческого звена.

В 1947 году звено, руководимое Агриппиной Щербиной, собрало в среднем по 31 центнера пшеницы с каждого гектара с участка площадью 8 гектаров. В 1948 году удостоена звания Герой Социалистического Труда.

После выхода на пенсию проживала в посёлке Голобородьковское Карловского района, где скончалась в 1986 году.

Награды
 Герой Социалистического Труда — указом Президиума Верховного Совета СССР от 30 апреля 1948 года
 Орден Ленина
 Медаль «За доблестный труд в Великой Отечественной войне 1941—1945 гг.»

Ссылки

 ЩЕРБИНА Горпина (Агріпіна) Сергіївна. Герой Соціалістичної Праці (1948)

redpajama_set_name: RedPajamaWikipedia


text:
La única unidad de infantería de marina de las fuerzas armadas alemanas fueron los Marinestoßtruppkompanie (Compañía de asalto naval) o MSK,  una unidad secreta de la Kriegsmarine creada en 1938 en Swinemünde a partir de la Marine-Artillerie.Abteilung 123. Diseñada para llevar a cabo operaciones de asalto como zapadores, no era una unidad de infantería de marina al uso, ya que no realizaban operaciones de desembarco, si no que eran transportados en buques de la marina hasta el objetivo y luego operaban como unidades terrestres convencionales. Tuvieron una participación activa en la conquista de Polonia y fueron ampliamente utilizados en el frente oriental, sufriendo numerosas bajas.

Inicios
La pequeña unidad operativa, considera una unidad de élite dentro de la Kriegsmarine, tuvo su bautismo de fuego en la Guerra Civil Española; en septiembre de 1938, un batallón al mando del Leutnant Walter Schug embarcó en el acorazado Deutschland rumbo a la isla de Ibiza, con el objetivo de neutralizar una estación de radio republicana.

En marzo de 1938, la MSK participó en la ocupación de Memelland. La 3. Marine-Stoßtrupp-Kompanie zarpó desde Swinemünde a bordo de torpederas y desembarcaron en Memel el 23 de marzo de 1939. No llegaron a entrar en combate ya que la guarnición lituana capituló sin ofrecer resistencia.

Bajo el mando del Oberleutnant Wilhem Henningsen, la unidad comenzó a prepararse para futuras operaciones.

Polonia
El 24 de agosto de 1939, un destacamento de 250 hombres del MSK embarcaron en el dragaminas M-1, en Memel, y fueron transportados a bordo del , en vísperas del comienzo de la invasión de Polonia. Su objetivo era asaltar y ocupar el bastión polaco que defendía la península de Westerplatte, en el puerto de Danzig. El asalto, que debía haber durado unas pocas horas, se convirtió en un asedio de una semana, con importantes bajas para la unidad de marines.

Tras la caída de la fortaleza, la unidad participó en la ocupación de Gdynia y en la batalla de la península de Hel.

Francia
En 1940, la unidad fue reforzada, convirtiéndose en la Marine-Stosstrupp-Abteilung o MSA, formada por 6 compañías. Desde julio de 1940 hasta marzo de 1941 tomó parte en la ocupación de Noruega y Normandía, donde comenzaron a prepararse para asaltar las islas del Canal de la Mancha. Tras cancelarse la invasión de Gran Bretaña, quedaron como tropas de guarnición en Francia.

Frente oriental y final de la guerra
En verano de 1941, la unidad fue destinada al frente del este, donde sufriría enormes bajas.
En enero de 1942 fue renombrada como Marine-Artillerie-Abteilung 531, combatiendo en la batalla de Leningrado entre 1941 y 1944, Narva en 1944, la Operación Tanne Ost en 1944, la defensa de la Isla de Oesel y finalmente, ya en 1945, en Gotenhafen y la península de Hel.

Tras ser retirada del frente del Este, participó en combates en el este de Prusia, antes de ser evacuada a Schleswig-Holstein en agosto de 1945.

Referencias

Enlaces externos
 Report in Ostpreußen-Anzeiger

Unidades de la Kriegsmarine
Kriegsmarine
Fuerzas especiales alemanas de la Segunda Guerra Mundial


Hey there, I'm Aimee, and I blog about crafts, DIY decor, and life as a twin mommy over at The Crazy Craft Lady.
A few months ago, I shared a scrap wood stencil wall art project with you. I'm so excited to be back here sharing another DIY decor project.
It wasn't particularly horrible, but it wasn't spectacular either. The shoe situation with the kiddos was slowly spiraling out of control. The pile of shoes kept creeping further into the entry, causing major tripping hazard and eyesore. I knew a cubby shelf of some sort was the answer. Not wanting to settle for a generic assemble-it-yourself white shelf, I put on my DIY Thinking Cap.
This bookcase happened to be the perfect size to fit in the left half of my entry closet. It was fate! I've also seen some really fun tutorials in the blog-o-sphere for hexagon wall shelves. I figured that if people can make hexagon wall shelves, I can make hexagon shoe shelves.
Off to The Home Depot I went… This post contains some affiliate links. Click here to read my full disclosure policy.
Your supply list is relatively simple and straight-forward. You can make as many cubbies as you like, and arrange them however you want. These instructions will yield 8 cubbies that will fit perfectly inside an Ikea Billy Bookcase.
Also note that a 1 x10 isn't really 10 inches. It's more like 9 1/4-inches. This means that your shoe cubbies will be 9 1/4-inches deep. This is the perfect size for kids and mommy (my size 7.5) shoes. If you live with a giant who wears size 14 shoes, you may want to make deeper cubbies.
Prep your shelf. My original bookcase was black stain. I quickly primed and painted it white, using leftover paint from other projects. If you have a white shelf already, or want to use a black shelf, go for it!
Do math. Try to remember high school trig. Google "how to calculate the dimensions of a hexagon." Cry. Pour a glass of wine.
You can use the math that I already did for you! Since the opening to my bookcase was 30-inches wide, I needed each cubby to be 10-inches (or just shy of) wide.
Make friends with someone who owns power tools.
The cutting involved in this project was a tad outside my range of comfort when it comes to using electric devices that have the ability to permanently remove appendages. So, I enlisted the help of my good friend Patrick. We did this step together. He did this step while I took pictures with my iPhone.
To get this exact shelf, you need 48 – 5 3/4-inch cuts of 1×10 wood.
We stared by doing 48 straight cuts at 5 3/4-inch. You may want to make a few extra, just in case.
Then we set the blade at 30-degrees and cut each end again.
Assemble your cubbies – phone a friend or brush off your yoga skills.
Since I was home alone when I assembled the cubbies, there is a chance I got a bit creative. By creative, I mean stabilizing the pieces of wood with my feet while I hammered the nails in place. Like I said. Yoga.
Each hexagon cubby will be a bit flimsy until the wood glue dries. I actually set all of the cubbies in place while the glue dried (overnight), so that all of my angles were just right.
It's time to get staining!
It's always a good idea to pre-treat wood before staining. A nice guy at The Home Depot once told me that I can cheat and just get the wood wet with a cloth and water, instead of buying a special product. I've used this method on a couple of projects now, and have been happy with the results.
I let the stain sit for about 5 minutes.
Assembly. It was a breeze.
Since I am now a math expert when it comes to calculating the dimensions of a hexagon, these shelves fit perfectly into my shelf. Seriously. They just slid in, and the tension between each cubby holds everything in place.
Regarding the shelves: I cut and stained some scrap wood to make divider shelves in 3 of the cubbies. I also used one of the original bookshelves at the top to create storage for baskets and smaller items.
I'm so happy with the way that my new shoe shelf turned out! But, I do have one regret: Why did I make such a beautiful shelf that will now be hidden away behind closed doors?!?! I think I will keep my closet door open for a while, so I can admire my work and wait for the novelty to wear off!
Never again will I feel bad about telling my twins to "go play in the closet." See how I transformed an odd-shaped storage closet into a play space for the kids.
Just because you rent, doesn't mean you have to miss out on the plank wall decor trend. See my $8 rental-friendly plank wall solution.
A big shout out and thanks to Tasha for letting me share my project and hang out with you all today. I will be back in a few months for another guest post. In the meantime, feel free to follow along with me on my blog at The Crazy Craft Lady.
These. are. brilliant!!! I'm in love with the look of a good hex, anything! Such a great alternative to the usual boring shoe rack.


Personal branding matters in today's work environment. It is one of the most effective ways that you have to differentiate yourself from your colleagues. If you are able to develop a clear and positive image that is readily associated with you by those who know you, then it becomes clearer to them what value you can offer when they have a problem that needs to be solved.
Most people already have a brand in the minds of those who know them. Whether you realise it or not, most people already have a sense of what they can expect from you. The challenge is that unless you are deliberately managing this image, you may be conveying something that you do not intend. You do however have the power to change that.
If you have ever heard someone say that they are surprised to know something about you, or someone say that they did not think to ask you to be a part of an activity or to answer a question then it is most likely that their image of you is not a complete representation of who you are. You of course, have to decide whether that is a problem for you. If you are completely comfortable with how you are currently perceived in your personal life and your profession or career, then you do not need to take any additional actions. However, if you would like to be seen in a way that is different from what currently exists then you will need to engage in a personal branding exercise. How do you decide whether personal branding is something that you need to do?
By developing a personal brand, you set perceptions about who you are, what you stand for, how you will behave and what you can do. If you are not satisfied with how these elements of your brand are currently showing up, then you may want to develop a plan for conveying a clear message about yourself.
If you have a personal brand, your colleagues, peers, superiors, direct reports, potential employers and customers will develop expectations of you based on the brand you define and live. This is a good thing because it enables everyone to know ahead of time what way you can help them when they need support. If this is not currently the case for you, if it is not readily known what you can contribute to an employer or a customer, then you may want to define your brand and decide for yourself, how you are going to live it.
It is important to note that personal branding is a long term approach to establishing yourself. It can allow you to expand the image that you may already have in the minds of those who know you. It allows you to carve out a niche for yourself that can positively impact your success throughout your career. It can also allow you to create clear perceptions of who you are and to convey readily what you can bring to the table. This is why it matters.
Helps you to move up the corporate ladder if brand projects positivity, energy, passion and the can-do-attitude.


Companies that are failing to recover their printing and photocopying costs could be losing thousands a month in potential revenue. Print Audit 6 Embedded enables organizations to track and bill for all of their walk-up printing, copying, scanning and faxing by prompting for a code and assigning it to each job. The solution can also significantly reduce costs by enforcing rules and limits to restrict how many pages a user can print, copy or fax – which are determined at setup.
Documents left at the printer are a security risk, a costly expense and an environmental concern. Secure Embedded reduces waste and increases document security by ensuring jobs are not printed until users are ready to pick them up at a Kyocera HyPAS-enabled device. This helps to maintain regulatory compliance and eliminates the stacks of unclaimed print jobs left at your printers.
Both Print Audit 6 Embedded and Secure Embedded integrate seamlessly with the PC versions of Print Audit 6 and Print Audit Secure, providing a comprehensive print management solution for controlling and recovering both walk-up and desktop document creation costs.
Print Audit for Kyocera is a comprehensive provider of managed print services (MPS) and print management solutions. The company enables organizations to monitor and control their printing costs via a broad range of capabilities that include secure print release, follow-me printing, rules-based printing, cost recovery, in-depth print assessment and remote meter reading.


This book examines representations of working-class masculine subjectivity in Victorian autobiography and fiction. In it, Ying focuses on ideas of domesticity and the male body and demonstrates that working-class masculinities differ substantially from those of the widely studied upper classes.
The book also maps the relationship between two trends: the early nineteenth-century efflorescence of published working-class autobiographies (in which working men construct their identities for a broad readership); and a contemporaneous surge of public interest in "the lower orders" that finds reflection in the depiction of working-class characters in popular novels by middle-class authors.
The book mimics this point of convergence by pairing three working-class autobiographies with three middle-class novels. Each chapter focuses on a particular type of work: domestic service, manual (not artisanal) labour, and literary labour (and the opportunities it offers for social advancement). Ying considers the specific ways in which classed and gendered consciousness emerges autobiographically and its significance in the writing of working-class subjectivity for public consumption. Then mainstream novels by Charles Dickens, Elizabeth Gaskell and Charles Kingsley are re-read from the perspective of these autobiographical pressure points.


Welcome to CanadaImmigrationHelp.ca. This website is operated by Carpenter & Carleton Ltd.
Carpenter & Carleton have been assisting Canadians and individuals wanting to immigrate to Canada for over 22 years. Our experience enables us to guide you through the process of immigrating to Canada. Our expertise and knowlege of the Canadian and Provincial Government's rules and processes will enable us to guide you through your application to immigrate to Canada.
Our indepth knowledge of the the appeal process and judicial system enables us to represent your rights as a prospective Canadian. Please reveiw our testimonials to see what individuals like you have said about our services.
Canada has a proud tradition of welcoming immigrants. Our immigration system, refugee system and network of organizations to help newcomers settle and integrate are among the best in the world.
To learn about the different ways individuals can qualify to immigrate to Canada please review the summaries below.
Carpenter & Carleton is here to answer your questions and provide the assistance you need to start a new life in Canada. Please feel free to call us or contact one of our consultants.
OTTAWA—The number of foreign workers in Canada tripled between 2002 and 2012 the parliamentary budget office reported.
New Legislation was introduced by the Federal Government of Canada.
Our site reflects these new changes. This new legislation has changed many of the regulations and qualifications for immigrating to Canada.


Offering crisply executed design, generous interior space and superb capability! The engine breathes better thanks to a turbocharger, improving both performance and economy. Lincoln prioritized practicality, efficiency, and style by including: front dual-zone air conditioning, a power liftgate, and a split folding rear seat. Under the hood you'll find a 4 cylinder engine with more than 200 horsepower, and for added security, dynamic Stability Control supplements the drivetrain.


The decrement operators used to subtract 1 to previous value. Decrement operator is unary operator because only one variable is used.
Here in our example first i is three(i=3) than i decrement by 1(i--). here i value is 2.
Here postfix is used so first i value is assigned to num ie 2 than i is decrement by 1 ie i value becomes 1.
Here in our example first i is three(i=3) than i decrement by 1(--i). here i value is 2.


It is so important for our children to learn to have their own personal relationship with the Father. One of the biggest ways we can help them with this is teaching them the importance of having devotions.
Today I want to share 2 incredible devos for girls.
The Brave Girls, Hope, Glory, Gracie, Honor and Faith help your girl grow as she learns that being brave means have simple faith in an extraordinary God.
Faithful Friends teaches girls how to have friends, how to be a friend and how to share her faith in Jesus with her friends. For some girls, making and being a friend is easy. Others struggle with it. Just as God is our forever Friend, the brave girls take readers through the pages of this devo encouraging your girl to be the best friend she can be.
Better than Perfect teaches girls how wonderful they really are. All young girls struggle with self worth. They wonderful if they are good enough, pretty enough, smart enough and so on. But the brave girls, Faith and Honor, will help your girl see how great she is!
These devos are packed with friendly, simple and easy to understand topics that resonate with today's girls. Perfect for girls ages 7-11, although my 13 year old daughter loves them too!
How would your daughter describe a "forever friend"?
To win both Faithful Friends and Better than Perfect, complete each task in the rafflecopter below.
Love the way we are teaching our girls to be faithful and brave!
I know a few young girls who would love these devotionals. My daughters are older now, but I believe would describe a forever friend as one who is there for her, in both good times and in bad.
As a homeschool family she doesn't get to see her bf everyday, so I think my daughter would say that a forever friend is someone who she could talk to, play with and dance with from the moment you see each other to the moment you have to go. No drama allowed, just love and fun!
My 5 year old daughter says a forever friend is someone you are friends with for a long time.