How to sort a dictionary in tcl with multiple index

I have a dictionary in tcl where the value is a list of items. For example, consider the dictionary given below:

1: {10,20,30}
2: {10,25,45}
3: {10,5,15}
4: {2,12,36}
5: {7,16,9}

where 1,2,3,4,5 are the keys, and the values are represented in braces. I want to sort the dictionary based on the first item of the list value, {index 1 0}. If 2 keys have the same value for {index 1 0}, I should sort by the second item of the list value, {index 1 1}. Finally, I should return the keys in the sorted order. Currently, I am using lsort to sort the contents. But I am not able to sort if two keys have the same { index 1 0 } value. I am using tcl 8.6. Currently, I am using the following code:

set sorted [lsort -stride 2 -integer -index {1 0} $dict_name]
set get_keys [dict keys $sorted ]
puts $get_keys

But the above code does not sort contents with the second item of the list if both have the same value for index {1 0}.
Expected output:

4: {2,12,36}
5: {7,16,9}
3: {10,5,15}
1: {10,20,30}
2: {10,25,45}

Key 4 has the lowest value for index 0, followed by key 5. Since keys 1,2, and 3 have the same value for index 0, they are sorted based on the values of index 1.

If you write a function that compares two lists element-by-element, it can be used with lsort's -stride, -index and -command options to sort as desired by passing the values of the dict to that comparison function.

#!/usr/bin/env tclsh

# Compare two values of integer lists element by element
proc sortIntLists {a b} {
    set lenA [llength $a]
    set lenB [llength $b]
    set len [::tcl::mathfunc::min $lenA $lenB]
    for {set n 0} {$n < $len} {incr n} {
        set diff [expr {[lindex $a $n] - [lindex $b $n]}]
        if {$diff != 0} {
            return $diff
        }
    }
    # Every pair of elements of the lists looked at has been equal
    # now if the lists are different lengths the shorter one is smaller
    if {$lenA == $lenB} {
        return 0
    } elseif {$lenA < $lenB} {
        return -1
    } else {
        return 1
    }
}

set myDict {
    1 {10 20 30}
    2 {10 25 45}
    3 {10 5 15}
    4 {2 12 36}
    5 {7 16 9}
}

set mySortedDict [lsort -stride 2 -index 1 -command sortIntLists $myDict]

dict for {k v} $mySortedDict {
    puts "$k: $v"
}

outputs

4: 2 12 36
5: 7 16 9
3: 10 5 15
1: 10 20 30
2: 10 25 45

Tcl uses a stable sort algorithm. To resolve duplicates on the primary key by using a secondary key, sort by the secondary key first, then sort the result by the primary key:

set data {
    1 {10 20 30}
    2 {10 25 45}
    3 {10 5 15}
    4 {2 12 36}
    5 {7 16 9}
}
set temp [lsort -stride 2 -integer -index {1 1} $data]
set final [lsort -stride 2 -integer -index {1 0} $temp]
puts [dict keys $final]

Result: 4 5 3 1 2

You can extend this to as many keys as you want. Just start sorting by the least significant key and work your way to the most significant key.