Given a binary search tree (BST) and two keys `p` and `q`, return the value of their lowest common ancestor (LCA) — the deepest node whose value lies between `p` and `q` inclusive. To keep the input language-agnostic, the tree is given as `insert_order`: a list of integers inserted into an initially empty BST using standard BST insertion (left if smaller, right if larger, duplicates ignored). Reconstruct the BST from this list, then find the LCA of `p` and `q`. Handle the case where one or both keys are absent: if either `p` or `q` does not exist in the BST, return the sentinel value `-1`. (All test trees use non-negative values, so `-1` is an unambiguous "not found" signal.) If the tree is empty, also return `-1`. The canonical BST LCA walk: starting at the root, if both keys are smaller than the current node go left, if both are larger go right, otherwise the current node is the LCA. This is the iterative solution. The equivalent recursive form is: ``` def lca(node, p, q): if node.val > p and node.val > q: return lca(node.left, p, q) if node.val < p and node.val < q: return lca(node.right, p, q) return node.val ``` **Example:** `insert_order = [6, 2, 8, 0, 4, 7, 9, 3, 5]`, `p = 2`, `q = 8` → `6` (the root is the split point between the two subtrees). With `p = 2`, `q = 4` → `2` (since 2 is an ancestor of 4). With `p = 3`, `q = 5` → `4`.