if fi.fh.Modified.IsZero() {
		return fi.fh.ModTime()
	}
	return fi.fh.Modified.UTC()
}
func (fi headerFileInfo) Mode() fs.FileMode { return fi.fh.Mode() }
func (fi headerFileInfo) Type() fs.FileMode { return fi.fh.Mode().Type() }
func (fi headerFileInfo) Sys() any          { return fi.fh }

func (fi headerFileInfo) Info() (fs.FileInfo, error) { return fi, nil }

func (fi headerFileInfo) String() string {

/**
 * {@link HashMap} with an upper limit on the number of entries. When a new entry is added, the oldest entry is discarded using LRU if the limit is exceeded.
 *
 * @author koichik
 * @param <K> the key type
 * @param <V> the value type
 */
public class LruHashMap<K, V> extends LinkedHashMap<K, V> {

    private static final long serialVersionUID = 1L;

    /**
     * Default initial capacity.
     */

    }

    public void test_getTika_text_sjis() {
        final InputStream in = ResourceUtil.getResourceAsStream("extractor/test_sjis.txt");
        Map<String, String> params = new HashMap<>();
        params.put("Content-Type", "text/plain");
        final ExtractData extractData = tikaExtractor.getText(in, params);
        final String content = extractData.getContent();
        CloseableUtil.closeQuietly(in);
        logger.info(content);

	lastSentResultIndex int64

	// Number of total items scanned against item type
	scannedItemsMap map[madmin.HealItemType]int64

	// Number of total items healed against item type
	healedItemsMap map[madmin.HealItemType]int64

	// Number of total items where healing failed against item type
	healFailedItemsMap map[madmin.HealItemType]int64

	// The time of the last scan/heal activity

     */
    public static byte SMB2_READFLAG_READ_UNBUFFERED = 0x1;
    /**
     * Channel type for standard read without RDMA
     */
    public static int SMB2_CHANNEL_NONE = 0x0;
    /**
     * Channel type for RDMA version 1
     */
    public static int SMB2_CHANNEL_RDMA_V1 = 0x1;
    /**
     * Channel type for RDMA version 1 with invalidate
     */
    public static int SMB2_CHANNEL_RDMA_V1_INVALIDATE = 0x2;

            out.write(inputStream);
        }
    }

    /**
     * Gets the type identifier for this dictionary file.
     *
     * @return the dictionary type
     */
    public abstract String getType();

    /**
     * Retrieves a paginated list of dictionary items.
     *

     * Encodes an NDR referent pointer.
     *
     * @param obj the object to encode as a referent
     * @param type the referent type
     */
    public void enc_ndr_referent(final Object obj, final int type) {
        if (obj == null) {
            enc_ndr_long(0);
            return;
        }
        switch (type) {
        case 1: /* unique */
        case 3: /* ref */
            enc_ndr_long(System.identityHashCode(obj));

n]");return e.each(function(){var e=a(this);if(e.is("[type=radio]")){var f=d.find('[type=radio][name="'+e.attr("name")+'"]');f.bind("blur.validation",function(){e.validateInputOnBlur(b,c,!0,"blur")}),c.validateCheckboxRadioOnClick&&f.bind("click.validation",function(){e.validateInputOnBlur(b,c,!0,"click")})}}),e.bind("blur.validation",function(){a(this).validateInputOnBlur(b,c,!0,"blur")}),c.validateCheckboxRadioOnClick&&this.find("input[type=checkbox][data-validation],input[type=radio][data-val...

      return DummyProxy.this;
    }

    @Override
    public String toString() {
      return "Dummy proxy for " + interfaceType;
    }

    // Since type variables aren't serializable, reduce the type down to raw type before
    // serialization.
        private Object writeReplace() {
      return new DummyHandler(TypeToken.of(interfaceType.getRawType()));
    }
  }

import (
	"context"
	"time"
)

type rebalPoolProgress struct {
	NumObjects  uint64        `json:"objects"`
	NumVersions uint64        `json:"versions"`
	Bytes       uint64        `json:"bytes"`
	Bucket      string        `json:"bucket"`
	Object      string        `json:"object"`
	Elapsed     time.Duration `json:"elapsed"`
	ETA         time.Duration `json:"eta"`
}

type rebalancePoolStatus struct {