char c2 = stringPool.charAt(offset + 1 + i);
      if (c1 != c2) {
        return c1 - c2;
      }
    }
    return labelLen - nodeLabelLen;
  }

  /**
   * A CharSequence that is composed of multiple chunks. This is used to work around the 64k size
   * limit for string literals in Java.
   */
  private static class ChunksCharSequence implements CharSequence {

#   your builds. This usually saves a lot of time, especially when
#   re-running tests. However, note that:
#
#    - New environments like new CUDA versions, changes to manylinux,
#      compilers, etc. can cause undefined behavior such as build failures
#      or tests passing incorrectly.
#    - Automatic LLVM updates are known to extend build time even with
#      the cache; this is unavoidable.

            assertFalse(init.getContextFlag(flag));
            assertEquals(0, init.getContextFlags());
        }

        @Test
        @DisplayName("Multiple flags can be combined correctly")
        void testMultipleFlagsCombination() {
            NegTokenInit init = new NegTokenInit();

            // Set multiple flags
            init.setContextFlag(NegTokenInit.DELEGATION, true);

    from jCIFS or another application will fail with the "file is being
    accessed by another process" error. The <code>FILE_SHARE_READ</code>,
    <code>FILE_SHARE_WRITE</code>, and <code>FILE_SHARE_DELETE</code> may be
    combined with the bitwise OR '|' to specify that other peocesses may read,
    write, and/or delete the file while the jCIFS user has the file open.
     *
     * @param url An smb URL representing the file to write to

        if (list.isEmpty()) {
            return Collections.emptyList();
        }

        Pattern pattern = null;
        if (StringUtil.isNotBlank(ignoreFailureType)) {
            pattern = Pattern.compile(ignoreFailureType);
        }
        final List<String> urlList = new ArrayList<>();
        for (final FailureUrl failureUrl : list) {
            if (pattern != null) {

  }

  // 'test' to demonstrate some potentially ambiguous overloads.  This 'test' is kind of strange,
  // but essentially each line will be a call to a Preconditions method that, but for a documented
  // change would be a compiler error.
  // See https://docs.oracle.com/javase/specs/jls/se25/html/jls-15.html#jls-15.12.2 for the spec on
  // how javac selects overloads
  @SuppressWarnings("null")
  public void overloadSelection() {

  }

  // 'test' to demonstrate some potentially ambiguous overloads.  This 'test' is kind of strange,
  // but essentially each line will be a call to a Preconditions method that, but for a documented
  // change would be a compiler error.
  // See https://docs.oracle.com/javase/specs/jls/se25/html/jls-15.html#jls-15.12.2 for the spec on
  // how javac selects overloads
  @SuppressWarnings("null")
  public void overloadSelection() {

    private void privateVarArgsMethod(String... varargs) {}
  }

  private static class SubPrepender extends Prepender {
    @SuppressWarnings("unused") // needed to satisfy compiler, never called
    SubPrepender() throws NullPointerException {
      throw new AssertionError();
    }
  }

#include "tensorflow/c/eager/tfe_context_internal.h"
#include "tensorflow/c/eager/tfe_op_internal.h"
#include "tensorflow/c/eager/tfe_tensorhandle_internal.h"
#include "tensorflow/c/tf_buffer_internal.h"
#include "tensorflow/compiler/jit/flags.h"
#include "tensorflow/core/common_runtime/eager/attr_builder.h"
#include "tensorflow/core/common_runtime/eager/context.h"
#include "tensorflow/core/common_runtime/eager/eager_operation.h"

        if (this.equivalence.equals(that.equivalence)) {
          /*
           * We'll accept that as sufficient "proof" that either equivalence should be able to
           * handle either reference, so it's safe to circumvent compile-time type checking.
           */
          @SuppressWarnings("unchecked")
          Equivalence<Object> equivalence = (Equivalence<Object>) this.equivalence;