if (userFriendly.matches("(?i)(?:American|English|ASCII)")) {
          // 1-byte UTF-8 sequences - "American" ASCII text
          return 0x80;
        } else if (userFriendly.matches("(?i)(?:French|Latin|Western.*European)")) {
          // Mostly 1-byte UTF-8 sequences, mixed with occasional 2-byte
          // sequences - "Western European" text
          return 0x90;

    }

    @Test
    @DisplayName("byte[] ctor: top-level non-SEQUENCE triggers PACDecodingException (type mismatch)")
    void byteArrayConstructor_topLevelNotSequence_throws() throws Exception {
        // Arrange: Encoded INTEGER instead of SEQUENCE
        byte[] notASequence = new ASN1Integer(42).getEncoded();

        // Act + Assert

Set<String> caseInsensitiveSet = new CaseInsensitiveSet<>();

// Java 21 Sequenced Collections support
SequencedCollection<String> sequenced = CollectionsUtil.newLinkedHashSet();
String first = CollectionsUtil.getFirst(sequenced);
String last = CollectionsUtil.getLast(sequenced);
SequencedCollection<String> reversed = CollectionsUtil.reversed(sequenced);

// Specialized collections

        // Test failed casting from sequence
        ASN1EncodableVector vector = new ASN1EncodableVector();
        vector.add(new ASN1Integer(10));
        ASN1Sequence sequence = new DERSequence(vector);
        assertThrows(PACDecodingException.class, () -> {
            ASN1Util.as(ASN1Boolean.class, sequence, 0);
        }, "Should throw PACDecodingException for incompatible types in sequence");
    }

        int index = offset;
        update(data, index, SmbConstants.SIGNATURE_OFFSET);
        index += SmbConstants.SIGNATURE_OFFSET;
        final byte[] sequence = new byte[8];
        SMBUtil.writeInt4(msg.getSignSeq(), sequence, 0);
        update(sequence, 0, sequence.length);
        index += 8;
        if (msg.getCommand() == ServerMessageBlock.SMB_COM_READ_ANDX) {
            /*

        }

        ASN1Sequence sequence;
        try {
            try (ASN1InputStream stream = new ASN1InputStream(new ByteArrayInputStream(token))) {
                sequence = ASN1Util.as(ASN1Sequence.class, stream);
            }
        } catch (IOException e) {
            throw new PACDecodingException("Malformed Kerberos Ticket", e);
        }
        return sequence;
    }

    /**

     * @param sequence the DLSequence
     * @param index the element index
     * @return sequence element cast to type
     * @throws PACDecodingException if types are incompatible
     */
    public static <T extends ASN1Primitive> T as(final Class<T> type, final DLSequence sequence, final int index)
            throws PACDecodingException {
        return as(type, sequence, index);
    }

    /**

        this.registrationId = registrationId;
    }

    /**
     * Gets the sequence number.
     *
     * @return the sequence number
     */
    public long getSequenceNumber() {
        return sequenceNumber;
    }

    /**
     * Sets the sequence number.
     *
     * @param sequenceNumber the sequence number
     */
    public void setSequenceNumber(long sequenceNumber) {

        return returnCode == 0;
    }

    /**
     * Gets the sequence number.
     *
     * @return the sequence number
     */
    public long getSequenceNumber() {
        return sequenceNumber;
    }

    /**
     * Sets the sequence number.
     *
     * @param sequenceNumber the sequence number
     */
    public void setSequenceNumber(long sequenceNumber) {

            }
            ASN1Sequence sequence = ASN1Sequence.getInstance(tagged, true);
            final Enumeration<ASN1Object> fields = sequence.getObjects();
            while (fields.hasMoreElements()) {
                tagged = (ASN1TaggedObject) fields.nextElement();
                switch (tagged.getTagNo()) {
                case 0:
                    sequence = ASN1Sequence.getInstance(tagged, true);