text, _ := reader.ReadString('\n')
			// convert CRLF to LF
			*keyHex = strings.ReplaceAll(text, "\n", "")
			*keyHex = strings.TrimSpace(*keyHex)
		}
	}

	var inputs []string

	// Parse parameters
	switch {
	case *stdin:
		// Parse 'mc support inspect --json' output
		input := struct {
			File string `json:"file"`
			Key  string `json:"key"`
		}{}
		got, err := io.ReadAll(os.Stdin)
		if err != nil {

    /**
     * Create username/password credentials with specified domain
     * 
     * @param domain
     * @param username
     * @param password
     */
    public NtlmPasswordAuthenticator ( String domain, String username, String password ) {
        this(domain, username, password, AuthenticationType.USER);
    }


    /**
     * Create username/password credentials with specified domain
     * 
     * @param domain

      scheme: default
      primary: teal
      accent: blue
      toggle:
        icon: octicons/sun-24
        name: "Switch to Dark Mode"
    - media: "(prefers-color-scheme: dark)"
      scheme: slate
      primary: teal
      accent: blue
      toggle:
        icon: octicons/moon-24
        name: "Switch to Light Mode"
  features:
  - navigation.tabs

extra_css:
  - 'assets/css/app.css'

markdown_extensions:

func (j xlMetaV2Version) getDataDir() string {
	if j.Valid() {
		switch j.Type {
		case LegacyType:
			return j.ObjectV1.DataDir
		case ObjectType:
			return uuid.UUID(j.ObjectV2.DataDir).String()
		}
	}
	return ""
}

// Valid xl meta xlMetaV2Version is valid
func (j xlMetaV2Version) Valid() bool {
	if !j.Type.valid() {
		return false
	}
	switch j.Type {
	case LegacyType:
		return j.ObjectV1 != nil &&

                char c = line.charAt(pos);

                switch (state) {
                    case 0:
                        if (c == '\\') {
                            state = 1;
                        } else if (contains(WHITE_SPACE, c)) {
                            // switch to the separator crossing state
                            state = 2;

	if len(data) > 0 && data[0] == 'x' {
		// needed to test failures
		return nil, errors.New("Should not start with 'x'")
	}

	// prepend asterisks
	return append([]byte("***"), data...), nil
}

type Num int64

func (i *Num) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		n, _ := strconv.Atoi(string(s))
		*i = Num(n)
	case int64:
		*i = Num(s)
	default:

                // Compare the entire list of items with null - not just the first one, MNG-6964
                for (Item i : this) {
                    int result = i.compareTo(null);
                    if (result != 0) {
                        return result;
                    }
                }
                return 0;
            }
            switch (item.getType()) {
                case INT_ITEM:

    }

    @Override
    BoundType typeAsUpperBound() {
      return BoundType.OPEN;
    }

    @Override
    Cut<C> withLowerBoundType(BoundType boundType, DiscreteDomain<C> domain) {
      switch (boundType) {
        case CLOSED:
          return this;
        case OPEN:
          C previous = domain.previous(endpoint);
          return (previous == null) ? Cut.<C>belowAll() : new AboveValue<C>(previous);

	// Start and end offset specified in range spec
	Start, End int64
}

// GetLength - get length of range
func (h *HTTPRangeSpec) GetLength(resourceSize int64) (rangeLength int64, err error) {
	switch {
	case resourceSize < 0:
		return 0, errors.New("Resource size cannot be negative")

	case h == nil:
		rangeLength = resourceSize

	case h.IsSuffixLength:
		specifiedLen := -h.Start
		rangeLength = specifiedLen

		return toAPIError(ctx, fmt.Errorf("error exporting %s with: %w", fname, err))
	}
	return toAPIError(ctx, fmt.Errorf("error exporting %s from %s with: %w", entity, fname, err))
}

// wraps import error for more context
func importError(ctx context.Context, err error, fname, entity string) APIError {
	if entity == "" {
		return toAPIError(ctx, fmt.Errorf("error importing %s with: %w", fname, err))
	}