Builder<E> combine(Builder<E> other) {
      addAll(other.contents, other.size);
      return this;
    }

    /**
     * Returns a newly-created {@code ImmutableList} based on the contents of the {@code Builder}.
     */
    @Override
    public ImmutableList<E> build() {
      forceCopy = true;
      return asImmutableList(contents, size);
    }

    /**

    }

    private void ensureRoomFor(int newElements) {
      @Nullable Object[] contents = this.contents;
      int newCapacity = expandedCapacity(contents.length, size + newElements);
      // expandedCapacity handles the overflow case
      if (contents.length < newCapacity || copyOnWrite) {
        this.contents = Arrays.copyOf(contents, newCapacity);
        copyOnWrite = false;
      }
    }

    /**

t.Errorf("PublicKeySize65 constant incorrect") } if PublicKeySize87 != pubKeySize(params87) { t.Errorf("PublicKeySize87 constant incorrect") } if SignatureSize44 != sigSize(params44) { t.Errorf("SignatureSize44 constant incorrect") } if SignatureSize65 != sigSize(params65) { t.Errorf("SignatureSize65 constant incorrect") } if SignatureSize87 != sigSize(params87) { t.Errorf("SignatureSize87 constant incorrect") } } func TestPower2Round(t *testing.T) { t.Parallel() for x := range uint32(q) { rr, _ := fieldToMontgomery(x)...

  }

  @SuppressWarnings("unchecked")
  private static <N> GraphConnections<N, Presence> connectionsOf(Graph<N> graph, N node) {
    Function<N, Presence> edgeValueFn =
        (Function<N, Presence>) Functions.constant(Presence.EDGE_EXISTS);
    return graph.isDirected()
        ? DirectedGraphConnections.ofImmutable(node, graph.incidentEdges(node), edgeValueFn)
        : UndirectedGraphConnections.ofImmutable(

  long[] xLongs;
  long[] yLongs;

  int[] constant;

  private static final long NONNEGATIVE_LONG_MASK = 0x7FFFFFFFFFFFFFFFL;

  @BeforeExperiment
  void setUp() {
    Random random = new Random(randomSeed);
    xInts = new int[SAMPLE_SIZE];
    yInts = new int[SAMPLE_SIZE];
    xLongs = new long[SAMPLE_SIZE];
    yLongs = new long[SAMPLE_SIZE];
    constant = new int[SAMPLE_SIZE];

  }

  static final class ConstantWeigher implements Weigher<Object, Object> {
    private final int constant;

    ConstantWeigher(int constant) {
      this.constant = constant;
    }

    @Override
    public int weigh(Object key, Object value) {
      return constant;
    }
  }

  static final class IntKeyWeigher implements Weigher<Integer, Object> {
    @Override

}

// IsARMCMP reports whether the op (as defined by an arm.A* constant) is
// one of the comparison instructions that require special handling.
func IsARMCMP(op obj.As) bool {
	switch op {
	case arm.ACMN, arm.ACMP, arm.ATEQ, arm.ATST:
		return true
	}
	return false
}

// IsARMSTREX reports whether the op (as defined by an arm.A* constant) is
// one of the STREX-like instructions that require special handling.

        checkNotNull(columnKey, "columnKey"),
        checkNotNull(value, "value"));
  }

  /**
   * A builder for creating immutable table instances, especially {@code public static final} tables
   * ("constant tables"). Example:
   *
   * {@snippet :
   * static final ImmutableTable<Integer, Character, String> SPREADSHEET =
   *     new ImmutableTable.Builder<Integer, Character, String>()
   *         .put(1, 'A', "foo")

TEXT errors(SB),$0
	VSHUF4IV	$16, V1, V2	// ERROR "operand out of range 0 to 15"
	XVSHUF4IV	$16, X1, X2	// ERROR "operand out of range 0 to 15"
	ADDV16		$1, R4, R5	// ERROR "the constant must be a multiple of 65536."
	ADDV16		$65535, R4, R5	// ERROR "the constant must be a multiple of 65536."
	SC		R4, 1(R5)	// ERROR "offset must be a multiple of 4."
	SCV		R4, 1(R5)	// ERROR "offset must be a multiple of 4."

import java.util.List;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;
import org.jspecify.annotations.Nullable;

/**
 * A double-ended priority queue, which provides constant-time access to both its least element and
 * its greatest element, as determined by the queue's specified comparator. If no comparator is
 * given at creation time, the natural order of elements is used. If no maximum size is given at