public static <C extends Comparable> ImmutableRangeSet<C> of(Range<C> range) {
    checkNotNull(range);
    if (range.isEmpty()) {
      return of();
    } else if (range.equals(Range.all())) {
      return all();
    } else {
      return new ImmutableRangeSet<>(ImmutableList.of(range));
    }
  }

  /** Returns an immutable range set containing the single range {@link Range#all()}. */
  @SuppressWarnings("unchecked")

  }

  @Override
  public void addAll(Iterable<Range<C>> ranges) {
    for (Range<C> range : ranges) {
      add(range);
    }
  }

  @Override
  public void removeAll(RangeSet<C> other) {
    removeAll(other.asRanges());
  }

  @Override
  public void removeAll(Iterable<Range<C>> ranges) {
    for (Range<C> range : ranges) {
      remove(range);
    }
  }

  @Override

      return null;
    } else {
      Range<K> range = ranges.get(index);
      return range.contains(key) ? immutableEntry(range, values.get(index)) : null;
    }
  }

  @Override
  public Range<K> span() {
    if (ranges.isEmpty()) {
      throw new NoSuchElementException();
    }
    Range<K> firstRange = ranges.get(0);
    Range<K> lastRange = ranges.get(ranges.size() - 1);

        new ImmutableRangeMap.Builder<Integer, Integer>()
            .put(Range.closed(2, 4), 5)
            .put(Range.open(6, 7), 3)
            .put(Range.closedOpen(8, 10), 4)
            .put(Range.openClosed(15, 17), 2)
            .build();

    ImmutableMap<Range<Integer>, Integer> test = nonEmptyRangeMap.asMapOfRanges();

    for (Range<Integer> range : test.keySet()) {
      SerializableTester.reserializeAndAssert(range);

        assertNull(range.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
        assertFalse(range.isSelectedVersionKnown(artifact), CHECK_SELECTED_VERSION_KNOWN);
        assertNull(range.getSelectedVersion(artifact), CHECK_SELECTED_VERSION);

        range = VersionRange.createFromVersionSpec("1.0");
        assertEquals("1.0", range.getRecommendedVersion().toString(), CHECK_VERSION_RECOMMENDATION);

	CADD	$32, X5					// ERROR "must be in range [-32, 31]"
	CADDI	$0, X5					// ERROR "immediate cannot be zero"
	CADDI	$31, X5, X6				// ERROR "rd must be the same as rs1"
	CADDI	$-33, X5				// ERROR "must be in range [-32, 31]"
	CADDI	$32, X5					// ERROR "must be in range [-32, 31]"
	CADDW	$-33, X5				// ERROR "must be in range [-32, 31]"
	CADDW	$32, X5					// ERROR "must be in range [-32, 31]"

      // The safe range is empty or the all safe code points lie in or above the
      // surrogate range. Either way the character range is empty.
      this.safeMinChar = Character.MAX_VALUE;
      this.safeMaxChar = 0;
    } else {
      // The safe range is non-empty and contains values below the surrogate
      // range but may extend above it. We may need to clip the maximum value.
      this.safeMinChar = (char) safeMin;

     * Gets the artifact coordinates whose version range should be resolved.
     * The coordinates may contain a version range (e.g., "[1.0,2.0)") or a single version.
     *
     * @return the artifact coordinates, never {@code null}
     */
    @Nonnull
    ArtifactCoordinates getArtifactCoordinates();

    /**
     * Gets the nature of repositories to query when resolving the version range.

	dataErrsByDisk = make(map[int][]int, len(onlineDisks))
	for i := range onlineDisks {
		dataErrsByDisk[i] = make([]int, len(latestMeta.Parts))
	}

	dataErrsByPart = make(map[int][]int, len(latestMeta.Parts))
	for i := range latestMeta.Parts {
		dataErrsByPart[i] = make([]int, len(onlineDisks))
	}

	inconsistent := 0
	for i, meta := range partsMetadata {
		if !meta.IsValid() {

        assertTrue(DcerpcError.DCERPC_FAULT_NDR >= 0 && DcerpcError.DCERPC_FAULT_NDR <= 0x0000FFFF,
                "DCERPC_FAULT_NDR should be in standard range");

        // Extended fault codes (0x1C000000 range)
        assertTrue((DcerpcError.DCERPC_FAULT_INVALID_TAG & 0xFF000000) == 0x1C000000, "DCERPC_FAULT_INVALID_TAG should be in 0x1C range");