}

    @Override
    public @Nullable E lower(@ParametricNullness E e) {
      return Iterators.find(unfiltered().headSet(e, false).descendingIterator(), predicate, null);
    }

    @Override
    public @Nullable E floor(@ParametricNullness E e) {
      return Iterators.find(unfiltered().headSet(e, true).descendingIterator(), predicate, null);
    }

    @Override

        NdrShort ns = new NdrShort(0xABCD); // value & 0xFF => 0xCD
        buf.reset();
        int startIndex = buf.getIndex();
        ns.encode(buf);

        // Find where the actual data starts (after alignment)
        int alignmentBytes = 0;
        if (startIndex % 2 != 0) {
            alignmentBytes = 1; // Need 1 byte of padding for 2-byte alignment
        }

                                // third time...)
                                if (resetArtifact.getVersion() == null && resetArtifact.getVersionRange() != null) {

                                    // go find the version. This is a total hack. See previous comment.
                                    List<ArtifactVersion> versions = resetArtifact.getAvailableVersions();
                                    if (versions == null) {

      if (foundTrustedCertificate) {
        return result
      }

      // The last link isn't trusted. Fail.
      throw SSLPeerUnverifiedException(
        "Failed to find a trusted cert that signed $toVerify",
      )
    }

    throw SSLPeerUnverifiedException("Certificate chain too long: $result")
  }

  /**

  ) {
    logEvent(ConnectionEvent.ConnectionAcquired(System.nanoTime(), connection, call))
  }

  override fun connectionReleased(
    connection: Connection,
    call: Call,
  ) {
    if (eventSequence.find { it is ConnectionEvent.ConnectStart && it.connection == connection } != null && connection is RealConnection) {
      if (connection.noNewExchanges) {
        assertThat(eventSequence).matchesPredicate { deque ->

    }

    public boolean isActive() {
        return active;
    }

    public void enable() {
        active = true;

        // TODO if it was null, we really need to go find them now... or is this taken care of by the ordering?
        if (children != null) {
            for (ResolutionNode node : children) {
                node.enable();
            }
        }
    }

 */

package jcifs.internal.smb1.trans2;

import jcifs.Configuration;
import jcifs.internal.smb1.trans.SmbComTransaction;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;

/**
 * SMB1 Trans2 Find First 2 transaction request implementation.
 * Initiates directory enumeration operations in SMB1 protocol, allowing clients
 * to search for files and directories matching specified patterns and criteria.
 *
 * @author mbechler

                    if (handler != null) {
                        break;
                    }
                }
            }
            if (handler == null) {
                throw new IOException("Unable to find default handler for protocol: " + protocol);
            }
            PROTOCOL_HANDLERS.put(protocol, handler);
            return handler;
        }
    }

                    workingDir = "%teamcity.build.checkoutDir%/dogfood-first-for-hash"
                    scriptContent =
                        """
                        set -x
                        MD5=`find . -type f | sort | xargs md5sum | md5sum | awk '{ print $1 }'`
                        echo "##teamcity[setParameter name='env.ORG_GRADLE_PROJECT_versionQualifier' value='gradleception-${'$'}MD5']"

          Comparator<? super E> comparator = spliterator.getComparator();
          if (comparator == null) {
            // A sorted spliterator with no comparator is already using natural order.
            // (We could probably find a way to avoid rawtypes here if we wanted.)
            @SuppressWarnings({"unchecked", "rawtypes"})
            Comparator<? super E> naturalOrder =
                (Comparator<? super E>) Comparator.<Comparable>naturalOrder();