// AnyOverlap reports whether x and y share memory at any (not necessarily
// corresponding) index. The memory beyond the slice length is ignored.
489925
func AnyOverlap(x, y []byte) bool {
	return len(x) > 0 && len(y) > 0 &&
		reflect.ValueOf(&x[0]).Pointer() <= reflect.ValueOf(&y[len(y)-1]).Pointer() &&
		reflect.ValueOf(&y[0]).Pointer() <= reflect.ValueOf(&x[len(x)-1]).Pointer()
}
119810
func (*Value) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Value_Int)(nil),
		(*Value_Uint)(nil),
		(*Value_Float)(nil),
		(*Value_Bool)(nil),
		(*Value_Str)(nil),
		(*Value_Bytes)(nil),
		(*Value_Object)(nil),
		(*Value_Array)(nil),
		(*Value_Null)(nil),
	}
}
711782
func (t *TSMReader) OverlapsKeyRange(min, max []byte) bool {
	return t.index.OverlapsKeyRange(min, max)
}
671749
func (s *Server) Any(path string, handler HandlerFunc, opts ...HandlerOption) {
	s.Match(methods[:], path, handler, opts...)
}
1081510
func anyMatch() regexpInfo {
	return regexpInfo{
		canEmpty: true,
		prefix:   []string{""},
		suffix:   []string{""},
		match:    allQuery,
	}
}
1035462
func AnyOverlap(x, y []byte) bool {
	// GopherJS: We can't rely on pointer arithmetic, so use GopherJS slice internals.
	return len(x) > 0 && len(y) > 0 &&
		js.InternalObject(x).Get("$array") == js.InternalObject(y).Get("$array") &&
		js.InternalObject(x).Get("$offset").Int() <= js.InternalObject(y).Get("$offset").Int()+len(y)-1 &&
		js.InternalObject(y).Get("$offset").Int() <= js.InternalObject(x).Get("$offset").Int()+len(x)-1
}
862710
func anyRune(s string) runeFn {
	return func(r rune) bool {
		return strings.IndexRune(s, r) > -1
	}
}
1184775
func (p *Pattern) geoOverlappingRings() {
	scale := utils.HexVal(p.Hash, 0, 1)
	ringSize := utils.Map(scale, 0, 15, 10, 60)
	strokeWidth := ringSize / 4

	p.Svg.SetHeight(int(ringSize * 6))
	p.Svg.SetWidth(int(ringSize * 6))

	i := 0
	for y := 0; y <= 5; y++ {
		for x := 0; x <= 5; x++ {

			val := utils.HexVal(p.Hash, i, 1)
			opacity := utils.Opacity(val)
			fill := utils.FillColor(val)

			styles := make(map[string]interface{})
			styles["fill"] = "none"
			styles["stroke"] = fill
			styles["style"] = map[string]string{"opacity": fmt.Sprintf("%v", opacity), "stroke-width": fmt.Sprintf("%vpx", strokeWidth)}

			p.Svg.Circle(float64(x)*ringSize, float64(y)*ringSize, ringSize-(strokeWidth/2), styles)

			if x == 0 {
				p.Svg.Circle(6*ringSize, float64(y)*ringSize, ringSize-(strokeWidth/2), styles)
			}

			if y == 0 {
				p.Svg.Circle(float64(x)*ringSize, 6*ringSize, ringSize-(strokeWidth/2), styles)
			}

			if x == 0 && y == 0 {
				p.Svg.Circle(6*ringSize, 6*ringSize, ringSize-(strokeWidth/2), styles)
			}

			i = i + 1
		}
	}
}
470770
func (s *ShapeIndex) clipVAxis(edge *clippedEdge, middle r1.Interval) (a, b *clippedEdge) {
	if edge.bound.Y.Hi <= middle.Lo {
		// Edge is entirely contained in the lower child.
		return edge, nil
	} else if edge.bound.Y.Lo >= middle.Hi {
		// Edge is entirely contained in the upper child.
		return nil, edge
	}
	// The edge bound spans both children.
	return s.clipVBound(edge, 1, middle.Hi), s.clipVBound(edge, 0, middle.Lo)
}
955376
func (group *RouterGroup) Any(relativePath string, handlers ...HandlerFunc) IRoutes {
	group.handle("GET", relativePath, handlers)
	group.handle("POST", relativePath, handlers)
	group.handle("PUT", relativePath, handlers)
	group.handle("PATCH", relativePath, handlers)
	group.handle("HEAD", relativePath, handlers)
	group.handle("OPTIONS", relativePath, handlers)
	group.handle("DELETE", relativePath, handlers)
	group.handle("CONNECT", relativePath, handlers)
	group.handle("TRACE", relativePath, handlers)
	return group.returnObj()
}
104776
func overflow(v interface{}, tp byte) error {
	return ErrOverflow.GenWithStack("constant %v overflows %s", v, TypeStr(tp))
}
973171
func (p *Polygon) anyLoopIntersects(o *Loop) bool {
	for _, l := range p.loops {
		if l.Intersects(o) {
			return true
		}
	}
	return false
}
822955
func Overlap(a Value, b Size, x Value, y Size) bool {
	return a.LessThan(x.Add(y)) && x.LessThan(a.Add(b))
}
211625
func (ctx *Context) DoOp(op *Op,
	alpha1 float64, aDesc *TensorDescriptor, aData Memory,
	alpha2 float64, bDesc *TensorDescriptor, bData Memory,
	beta float64, cDesc *TensorDescriptor, cData Memory) error {

	// dtype checks
	if !(aDesc.dataType == bDesc.dataType && bDesc.dataType == cDesc.dataType) {
		return errors.Errorf(dtypeMismatch3, cDesc.dataType, aDesc.dataType, bDesc.dataType)
	}

	if cDesc.dataType == Double && op.dataType != cDesc.dataType {
		return errors.Errorf(dtypeMismatch3, Double, cDesc.dataType, op.dataType)
	}

	if op.dataType != Float && op.dataType != Double {
		return errors.Errorf(dtypeMismatch2, Float, Double, op.dataType)
	}

	// shapecheck
	if !(shapeEq(aDesc.shape, bDesc.shape) && shapeEq(bDesc.shape, cDesc.shape)) {
		return errors.Errorf(shapeMismatch3, aDesc.shape, bDesc.shape, cDesc.shape)
	}

	// location check
	if bData.Uintptr() == cData.Uintptr() && aData.Uintptr() != cData.Uintptr() {
		// If the input tensor B is the same tensor as the destination tensor C,
		// then the input tensor A also must be the same tensor as the destination tensor C.
		return errors.Errorf(memoryError3, cData.Uintptr(), aData.Uintptr(), bData.Uintptr())
	}

	// alpha beta generation
	var alpha1C, alpha2C, betaC unsafe.Pointer
	if op.dataType == Float {
		var a1, a2, b C.float
		a1 = C.float(float32(alpha1))
		a2 = C.float(float32(alpha2))
		b = C.float(float32(beta))

		alpha1C = unsafe.Pointer(&a1)
		alpha2C = unsafe.Pointer(&a2)
		betaC = unsafe.Pointer(&b)
	} else {
		var a1, a2, b C.double
		a1 = C.double(alpha1)
		a2 = C.double(alpha2)
		b = C.double(beta)

		alpha1C = unsafe.Pointer(&a1)
		alpha2C = unsafe.Pointer(&a2)
		betaC = unsafe.Pointer(&b)
	}

	res := C.cudnnOpTensor(ctx.internal, op.internal,
		alpha1C, aDesc.internal, aData.Pointer(),
		alpha2C, bDesc.internal, bData.Pointer(),
		betaC, cDesc.internal, cData.Pointer(),
	)
	return result(res)
}
559761
func DoLinesOverlap(line1End1, line1End2, line2End1, line2End2 geom.Coord) bool {
	return internal.DoLinesOverlap(line1End1, line1End2, line2End1, line2End2)
}
409655
func getOverlappingControllers(c client.ReplicationControllerInterface, rc *api.ReplicationController) ([]api.ReplicationController, error) {
	rcs, err := c.List(api.ListOptions{})
	if err != nil {
		return nil, fmt.Errorf("error getting replication controllers: %v", err)
	}
	var matchingRCs []api.ReplicationController
	rcLabels := labels.Set(rc.Spec.Selector)
	for _, controller := range rcs.Items {
		newRCLabels := labels.Set(controller.Spec.Selector)
		if labels.SelectorFromSet(newRCLabels).Matches(rcLabels) || labels.SelectorFromSet(rcLabels).Matches(newRCLabels) {
			matchingRCs = append(matchingRCs, controller)
		}
	}
	return matchingRCs, nil
}
815616
func (p *Pattern) geoOverlappingCircles() {
	scale := utils.HexVal(p.Hash, 0, 1)
	diameter := utils.Map(scale, 0, 15, 25, 200)
	radius := diameter / 2

	p.Svg.SetHeight(int(radius * 6))
	p.Svg.SetWidth(int(radius * 6))

	i := 0
	for y := 0; y <= 5; y++ {
		for x := 0; x <= 5; x++ {

			val := utils.HexVal(p.Hash, i, 1)
			opacity := utils.Opacity(val)
			fill := utils.FillColor(val)

			styles := make(map[string]interface{})
			styles["fill"] = fill
			styles["style"] = map[string]string{"opacity": fmt.Sprintf("%v", opacity)}

			p.Svg.Circle(float64(x)*radius, float64(y)*radius, radius, styles)

			if x == 0 {
				p.Svg.Circle(6*radius, float64(y)*radius, radius, styles)
			}

			if y == 0 {
				p.Svg.Circle(float64(x)*radius, 6*radius, radius, styles)
			}

			if x == 0 && y == 0 {
				p.Svg.Circle(6*radius, 6*radius, radius, styles)
			}

			i = i + 1
		}
	}
}