/** The NetBIOS error class */
    public int errorClass;
    /** The NetBIOS error code */
    public int errorCode;

    /**
     * Converts NetBIOS error class and code to a human-readable string.
     *
     * @param errorClass the error class
     * @param errorCode the error code
     * @return a descriptive error string
     */

 */

package jcifs.util;

/**
 * Utility class for hexadecimal dumping of binary data.
 * This class provides methods for converting binary data to readable hex format.
 */

public class Hexdump {

    /**
     * Default constructor.
     */
    public Hexdump() {
        // Utility class - no instance variables to initialize
    }

    /**

    Java Language specification, sections 8.1.1, 8.3.1 and 8.4.3. It is not that
    the standard is perfect, but having a consistent order makes the code more
    readable and no other order is compellingly better than the standard.
    The correct order is:
            public
            protected
            private
            abstract
            static
            final

                    e);
            return new PersistedToolchains();
        } catch (IOException e) {
            problems.add(
                    Problem.Severity.FATAL,
                    "Non-readable toolchains " + toolchainsSource.getLocation() + ": " + e.getMessage(),
                    -1,
                    -1,
                    e);
            return new PersistedToolchains();
        }

        "expected IllegalArgumentException for call to slice with length -1: " + source,
        IllegalArgumentException.class,
        () -> source.slice(0, -1));
  }

  // Test that you can not expand the readable data in a previously sliced ByteSource.
  public void testSlice_constrainedRange() throws IOException {
    long size = source.read().length;
    if (size >= 2) {
      ByteSource sliced = source.slice(1, size - 2);

			if !osIsNotExist(err) && !osIsPermission(err) {
				return nil, err
			}
			continue
		}
		data, _ = json.Marshal(cfg)
		break
	}
	if osIsPermission(err) {
		logger.Info("Older config found but is not readable %s, proceeding to read config from other places", err)
	}
	if osIsNotExist(err) || osIsPermission(err) || len(data) == 0 {
		data, err = readConfig(GlobalContext, objAPI, configFile)
		if err != nil {

   * #asMapOfRanges()}.
   */
  @Override
  boolean equals(@Nullable Object o);

  /** Returns {@code asMapOfRanges().hashCode()}. */
  @Override
  int hashCode();

  /** Returns a readable string representation of this range map. */
  @Override
  String toString();

                || algorithm == COMPRESSION_LZNT1 || algorithm == COMPRESSION_PATTERN_V1;
    }

    /**
     * Gets a human-readable name for the compression algorithm.
     *
     * @param algorithm the algorithm constant
     * @return the algorithm name
     */
    public static String getAlgorithmName(int algorithm) {

                It is UTF-8-encoded data. The interpretation of the reason is up to the
                application, it is not specified by the WebSocket specification.

                It could contain text that could be human-readable or interpretable
                by the client code, etc.
                """
            ),
        ] = None,
    ) -> None:
        super().__init__(code=code, reason=reason)

        }

        return "Sent log notifications: " + events.size() + " events.";
    }

    /**
     * Formats a list of log notification events into a human-readable summary string.
     *
     * @param events the list of log notification events
     * @param maxDetailsLength the maximum length of the details string
     * @param maxDisplayEvents the maximum number of events to display