# We're at a ( || atom ... ) type level

	# We're at a ( || atom ... ) type level and need to make a choice

	target = None

	# Our preference order is for an the first item that:

	# a) contains all unmasked packages with the same key as installed packages

	# b) contains all unmasked packages

	# c) contains masked installed packages

	# d) is the first item

	preferred = []

	other = []

	# Alias the trees we'll be checking availability against

	vardb = trees[myroot]["vartree"].dbapi

	if use_binaries:

		mydbapi = trees[myroot]["bintree"].dbapi

	else:

		mydbapi = trees[myroot]["porttree"].dbapi

	# Sort the deps into preferred (installed) and other

	# with values of [[required_atom], availablility]

		if not missing_atoms:

		all_installed = True

			if isinstance(dep, list):

		for atom in atoms:

				return atoms  # Sorted out by the recursed dep_zapdeps call

			if not vardb.match(dep_getkey(atom)):

			else:

				all_installed = False

				target = dep_getkey(dep) # An installed package that's not yet in the graph

		if not target:

		all_available = True

			if use_binaries:

		for atom in atoms:

				missing_atoms = [atom for atom in atoms if not trees[myroot]["bintree"].dbapi.match(atom)]

			if not mydbapi.match(atom):

			else:

				all_available = False

				missing_atoms = [atom for atom in atoms if not trees[myroot]["porttree"].dbapi.xmatch("match-visible", atom)]

				break

			if not missing_atoms:

				target = (dep, satisfied)

		# Check if the set of atoms will result in a downgrade of

		# an installed package. If they will then don't prefer them

	if not target:

		# over other atoms.

		if isinstance(deps[0], list):

		if all_installed and all_available:

			return dep_zapdeps(deps[0], satisfieds[0], myroot,

			for atom in atoms:

				use_binaries=use_binaries, trees=trees)

				inst_pkgs = vardb.match(dep_getkey(atom))

				avail_pkg = best(mydbapi.match(atom))

				avail_slot = mydbapi.aux_get(avail_pkg, ["SLOT"])[0]

				avail_split = pkgsplit(avail_pkg.split("/")[1])

				is_okay = False

				for pkg in inst_pkgs:

					inst_split = pkgsplit(pkg.split("/")[1])

					inst_slot = vardb.aux_get(pkg, ["SLOT"])[0]

					if inst_slot != avail_slot:

						continue

					if pkgcmp(avail_split, inst_split) >= 0:

						is_okay = True

						break

				if not is_okay:

					all_installed = False

					break

		if all_installed:

			preferred.append([atoms, all_available])

			return [deps[0]]

			other.append([atoms, all_available])

	if isinstance(target, tuple): # Nothing matching installed

	# preferred now contains a) and c) from the order above with

		if isinstance(target[0], list): # ... and the first available was a sublist

	# the masked flag differentiating the two. other contains b)

			return dep_zapdeps(target[0], target[1], myroot,

	# and d) so adding other to preferred will give us a suitable

				use_binaries=use_binaries, trees=trees)

	# list to iterate over.

		else: # ... and the first available was a single atom

	preferred.extend(other)

			target = dep_getkey(target[0])

	for allow_masked in (False, True):

		for (atoms, all_available) in preferred:

			if all_available or allow_masked:

				return atoms

	relevant_atoms = [dep for dep in deps if not isinstance(dep, list) and dep_getkey(dep) == target]

	assert(False) # This point should not be reachable