if ok && len(b.buf) >= size {
		return b
	}
	r := new(Reader)
	r.reset(make([]byte, max(size, minReadBufferSize)), rd)
	return r
}

// NewReader returns a new [Reader] whose buffer has the default size.
func NewReader(rd io.Reader) *Reader {
	return NewReaderSize(rd, defaultBufSize)
}

// Size returns the size of the underlying buffer in bytes.
func (b *Reader) Size() int { return len(b.buf) }

	{ // 1. no replication config
		name:         "no replication config",
		info:         ObjectInfo{Size: 100},
		rcfg:         replicationConfig{Config: nil},
		expectedSync: false,
	},
	{ // 2. existing object replication config enabled, no versioning
		name:         "existing object replication config enabled, no versioning",
		info:         ObjectInfo{Size: 100},
		rcfg:         replicationConfig{Config: &configs[0]},
		expectedSync: false,
	},

  int size;

  // use concrete classes to remove any possible polymorphic overhead?
  Object[] array;
  ArrayList<Object> arrayList;
  LinkedList<Object> linkedList;

  @BeforeExperiment
  void setUp() {
    array = new Object[size];
    arrayList = Lists.newArrayListWithCapacity(size);
    linkedList = new LinkedList<>();

    for (int i = 0; i < size; i++) {
      Object value = new Object();

    int len = string.length();
    int size = len * count;
    char[] array = new char[size];
    string.getChars(0, len, array, 0);
    int n;
    for (n = len; n < size - n; n <<= 1) {
      System.arraycopy(array, 0, array, n, n);
    }
    System.arraycopy(array, 0, array, n, size - n);
    return new String(array);
  }

        request.setIndex(index);
        return this;
    }

    /**
     * Sets the size of results for the request.
     * @param size The size.
     * @return This builder instance.
     */
    public PopularWordsRequestBuilder setSize(final int size) {
        request.setSize(size);
        return this;
    }

    /**
     * Adds a tag to filter by.
     * @param tag The tag.

        return this;
    }

    /**
     * Gets the fragment size.
     *
     * @return the fragment size in characters
     */
    public int getFragmentSize() {
        return fragmentSize;
    }

    /**
     * Sets the fragment size with fluent interface.
     *
     * @param fragmentSize the fragment size in characters
     * @return this HighlightInfo instance for method chaining
     */

  @BeforeExperiment
  void setUp() {
    checkArgument(size > 0, "empty collection not supported");
    Set<Integer> set = new LinkedHashSet<>(size);

    Random random = new Random();
    while (set.size() < size) {
      set.add(random.nextInt());
    }
    List<Integer> list = new ArrayList<>(set);
    inputOrder.arrange(list);
    input = ImmutableList.copyOf(list);
  }

  @Benchmark
  int collections(int reps) {

     *
     * @return the version
     */
    public final int getVersion() {
        return this.version;
    }

    /**
     * Gets the size of this referral entry in bytes.
     *
     * @return the size
     */
    public final int getSize() {
        return this.size;
    }

    /**
     * Gets the server type of this referral.
     *
     * @return the serverType
     */

        writeLittleEndianInt(baos, PacConstants.LOGON_INFO); // type
        writeLittleEndianInt(baos, 10); // size
        writeLittleEndianLong(baos, 25); // Unaligned offset (not multiple of 8)
        // Add enough data to avoid array bounds issues
        while (baos.size() < 35) {
            baos.write(0);
        }
        byte[] pacData = baos.toByteArray();

				err = z.Metadata[za0002].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Metadata", za0002)
					return
				}
			}
		case "Size":
			err = z.Size.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Size")
				return
			}
		case "Type":
			z.Type, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Type")
				return
			}