* specifies to use <i>n</i> steps, a total of <i>3^n</i> tests are actually performed.
 *
 * <p>For instance, if <i>steps</i> is 5, one example sequence that will be tested is:
 *
 * <ol>
 *   <li>remove();
 *   <li>hasNext()
 *   <li>hasNext();
 *   <li>remove();
 *   <li>next();
 * </ol>
 *

        }

        ASN1Sequence sequence;
        try {
            sequence = ASN1Util.as(ASN1Sequence.class, derToken.getBaseObject());
        } catch (IOException e) {
            throw new PACDecodingException("Malformed kerberos ticket", e);
        }

        Enumeration<?> fields = sequence.getObjects();
        while (fields.hasMoreElements()) {

    if (peek == null) {
      skipCommasAndWhitespace()
      peek = readToken()
      if (peek == null) return
    }

    val schemeName = peek

    // Read a token68, a sequence of parameters, or nothing.
    val commaPrefixed = skipCommasAndWhitespace()
    peek = readToken()
    if (peek == null) {
      if (!exhausted()) return // Expected a token; got something else.

   * SET types.
   *
   * The fields are specified as a list of member adapters. When decoding, a value for each
   * non-optional member but be included in sequence.
   *
   * TODO: for sets, sort by tag when encoding.
   * TODO: for set ofs, sort by encoded value when encoding.
   */
  fun <T> sequence(
    name: String,
    vararg members: DerAdapter<*>,

        try (ASN1InputStream der = new ASN1InputStream(token)) {
            ASN1TaggedObject tagged = (ASN1TaggedObject) der.readObject();
            final ASN1Sequence sequence = ASN1Sequence.getInstance(tagged, true);
            final Enumeration<?> fields = sequence.getObjects();
            while (fields.hasMoreElements()) {
                tagged = (ASN1TaggedObject) fields.nextElement();
                switch (tagged.getTagNo()) {

        final byte[] seqBytes = new byte[4];
        SMBUtil.writeInt4(seqNum, seqBytes, 0);

        final MessageDigest mac = Crypto.getHMACT64(sk);
        mac.update(seqBytes); // sequence
        mac.update(data); // data
        final byte[] dgst = mac.digest();
        byte[] trunc = new byte[8];
        System.arraycopy(dgst, 0, trunc, 0, 8);

        if (log.isDebugEnabled()) {

        i = inc(i);
      }
      return false;
    } finally {
      monitor.leave();
    }
  }

  /**
   * Returns an array containing all of the elements in this queue, in proper sequence.
   *
   * <p>The returned array will be "safe" in that no references to it are maintained by this queue.
   * (In other words, this method must allocate a new array). The caller is thus free to modify the

      if (Character.isISOControl(codePoint) && !Character.isWhitespace(codePoint)) {
        return false
      }
    }
    return true
  } catch (_: EOFException) {
    return false // Truncated UTF-8 sequence.
  }

        /** The high field of the timestamp multiplexed with the version number */
        public short time_hi_and_version;
        /** The high field of the clock sequence multiplexed with the variant */
        public byte clock_seq_hi_and_reserved;
        /** The low field of the clock sequence */
        public byte clock_seq_low;
        /** The spatially unique node identifier */
        public byte[] node;

        @Override

 */
public class EditForm extends CreateForm {

    /** Unique identifier for the search list entry */
    public String id;

    /** Sequence number for ordering search list entries */
    @ValidateTypeFailure
    public Long seqNo;

    /** Primary term value for search list configuration */
    @ValidateTypeFailure
    public Long primaryTerm;