test(ok, true)
	case <-c2:
		log.Fatal("bad select")
	}

	close(c)
	i, ok = <-c
	test(i, 0)
	test(ok, false)

	_, ok = <-c
	test(ok, false)

	// Map indexing.
	m := make(map[int]int)

	i, ok = m[0]
	test(i, 0)
	test(ok, false)

	_, ok = m[0]
	test(ok, false)

	m[0] = 42
	i, ok = m[0]
	test(i, 42)
	test(ok, true)

	_, ok = m[0]
	test(ok, true)

		panic("fail")
	}
	for i := lb; i < hb; i++ {
		if fx[i] != fy[i-lb] {
			println("t=", t, "lb=", lb, "hb=", hb,
				"fx[", i, "]=", fx[i],
				"fy[", i-lb, "]=", fy[i-lb])
			panic("fail")
		}
	}
	fy = nil
}

func init() {
	bx = make([]byte, 10)
	for i := 0; i < len(bx); i++ {
		bx[i] = byte(i + 20)
	}
	by = nil

	fx = make([]float64, 10)

24:		y := id(0)
25:		fmt.Println(x)
0:
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
x = 0
y = 0
26:		for i := x; i < 3; i++ {
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
x = 1
y = 0
26:		for i := x; i < 3; i++ {
27:			x := i * i
28:			y += id(x) //gdb-dbg=(x,y)//gdb-opt=(x,y)
x = 4
y = 1
26:		for i := x; i < 3; i++ {
31:		fmt.Println(x, y)

    labels:
      istio.io/benchmark: "true"
---
{{- range $i := until .Services }}
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: vs-{{$i}}
  namespace: gateway
spec:
  hosts:
  - random-a-{{$i}}.host.example
  - random-b-{{$i}}.host.example
  - random-c-{{$i}}.host.example
  gateways:
  - gateway/gateway-{{$i}}
  http:
  - match:
    - uri:
        prefix: "/route-{{$i}}"

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      doubleInIntRange[i] = randomDouble(Integer.SIZE - 2);
      doubleInLongRange[i] = randomDouble(Long.SIZE - 2);
      positiveDoubles[i] = randomPositiveDouble();
    }
  }

  @Benchmark
  int roundToInt(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;

		sum := 0
		for i := 0; i < 1000; i++ {
			sum += i
		}
		fmt.Println("Computed once:", sum)
		return sum
	})
	done := make(chan bool)
	for i := 0; i < 10; i++ {
		go func() {
			const want = 499500
			got := once()
			if got != want {
				fmt.Println("want", want, "got", got)
			}
			done <- true
		}()
	}
	for i := 0; i < 10; i++ {
		<-done
	}
	// Output:

//                       i                i
//
//      The advantage of (3) is that s  and y  can be computed by
//                                    i      i
//      the following recurrence formula:
//          if (3) is false
//
//          s     =  s  ,       y    = y   ;                     (4)
//           i+1      i          i+1    i
//
//      otherwise,
//                         -i                      -(i+1)

		}
	}
}

func TestBitLen16(t *testing.T) {
	for i := 0; i <= 16; i++ {
		got := bits.Len16(1 << i)
		want := i + 1
		if want == 17 {
			want = 0
		}
		if got != want {
			t.Errorf("Len16(1<<%d) = %d, want %d", i, got, want)
		}
	}
}

func TestBitLen8(t *testing.T) {
	for i := 0; i <= 8; i++ {
		got := bits.Len8(1 << i)
		want := i + 1
		if want == 9 {

		m := map[interface{}]int{}
		for i := 0; i < n; i++ {
			m[i] = 1
		}
	})

	// ~7ms on a 1.6GHz Zeon.
	// Regression test for CL 119360043.
	checkLinear("iface", 10000, func(n int) {
		m := map[I]int{}
		for i := 0; i < n; i++ {
			m[C(i)] = 1
		}
	})

	// ~6ms on a 1.6GHz Zeon.
	checkLinear("int", 10000, func(n int) {
		m := map[int]int{}
		for i := 0; i < n; i++ {
			m[i] = 1
		}
	})

	v := AccElem{}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgAccElem(b *testing.B) {
	v := AccElem{}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])
	b.SetBytes(int64(len(bts)))
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		bts, _ = v.MarshalMsg(bts[0:0])
	}
}