Summing the Four Largest Unique Values

As described in my earlier comment below, the UNIQUE and UniquePlus functions return unique rows or columns of a contiguous range or array.
My Excel Toolbox now includes the following function to return unique values ignoring rows and columns:
    =UniqueItems(Items, [SkipEmpty], [ExactlyOnce], [CaseSensitive])
Items can be any range or array; it is treated as a basket of values without structure. If Items is a noncontiguous cell range, it must be parenthesized.
If SkipEmpty is TRUE, empty values (e.g., empty cells) will be ignored.
If ExactlyOnce is TRUE, values that occur more than once will be ignored.
If CaseSensitive is TRUE, text comparisons will be case-sensitive.
Optional parameters are FALSE by default.
This function returns an array with 1 row and N columns; use TRANSPOSE to return a column with N rows. There will be no repetition in the result.
Here's an abbreviated version:

Function UniqueItems(ByVal Items As Variant, _
    Optional SkipEmpty As Boolean, Optional ExactlyOnce As Boolean)
    Dim Uniq As Object, Once As Object, isRange As Boolean, item As Variant
    Set Uniq = CreateObject("Scripting.Dictionary")
    If ExactlyOnce Then Set Once = CreateObject("Scripting.Dictionary")
    isRange = (TypeOf Items Is Range)
    If isRange Then Set Items = Intersect(Items, Items.Worksheet.UsedRange)
    For Each item In Items
        If isRange Then item = item.Value
        If Uniq.Exists(item) Then
            If ExactlyOnce Then
                If Once.Exists(item) Then Once.Remove item
            End If
        Else
            Uniq.Add item, Null
            If ExactlyOnce Then Once.Add item, Null
        End If
    Next item
    If ExactlyOnce Then
        If SkipEmpty And Once.Exists(Empty) Then Once.Remove Empty
        UniqueItems = Once.Keys
    Else
        If SkipEmpty And Uniq.Exists(Empty) Then Uniq.Remove Empty
        UniqueItems = Uniq.Keys
    End If
End Function

Correction: My most recent comment below said UNIQUE "treats empty cells as zero values." Actually it treats them as empty values and returns them as empty values, but when a function in a cell formula returns an empty value it is displayed as zero (0). UniquePlus works like UNIQUE in this respect.
Note ISBLANK returns TRUE for an empty value but FALSE for a blank text value (""), a.k.a. null string; therefore, ISBLANK should be named ISEMPTY.
For more on this subject, see https://excelribbon.tips.net/T010105_Returning_Zero_When_a_Referenced_Cell_is_Blank.html

Re. my previous comment below, LARGE and SMALL ignore empty cells plus text and logical values, but not error values.
UNIQUE returns unique rows or columns of a contiguous range or array. It treats empty cells as zero values, includes text, logical, and error values, but ignores text case.
My Excel Toolbox includes the following function that works like UNIQUE but provides additional options:
    =UniquePlus(RangeArray, [LeftRight], [ExactlyOnce], [HasHeader],
        [CaseSensitive])
The first three parameters match Excel's UNIQUE function.
When HasHeader is TRUE, the first row (LeftRight=FALSE) or first column (LeftRight=TRUE) is returned even if it is not unique.
Case-sensitive comparisons are done when CaseSensitive is TRUE.
This function does not require Excel 2021 or later.
See https://sites.google.com/view/MyExcelToolbox

I think the title of this tip is a little ambiguous.

Given the data as shown, should 21 be counted once only, or should 21 be ignored because it is not unique?

The unique function can accommodate both interpretations, so if the source data contains 21,37,22,13,21,15,1,2,3 say:-

=SUM(LARGE(UNIQUE(A:A,,FALSE),{1,2,3,4})) returns 95, counting 21 once, but:-

=SUM(LARGE(UNIQUE(A:A,,TRUE),{1,2,3,4})) returns 87, ignoring 21 as it is not unique in the source data.

The UNIQUE function requires a contiguous range or array.
The Tip's UDF requires a range (contiguous or not) but will not accept an array. This is appropriate given Vince's requirement described in the first paragraph.
As implied by Ken Kast, here's a more efficient version that works with any range or array:

Function SumTop4Unique2(rng As Variant) As Double
    Dim lastVal As Double, nextVal As Double, J As Integer, K As Integer
    lastVal = WorksheetFunction.Small(rng, 1)
    Do
        J = J + 1
        Do
            K = K + 1
            nextVal = WorksheetFunction.Large(rng, K)
        Loop Until nextVal <> lastVal
        lastVal = nextVal
        SumTop4Unique2 = SumTop4Unique2 + lastVal
    Loop Until J = 4
End Function

Consistent with the function's name, if there are less than 4 unique values the result is a #VALUE! error.

Since you're going to sort anyway, wouldn't it be easier to first sort the list, then have a loop that starts at the top and adds successively, skipping an entry if it's the same as the previous. You'd exit the loop when you've added four numbers.