code: func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
  	indirects := 1
  	vt := v.Type()
  	upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
  	rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
  	if rvf&flagIndir != 0 {
  		vt = reflect.PtrTo(v.Type())
  		indirects++
  	} else if offsetScalar != 0 {
  		// The value is in the scalar field when it's not one of the
  		// reference types.
  		switch vt.Kind() {
  		case reflect.Uintptr:
  		case reflect.Chan:
  		case reflect.Func:
  		case reflect.Map:
  		case reflect.Ptr:
  		case reflect.UnsafePointer:
  		default:
  			upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
  				offsetScalar)
  		}
  	}
  
  	pv := reflect.NewAt(vt, upv)
  	rv = pv
  	for i := 0; i < indirects; i++ {
  		rv = rv.Elem()
  	}
  	return rv
  }
docs: // unsafeReflectValue converts the passed reflect.Value into a one that bypasses
  // the typical safety restrictions preventing access to unaddressable and
  // unexported data.  It works by digging the raw pointer to the underlying
  // value out of the protected value and generating a new unprotected (unsafe)
  // reflect.Value to it.
  //
  // This allows us to check for implementations of the Stringer and error
  // interfaces to be used for pretty printing ordinarily unaddressable and
  // inaccessible values such as unexported struct fields.