order Order
	write func(*Writer, uint32) error
	nBits uint
	width uint
	bits  uint32
	// hi is the code implied by the next code emission.
	// overflow is the code at which hi overflows the code width.
	hi, overflow uint32
	// savedCode is the accumulated code at the end of the most recent Write
	// call. It is equal to invalidCode if there was no such call.
	savedCode uint32

		if of.IsNil() {
			continue
		}
		if tf.IsNil() {
			tf.Set(of)
			continue
		}

		// Make a copy of tf for tf to call. (Otherwise it
		// creates a recursive call cycle and stack overflows)
		tfCopy := reflect.ValueOf(tf.Interface())

		// We need to call both tf and of in some order.
		newFunc := reflect.MakeFunc(hookType, func(args []reflect.Value) []reflect.Value {
			tfCopy.Call(args)

	// with the upper bound incrementing on each code seen.
	//
	// overflow is the code at which hi overflows the code width. It always
	// equals 1 << width.
	//
	// last is the most recently seen code, or decoderInvalidCode.
	//
	// An invariant is that hi < overflow.
	clear, eof, hi, overflow, last uint16

	// Each code c in [lo, hi] expands to two or more bytes. For c != hi:

// than int32.
// Deprecated: use FromInt32 instead.
func FromInt(val int) IntOrString {
	if val > math.MaxInt32 || val < math.MinInt32 {
		klog.Errorf("value: %d overflows int32\n%s\n", val, debug.Stack())
	}
	return IntOrString{Type: Int, IntVal: int32(val)}
}

// FromInt32 creates an IntOrString object with an int32 value.
func FromInt32(val int32) IntOrString {

			pos, end := ret.Pos(), ret.End()
			// golang/go#64547: cfg.Block.Return may return a synthetic
			// ReturnStmt that overflows the file.
			if pass.Fset.File(pos) != pass.Fset.File(end) {
				end = pos
			}
			pass.Report(analysis.Diagnostic{
				Pos:     pos,
				End:     end,

const MaxUintptr = ^uintptr(0)

// MulUintptr returns a * b and whether the multiplication overflowed.
// On supported platforms this is an intrinsic lowered by the compiler.
func MulUintptr(a, b uintptr) (uintptr, bool) {
	if a|b < 1<<(4*goarch.PtrSize) || a == 0 {
		return a * b, false
	}
	overflow := b > MaxUintptr/a
	return a * b, overflow
}

// Mul64 returns the 128-bit product of x and y: (hi, lo) = x * y

  @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"))

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%;

	if len < 0 {
		panicunsafeslicelen1(getcallerpc())
	}

	if et.Size_ == 0 {
		if ptr == nil && len > 0 {
			panicunsafeslicenilptr1(getcallerpc())
		}
	}

	mem, overflow := math.MulUintptr(et.Size_, uintptr(len))
	if overflow || mem > -uintptr(ptr) {
		if ptr == nil {
			panicunsafeslicenilptr1(getcallerpc())
		}
		panicunsafeslicelen1(getcallerpc())
	}
}

		Ln2Lo = 1.90821492927058770002e-10
		Log2e = 1.44269504088896338700e+00

		Overflow  = 7.09782712893383973096e+02
		Underflow = -7.45133219101941108420e+02
		NearZero  = 1.0 / (1 << 28) // 2**-28
	)

	// special cases
	switch {
	case IsNaN(x) || IsInf(x, 1):
		return x
	case IsInf(x, -1):
		return 0
	case x > Overflow:
		return Inf(1)
	case x < Underflow:
		return 0