break
		}
	}
	switch t.tok {
	case '\n':
		t.line++
	case '-':
		if s.Peek() == '>' {
			s.Next()
			t.tok = ARR
			return ARR
		}
	case '@':
		if s.Peek() == '>' {
			s.Next()
			t.tok = ROT
			return ROT
		}
	case '<':
		if s.Peek() == '<' {
			s.Next()
			t.tok = LSH
			return LSH
		}
	case '>':
		if s.Peek() == '>' {
			s.Next()

			return
		}
		switch msgp.UnsafeString(field) {
		case "ReplicatedSize":
			z.ReplicatedSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "ReplicatedSize")
				return
			}
		case "ReplicaSize":
			z.ReplicaSize, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "ReplicaSize")
				return
			}
		case "FailStats":
			err = z.FailStats.DecodeMsg(dc)
			if err != nil {

  }

  /**
   * Gets a {@code Throwable} cause chain as a list. The first entry in the list will be {@code
   * throwable} followed by its cause hierarchy. Note that this is a snapshot of the cause chain and
   * will not reflect any subsequent changes to the cause chain.
   *
   * <p>Here's an example of how it can be used to find specific types of exceptions in the cause
   * chain:
   *
   * <pre>

        // Test constructor with message and cause
        String message = "Failed to generate thumbnail for document";
        Exception cause = new RuntimeException("Image processing error");
        ThumbnailGenerationException exception = new ThumbnailGenerationException(message, cause);

        assertEquals(message, exception.getMessage());
        assertEquals(cause, exception.getCause());

    /**
     * Constructs a new SearchEngineClientException with the specified message and cause.
     *
     * @param message the detail message explaining the exception
     * @param cause   the underlying cause of the exception
     */
    public SearchEngineClientException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**

			return
		}
		switch msgp.UnsafeString(field) {
		case "Name":
			z.Name, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Name")
				return
			}
		case "Writer":
			z.Writer, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Writer")
				return
			}
		case "UID":
			z.UID, err = dc.ReadString()
			if err != nil {

    /**
     * Constructs a new TransportException with the specified root cause.
     *
     * @param rootCause the root cause of this exception
     */
    public TransportException(final Throwable rootCause) {
        this.rootCause = rootCause;
    }

    /**
     * Constructs a new TransportException with the specified detail message and root cause.
     *
     * @param msg the detail message

     *
     * @param targetClass
     *            Target class
     * @param cause
     *            The cause of the exception
     */
    public InstantiationRuntimeException(final Class<?> targetClass, final InstantiationException cause) {
        super("ECL0041", asArray(targetClass.getName(), cause), cause);
        this.targetClass = targetClass;
    }

    @Override

        return switch (o) {
        case null -> null;
        case Long l -> l;
        case Number n -> n.longValue();
        case String s -> toLong(s);
        case java.util.Date d -> pattern != null ? Long.valueOf(new SimpleDateFormat(pattern).format(d)) : d.getTime();
        case Boolean b -> b ? 1L : 0L;
        default -> toLong(o.toString());
        };
    }

        // Test constructor with message and Exception cause
        String message = "SSO token validation error";
        Exception cause = new RuntimeException("Invalid token format");
        SsoProcessException exception = new SsoProcessException(message, cause);

        assertEquals(message, exception.getMessage());
        assertEquals(cause, exception.getCause());
    }