Merge Two Descending Linked Lists

Given the heads of two singly linked lists listA and listB, each sorted in nonincreasing order, merge their nodes into one linked list that is also sorted in nonincreasing order.
Preserve every node value, including duplicates. Either input list may be empty.

Function
mergeDescendingLists(listA: ListNode, listB: ListNode) → ListNode

Examples
Example 1
listA = [9,7,3]
listB = [10,8,7,1]
return = [10,9,8,7,7,3,1]
At each step, append the larger current head. Both nodes with value 7 remain in the merged list.
Example 2
listA = []
listB = [5,5,2]
return = [5,5,2]
When one input is empty, the other list is already the complete descending result.
Example 3
listA = [4,2]
listB = [3]
return = [4,3,2]
The head 4 is followed by 3, then the remaining node 2.

Constraints
The two lists contain at most 100000 nodes in total.
Every node value is a signed 32-bit integer.
Each input list is sorted in nonincreasing order.

The trick is the merge step from merge sort, run on linked lists. Make a dummy head and a tail pointer. Compare the current heads of listA and listB. Attach the larger one to tail, advance that list, advance tail. When one list runs out, attach the other whole, since it's already descending. Return dummy.next. Ties are fine: with equal values, take either one, and both 7s in Example 1 survive because you never skip a node. The common pitfalls are flipping the comparison the wrong way and ascending by habit, forgetting to handle an empty list, and creating new nodes instead of relinking. With up to 100000 nodes total, recursion risks stack depth, so go iterative. That's O(n+m) time and O(1) extra space. If your mind goes blank mid-assessment, StealthCoder is the hedge that hands you the pointer logic live.

If this hits your live OA and you blank, StealthCoder solves it in seconds, invisible to the proctor.