functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
                ElevateWordToLabelCQ cf = new ElevateWordToLabelCQ();
                cqLambda.callback(cf);
                list.add(new FilterFunctionBuilder(cf.getQuery(), scoreFunctionBuilder));
            });
        }
        final FunctionScoreQueryBuilder builder = regFunctionScoreQ(cq.getQuery(), list);
        if (opLambda != null) {

import jcifs.ntlmssp.Type2Message;
import jcifs.ntlmssp.Type3Message;
import jcifs.util.Crypto;
import jcifs.util.Hexdump;

/**
 * For initiating NTLM authentication (including NTLMv2). If you want to add NTLMv2 authentication support to something
 * this is what you want to use. See the code for details. Note that JCIFS does not implement the acceptor side of NTLM
 * authentication.
 *
 */

        lenient().doCallRealMethod().when(handle).doReceiveFragment(any(byte[].class));
        lenient().doCallRealMethod().when(handle).close();

        // Add getMaxRecv() to return correct value
        lenient().when(handle.getMaxRecv()).thenReturn(4280);

        return handle;
    }

    @Nested
    @DisplayName("Constructor Tests")

   */
  private static long timeoutSeconds() {
    // This class can make no hard guarantees.  The methods in this class are inherently flaky, but
    // we try hard to make them robust in practice.  We could additionally try to add in a system
    // load timeout multiplier.  Or we could try to use a CPU time bound instead of wall clock time
    // bound.  But these ideas are harder to implement.  We do not try to detect or handle a

          }
          i++;
          buffer |= codePointToFourUtf8Bytes(codePoint) << shift;
          if (supplementaryPlaneFix) { // bug compatibility: earlier versions did not have this add
            shift += 32;
          }
          len += 4;
        }

        if (shift >= 32) {
          int k1 = mixK1((int) buffer);
          h1 = mixH1(h1, k1);
          buffer = buffer >>> 32;

    }
  }

  static void checkExactMatches(CharMatcher m, char[] chars) {
    Set<Character> positive = Sets.newHashSetWithExpectedSize(chars.length);
    for (char c : chars) {
      positive.add(c);
    }
    for (int c = 0; c <= Character.MAX_VALUE; c++) {
      assertFalse(positive.contains(Character.valueOf((char) c)) ^ m.matches((char) c));
    }
  }

    }

    /**
     * {@inheritDoc}
     *
     * @since 10.0
     */
    @Override
    public void addListener(Runnable listener, Executor exec) {
      executionList.add(listener, exec);
    }

    /**
     * Subclasses should invoke this method to set the result of the computation to {@code value}.

                final CreateContextResponse cc = createContext(nameBytes);
                if (cc != null) {
                    cc.decode(buffer, createContextStart + dataOffset, dataLength);
                    contexts.add(cc);
                }

                cci = Math.max(cci, createContextStart + dataOffset + dataLength);

                if (next > 0) {
                    createContextStart += next;
                }

            throw new SmbException("Buffer access out of bounds");
        }
    }

    /**
     * Safely add integers checking for overflow
     *
     * @param a first value
     * @param b second value
     * @return sum
     * @throws SmbException if overflow would occur
     */

        table[tableIndex] = effectiveEntry;
      } else {
        // We already saw this key, and the first value we saw (going backwards) is the one we are
        // keeping. So we won't touch table[], but we do still want to add the existing entry that
        // we found to entries[] so that we will see this key in the right place when iterating.
        if (duplicates == null) {
          duplicates = new IdentityHashMap<>();
        }