@Test fun nonBasicCodePointInInsertionCoding() {
    assertNull(Punycode.decode("xn--cat-ñ3h"))
  }

  @Test fun unterminatedCodePoint() {
    assertNull(Punycode.decode("xn--cat-n"))
  }

  @Test fun overflowI() {
    assertNull(Punycode.decode("xn--99999999"))
  }

  @Test fun overflowMaxCodePoint() {
    assertNull(Punycode.decode("xn--a-b.net"))
    assertNull(Punycode.decode("xn--a-9b.net"))

			n = 0
			err = strconv.ErrSyntax
			goto Error
		}

		if n >= cutoff {
			// n*base overflows
			n = 1<<64 - 1
			err = strconv.ErrRange
			goto Error
		}
		n *= uint64(base)

		n1 := n + uint64(v)
		if n1 < n || n1 > maxVal {
			// n+v overflows
			n = 1<<64 - 1
			err = strconv.ErrRange
			goto Error
		}
		n = n1
	}

	return n, nil

		return
	}

	// If we'd need to let the counter overflow and keep generating output,
	// panic immediately. If instead we'd only reach the last block, remember
	// not to generate any more output after the buffer is drained.
	numBlocks := (uint64(len(src)) + blockSize - 1) / blockSize
	if s.overflow || uint64(s.counter)+numBlocks > 1<<32 {
		panic("chacha20: counter overflow")
	} else if uint64(s.counter)+numBlocks == 1<<32 {

	overflow := b.overflow.Load()
	time = b.overflowTime.Load()
	for {
		count = uint32(overflow)
		if count == 0 {
			time = 0
			break
		}
		// Increment generation, clear overflow count in low bits.
		if b.overflow.CompareAndSwap(overflow, ((overflow>>32)+1)<<32) {
			break
		}
		overflow = b.overflow.Load()
		time = b.overflowTime.Load()
	}
	return uint32(overflow), time
}

      long result = origin + distance;
      if (result < 0) {
        checkArgument(origin < 0, "overflow");
      }
      return result;
    }

    @Override
    public long distance(Long start, Long end) {
      long result = end - start;
      if (end > start && result < 0) { // overflow
        return Long.MAX_VALUE;
      }
      if (end < start && result > 0) { // underflow

		}
		for i := 0; i < scenario.iters; i++ {
			err, ovf = m.MergeCounters(scenario.dst, scenario.src)
			if ovf != scenario.overflow {
				t.Fatalf("case %d overflow mismatch: got %v want %v", k, ovf, scenario.overflow)
			}
			if !scenario.merr && err != nil {
				t.Fatalf("case %d unexpected err %v", k, err)
			}
			if scenario.merr && err == nil {

	if ok {
		t.Errorf("expected to hit underflow bucket: (%d, %d)", -1, 0)
	}
	if c != 1 {
		t.Errorf("overflow bucket has count that is not 1: %d", c)
	}

	c, ok = h.Count(TimeHistNumBuckets+1, 0)
	if ok {
		t.Errorf("expected to hit overflow bucket: (%d, %d)", TimeHistNumBuckets+1, 0)
	}
	if c != 2 {
		t.Errorf("overflow bucket has count that is not 2: %d", c)
	}

	dummyTimeHistogram = TimeHistogram{}
}

body {
  overflow: hidden; /* Want scrollbar not here, but in #stack-holder */
}
/* Scrollable container for flame graph */
#stack-holder {
  width: 100%;
  flex-grow: 1;
  overflow-y: auto;
  background: #eee; /* Light grey gives better contrast with boxes */
  position: relative; /* Allows absolute positioning of child boxes */
}
/* Flame graph */
#stack-chart {
  width: 100%;

		t.Errorf("shift overflow mishandled")
	}
	if one16>>N>>N == 1 {
		t.Errorf("shift overflow mishandled")
	}
	if one16u>>N>>N == 1 {
		t.Errorf("shift overflow mishandled")
	}
	if one8<<N<<N == 1 {
		t.Errorf("shift overflow mishandled")
	}
	if one8>>N>>N == 1 {
		t.Errorf("shift overflow mishandled")
	}
	if one8u>>N>>N == 1 {
		t.Errorf("shift overflow mishandled")
	}
}

		// Drop the head of the list.
		return head.overflow.Load(), true
	}
	i := &head.overflow
	e := i.Load()
	for e != nil {
		if keyEqual(unsafe.Pointer(&e.key), abi.NoEscape(unsafe.Pointer(&key))) &&
			valEqual(unsafe.Pointer(&e.value), abi.NoEscape(unsafe.Pointer(&value))) {
			i.Store(e.overflow.Load())
			return head, true
		}
		i = &e.overflow
		e = e.overflow.Load()
	}
	return head, false
}