imports = "java.util.Collections")
  // We can't compatibly make this `final` now.
  @InlineMeValidationDisabled(
      "While binarySearch() is not final, the inlining is still safe as long as any overrides"
          + " follow the contract.")
  @Deprecated
  public int binarySearch(
      List<? extends T> sortedList, @ParametricNullness T key) {

      }
    } catch (NullPointerException | ClassCastException e) {
      return false;
    }
  }

  private int unsafeBinarySearch(Object key) throws ClassCastException {
    return Collections.binarySearch(elements, key, unsafeComparator());
  }

  @Override
  boolean isPartialView() {
    return elements.isPartialView();
  }

  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {

        for (int key = 0; key <= 10; key++) {
          assertModelAgrees(
              LIST_WITHOUT_DUPS,
              key,
              SortedLists.binarySearch(LIST_WITHOUT_DUPS, key, presentBehavior, absentBehavior),
              presentBehavior,
              absentBehavior);
        }
      }
    }
  }

  public void testWithDups() {

      return this;
    }
    int lowerIndex =
        SortedLists.binarySearch(
            ranges,
            Range::upperBound,
            range.lowerBound,
            KeyPresentBehavior.FIRST_AFTER,
            KeyAbsentBehavior.NEXT_HIGHER);
    int upperIndex =
        SortedLists.binarySearch(
            ranges,
            Range::lowerBound,
            range.upperBound,

    // will look like: [foo, bar, com], [bar, com], [com]. The longest matching rule wins.
    var exactMatch: String? = null
    for (i in domainLabelsUtf8Bytes.indices) {
      val rule = publicSuffixList.bytes.binarySearch(domainLabelsUtf8Bytes, i)
      if (rule != null) {
        exactMatch = rule
        break
      }
    }

    // In theory, wildcard rules are not restricted to having the wildcard in the leftmost position.

      fromIndex =
          SortedLists.binarySearch(
              ranges,
              Range::upperBound,
              range.lowerBound,
              KeyPresentBehavior.FIRST_AFTER,
              KeyAbsentBehavior.NEXT_HIGHER);
    } else {
      fromIndex = 0;
    }

    int toIndex;
    if (range.hasUpperBound()) {
      toIndex =
          SortedLists.binarySearch(
              ranges,

      for (int i = 0; i < strictlyOrderedList.size(); i++) {
        assertEquals(i, ordering.binarySearch(strictlyOrderedList, strictlyOrderedList.get(i)));
      }
      List<T> newList = new ArrayList<>(strictlyOrderedList);
      T valueNotInList = newList.remove(1);
      assertEquals(-2, ordering.binarySearch(newList, valueNotInList));
    }

    void testSortedCopy() {

      for (int i = 0; i < strictlyOrderedList.size(); i++) {
        assertEquals(i, ordering.binarySearch(strictlyOrderedList, strictlyOrderedList.get(i)));
      }
      List<T> newList = new ArrayList<>(strictlyOrderedList);
      T valueNotInList = newList.remove(1);
      assertEquals(-2, ordering.binarySearch(newList, valueNotInList));
    }

    void testSortedCopy() {

            }
            // requireNonNull is safe because the first `size` elements have been filled in.
            // We're careful to put only K instances in.
            int index =
                Arrays.binarySearch((K[]) sortedKeys, (K) requireNonNull(keys[i]), comparator);
            sortedValues[index] = requireNonNull(values[i]);
          }
          return new ImmutableSortedMap<K, V>(