def mergesort_reversed(list):
    """
    A mergesort implementation. The only difference is that it sorts the input list in a REVERSED ORDER.
    I.e. the elements are sorted in a DESCENDING order.

    :param list:
    :type list: list
    :return: list sorted in descending order
    :rtype: list
    """

    def _merge(left,right):
        """
        The "conquert" part of merge-sort. Compare two lists item, by item, and append the one that is greater.
        This ensures the descending order of this implementation of mergesort.

        :param left: an input sorted with mergesort
        :type left: list
        :param right: an input sorted with mergesort
        :type right: list

        :return: merged and sorted list (in descending order) or all elements from left and right lists
        """
        merged = []
        left_index,right_index = 0,0

        while left_index < len(left) and right_index < len(right):
            if left[left_index] < right[right_index]:
                merged.append(right[right_index])
                right_index += 1
            else:
                merged.append(left[left_index])
                left_index += 1

        merged += left[left_index:]
        merged += right[right_index:]

        return merged

    def _mergesort(items):
        """
        The "divide" part of the mergesort. Recurrently calls mergesort to split array into a single element lists
        (left and right). Merges those two lists, returning a sorted list in a descending order.
        """
        if len(items) <= 1:
            return items

        mid = len(items) // 2
        left = items[:mid]
        right = items[mid:]

        left = _mergesort(left)
        right = _mergesort(right)

        return _merge(left, right)

    return _mergesort(list)