if u.detail == "" {
		if u.msg != "" {
			return u.msg
		}
		return "<nil>"
	}
	return u.detail
}

// Msg - Replace the current error's message
func (u Err) Msg(m string, args ...interface{}) Err {
	e := u.Clone()
	e.msg = fmt.Sprintf(m, args...)
	return e
}

// Hint - Replace the current error's message
func (u Err) Hint(m string, args ...interface{}) Err {
	e := u.Clone()

                    "type": "missing",
                    "loc": ["body", 0, "name"],
                    "msg": "Field required",
                    "input": {"age": "five"},
                },
                {
                    "type": "decimal_parsing",
                    "loc": ["body", 0, "age"],
                    "msg": "Input should be a valid decimal",
                    "input": "five",
                },
                {

        super();
    }


    /**
     * @param msg
     * @param rootCause
     */
    public SMBSignatureValidationException ( String msg, Throwable rootCause ) {
        super(msg, rootCause);
    }


    /**
     * @param msg
     */
    public SMBSignatureValidationException ( String msg ) {
        super(msg);
    }

    /**
     * 
     */

	msg.Flags.Clear(FlagSubroute)
	if payload != nil {
		if sz := payload.Msgsize(); cap(msg.Payload) < sz {
			PutByteBuffer(msg.Payload)
			msg.Payload = GetByteBufferCap(sz)
		}
		var err error
		msg.Payload, err = payload.MarshalMsg(msg.Payload[:0])
		msg.Op = payload.Op()
		if err != nil {
			return err
		}
	}
	defer PutByteBuffer(msg.Payload)
	dst := GetByteBufferCap(msg.Msgsize())

		return tls.Certificate{}, ErrTLSReadError(nil).Msg("Unable to read the public key: %s", err)
	}
	keyPEMBlock, err := os.ReadFile(keyFile)
	if err != nil {
		return tls.Certificate{}, ErrTLSReadError(nil).Msg("Unable to read the private key: %s", err)
	}
	key, rest := pem.Decode(keyPEMBlock)
	if len(rest) > 0 {
		return tls.Certificate{}, ErrTLSUnexpectedData(nil).Msg("The private key contains additional data")
	}
	if key == nil {

	for _, totalSize := range totalSizes {
		// Check if totalSize has minimum range upto setSize
		if totalSize < setSizes[0] || totalSize < setDriveCount {
			msg := fmt.Sprintf("Incorrect number of endpoints provided %s", args)
			return nil, config.ErrInvalidNumberOfErasureEndpoints(nil).Msg(msg)
		}
	}

	commonSize := getDivisibleSize(totalSizes)
	possibleSetCounts := func(setSize uint64) (ss []uint64) {
		for _, s := range setSizes {

        this.error = error;
    }


    /**
     * @param msg
     */
    public DcerpcException ( String msg ) {
        super(msg);
    }


    /**
     * @param msg
     * @param rootCause
     */
    public DcerpcException ( String msg, Throwable rootCause ) {
        super(msg, rootCause);
    }


    /**
     * 
     * @return the error code
     */

                {
                    "type": "missing",
                    "loc": ["body", "item"],
                    "msg": "Field required",
                    "input": None,
                },
                {
                    "type": "missing",
                    "loc": ["body", "user"],
                    "msg": "Field required",
                    "input": None,
                },
                {

                    "loc": ["query", "q", 0],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "five",
                },
                {
                    "type": "int_parsing",
                    "loc": ["query", "q", 1],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",

 *
 */
@Deprecated
public class MavenReportException extends Exception {
    public MavenReportException(String msg) {
        super(msg);
    }

    public MavenReportException(String msg, Exception e) {
        super(msg, e);
    }