m.expMovingAvg = float64(bytesSinceLastWindow) / duration.Seconds()
		return
	}

	increment := float64(bytesSinceLastWindow) / duration.Seconds()
	m.expMovingAvg = exponentialMovingAverage(betaBucket, m.expMovingAvg, increment)
}

// exponentialMovingAverage calculates the exponential moving average
func exponentialMovingAverage(beta, previousAvg, incrementAvg float64) float64 {

// errorcheck

// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 12525: confusing error trying to increment boolean value

package main

func main() {
	var i int
	i++

	var f float64
	f++

	var c complex128
	c++

	var b bool
	b++ // ERROR "invalid operation: b\+\+ \(non-numeric type bool\)"

    }
    // x is positive, finite, and normal
    boolean increment;
    switch (mode) {
      case UNNECESSARY:
        checkRoundingUnnecessary(isPowerOfTwo(x));
        // fall through
      case FLOOR:
        increment = false;
        break;
      case CEILING:
        increment = !isPowerOfTwo(x);
        break;
      case DOWN:
        increment = exponent < 0 & !isPowerOfTwo(x);
        break;

    }
    // x is positive, finite, and normal
    boolean increment;
    switch (mode) {
      case UNNECESSARY:
        checkRoundingUnnecessary(isPowerOfTwo(x));
        // fall through
      case FLOOR:
        increment = false;
        break;
      case CEILING:
        increment = !isPowerOfTwo(x);
        break;
      case DOWN:
        increment = exponent < 0 & !isPowerOfTwo(x);
        break;

	// prevent memory leaks.
	if event == model.EventDelete {
		inboundServiceDeletes.Increment()
		s.Env.EndpointIndex.DeleteServiceShard(shard, hostname, namespace, false)
	} else {
		inboundServiceUpdates.Increment()
	}
}

// EDSUpdate computes destination address membership across all clusters and networks.
// This is the main method implementing EDS.

// compile

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This program results in a loop inferred to increment
// j by 0, causing bounds check elimination to attempt
// something%0, which panics (in the bug).

package q

func f() {
	var s1 string
	var b bool
	if b {
		b = !b
		s1 += "a"
	}

	var s2 string

package com.google.common.hash;


/**
 * Abstract interface for objects that can concurrently add longs.
 *
 * @author Louis Wasserman
 */
@ElementTypesAreNonnullByDefault
interface LongAddable {
  void increment();

  void add(long x);

  long sum();

	i, val := 0, atomic.LoadUint64(&a)
	for ; val == 0 && i < 100; val, i = atomic.LoadUint64(&a), i+1 {
		time.Sleep(100 * time.Millisecond)
	}
	if val == 0 {
		fmt.Printf("Failed to observe atomic increment after %d tries\n", i)
	}

	"provider_lookup_cluster_failures",
	"Number of times a cluster lookup failed",
)

func IncLookupClusterFailures(provider string) {
	providerLookupClusterFailures.With(typeTag.Value(provider)).Increment()

 */

package com.google.common.cache;

/**
 * GWT emulated version of LongAdder.
 *
 * @author Charles Fry
 */
class LongAdder implements LongAddable {

  private long value;

  public void increment() {
    value++;
  }

  public void add(long x) {
    value += x;
  }

  public long sum() {
    return value;
  }