int error;

	char temp[64], *cp, *cp2 = a, *cp3 = m;

	struct radix_node *base, *next;

	size_t length = min(LEN(v_arg), LEN(n_arg));

	u_char *xa = (u_char *)a;

	struct subtree_info si;

	u_char *xm = (u_char *)m;

	register struct radix_node *rn, *last = 0 /* shut up gcc */;

	if (!m)

	int stopping = 0;

		return rn_waltree_with(h, a, f, w);

	int lastb;

	if (length > sizeof(temp)) {

		R_Malloc(si.si_maskedkey, char *, length);

	/*

	} else {

	 * rn_search_m is sort-of-open-coded here. We cannot use the

		si.si_maskedkey = temp;

	 * function because we need to keep track of the last node seen.

	 */

	/* printf("about to search\n"); */

	for (rn = h->rnh_treetop; rn->rn_bit >= 0; ) {

		last = rn;

		/* printf("rn_bit %d, rn_bmask %x, xm[rn_offset] %x\n",

		       rn->rn_bit, rn->rn_bmask, xm[rn->rn_offset]); */

		if (!(rn->rn_bmask & xm[rn->rn_offset])) {

			break;

		}

		if (rn->rn_bmask & xa[rn->rn_offset]) {

			rn = rn->rn_right;

		} else {

			rn = rn->rn_left;

		}

	}

	/* printf("done searching\n"); */

	/*

	 * Two cases: either we stepped off the end of our mask,

	 * in which case last == rn, or we reached a leaf, in which

	 * case we want to start from the last node we looked at.

	 * Either way, last is the node we want to start from.

	 */

	rn = last;

	lastb = rn->rn_bit;

	/* printf("rn %p, lastb %d\n", rn, lastb);*/

	/*

	 * This gets complicated because we may delete the node

	 * while applying the function f to it, so we need to calculate

	 * the successor node in advance.

	 */

	while (rn->rn_bit >= 0)

		rn = rn->rn_left;

	while (!stopping) {

		/* printf("node %p (%d)\n", rn, rn->rn_bit); */

		base = rn;

		/* If at right child go back up, otherwise, go right */

		while (rn->rn_parent->rn_right == rn

		       && !(rn->rn_flags & RNF_ROOT)) {

			rn = rn->rn_parent;

			/* if went up beyond last, stop */

			if (rn->rn_bit <= lastb) {

				stopping = 1;

				/* printf("up too far\n"); */

				/*

				 * XXX we should jump to the 'Process leaves'

				 * part, because the values of 'rn' and 'next'

				 * we compute will not be used. Not a big deal

				 * because this loop will terminate, but it is

				 * inefficient and hard to understand!

				 */

			}

		}

		/* 

		 * At the top of the tree, no need to traverse the right

		 * half, prevent the traversal of the entire tree in the

		 * case of default route.

		 */

		if (rn->rn_parent->rn_flags & RNF_ROOT)

			stopping = 1;

		/* Find the next *leaf* since next node might vanish, too */

		for (rn = rn->rn_parent->rn_right; rn->rn_bit >= 0;)

			rn = rn->rn_left;

		next = rn;

		/* Process leaves */

		while ((rn = base) != 0) {

			base = rn->rn_dupedkey;

			/* printf("leaf %p\n", rn); */

			if (!(rn->rn_flags & RNF_ROOT)

			    && (error = (*f)(rn, w)))

				return (error);

		}

		rn = next;

		if (rn->rn_flags & RNF_ROOT) {

			/* printf("root, stopping"); */

			stopping = 1;

		}

rn_walktree(h, f, w)

rn_walktree1(rn, skipfirst, f, w)

	struct radix_node_head *h;

	struct radix_node *rn;

	int skipfirst;