protected void resolveConflict(int s, int newValue) {

		// The set of children values
		TreeSet<Integer> values = new TreeSet<Integer>();

		// Add the value-to-add 
		values.add(new Integer(newValue));

		// Find all existing children and add them too.
		for (int c = 0; c < alphabetLength; c++) {
			int tempNext = getBase(s) + c;
			if (tempNext < getSize() && getCheck(tempNext) == s)
				values.add(new Integer(c));
		}

		// Find a place to move them.
		int newLocation = nextAvailableMove(values);

		// newValue is not yet a child of s, so we should not check for it.
		values.remove(new Integer(newValue));
		
		/*
		 * This is where the job is done. For each child of s, 
		 */
		for (Integer value : values) {
			int c = value.intValue();		// The child state to move
			int tempNext = getBase(s) + c;	// 
			assert tempNext < getSize();
			assert getCheck(tempNext) == s;
			/*
			 * base(s)+c state is child of s.
			 * Mark new position as owned by s.
			 */
			assert getCheck(newLocation + c) == EMPTY_VALUE;
			setCheck(newLocation + c, s);

			/*
			 * Copy pointers to children for this child of s.
			 * Note that even if this child is a leaf, this is needed.
			 */
			assert getBase(newLocation + c) == EMPTY_VALUE;
			setBase(newLocation + c, getBase(getBase(s) + c));
			updateChildMove(s, c, newLocation);
			/*
			 * Here the child c is moved, but not *its* children. They must be
			 * updated so that their check values point to the new position of their
			 * parent (i.e. c)
			 */
			if (getBase(getBase(s) + c) != LEAF_BASE_VALUE) {
				 // First, iterate over all possible children of c
				 for (int d = 0; d < alphabetLength; d++) {
					/*
					 *  Get the child. This could well be beyond the store size
					 *  since we don't know how many children c has.
					 */
					int tempNextChild = getBase(getBase(s) + c) + d;
					/* 
					 * Here we could also check if tempNext > 0, since
					 * negative values end the universe. However, since the
					 * implementation of nextAvailableHop never returns
					 * negative values, this should never happen. Presto, a
					 * nice way of catching bugs.
					 */
					if (tempNextChild < getSize() && getCheck(tempNextChild) == getBase(s) + c) {
						// Update its check value, so that it shows to the new position of this child of s.
						setCheck(getBase(getBase(s) + c) + d, newLocation + c);
					}
					else if (tempNextChild >= getSize()) {
						/*
						 *  Minor optimization here. If the above if fails then tempNextChild > check.size()
						 *  or the tempNextChild position is already owned by some other state. Remember
						 *  that children states are stored in increasing order (though not necessarily
						 *  right next to each other, since other states can be between the gaps they leave).
						 *  That means that failure of the second part of the conjuction of the if above
						 *  does not mean failure, since the next child can exist. Failure of the first conjuct
						 *  however means we are done, since all the rest of the children will only be further
						 *  down the store and therefore beyond its end also. Nothing left to do but break  
						 */
						break;
					}
				}
				// Finally, free the position held by this child of s
				setBase(getBase(s) + c, EMPTY_VALUE);
				setCheck(getBase(s) + c, EMPTY_VALUE);
			}
		}
		// Here, all children and grandchildren (if existent) of s have been
		// moved or updated. That which remains is for the state s to show
		// to its new children
		setBase(s, newLocation);
		updateStateMove(s, newLocation);
	}