code: func (d *Decoder) parseValue(v reflect.Value) (bool, error) {
  	// we support one level of indirection at the moment
  	if v.Kind() == reflect.Ptr {
  		// if the pointer is nil, allocate a new element of the type it
  		// points to
  		if v.IsNil() {
  			v.Set(reflect.New(v.Type().Elem()))
  		}
  		v = v.Elem()
  	}
  
  	if d.parseUnmarshaler(v) {
  		return true, nil
  	}
  
  	// common case: interface{}
  	if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
  		iface, _ := d.parseValueInterface()
  		v.Set(reflect.ValueOf(iface))
  		return true, nil
  	}
  
  	b, err := d.r.ReadByte()
  	if err != nil {
  		panic(err)
  	}
  	d.Offset++
  
  	switch b {
  	case 'e':
  		return false, nil
  	case 'd':
  		return true, d.parseDict(v)
  	case 'l':
  		return true, d.parseList(v)
  	case 'i':
  		d.parseInt(v)
  		return true, nil
  	default:
  		if b >= '0' && b <= '9' {
  			// It's a string.
  			d.buf.Reset()
  			// Write the first digit of the length to the buffer.
  			d.buf.WriteByte(b)
  			return true, d.parseString(v)
  		}
  
  		d.raiseUnknownValueType(b, d.Offset-1)
  	}
  	panic("unreachable")
  }
docs: // Returns true if there was a value and it's now stored in 'v', otherwise
  // there was an end symbol ("e") and no value was stored.