eventListener.responseHeadersEnd(call, response)
  }

  @Throws(IOException::class)
  fun openResponseBody(response: Response): ResponseBody {
    try {
      val contentType = response.header("Content-Type")
      val contentLength = codec.reportedContentLength(response)
      val rawSource = codec.openResponseBodySource(response)
      val source = ResponseBodySource(rawSource, contentLength)

	"unicode"
)

// conversion type-checks the conversion T(x).
// The result is in x.
func (check *Checker) conversion(x *operand, T Type) {
	constArg := x.mode == constant_

	constConvertibleTo := func(T Type, val *constant.Value) bool {
		switch t, _ := under(T).(*Basic); {
		case t == nil:
			// nothing to do
		case representableConst(x.val, check, t, val):
			return true
		case isInteger(x.typ) && isString(t):

				return true
			}
		}
	}

	// Otherwise, pattern and val must match recursively.
	if !pattern.IsValid() || !val.IsValid() {
		return !pattern.IsValid() && !val.IsValid()
	}
	if pattern.Type() != val.Type() {
		return false
	}

	// Special cases.
	switch pattern.Type() {
	case identType:
		// For identifiers, only the names need to match
		// (and none of the other *ast.Object information).

	"unicode"
)

// conversion type-checks the conversion T(x).
// The result is in x.
func (check *Checker) conversion(x *operand, T Type) {
	constArg := x.mode == constant_

	constConvertibleTo := func(T Type, val *constant.Value) bool {
		switch t, _ := under(T).(*Basic); {
		case t == nil:
			// nothing to do
		case representableConst(x.val, check, t, val):
			return true
		case isInteger(x.typ) && isString(t):

	sink = r
}

func caller12d() {
	i := 0  // ERROR "moved to heap: i$"
	p := &i // ERROR "moved to heap: p$"
	r := Indir{}
	r.param12(&p)
	sink = **r.p
}

// in -> value rcvr
type Val struct {
	p **int
}

func (v Val) param13(i *int) { // ERROR "v does not escape$" "leaking param: i$"
	*v.p = i
}

func caller13a() {
	i := 0 // ERROR "moved to heap: i$"
	var p *int

		switch {
		case keepNull && val == nil:
			filteredMap[key] = nil
		case val != nil:
			switch typedVal := val.(type) {
			case map[string]interface{}:
				// Explicitly-set empty maps are treated as values instead of empty patches
				if len(typedVal) == 0 {
					if !keepNull {
						filteredMap[key] = typedVal
					}
					continue
				}

				var filteredSubMap map[string]interface{}

	return nil, fmt.Errorf("type conversion error from 'Format' to '%v'", typeDesc)
}

func (d *Format) ConvertToType(typeVal ref.Type) ref.Val {
	switch typeVal {
	case FormatType:
		return d
	case types.TypeType:
		return FormatType
	default:
		return types.NewErr("type conversion error from '%s' to '%s'", FormatType, typeVal)
	}
}

func (d *Format) Equal(other ref.Val) ref.Val {
	otherDur, ok := other.(*Format)
	if !ok {

}

func (d Quantity) ConvertToType(typeVal ref.Type) ref.Val {
	switch typeVal {
	case quantityTypeValue:
		return d
	case types.TypeType:
		return quantityTypeValue
	default:
		return types.NewErr("type conversion error from '%s' to '%s'", quantityTypeValue, typeVal)
	}
}

func (d Quantity) Equal(other ref.Val) ref.Val {
	otherDur, ok := other.(Quantity)

}

// ConvertToType implements ref.Val.ConvertToType.
func (d URL) ConvertToType(typeVal ref.Type) ref.Val {
	switch typeVal {
	case typeValue:
		return d
	case types.TypeType:
		return typeValue
	}
	return types.NewErr("type conversion error from '%s' to '%s'", typeValue, typeVal)
}

// Equal implements ref.Val.Equal.
func (d URL) Equal(other ref.Val) ref.Val {
	otherDur, ok := other.(URL)

}

// ConvertToType implements ref.Val.ConvertToType.
func (d IP) ConvertToType(typeVal ref.Type) ref.Val {
	switch typeVal {
	case IPType:
		return d
	case types.TypeType:
		return IPType
	case types.StringType:
		return types.String(d.Addr.String())
	}
	return types.NewErr("type conversion error from '%s' to '%s'", IPType, typeVal)
}

// Equal implements ref.Val.Equal.
func (d IP) Equal(other ref.Val) ref.Val {