}

  private final class SubList extends ImmutableList<E> {
    final transient int offset;
    final transient int length;

    SubList(int offset, int length) {
      this.offset = offset;
      this.length = length;
    }

    @Override
    public int size() {
      return length;
    }

    @Override
    @Nullable Object @Nullable [] internalArray() {

        // Verify size
        assertEquals(24 + 2 * manyDialects.length, encodedLength);

        // Verify dialect count
        assertEquals(manyDialects.length, SMBUtil.readInt2(buffer, 22));

        // Verify all dialects
        for (int i = 0; i < manyDialects.length; i++) {
            assertEquals(manyDialects[i], SMBUtil.readInt2(buffer, 24 + i * 2));
        }
    }

    @Override
    public boolean isRoot() {
        // length == 0 should not happen
        return getShare() == null && getUNCPath().length() <= 1;
    }

    boolean isRootOrShare() {
        // length == 0 should not happen
        return getUNCPath().length() <= 1;
    }

    /**
     * @throws MalformedURLException
     *
     */
    private synchronized void canonicalizePath() {

        byte[] derived = new byte[length];

        // Combine inputs
        byte[] labelBytes = label.getBytes(java.nio.charset.StandardCharsets.UTF_8);
        byte[] input = new byte[baseKey.length + labelBytes.length + (context != null ? context.length : 0)];

        int pos = 0;
        System.arraycopy(baseKey, 0, input, pos, baseKey.length);
        pos += baseKey.length;

        if (resourceBundle == null) {
            return null;
        }

        final int length = messageCode.length();
        if (length > CODE_NUMBER_LENGTH) {
            final String key = messageCode.charAt(0) + messageCode.substring(length - CODE_NUMBER_LENGTH);
            final String pattern = ResourceBundleUtil.getString(resourceBundle, key);
            if (pattern != null) {

        int i;

        if (len > pipe_buf.length - used) {
            byte[] tmp;
            int new_size = pipe_buf.length * 2;

            if (len > new_size - used) {
                new_size = len + used;
            }
            tmp = pipe_buf;
            pipe_buf = new byte[new_size];
            i = tmp.length - beg_idx;
            if (used > i) { /* 2 chunks */

        assertThat(args.length, is(1));
        assertThat(args[0].getRawClass(), is(sameClass(Integer.class)));

        desc = ParameterizedClassDescFactory.createParameterizedClassDesc(method, 1, map);
        assertThat(desc.getRawClass(), is(sameClass(Map.class)));
        args = desc.getArguments();
        assertThat(args.length, is(2));

    @Override
    public Entry<K, V>[] createArray(int length) {
      return generator.createArray(length);
    }

    @Override
    public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
      return generator.order(insertionOrder);
    }

    @SuppressWarnings("unchecked")
    @Override
    public K[] createKeyArray(int length) {
      return (K[]) new Object[length];
    }

    @SuppressWarnings("unchecked")

    public static String encode(final byte[] bytes) {
        int length = bytes.length;
        if (length == 0) {
            return "";
        }
        final StringBuilder buffer = new StringBuilder((int) Math.ceil(length / 3d) * 4);
        final int remainder = length % 3;
        length -= remainder;
        int block;
        int i = 0;
        while (i < length) {

     * @param length the number of bytes to dump from the source array
     */

    public static void hexdump(final PrintStream ps, final byte[] src, final int srcIndex, final int length) {
        if (length == 0) {
            return;
        }

        final int s = length % 16;
        final int r = s == 0 ? length / 16 : length / 16 + 1;
        final char[] c = new char[r * (74 + NL_LENGTH)];