</p>

<p class="rule">
A send on a channel is synchronized before the completion of the
corresponding receive from that channel.
</p>

<p>
This program:
</p>

<pre>
var c = make(chan int, 10)
var a string

func f() {
	a = "hello, world"
	c &lt;- 0
}

func main() {
	go f()
	&lt;-c
	print(a)
}
</pre>

<p>

		DiskID:   *client.diskID.Load(),
		ScanMode: int(scanMode),
		Cache:    &cache,
	})
	if err != nil {
		return cache, toStorageErr(err)
	}
	var final *dataUsageCache
	err = st.Results(func(resp *nsScannerResp) error {
		if resp.Update != nil {
			select {
			case <-ctx.Done():
			case updates <- *resp.Update:
			}
		}
		if resp.Final != nil {

package cmd

import "strconv"

func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[osMetricRemoveAll-0]
	_ = x[osMetricMkdirAll-1]
	_ = x[osMetricMkdir-2]
	_ = x[osMetricRename-3]
	_ = x[osMetricOpenFileW-4]
	_ = x[osMetricOpenFileR-5]
	_ = x[osMetricOpenFileWFd-6]

		return false
	}

	xhttp.Flush(writer.writer)
	return true
}

func (writer *messageWriter) start() {
	keepAliveTicker := time.NewTicker(1 * time.Second)
	var progressTicker *time.Ticker
	var progressTickerC <-chan time.Time
	if writer.getProgressFunc != nil {
		progressTicker = time.NewTicker(1 * time.Minute)
		progressTickerC = progressTicker.C
	}

)

// Benchmark utility functions for ObjectLayer.PutObject().
// Creates Object layer setup ( MakeBucket ) and then runs the PutObject benchmark.
func runPutObjectBenchmark(b *testing.B, obj ObjectLayer, objSize int) {
	var err error
	// obtains random bucket name.
	bucket := getRandomBucketName()
	// create bucket.
	err = obj.MakeBucket(b.Context(), bucket, MakeBucketOptions{})
	if err != nil {
		b.Fatal(err)
	}

	"encoding/gob"
	"io"
	"testing"
	"time"

	"github.com/tinylib/msgp/msgp"
)

func BenchmarkDecodeVolInfoMsgp(b *testing.B) {
	v := VolInfo{
		Name:    "uuid",
		Created: time.Now(),
	}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	rd := msgp.NewEndlessReader(buf.Bytes(), b)
	dc := msgp.NewReader(rd)
	b.Log("Size:", buf.Len(), "bytes")
	b.SetBytes(1)
	b.ReportAllocs()

	for b.Loop() {

internal fun Headers.commonValue(index: Int): String =
  namesAndValues.getOrNull(index * 2 + 1) ?: throw IndexOutOfBoundsException("value[$index]")

internal fun Headers.commonValues(name: String): List<String> {
  var result: MutableList<String>? = null
  for (i in 0 until size) {
    if (name.equals(name(i), ignoreCase = true)) {
      if (result == null) result = ArrayList(2)
      result.add(value(i))
    }
  }

				"BETWEEN_64_KB_AND_256_KB": 1,
				"BETWEEN_1024B_AND_1_MB":   2,
				"BETWEEN_10_MB_AND_64_MB":  1,
			},
		},
	}
	for i, test := range tests {
		t.Run(fmt.Sprintf("Test-%d", i), func(t *testing.T) {
			var h sizeHistogram
			for _, sz := range test.sizes {
				h.add(sz)
			}
			got := h.toMap()
			exp := test.want
			// what is in exp is in got
			for k := range exp {
				if exp[k] != got[k] {

package grid

import "strconv"

func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[handlerInvalid-0]
	_ = x[HandlerLockLock-1]
	_ = x[HandlerLockRLock-2]
	_ = x[HandlerLockUnlock-3]
	_ = x[HandlerLockRUnlock-4]
	_ = x[HandlerLockRefresh-5]
	_ = x[HandlerLockForceUnlock-6]

		if tarinsecurepath.Value() == "0" {
			tarinsecurepath.IncNonDefault()
			err = ErrInsecurePath
		}
	}
	return hdr, err
}

func (tr *Reader) next() (*Header, error) {
	var paxHdrs map[string]string
	var gnuLongName, gnuLongLink string

	// Externally, Next iterates through the tar archive as if it is a series of
	// files. Internally, the tar format often uses fake "files" to add meta