return e;
          }
        }
      }

      return null;
    }

    @Nullable E getLiveEntry(Object key, int hash) {
      return getEntry(key, hash);
    }

    @Nullable V get(Object key, int hash) {
      try {
        E e = getLiveEntry(key, hash);
        if (e == null) {
          return null;
        }

            return StringUtil.EMPTY;
        }
        if (StringUtil.isEmpty(pi.getPath())) {
            return pi.getName();
        }
        return pi.getPath() + "/" + pi.getName();
    }

    /**
     * Converts an encoded ID to a PathInfo object containing path and name.
     *
     * @param id the encoded ID to convert
     * @return PathInfo object with separated path and name

        /**
         * Gets the IP address.
         *
         * @return the IP address
         */
        public InetAddress getAddress() {
            return address;
        }

        /**
         * Gets the address flags.
         *
         * @return the flags
         */
        public int getFlags() {
            return flags;
        }

        /**

   */
  protected V get(K key) {
    return getMap().get(key);
  }

  protected final K k0() {
    return e0().getKey();
  }

  protected final V v0() {
    return e0().getValue();
  }

  protected final K k1() {
    return e1().getKey();
  }

  protected final V v1() {
    return e1().getValue();
  }

  protected final K k2() {

     *
     * @see org.codelibs.fess.crawler.entity.AccessResult#getUrl()
     */
    @Override
    public String getUrl() {
        return url;
    }

    /*
     * (non-Javadoc)
     *
     * @see org.codelibs.fess.crawler.entity.AccessResult#setUrl(java.lang.String)
     */
    @Override
    public void setUrl(final String url) {
        this.url = url;
    }

    /*

                return false;
            }
        } else if (!first.equals(other.first)) {
            return false;
        }
        if (second == null) {
            if (other.second != null) {
                return false;
            }
        } else if (!second.equals(other.second)) {
            return false;
        }
        return true;
    }

			ok = true
		}
	}
	if ok {
		return z.rebalMeta.save(ctx, z.serverPools[0])
	}

	return nil
}

func (z *erasureServerPools) findIndex(index int) int {
	if z.rebalMeta == nil {
		return 0
	}
	for i := range len(z.rebalMeta.PoolStats) {
		if i == index {
			return index
		}
	}
	return -1
}

    checkNotNull(o);
    return UnsignedLongs.compare(value, o.value);
  }

  @Override
  public int hashCode() {
    return Long.hashCode(value);
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    if (obj instanceof UnsignedLong) {
      UnsignedLong other = (UnsignedLong) obj;
      return value == other.value;
    }
    return false;
  }

        fq = filterQueryString;
    }

    /**
     * Returns the query string.
     * @return The query string.
     */
    public String getQueryString() {
        return q;
    }

    /**
     * Returns the filter query string.
     * @return The filter query string.
     */
    public String getFilterQueryString() {
        return fq;
    }

        return getMimeType(extension, "application/octet-stream");
    }

    /**
     * Returns the MIME type for the given file extension with a custom default.
     *
     * @param extension the file extension to look up (without the dot)
     * @param def the default MIME type to return if no mapping is found
     * @return the MIME type for the extension, or the specified default if not found