reflect.Value.Elem (method)

383 uses

	reflect (current package)
		deepequal.go#L115: 		return deepValueEqual(v1.Elem(), v2.Elem(), visited)
		deepequal.go#L120: 		return deepValueEqual(v1.Elem(), v2.Elem(), visited)
		type.go#L2611: 		typ = (*structType)(unsafe.Pointer(tt.Elem().Field(0).UnsafeAddr()))
		type.go#L2612: 		ut = (*uncommonType)(unsafe.Pointer(tt.Elem().Field(1).UnsafeAddr()))
		type.go#L2614: 		copy(tt.Elem().Field(2).Slice(0, len(methods)).Interface().([]method), methods)
		value.go#L811: func (v Value) Elem() Value {
		value.go#L891: 				v = v.Elem()
		value.go#L2346: 	return v.Elem()
		value.go#L2611: 	ret := New(t).Elem()
		value.go#L2618: 	ret := New(t).Elem()
		value.go#L2625: 	ret := New(t).Elem()
		value.go#L2754: 	return cvtT2I(v.Elem(), typ)

	database/sql/driver
		types.go#L264: 			return defaultConverter{}.ConvertValue(rv.Elem().Interface())

	encoding/asn1
		asn1.go#L1117: 	offset, err := parseField(v.Elem(), b, 0, parseFieldParameters(params))
		marshal.go#L585: 		return makeField(v.Elem(), params)
		marshal.go#L593: 		defaultValue := reflect.New(v.Type()).Elem()

	encoding/binary
		binary.go#L247: 		v = v.Elem()

	encoding/gob
		decode.go#L235: 		v = v.Elem()
		decode.go#L573: 		key := decodeIntoValue(state, keyOp, keyIsPtr, keyP.Elem(), keyInstr)
		decode.go#L574: 		elem := decodeIntoValue(state, elemOp, elemIsPtr, elemP.Elem(), elemInstr)
		decode.go#L576: 		keyP.Elem().Set(keyZ)
		decode.go#L577: 		elemP.Elem().Set(elemZ)
		decode.go#L1258: 	return reflect.New(t).Elem()
		encode.go#L168: 		pv = pv.Elem()
		encode.go#L388: 	elem := iv.Elem()
		encode.go#L390: 		errorf("gob: cannot encode nil pointer of type %s inside interface", iv.Elem().Type())
		encode.go#L400: 	ut := userType(iv.Elem().Type())

	encoding/json
		decode.go#L448: 			e := v.Elem()
		decode.go#L449: 			if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
		decode.go#L467: 		if v.Elem().Kind() == reflect.Interface && v.Elem().Elem() == v {
		decode.go#L468: 			v = v.Elem()
		decode.go#L489: 			v = v.Elem()
		decode.go#L689: 				mapElem = reflect.New(elemType).Elem()
		decode.go#L731: 						subv = subv.Elem()
		decode.go#L781: 				kv = kv.Elem()
		encode.go#L716: 	e.reflectValue(v.Elem(), opts)
		encode.go#L745: 				fv = fv.Elem()
		encode.go#L944: 	pe.elemEnc(e, v.Elem(), opts)

	encoding/xml
		marshal.go#L427: 		val = val.Elem()
		marshal.go#L606: 		val = val.Elem()
		marshal.go#L800: 		vf = vf.Elem()
		read.go#L151: 	return d.unmarshal(val.Elem(), start)
		read.go#L251: 		val = val.Elem()
		read.go#L326: 		e := val.Elem()
		read.go#L336: 		val = val.Elem()
		read.go#L609: 		dst = dst.Elem()
		typeinfo.go#L368: 				v = v.Elem()

	fmt
		print.go#L293: 		val = val.Elem()
		print.go#L810: 		value := f.Elem()
		print.go#L873: 			switch a := f.Elem(); a.Kind() {
		scan.go#L1024: 		switch v := ptr.Elem(); v.Kind() {

	github.com/aws/aws-sdk-go/aws/awsutil
		copy.go#L45: 			if dst.Kind() == reflect.Ptr && dst.Elem().CanSet() {
		copy.go#L46: 				dst.Elem().Set(src)
		copy.go#L57: 					tempValue.Elem().Set(src.Elem())
		copy.go#L62: 			if src.Elem().IsValid() {
		copy.go#L64: 				rcopy(dst.Elem(), src.Elem(), root)
		copy.go#L96: 			v2 := reflect.New(v.Type()).Elem()
		path_value.go#L90: 				value = value.Elem()
		path_value.go#L214: 			srcVal = reflect.ValueOf(src).Elem()
		prettify.go#L22: 		v = v.Elem()
		string_value.go#L19: 		v = v.Elem()

	github.com/aws/aws-sdk-go/aws/request
		request.go#L262: 	return r.Params != nil && reflect.ValueOf(r.Params).Elem().IsValid()
		request.go#L269: 	return r.Data != nil && reflect.ValueOf(r.Data).Elem().IsValid()

	github.com/aws/aws-sdk-go/private/protocol
		idempotency.go#L48: 		v = v.Elem()

	github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
		build.go#L293: 		value = value.Elem()
		unmarshal.go#L139: 		value = value.Elem()
		unmarshal.go#L219: 		vvalue := reflect.New(value.Type().Elem()).Elem()

	github.com/aws/aws-sdk-go/private/protocol/query/queryutil
		queryutil.go#L25: 		value = value.Elem()

	github.com/aws/aws-sdk-go/private/protocol/rest
		build.go#L49: 		v := reflect.ValueOf(r.Params).Elem()
		build.go#L59: 		v := reflect.ValueOf(r.Params).Elem()
		build.go#L86: 				m = m.Elem()
		build.go#L88: 				if !m.Elem().IsValid() {
		payload.go#L11: 	v := reflect.ValueOf(i).Elem()
		unmarshal.go#L200: 		if !v.IsValid() || (header == "" && v.Elem().Kind() != reflect.String) {

	github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
		build.go#L40: 		value = value.Elem()
		unmarshal.go#L124: 		r = r.Elem()
		unmarshal.go#L241: 			valueR := reflect.New(r.Type().Elem()).Elem()

	github.com/ghodss/yaml
		fields.go#L33: 			e := v.Elem()
		fields.go#L34: 			if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
		fields.go#L44: 		if v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {
		fields.go#L62: 		v = v.Elem()

	github.com/go-git/gcfg
		set.go#L80: 		reflect.ValueOf(d).Elem().Set(reflect.ValueOf(true))
		set.go#L85: 		reflect.ValueOf(d).Elem().Set(reflect.ValueOf(b))
		set.go#L209: 		if err = c.Collect(gd.DecodeValue(pv.Elem())); err != nil {
		set.go#L220: 	if vPCfg.Kind() != reflect.Ptr || vPCfg.Elem().Kind() != reflect.Struct {
		set.go#L223: 	vCfg := vPCfg.Elem()
		set.go#L254: 		vSect = pv.Elem()
		set.go#L286: 		vVar = vVar.Elem()
		set.go#L293: 		vVal = reflect.New(vVar.Type().Elem()).Elem()

	github.com/go-git/gcfg/types
		scan.go#L11: 	t := reflect.ValueOf(ptr).Elem().Type()

	github.com/go-git/go-git/v5/plumbing/transport/ssh
		common.go#L217: 	vc := reflect.ValueOf(c).Elem()
		common.go#L218: 	vo := reflect.ValueOf(overrides).Elem()

	github.com/go-redis/redis/v8/internal/proto
		scan.go#L118: 	v = v.Elem()
		scan.go#L147: 				return elem.Elem()
		scan.go#L152: 			return elem.Elem()

	github.com/golang/protobuf/proto
		extensions.go#L175: 		rv2.Elem().Set(rv)
		extensions.go#L237: 		if isScalarKind(rv.Elem().Kind()) {
		extensions.go#L238: 			v = rv.Elem().Interface()

	github.com/google/go-cmp/cmp
		compare.go#L148: 			vvx := reflect.New(t).Elem()
		compare.go#L153: 			vvy := reflect.New(t).Elem()
		compare.go#L382: 			return reflect.New(t).Elem()
		compare.go#L578: 	vx, vy = vx.Elem(), vy.Elem()
		compare.go#L587: 	vx, vy = vx.Elem(), vy.Elem()
		compare.go#L679: 	vc := reflect.New(v.Type()).Elem()
		export_unsafe.go#L23: 	ve := reflect.NewAt(f.Type, unsafe.Pointer(uintptr(unsafe.Pointer(v.UnsafeAddr()))+f.Offset)).Elem()
		report_reflect.go#L285: 		out = opts.FormatValue(v.Elem(), t.Kind(), ptrs)
		report_reflect.go#L296: 		return opts.WithTypeMode(emitType).FormatValue(v.Elem(), t.Kind(), ptrs)
		report_slices.go#L93: 		vx2, vy2 := reflect.New(t).Elem(), reflect.New(t).Elem()

	github.com/google/go-cmp/cmp/cmpopts
		sort.go#L128: 		v := reflect.New(outType).Elem()

	github.com/google/go-cmp/cmp/internal/value
		sort.go#L81: 		vx, vy := x.Elem(), y.Elem()
		sort.go#L87: 			return isLess(x.Elem(), y.Elem())

	github.com/google/safehtml/internal/safehtmlutil
		safehtmlutil.go#L160: 		v = v.Elem()
		safehtmlutil.go#L177: 		v = v.Elem()

	github.com/google/safehtml/template
		escape.go#L814: 		v = v.Elem()

	github.com/imdario/mergo
		map.go#L70: 		dst = dst.Elem()
		map.go#L87: 				srcElement = srcElement.Elem()
		merge.go#L96: 			dstCp := reflect.New(dst.Type()).Elem()
		merge.go#L103: 					rf = reflect.NewAt(rf.Type(), unsafe.Pointer(rf.UnsafeAddr())).Elem() //nolint:gosec
		merge.go#L109: 					dstRF = reflect.NewAt(dstRF.Type(), unsafe.Pointer(dstRF.UnsafeAddr())).Elem() //nolint:gosec
		merge.go#L217: 				if dst, err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
		merge.go#L221: 			} else if dst.Elem().Type() == src.Type() {
		merge.go#L222: 				if dst, err = deepMerge(dst.Elem(), src, visited, depth+1, config); err != nil {
		merge.go#L238: 		} else if _, err = deepMerge(dst.Elem(), src.Elem(), visited, depth+1, config); err != nil {
		mergo.go#L52: 		return isEmptyValue(v.Elem())
		mergo.go#L66: 	vDst = reflect.ValueOf(dst).Elem()
		mergo.go#L74: 		vSrc = vSrc.Elem()

	github.com/jackc/pgtype
		aclitem_array.go#L227: 			value = value.Elem()
		aclitem_array.go#L274: 			value.Set(reflect.New(typ).Elem())
		array_type.go#L106: 	sliceVal := ptrSlice.Elem()
		array_type.go#L125: 			slice.Index(i).Set(ptrElem.Elem())
		bool_array.go#L230: 			value = value.Elem()
		bool_array.go#L277: 			value.Set(reflect.New(typ).Elem())
		bpchar_array.go#L230: 			value = value.Elem()
		bpchar_array.go#L277: 			value.Set(reflect.New(typ).Elem())
		bytea_array.go#L202: 			value = value.Elem()
		bytea_array.go#L249: 			value.Set(reflect.New(typ).Elem())
		cidr_array.go#L259: 			value = value.Elem()
		cidr_array.go#L306: 			value.Set(reflect.New(typ).Elem())
		composite_type.go#L192: 	dstElemValue := dstValue.Elem()
		convert.go#L24: 		convVal := refVal.Elem().Interface()
		convert.go#L79: 		convVal := refVal.Elem().Interface()
		convert.go#L98: 		convVal := refVal.Elem().Interface()
		convert.go#L119: 		convVal := refVal.Elem().Interface()
		convert.go#L138: 		convVal := refVal.Elem().Interface()
		convert.go#L154: 		convVal := refVal.Elem().Interface()
		convert.go#L175: 		convVal := refVal.Elem().Interface()
		convert.go#L196: 		convVal := refVal.Elem().Interface()
		convert.go#L284: 				el := v.Elem()
		convert.go#L317: 		el := v.Elem()
		convert.go#L336: 				el := v.Elem()
		convert.go#L359: 		el := v.Elem()
		convert.go#L377: 	dstVal := dstPtr.Elem()
		convert.go#L405: 	dstVal := dstPtr.Elem()
		date_array.go#L231: 			value = value.Elem()
		date_array.go#L278: 			value.Set(reflect.New(typ).Elem())
		enum_array.go#L227: 			value = value.Elem()
		enum_array.go#L274: 			value.Set(reflect.New(typ).Elem())
		float4_array.go#L230: 			value = value.Elem()
		float4_array.go#L277: 			value.Set(reflect.New(typ).Elem())
		float8_array.go#L230: 			value = value.Elem()
		float8_array.go#L277: 			value.Set(reflect.New(typ).Elem())
		hstore_array.go#L202: 			value = value.Elem()
		hstore_array.go#L249: 			value.Set(reflect.New(typ).Elem())
		inet_array.go#L259: 			value = value.Elem()
		inet_array.go#L306: 			value.Set(reflect.New(typ).Elem())
		int2_array.go#L622: 			value = value.Elem()
		int2_array.go#L669: 			value.Set(reflect.New(typ).Elem())
		int4_array.go#L622: 			value = value.Elem()
		int4_array.go#L669: 			value.Set(reflect.New(typ).Elem())
		int8_array.go#L622: 			value = value.Elem()
		int8_array.go#L669: 			value.Set(reflect.New(typ).Elem())
		jsonb_array.go#L230: 			value = value.Elem()
		jsonb_array.go#L277: 			value.Set(reflect.New(typ).Elem())
		macaddr_array.go#L231: 			value = value.Elem()
		macaddr_array.go#L278: 			value.Set(reflect.New(typ).Elem())
		numeric_array.go#L398: 			value = value.Elem()
		numeric_array.go#L445: 			value.Set(reflect.New(typ).Elem())
		pgtype.go#L365: 			value = reflect.New(reflect.ValueOf(t).Elem().Type()).Interface().(Value)
		pgtype.go#L607: 			refVal.Elem().Set(nilPtr)
		pgtype.go#L614: 		refVal.Elem().Set(elemPtr)
		pgtype.go#L863: 		return reflect.New(reflect.ValueOf(v).Elem().Type()).Interface().(Value)
		record.go#L93: 	binaryDecoder = reflect.New(reflect.ValueOf(binaryDecoder).Elem().Type()).Interface().(BinaryDecoder)
		text_array.go#L230: 			value = value.Elem()
		text_array.go#L277: 			value.Set(reflect.New(typ).Elem())
		timestamp_array.go#L231: 			value = value.Elem()
		timestamp_array.go#L278: 			value.Set(reflect.New(typ).Elem())
		timestamptz_array.go#L231: 			value = value.Elem()
		timestamptz_array.go#L278: 			value.Set(reflect.New(typ).Elem())
		tsrange_array.go#L183: 			value = value.Elem()
		tsrange_array.go#L230: 			value.Set(reflect.New(typ).Elem())
		tstzrange_array.go#L183: 			value = value.Elem()
		tstzrange_array.go#L230: 			value.Set(reflect.New(typ).Elem())
		uuid_array.go#L286: 			value = value.Elem()
		uuid_array.go#L333: 			value.Set(reflect.New(typ).Elem())
		varchar_array.go#L230: 			value = value.Elem()
		varchar_array.go#L277: 			value.Set(reflect.New(typ).Elem())

	github.com/jackc/pgx/v4
		extended_query_builder.go#L118: 		arg = refVal.Elem().Interface()
		values.go#L132: 		arg = refVal.Elem().Interface()
		values.go#L184: 		arg = refVal.Elem().Interface()

	github.com/jmespath/go-jmespath
		interpreter.go#L332: 		rv = rv.Elem()
		util.go#L41: 		element := rv.Elem()

	github.com/lann/builder
		builder.go#L198: 	structVal := reflect.New(reflect.TypeOf(strct)).Elem()
		registry.go#L57: 	newStruct := reflect.New(*structType).Elem()

	github.com/lib/pq
		array.go#L319: 	dv := dpv.Elem()

	github.com/Masterminds/squirrel
		expr.go#L178: 				val = r.Elem().Interface()

	go.opentelemetry.io/otel/label
		set.go#L443: 	at := reflect.New(reflect.ArrayOf(len(kvs), keyValueType)).Elem()

	go/ast
		print.go#L151: 		p.print(x.Elem())
		print.go#L178: 			p.print(x.Elem())

	golang.org/x/crypto/ssh
		messages.go#L375: 	v := reflect.ValueOf(out).Elem()
		messages.go#L563: 				nValue.Elem().Set(field)

	golang.org/x/pkgsite/internal/database
		reflect.go#L43: 		v = v.Elem()
		reflect.go#L68: 		v := reflect.ValueOf(p).Elem()
		reflect.go#L94: 	if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Ptr {
		reflect.go#L107: 	ntype := n.ptr.Elem().Type() // T
		reflect.go#L109: 		n.ptr.Elem().Set(reflect.Zero(ntype)) // *v = nil
		reflect.go#L112: 		p.Elem().Set(reflect.ValueOf(value)) // *p = value
		reflect.go#L113: 		n.ptr.Elem().Set(p)                  // *v = p
		reflect.go#L119: 	if n.ptr.Elem().IsNil() {
		reflect.go#L122: 	return n.ptr.Elem().Elem().Interface(), nil
		reflect.go#L136: 	ve := v.Elem()
		reflect.go#L157: 			e = e.Elem()
		reflect.go#L165: 	v.Elem().Set(ve)

	golang.org/x/pkgsite/internal/godoc/dochtml
		template.go#L48: 		vz := reflect.New(v.Type()).Elem()

	golang.org/x/pkgsite/internal/postgres
		details.go#L174: 		vptr.Elem().Set(reflect.Zero(vptr.Elem().Type()))
		details.go#L182: 	v := reflect.New(vptr.Elem().Type())
		details.go#L188: 	vptr.Elem().Set(v.Elem())

	golang.org/x/xerrors
		wrap.go#L95: 			val.Elem().Set(reflect.ValueOf(err))

	google.golang.org/api/internal/gensupport
		json.go#L125: 		v = v.Elem()

	google.golang.org/api/iterator
		iterator.go#L224: 	e := vslicep.Elem()

	google.golang.org/protobuf/internal/descfmt
		stringer.go#L220: 				rv = rv.Elem()

	google.golang.org/protobuf/internal/impl
		codec_field.go#L56: 			vi := p.AsValueOf(ft).Elem() // oneof field value of interface kind
		codec_field.go#L57: 			if !vi.IsNil() && !vi.Elem().IsNil() && vi.Elem().Elem().Type() == ot {
		codec_field.go#L58: 				vw = vi.Elem()
		codec_field.go#L71: 		v := p.AsValueOf(ft).Elem()
		codec_field.go#L75: 		v = v.Elem() // interface -> *struct
		codec_field.go#L79: 		return pointerOfValue(v).Apply(zeroOffset), oneofFields[v.Elem().Type()]
		codec_field.go#L103: 			dst.AsValueOf(ft).Elem().Set(reflect.New(src.AsValueOf(ft).Elem().Elem().Elem().Type()))
		codec_field.go#L104: 			dstp = pointerOfValue(dst.AsValueOf(ft).Elem().Elem()).Apply(zeroOffset)
		codec_field.go#L206: 				m := asMessage(p.AsValueOf(ft).Elem())
		codec_field.go#L210: 				m := asMessage(p.AsValueOf(ft).Elem())
		codec_field.go#L214: 				mp := p.AsValueOf(ft).Elem()
		codec_field.go#L221: 				m := asMessage(p.AsValueOf(ft).Elem())
		codec_field.go#L362: 				m := asMessage(p.AsValueOf(ft).Elem())
		codec_field.go#L366: 				m := asMessage(p.AsValueOf(ft).Elem())
		codec_field.go#L370: 				mp := p.AsValueOf(ft).Elem()
		codec_field.go#L377: 				m := asMessage(p.AsValueOf(ft).Elem())
		codec_map.go#L54: 			return sizeMap(p.AsValueOf(ft).Elem(), mapi, f, opts)
		codec_map.go#L57: 			return appendMap(b, p.AsValueOf(ft).Elem(), mapi, f, opts)
		codec_map.go#L61: 			if mp.Elem().IsNil() {
		codec_map.go#L62: 				mp.Elem().Set(reflect.MakeMap(mapi.goType))
		codec_map.go#L65: 				return consumeMap(b, mp.Elem(), wtyp, mapi, f, opts)
		codec_map.go#L67: 				return consumeMapOfMessage(b, mp.Elem(), wtyp, mapi, f, opts)
		codec_map.go#L81: 			return isInitMap(p.AsValueOf(ft).Elem(), mapi, f)
		codec_map.go#L341: 	dstm := dst.AsValueOf(f.ft).Elem()
		codec_map.go#L342: 	srcm := src.AsValueOf(f.ft).Elem()
		codec_map.go#L356: 	dstm := dst.AsValueOf(f.ft).Elem()
		codec_map.go#L357: 	srcm := src.AsValueOf(f.ft).Elem()
		codec_map.go#L371: 	dstm := dst.AsValueOf(f.ft).Elem()
		codec_map.go#L372: 	srcm := src.AsValueOf(f.ft).Elem()
		convert_list.go#L34: 	pv.Elem().Set(v)
		convert_list.go#L43: 	return rv.Elem()
		convert_list.go#L111: 	return ls.v.Elem().Len()
		convert_list.go#L114: 	return ls.conv.PBValueOf(ls.v.Elem().Index(i))
		convert_list.go#L117: 	ls.v.Elem().Index(i).Set(ls.conv.GoValueOf(v))
		convert_list.go#L120: 	ls.v.Elem().Set(reflect.Append(ls.v.Elem(), ls.conv.GoValueOf(v)))
		convert_list.go#L131: 	ls.v.Elem().Set(ls.v.Elem().Slice(0, i))
		legacy_enum.go#L102: 	v := reflect.New(e.goTyp).Elem()
		merge.go#L139: 		dm := dst.AsValueOf(f.ft).Elem()
		merge.go#L140: 		sm := src.AsValueOf(f.ft).Elem()
		message_reflect_field.go#L57: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L58: 			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
		message_reflect_field.go#L64: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L65: 			if rv.IsNil() || rv.Elem().Type().Elem() != ot {
		message_reflect_field.go#L76: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L77: 			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
		message_reflect_field.go#L80: 			rv = rv.Elem().Elem().Field(0)
		message_reflect_field.go#L84: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L85: 			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
		message_reflect_field.go#L88: 			rv = rv.Elem().Elem().Field(0)
		message_reflect_field.go#L95: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L96: 			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {
		message_reflect_field.go#L99: 			rv = rv.Elem().Elem().Field(0)
		message_reflect_field.go#L129: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L133: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L140: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L147: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L155: 			v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L182: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L186: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L194: 			if rv.Elem().Len() == 0 {
		message_reflect_field.go#L200: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L205: 			rv.Set(pv.Elem())
		message_reflect_field.go#L244: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L264: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L271: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L277: 					rv = rv.Elem()
		message_reflect_field.go#L283: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L288: 				rv = rv.Elem()
		message_reflect_field.go#L390: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L394: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L401: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L405: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L412: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L441: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L454: 			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
		message_reflect_field.go#L458: 			rv = rv.Elem()

	gopkg.in/yaml.v2
		decode.go#L308: 			out = out.Elem()
		decode.go#L569: 			elem.Elem().Set(reflect.ValueOf(resolved))
		decode.go#L580: 	sv := reflect.New(v.Type()).Elem()
		decode.go#L608: 		e := reflect.New(et).Elem()
		decode.go#L637: 			slicev := reflect.New(d.mapType).Elem()
		decode.go#L666: 		k := reflect.New(kt).Elem()
		decode.go#L670: 				kkind = k.Elem().Kind()
		decode.go#L675: 			e := reflect.New(et).Elem()
		decode.go#L711: 		k := reflect.ValueOf(&item.Key).Elem()
		decode.go#L713: 			v := reflect.ValueOf(&item.Value).Elem()
		decode.go#L736: 		inlineMap.Set(reflect.New(inlineMap.Type()).Elem())
		decode.go#L772: 			value := reflect.New(elemType).Elem()
		encode.go#L147: 		e.marshal(tag, in.Elem())
		encode.go#L152: 			e.timev(tag, in.Elem())
		encode.go#L154: 			e.marshal(tag, in.Elem())
		sorter.go#L18: 		a = a.Elem()
		sorter.go#L22: 		b = b.Elem()
		yaml.go#L128: 		out = out.Elem()
		yaml.go#L146: 			v = v.Elem()

	html/template
		content.go#L125: 		v = v.Elem()
		content.go#L144: 		v = v.Elem()
		js.go#L136: 		v = v.Elem()

	internal/execabs
		execabs.go#L51: 		lookPathErr := (*error)(unsafe.Pointer(reflect.ValueOf(cmd).Elem().FieldByName("lookPathErr").Addr().Pointer()))

	internal/fmtsort
		sort.go#L174: 		c := compare(reflect.ValueOf(aVal.Elem().Type()), reflect.ValueOf(bVal.Elem().Type()))
		sort.go#L178: 		return compare(aVal.Elem(), bVal.Elem())

	net/http/httptrace
		trace.go#L179: 	tv := reflect.ValueOf(t).Elem()
		trace.go#L180: 	ov := reflect.ValueOf(old).Elem()

	text/template
		exec.go#L767: 			value = value.Elem()
		exec.go#L779: 			value = value.Elem()
		exec.go#L842: 		value := reflect.New(typ).Elem()
		exec.go#L853: 		value := reflect.New(typ).Elem()
		exec.go#L864: 		value := reflect.New(typ).Elem()
		exec.go#L875: 		value := reflect.New(typ).Elem()
		exec.go#L886: 		value := reflect.New(typ).Elem()
		exec.go#L896: 		value := reflect.New(typ).Elem()
		exec.go#L935: 	for ; v.Kind() == reflect.Ptr || v.Kind() == reflect.Interface; v = v.Elem() {
		exec.go#L954: 	return v.Elem()

	vendor/golang.org/x/crypto/cryptobyte
		asn1.go#L263: 	switch reflect.ValueOf(out).Elem().Kind() {
		asn1.go#L266: 		if !s.readASN1Int64(&i) || reflect.ValueOf(out).Elem().OverflowInt(i) {
		asn1.go#L269: 		reflect.ValueOf(out).Elem().SetInt(i)
		asn1.go#L273: 		if !s.readASN1Uint64(&u) || reflect.ValueOf(out).Elem().OverflowUint(u) {
		asn1.go#L276: 		reflect.ValueOf(out).Elem().SetUint(u)
		asn1.go#L615: 		switch reflect.ValueOf(out).Elem().Kind() {
		asn1.go#L618: 			reflect.ValueOf(out).Elem().Set(reflect.ValueOf(defaultValue))