t turns out that this function template would have been legal both before and after C++11 was released. As we saw, though, C++11 added Move Semantics to the language. In a couple of sentences, briefly explain the impact, if any, that move semantics has had on the run-time performance of this insertionSort function template, relative to the performance that we would have seen before C++11.BackgroundThe sorting algorithms we saw this week were all Comparison-Based Sorting algorithms, which means that they do their work by comparing pairs of elements and taking action on the basis of those comparisons. Many of these algorithms reposition the elements primarily by swapping them with each other. Now suppose you had the following C++ implementation of insertion sort, which is similar to what we saw in the notes, except for two changes:Pointer arithmetic is used to maneuver around the array instead of indexing. The function has been made into a function template with two type parameters: the first representing the type of the elements in the array and the second representing the type of the comparer (i. e., a function object that compares two elements and returns true if and only if the first should come before the second once they're sorted).template void insertionSort(Element* begin, Element* end, Comparer shouldBeBefore){ for (Element* i = begin + 1; i != end; ++i) { for (Element* j = i; j != begin && shouldBeBefore(*j, *(j - 1)); --j) { std::swap(*j, *(j - 1)); } }}The changes have made insertionSort a much more broadly-useful implementation.// Sorting integers in descending orderint a[8] = { 3, 7, 6, 1, 2, 8, 5, 4 };insertionSort(a, a + 8, [](int i, int j) { return i > j; });// Sorting strings in ascending order of their lengthstd::string s[5] = { "Boo", "is", "good", "and", "perfect" };insertionSort(s, s + 5, [](const std::string& i, const std::string& j) { return i. size() < j. size(); });