• The number of nodes in the list is in the range [0, 200]
• -100 <= Node.val <= 100
• -200 <= x <= 200
• Relative order within each partition must be preserved (stable).

We must split the list into two groups — values below x, then values x-and-above — while keeping the original order inside each group (that is what stable means). It's the braid from Odd Even Linked List again, with one thing changed: instead of routing nodes by their position (odd vs even), we route them by a value test (val < x vs not). Everything else — grow two chains in place, then join them — carries over.

The direct approach: two buffers. Walk the list, push each node into a "less" list or a "greater-or-equal" list, then concatenate. Correct, and stable because we append in traversal order — but it spends O(N) extra space on the buffers. As in Odd Even, the buffers only exist to hold nodes aside; since the nodes never actually need to move in memory, we can build both groups in place and skip the buffers entirely.

Keep two growing chains — a less chain and a more chain — each with its own tail pointer so appending is O(1). Walk the original list once; for each node, test val < x and append it to the matching chain's tail. Because we visit nodes in their original order and only ever append, order inside each chain is automatically preserved — stability comes for free from append-in-order. When the walk ends, join the less-tail to the more-head, and we're done. Each chain gets a dummy head so "append to an empty chain" is the same code as any other append — no first-node special case, the same trick used to build the result in Add Two Numbers.

less = Node(0)             # dummy head of the "< x" chain
more = Node(0)             # dummy head of the ">= x" chain
less_tail, more_tail = less, more

curr = head
while curr:
    if curr.val < x:
        less_tail.next = curr
        less_tail = curr
    else:
        more_tail.next = curr
        more_tail = curr
    curr = curr.next

more_tail.next = None       # terminate the "more" chain
less_tail.next = more.next  # join: less chain -> first real "more" node
return less.next

One pass, fixed pointers: O(N) time, O(1) space. This is the twin of Odd Even Linked List — split one list into two by walking once and routing each node, then join — with the routing rule swapped from parity to a value predicate. The transferable reflex is that pairing: dummy-headed chains + tail pointers + null-terminate the trailing chain before joining. Whenever a problem says "group these into two (or more) categories, in place, keeping order," reach for exactly this braid and remember to sever the old tail link, or a silent cycle will bite you.