}

// Buffered returns the number of bytes that have been written into the current buffer.
func (b *Writer) Buffered() int { return b.n }

// Write writes the contents of p into the buffer.
// It returns the number of bytes written.
// If nn < len(p), it also returns an error explaining
// why the write is short.
func (b *Writer) Write(p []byte) (nn int, err error) {
	for len(p) > b.Available() && b.err == nil {
		var n int

        addFieldDescs(interfaceClass);
        final Class<?>[] interfaces = interfaceClass.getInterfaces();
        for (final Class<?> intf : interfaces) {
            setupFieldDescsByInterface(intf);
        }
    }

    /**
     * Prepares the fields defined in the class.
     *
     * @param targetClass
     *            the target class
     */

     */
    protected static String read(final Reader reader, final int initialCapacity) {
        int bufferSize;
        if (initialCapacity > 0 && initialCapacity <= MAX_BUF_SIZE) {
            bufferSize = initialCapacity;
        } else {
            bufferSize = DEFAULT_BUF_SIZE;
        }
        char[] buf = new char[bufferSize];
        int size = 0;
        int len;
        try {

    /**
     * The maximum size of the client factory list.
     */
    protected int maxClientFactorySize = 10000;

    /**
     * Registers a CrawlerClientFactory with this creator.
     * All existing client mappings will be loaded into the new factory.
     * @param crawlerClientFactory The CrawlerClientFactory to register.
     */

    }

    // Helper methods to write data to byte arrays for testing read methods
    private void writeInt2(int val, byte[] dst, int dstIndex) {
        dst[dstIndex] = (byte) val;
        dst[dstIndex + 1] = (byte) (val >> 8);
    }

    private void writeInt4(int val, byte[] dst, int dstIndex) {
        dst[dstIndex] = (byte) val;
        dst[dstIndex + 1] = (byte) (val >> 8);

   * @since 32.0.0
   */
  public static void rotate(long[] array, int distance, int fromIndex, int toIndex) {
    // See Ints.rotate for more details about possible algorithms here.
    checkNotNull(array);
    checkPositionIndexes(fromIndex, toIndex, array.length);
    if (array.length <= 1) {
      return;
    }

    int length = toIndex - fromIndex;

    }

    override fun windowUpdate(
      streamId: Int,
      windowSizeIncrement: Long,
    ) {
      check(type == -1)
      this.type = Http2.TYPE_WINDOW_UPDATE
      this.streamId = streamId
      this.windowSizeIncrement = windowSizeIncrement
    }

    override fun priority(
      streamId: Int,
      streamDependency: Int,
      weight: Int,
      exclusive: Boolean,

  @Benchmark
  int factorial(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += BigIntegerMath.factorial(factorials[j]).intValue();
    }
    return tmp;
  }

  @Benchmark
  int binomial(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & 0xffff;
      tmp += BigIntegerMath.binomial(factorials[j], binomials[j]).intValue();

     */

    /** The operation completed successfully */
    int NT_STATUS_SUCCESS = 0x00000000;
    /** The request is pending */
    int NT_STATUS_PENDING = 0x00000103;
    /** A notify change request is being completed and information is being returned */
    int NT_STATUS_NOTIFY_ENUM_DIR = 0x0000010C;
    /** The data was too large to fit into the specified buffer */
    int NT_STATUS_BUFFER_OVERFLOW = 0x80000005;

     * @param off
     * @param tot
     * @return
     * @throws IOException
     */
    private int sendFragments(final DcerpcMessage msg, final byte[] out, final NdrBuffer buf) throws IOException {
        int off = 0;
        final int tot = buf.getLength() - 24;
        while (off < tot) {
            int fragSize = tot - off;
            if (24 + fragSize > this.max_xmit) {
                // need fragementation