if (this.netname != null) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(this.netname);

            }
        }

        @Override
        public void decode(NdrBuffer _src) throws NdrException {
            _src.align(4);
            final int _netnamep = _src.dec_ndr_long();

            if (_netnamep != 0) {
                _src = _src.deferred;

                if (info == null) { /* YOYOYO */
                    info = new DfsEnumStruct();
                }
                info.decode(_src);

            }
            final int _totalentriesp = _src.dec_ndr_long();
            if (_totalentriesp != 0) {
                totalentries.decode(_src);

            }
            retval = _src.dec_ndr_long();
        }
    }

    /**
     * Convert the input string to a code point. Accepts regular decimal numerals, hex strings, and
     * some symbolic names meaningful to humans.
     */
    private static int decode(String userFriendly) {
      try {
        return Integer.decode(userFriendly);
      } catch (NumberFormatException ignored) {
        if (userFriendly.matches("(?i)(?:American|English|ASCII)")) {
          // 1-byte UTF-8 sequences - "American" ASCII text

        SMBUtil.writeInt2(20, buffer, 42); // byteCount

        int length = testBlock.decode(buffer, 0);

        assertTrue(length > 0);
        assertEquals(4, testBlock.wordCount);
        assertNull(testBlock.getAndx());
    }

    @Test
    @DisplayName("Test decode with retain payload")
    void testDecodeWithRetainPayload() throws SMBProtocolDecodingException {

                _src = _src.deferred;
                root_directory.decode(_src);

            }
            if (_object_namep != 0) {
                if (object_name == null) { /* YOYOYO */
                    object_name = new rpc.unicode_string();
                }
                _src = _src.deferred;
                object_name.decode(_src);

            }
            if (_security_quality_of_servicep != 0) {

	// server admin credentials change. This is done to ensure
	// that clients cannot decode the token using the temp
	// secret keys and generate an entirely new claim by essentially
	// hijacking the policies. We need to make sure that this is
	// based on admin credential such that token cannot be decoded
	// on the client side and is treated like an opaque value.
	claims, err := auth.ExtractClaims(token, secret)

        return stream(getRoles()).get(stream -> stream.map(this::decode).toArray(n -> new String[n]));
    }

    @Override
    public String[] getGroupNames() {
        return stream(getGroups()).get(stream -> stream.map(this::decode).toArray(n -> new String[n]));
    }

    private String decode(final String value) {
        return new String(Base64.getDecoder().decode(value), Constants.CHARSET_UTF_8);
    }

    @Override

        int bytesEncoded = originalInfo.encode(buffer, 0);

        // When - Decode
        FileBasicInfo decodedInfo = new FileBasicInfo();
        int bytesDecoded = decodedInfo.decode(buffer, 0, bytesEncoded);

        // Then
        assertEquals(40, bytesEncoded);
        assertEquals(36, bytesDecoded); // decode returns 36, encode returns 40

            }
            _dst.enc_ndr_long(this.access_mask);
        }

        @Override
        public void decode_out(final NdrBuffer _src) throws NdrException {
            this.handle.decode(_src);
            this.retval = _src.dec_ndr_long();
        }
    }

    /**
     * SAMR Connect4 operation for establishing a connection to the SAM database.

            }
            _dst.enc_ndr_long(access_mask);
        }

        @Override
        public void decode_out(final NdrBuffer _src) throws NdrException {
            handle.decode(_src);
            retval = _src.dec_ndr_long();
        }
    }

    /**
     * SAMR Connect4 operation for establishing a connection to the SAM database.