if wi.Endpoint.Address != "" {
		i.ipToKeys.Insert(wi.Endpoint.Address, key)
	}
	return previous
}

// Delete implements Index.
func (i *index) Delete(wi *model.WorkloadInstance) *model.WorkloadInstance {
	i.mu.Lock()
	defer i.mu.Unlock()

	key := i.keyFunc(wi)
	previous := i.keyToInstance[key]
	if previous != nil {
		i.ipToKeys.Delete(previous.Endpoint.Address, key)
	}
	i.ipToKeys.Delete(wi.Endpoint.Address, key)

	var apT [2 * count]*T

	for i := 0; i < count; i++ {
		s := strconv.Itoa(i)
		s10 := strconv.Itoa(i * 10)
		f := float32(i)
		t := T{int64(i), f}
		apT[i] = new(T)
		apT[i].i = int64(i)
		apT[i].f = f
		apT[2*i] = new(T) // need twice as many entries as we use, for the nonexistence check
		apT[2*i].i = int64(i)
		apT[2*i].f = f
		m := M{i: i + 1}
		mib[i] = (i != 0)
		mii[i] = 10 * i
		mfi[float32(i)] = 10 * i

    }
    EXPECT_EQ(matmul_const.arg0_data(), matmul.arg_data(0));
    for (int i = 0; i < 6; ++i) {
      EXPECT_EQ(matmul_const.arg1(i / 2, i % 2), args[i + 6]);
      EXPECT_EQ(matmul_const.arg1_data()[i], args[i + 6]);
    }
    EXPECT_EQ(matmul_const.arg1_data(), matmul.arg_data(1));
    for (int i = 0; i < 4; ++i) {
      EXPECT_EQ(matmul_const.result0(i / 2, i % 2), results[i]);

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      exponent[i] = randomExponent();
      factorial[i] = RANDOM_SOURCE.nextInt(50);
      binomial[i] = RANDOM_SOURCE.nextInt(factorial[i] + 1);
      positive[i] = randomPositiveBigInteger(Integer.SIZE - 1).intValue();
      nonnegative[i] = randomNonNegativeBigInteger(Integer.SIZE - 1).intValue();
      ints[i] = RANDOM_SOURCE.nextInt();
    }
  }

	c complex128
}
var m map[complex128]complex128

func main() {
	// array of complex128
	for i := 0; i < len(a); i++ {
		a[i] = complex(float64(i), float64(-i))
	}
	if a[5] != 5-5i {
		panic(a[5])
	}

	// slice of complex128
	s = make([]complex128, len(a))
	for i := 0; i < len(s); i++ {
		s[i] = a[i]
	}
	if s[5] != 5-5i {
		panic(s[5])
	}

	// chan
	c = make(chan complex128)
	go chantest(c)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		x.Add(x, y)
	}
}

func BenchmarkMultiply(b *testing.B) {
	x := new(Element).One()
	y := new(Element).Add(x, x)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		x.Multiply(x, y)
	}
}

func BenchmarkSquare(b *testing.B) {
	x := new(Element).Add(feOne, feOne)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		x.Square(x)
	}
}

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

func BenchmarkAppendMsgBaseOptions(b *testing.B) {
	v := BaseOptions{}
	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])
	}
}

		n = n*10 + int(s[i]-'0')
		if n >= big {
			return big, i, false
		}
	}
	if i == 0 {
		return 0, 0, false
	}
	return n, i, true
}

// Hexadecimal to integer.
// Returns number, characters consumed, success.
func xtoi(s string) (n int, i int, ok bool) {
	n = 0
	for i = 0; i < len(s); i++ {
		if '0' <= s[i] && s[i] <= '9' {
			n *= 16
			n += int(s[i] - '0')

	// BAD: i should not escape
	i := 0 // ERROR "moved to heap: i"
	// BAD: j should not escape
	j := 0 // ERROR "moved to heap: j"
	m[&i] = &j
	_ = m
}

func map1() *int {
	m := make(map[*int]*int) // ERROR "make\(map\[\*int\]\*int\) does not escape"
	// BAD: i should not escape
	i := 0 // ERROR "moved to heap: i"
	j := 0 // ERROR "moved to heap: j"
	m[&i] = &j
	return m[&i]
}

	sink = &x
	for i := 0; i < b.N; i++ {
		atomic.Store(&x, 0)
	}
}

func BenchmarkAnd8(b *testing.B) {
	var x [512]uint8 // give byte its own cache line
	sink = &x
	for i := 0; i < b.N; i++ {
		atomic.And8(&x[255], uint8(i))
	}
}

func BenchmarkAnd(b *testing.B) {
	var x [128]uint32 // give x its own cache line
	sink = &x
	for i := 0; i < b.N; i++ {
		atomic.And(&x[63], uint32(i))
	}
}