abs = r.i + offset
	case io.SeekEnd:
		abs = int64(len(r.s)) + offset
	default:
		return 0, errors.New("bytes.Reader.Seek: invalid whence")
	}
	if abs < 0 {
		return 0, errors.New("bytes.Reader.Seek: negative position")
	}
	r.i = abs
	return abs, nil
}

// WriteTo implements the [io.WriterTo] interface.
func (r *Reader) WriteTo(w io.Writer) (n int64, err error) {
	r.prevRune = -1
	if r.i >= int64(len(r.s)) {

      @Override
      public void remove() {
        throw new UnsupportedOperationException();
      }
    };
  }

  static <T extends @Nullable Object> T get(Iterator<T> iterator, int position) {
    for (int i = 0; i < position; i++) {
      iterator.next();
    }
    return iterator.next();
  }

  private static final class EntryComparator<K extends @Nullable Object, V extends @Nullable Object>

        void testReadBytesWireFormatDifferentStartPositions() throws SMBProtocolDecodingException {
            // Given
            byte[] buffer = new byte[20];

            // Test at different positions
            int[] positions = { 0, 5, 10, 15 };

            for (int pos : positions) {
                SMBUtil.writeInt2(4, buffer, pos);

     */
    public String[] lang;

    /**
     * Array of additional query strings to exclude from search.
     */
    public String[] ex_q;

    /**
     * The starting position for search results pagination.
     */
    @ValidateTypeFailure
    public Integer start;

    /**
     * The offset for search results.
     */
    @ValidateTypeFailure
    public Integer offset;

	} else {
		sql = numericPlaceholder.ReplaceAllString(sql, "$$$1$$")

		sql = numericPlaceholderRe.ReplaceAllStringFunc(sql, func(v string) string {
			num := v[1 : len(v)-1]
			n, _ := strconv.Atoi(num)

			// position var start from 1 ($1, $2)
			n -= 1
			if n >= 0 && n <= len(vars)-1 {
				return vars[n]
			}
			return v
		})
	}

	return sql

	if !found {
		// Check if index.
		if after, ok := strings.CutPrefix(name, "_"); ok {
			idx, err := strconv.Atoi(after)
			if err != nil {
				return nil, fmt.Errorf("column %v not found", name)
			}
			// The position count starts at 1.
			idx--
			if idx >= len(r.csvRecord) || idx < 0 {
				// If field index > number of columns, return null
				return sql.FromNull(), nil
			}
			return sql.FromBytes([]byte(r.csvRecord[idx])), nil

   */
  private fun assertWildcardRule(rule: String) {
    check(rule.startsWith(WILDCARD_CHAR)) {
      """Wildcard Assertion Failure: '$rule'
A wildcard rule was added with a wildcard that is not in leftmost position! We'll need to change the ${PublicSuffixDatabase::class.java.name} to handle this."""
    }
    check(rule.indexOf(WILDCARD_CHAR, 1) == -1) {
      """Wildcard Assertion Failure: '$rule'

      testConstructorParameter(ctor, nullIndex);
    }
  }

  /**
   * Verifies that {@code method} produces a {@link NullPointerException} or {@link
   * UnsupportedOperationException} when the parameter in position {@code paramIndex} is null. If
   * this parameter is marked nullable, this method does nothing.
   *
   * @param instance the instance to invoke {@code method} on, or null if {@code method} is static
   */

 */
public class UUID extends rpc.uuid_t {

    /**
     * Convert hexadecimal characters to binary integer
     *
     * @param arr the character array containing hex digits
     * @param offset the starting position in the array
     * @param length the number of hex digits to convert
     * @return the integer value of the hex digits
     */
    public static int hex_to_bin(final char[] arr, final int offset, final int length) {

        // This means bytes 20-27 will be zero (8 bytes written by writeInt8)
        for (int i = 20; i < 28; i++) {
            assertEquals(0, buffer[i], "Padding byte at position " + i + " should be 0");
        }

        // The byte at position 28 should be unchanged
        assertEquals((byte) 0xFF, buffer[28], "Byte after padding should be unchanged");
    }

    @Test