function precacheChildNodes(inst, node) {
	  if (inst._flags & Flags.hasCachedChildNodes) {
	    return;
	  }
	  var children = inst._renderedChildren;
	  var childNode = node.firstChild;
	  outer: for (var name in children) {
	    if (!children.hasOwnProperty(name)) {
	      continue;
	    }
	    var childInst = children[name];
	    var childID = getRenderedHostOrTextFromComponent(childInst)._domID;
	    if (childID === 0) {
	      // We're currently unmounting this child in ReactMultiChild; skip it.
	      continue;
	    }
	    // We assume the child nodes are in the same order as the child instances.
	    for (; childNode !== null; childNode = childNode.nextSibling) {
	      if (shouldPrecacheNode(childNode, childID)) {
	        precacheNode(childInst, childNode);
	        continue outer;
	      }
	    }
	    // We reached the end of the DOM children without finding an ID match.
	     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unable to find element with ID %s.', childID) : _prodInvariant('32', childID) : void 0;
	  }
	  inst._flags |= Flags.hasCachedChildNodes;
	}
Populate `_hostNode` on each child of `inst`, assuming that the children
match up with the DOM (element) children of `node`.

We cache entire levels at once to avoid an n^2 problem where we access the
children of a node sequentially and have to walk from the start to our target
node every time.

Since we update `_renderedChildren` and the actual DOM at (slightly)
different times, we could race here and see a newer `_renderedChildren` than
the DOM nodes we see. To avoid this, ReactMultiChild calls
`prepareToManageChildren` before we change `_renderedChildren`, at which
time the container's child nodes are always cached (until it unmounts).