switch whence {
	case io.SeekStart:
		if offset < 0 {
			return 0, errors.New("Invalid offset")
		}
		d.idx = offset
	case io.SeekCurrent:
		if d.idx+offset < 0 {
			return 0, errors.New("Invalid offset")
		}
		d.idx += offset
	case io.SeekEnd:
		if d.length+offset < 0 {
			return 0, errors.New("Invalid offset")
		}
		d.idx = d.length + offset
	}
	return d.idx, nil
}

 *   <li>Handling of voiced (ﾞ) and semi-voiced (ﾟ) sound marks to produce the correct Zenkaku Kana characters.</li>
 * </ul>
 *
 * <p>Example usage:</p>
 * <pre>
 * {@code
 * HankakuKanaToZenkakuKana normalizer = new HankakuKanaToZenkakuKana();
 * String normalized = normalizer.normalize("ｶﾞｷﾞｸﾞｹﾞｺﾞ", "field");
 * System.out.println(normalized); // Outputs: ガギグゲゴ
 * }
 * </pre>
 *

  @Override
  public SampleElements<Character> samples() {
    return new Chars();
  }

  @Override
  public List<Character> create(Object... elements) {
    Character[] array = new Character[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (Character) e;
    }
    return create(array);
  }

  /**

 */
@NullUnmarked
public class ForwardingListMultimapTest extends TestCase {

  @SuppressWarnings("rawtypes")
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            ListMultimap.class,
            new Function<ListMultimap, ListMultimap<?, ?>>() {
              @Override
              public ListMultimap<?, ?> apply(ListMultimap delegate) {

  @Override
  public SampleElements<String> samples() {
    return new Strings();
  }

  @Override
  public List<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  /**
   * Creates a new collection containing the given elements; implement this method instead of {@link

  static final RegularImmutableBiMap<Object, Object> EMPTY =
      new RegularImmutableBiMap<Object, Object>();

  private final ImmutableBiMap<V, K> inverse;

  @SuppressWarnings("unchecked") // used only for the empty map, which works for any types
  RegularImmutableBiMap() {
    super(new RegularImmutableMap<K, V>(new HashMap<K, V>()));
    this.inverse = (ImmutableBiMap<V, K>) this;
  }

    public FacetResponse getFacetResponse() {
        return facetResponse;
    }

    /**
     * Creates a new SearchResultBuilder for constructing SearchResult instances.
     *
     * @return A new SearchResultBuilder instance
     */
    public static SearchResultBuilder create() {
        return new SearchResultBuilder();
    }

    @Override
    public String toString() {

@Deprecated
@Named
@Singleton
public class StringSearchModelInterpolator extends AbstractStringBasedModelInterpolator {

    private static final Map<Class<?>, Field[]> FIELDS_BY_CLASS = new WeakHashMap<>();
    private static final Map<Class<?>, Boolean> PRIMITIVE_BY_CLASS = new WeakHashMap<>();

    public StringSearchModelInterpolator() {}

    public StringSearchModelInterpolator(PathTranslator pathTranslator) {
        super(pathTranslator);
    }

					association.Error = associationDB.Model(nil).Where(clause.IN{Column: column, Values: values}).Delete(reflect.New(rel.FieldSchema.ModelType).Interface()).Error
				}
			}
		case schema.HasOne, schema.HasMany:
			model := reflect.New(rel.FieldSchema.ModelType).Interface()
			tx := association.DB.Model(model)

   */
  private static <N> boolean subgraphHasCycle(
      Graph<N> graph, Map<Object, NodeVisitState> visitedNodes, N startNode) {
    Deque<NodeAndRemainingSuccessors<N>> stack = new ArrayDeque<>();
    stack.addLast(new NodeAndRemainingSuccessors<>(startNode));

    while (!stack.isEmpty()) {
      // To peek at the top two items, we need to temporarily remove one.