docs: private List<NodeValue<ByteArray, byte[]>> resolveReadConflicts(final List<NodeValue<ByteArray, byte[]>> nodeValues) {
  
          if(logger.isTraceEnabled()) {
              logger.trace("NodeValues passed into resolveReadConflicts.");
              if(nodeValues.size() == 0) {
                  logger.trace("Empty nodeValues passed to resolveReadConflicts");
              }
              for(NodeValue<ByteArray, byte[]> nodeValue: nodeValues) {
                  logger.trace("\t" + nodeValue.getNodeId() + " - " + nodeValue.getKey().toString()
                               + " - " + nodeValue.getVersion().toString());
              }
          }
  
          // If orphaned values exist, add them to fake nodes to be processed by
          // "getRepairs"
          int currentFakeNodeId = fakeNodeID;
          if(this.orphanedValues != null) {
              for(Versioned<byte[]> value: this.orphanedValues.getValues()) {
                  nodeValues.add(new NodeValue<ByteArray, byte[]>(currentFakeNodeId,
                                                                  this.orphanedValues.getKey(),
                                                                  value));
                  currentFakeNodeId++;
              }
          }
  
          // Some cut-paste-and-modify coding from
          // store/routed/action/AbstractReadRepair.java and
          // store/routed/ThreadPoolRoutedStore.java
          ReadRepairer<ByteArray, byte[]> readRepairer = new ReadRepairer<ByteArray, byte[]>();
          List<NodeValue<ByteArray, byte[]>> nodeKeyValues = readRepairer.getRepairs(nodeValues);
  
          if(logger.isTraceEnabled()) {
              if(nodeKeyValues.size() == 0) {
                  logger.trace("\treadRepairer returned an empty list.");
              }
              for(NodeValue<ByteArray, byte[]> nodeKeyValue: nodeKeyValues) {
                  logger.trace("\tNodeKeyValue result from readRepairer.getRepairs : "
                               + ByteUtils.toHexString(nodeKeyValue.getKey().get())
                               + " on node with id " + nodeKeyValue.getNodeId() + " for version "
                               + nodeKeyValue.getVersion());
              }
          }
  
          List<NodeValue<ByteArray, byte[]>> toReadRepair = Lists.newArrayList();
          for(NodeValue<ByteArray, byte[]> v: nodeKeyValues) {
              if(v.getNodeId() > currentFakeNodeId) {
                  // Only copy repairs intended for real nodes.
                  Versioned<byte[]> versioned = Versioned.value(v.getVersioned().getValue(),
                                                                ((VectorClock) v.getVersion()).clone());
                  toReadRepair.add(new NodeValue<ByteArray, byte[]>(v.getNodeId(),
                                                                    v.getKey(),
                                                                    versioned));
              } else {
                  if(logger.isDebugEnabled()) {
                      logger.debug("\tIgnoring repair to fake node: "
                                   + ByteUtils.toHexString(v.getKey().get()) + " on node with id "
                                   + v.getNodeId() + " for version " + v.getVersion());
                  }
              }
  
          }
  
          if(logger.isTraceEnabled()) {
              if(toReadRepair.size() == 0) {
                  logger.trace("\ttoReadRepair is empty.");
              }
              for(NodeValue<ByteArray, byte[]> nodeKeyValue: toReadRepair) {
                  logger.trace("\tRepair key " + ByteUtils.toHexString(nodeKeyValue.getKey().get())
                               + " on node with id " + nodeKeyValue.getNodeId() + " for version "
                               + nodeKeyValue.getVersion());
  
              }
          }
          return toReadRepair;
      }