checkPositionIndexes(fromIndex, toIndex, size());
    int length = toIndex - fromIndex;
    if (length == size()) {
      return this;
    } else if (length == 0) {
      return of();
    } else if (length == 1) {
      return of(get(fromIndex));
    } else {
      return subListUnchecked(fromIndex, toIndex);
    }
  }

  /**

   *
   * @return set of table cells consisting of row key / column key / value triplets
   */
  Set<Cell<R, C, V>> cellSet();

  /**
   * Returns a set of row keys that have one or more values in the table. Changes to the set will
   * update the underlying table, and vice versa.
   *
   * @return set of row keys
   */
  Set<R> rowKeySet();

  /**

          return equivalence.equivalent(this.reference, that.reference);
        }
      }
      return false;
    }

    /** Returns the result of {@link Equivalence#hash(Object)} applied to the wrapped reference. */
    @Override
    public int hashCode() {
      return equivalence.hash(reference);
    }

    /**

				// filtering requested to return by caller.
				return nil
			}
		}
	}
	return nil
}

// Return entries at the directory dirPath.
func readDirWithOpts(dirPath string, opts readDirOpts) (entries []string, err error) {
	d, err := Open(dirPath)
	if err != nil {
		return nil, osErrToFileErr(err)
	}
	defer d.Close()

	maxEntries := 1000

public interface Location {

    /**
     * Return the line number where the current event ends,
     * returns -1 if none is available.
     * @return the current line number
     */
    int getLineNumber();

    /**
     * Return the column number where the current event ends,
     * returns -1 if none is available.
     * @return the current column number
     */
    int getColumnNumber();

    /**

   * Reserves next ticket and returns the wait time that the caller must wait for.
   *
   * @return the required wait time, never negative
   */
  final long reserveAndGetWaitLength(int permits, long nowMicros) {
    long momentAvailable = reserveEarliestAvailable(permits, nowMicros);
    return max(momentAvailable - nowMicros, 0);
  }

  /**
   * Returns the earliest time that permits are available (with one caveat).
   *

      if (charset.equals(this.charset)) {
        return CharSource.this;
      }
      return super.asCharSource(charset);
    }

    @Override
    public InputStream openStream() throws IOException {
      return new ReaderInputStream(CharSource.this.openStream(), charset, 8192);
    }

    @Override
    public String toString() {
      return CharSource.this.toString() + ".asByteSource(" + charset + ")";

          uid = alreadySet;
        }
      }
      return uid;
    }

    @Override
    public int compare(@CheckForNull Object left, @CheckForNull Object right) {
      if (left == right) {
        return 0;
      } else if (left == null) {
        return -1;
      } else if (right == null) {
        return 1;
      }
      int leftCode = identityHashCode(left);

        if (current < maxValueDivs[radix]) {
          return false;
        }
        if (current > maxValueDivs[radix]) {
          return true;
        }
        // current == maxValueDivs[radix]
        return (digit > maxValueMods[radix]);
      }

      // current < 0: high bit is set
      return true;
    }
  }

  /**
   * Returns a string representation of x, where x is treated as unsigned.

				return nil, err
			}
			targets = append(targets, t)
		}
	case config.NotifyESSubSys:
		esTargets, err := GetNotifyES(cfg[config.NotifyESSubSys], transport)
		if err != nil {
			return nil, err
		}
		for id, args := range esTargets {
			if !args.Enable {
				continue
			}
			t, err := target.NewElasticsearchTarget(id, args, logOnceIf)
			if err != nil {
				return nil, err
			}