code: def update(self, key: bytes, value: bytes, node_updates: Sequence[Hash32]):
          
          validate_is_bytes(key)
          validate_length(key, self._key_size)
  
          # Path diff is the logical XOR of the updated key and this account
          path_diff = (to_int(self.key) ^ to_int(key))
  
          # Same key (diff of 0), update the tracked value
          if path_diff == 0:
              self._value = value
              # No need to update branch
          else:
              # Find the first mismatched bit between keypaths. This is
              # where the branch point occurs, and we should update the
              # sibling node in the source branch at the branch point.
              # NOTE: Keys are in MSB->LSB (root->leaf) order.
              #       Node lists are in root->leaf order.
              #       Be sure to convert between them effectively.
              for bit in reversed(range(self._branch_size)):
                  if path_diff & (1 << bit) > 0:
                      branch_point = (self._branch_size - 1) - bit
                      break
  
              # NOTE: node_updates only has to be as long as necessary
              #       to obtain the update. This allows an optimization
              #       of pruning updates to the maximum possible depth
              #       that would be required to update, which may be
              #       significantly smaller than the tree depth.
              if len(node_updates) <= branch_point:
                  raise ValidationError("Updated node list is not deep enough")
  
              # Update sibling node in the branch where our key differs from the update
              self._branch[branch_point] = node_updates[branch_point]
docs: Merge an update for another key with the one we are tracking internally.
  
          :param key: keypath of the update we are processing
          :param value: value of the update we are processing
          :param node_updates: sequence of sibling nodes (in root->leaf order)
                               must be at least as large as the first diverging
                               key in the keypath