if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodelocalLockMap Msgsize() is inaccurate")
	}

	vn := localLockMap{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodelocalLockMap(b *testing.B) {
	v := localLockMap{}
	var buf bytes.Buffer

		echo \"Failed attempts: $ATTEMPTS\"
		if [ $ATTEMPTS -gt $LIMIT ]; then
			exit 1
		fi
		sleep 2 # 1 second intervals between attempts
		$MC_COMMAND
		STATUS=$?
	done
	set -e # reset `e` as active
	return 0
}

# checkBucketExists ($bucket)
# Check if the bucket exists, by using the exit code of `mc ls`
checkBucketExists() {
	BUCKET=$1
	CMD=$(${MC} stat myminio/$BUCKET >/dev/null 2>&1)

                }

                doReceiveFragment(frag, isDirect);
                fbuf.reset();
                fbuf.setIndex(8);
                fbuf.setLength(fbuf.dec_ndr_short());

                if (securityProvider != null)
                    securityProvider.unwrap(fbuf);

                fbuf.reset();
                msg.decode_header(fbuf);
                stub_frag_len = msg.length - 24;

  </scm>
  <distributionManagement>
    <site><!-- overriding 1 element will reset all elements, but not child.site.url.inherit.append.path attribute -->
      <name>reset</name>
    </site>
  </distributionManagement>

        primarySetupOffset = PRIMARY_SETUP_OFFSET;
        secondaryParameterOffset = SECONDARY_PARAMETER_OFFSET;
    }

    void reset() {
        super.reset();
        isPrimary = hasMore = true; 
    }
    void reset( int key, String lastName ) {
        reset();
    }
    public boolean hasMoreElements() {
        return hasMore;
    }
    public Object nextElement() {
        if( isPrimary ) {

    }

    @Override
    public boolean markSupported() {
        return fileInputStream.markSupported();
    }

    @Override
    public synchronized void reset() throws IOException {
        fileInputStream.reset();
    }

    @Override
    public long skip(final long n) throws IOException {
        return fileInputStream.skip(n);
    }

    }

    @Override
    public int read(final byte[] b) throws IOException {
        return inputStream.read(b);
    }

    @Override
    public synchronized void reset() throws IOException {
        inputStream.reset();
    }

    @Override
    public long skip(final long n) throws IOException {
        return inputStream.skip(n);
    }

    @Override
    public String toString() {

// the buffered reader to read from r.
// Calling Reset on the zero value of [Reader] initializes the internal buffer
// to the default size.
// Calling b.Reset(b) (that is, resetting a [Reader] to itself) does nothing.
func (b *Reader) Reset(r io.Reader) {
	// If a Reader r is passed to NewReader, NewReader will return r.
	// Different layers of code may do that, and then later pass r
	// to Reset. Avoid infinite recursion in that case.
	if b == r {

// These APIs are mainly to facilitate testing and are subject to change.
namespace internal {
absl::Status Reset(AbstractOperation* op_, const char* op,
                   const char* raw_device_name, ForwardOperation* forward_op_) {
  forward_op_->op_name = op;
  forward_op_->attrs.Reset(op);
  return op_->Reset(op, raw_device_name);
}
absl::Status AddInput(AbstractOperation* op_, AbstractTensorHandle* input,

		panic("bytes.Reader.WriteTo: invalid Write count")
	}
	r.i += int64(m)
	n = int64(m)
	if m != len(b) && err == nil {
		err = io.ErrShortWrite
	}
	return
}

// Reset resets the [Reader] to be reading from b.
func (r *Reader) Reset(b []byte) { *r = Reader{b, 0, -1} }

// NewReader returns a new [Reader] reading from b.