// Operand 1 is a symbol name in the form foo(SB).
	nameAddr := p.address(operands[1])
	if !p.validSymbol("FUNCDATA", &nameAddr, true) {
		return
	}

	prog := &obj.Prog{
		Ctxt: p.ctxt,
		As:   obj.AFUNCDATA,
		Pos:  p.pos(),
		From: valueAddr,
		To:   nameAddr,
	}
	p.append(prog, "", true)
}

// asmJump assembles a jump instruction.
// JMP	R1
// JMP	exit
// JMP	3(PC)

    node: light
    properties: []
    builders:
      - shell: |
          #!/usr/local/bin/runbld --job-name elastic+elasticsearch+%BRANCH%+git+push

    /**
     * Test SearchResult with partial results flag.
     */
    @Test
    public void test_searchResultWithPartialResults() {
        final SearchResult result = SearchResult.create().allRecordCount(1000).partialResults(true).build();

        assertTrue(result.isPartialResults());
    }

    /**
     * Test SearchResult with facet response.
     */
    @Test
    public void test_searchResultWithFacetResponse() {

import java.time.Year

plugins {
    id("gradlebuild.module-identity")
    id("gradlebuild.publish-defaults")
    id("java-library")
    id("signing")
    `maven-publish`
}

gradleModule {
    published = true
}

configureJavadocVariant()

publishing {
    publications {
        create<MavenPublication>("gradleDistribution") {
            configureGradleModulePublication()
        }
    }

  private enum EqualsImplementation {
    ANDING_BOOLEANS {
      @Override
      boolean doEquals(byte[] a, byte[] b) {
        if (a.length != b.length) {
          return false;
        }
        boolean areEqual = true;
        for (int i = 0; i < a.length; i++) {
          areEqual &= a[i] == b[i];
        }
        return areEqual;
      }
    },
    XORING_TO_BYTE {
      @Override

    for (int trial = 0; trial < NUM_TRIALS; ++trial) {
      MutableNetwork<Integer, Object> network =
          networkBuilder.allowsParallelEdges(true).allowsSelfLoops(true).build();

      assertThat(network.nodes()).isEmpty();
      assertThat(network.edges()).isEmpty();
      AbstractNetworkTest.validateNetwork(network);

      while (network.nodes().size() < NUM_NODES) {

  }

  @Throws(IOException::class)
  @JvmOverloads
  fun start(port: Int = 0) {
    started = true
    delegate.start(port)
  }

  @Throws(IOException::class)
  fun start(
    inetAddress: InetAddress,
    port: Int,
  ) {
    started = true
    delegate.start(inetAddress, port)
  }

  @Synchronized
  @Throws(IOException::class)
  fun shutdown() {

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ImmutableEnumSet) {
      object = ((ImmutableEnumSet<?>) object).delegate;
    }
    return delegate.equals(object);
  }

  @Override
  boolean isHashCodeFast() {
    return true;
  }

  @LazyInit private transient int hashCode;

  @Override

    return new MinimalCollection<>(Object.class, true, contents);
  }

  // TODO: use this
  public static <E extends @Nullable Object> MinimalCollection<E> ofClassAndContents(
      Class<? super @NonNull E> type, E... contents) {
    return new MinimalCollection<>(type, true, contents);
  }

  private final E[] contents;
  private final Class<? super @NonNull E> type;

 *
 * @author Osvaldo Doederlein
 */
@NullUnmarked
public class ToStringHelperBenchmark {

  @Param({"0", "1", "5"})
  int dataSize;

  @Param({"false", "true"})
  boolean omitNulls;

  enum Dataset {
    SMALL {
      @Override
      void addEntries(MoreObjects.ToStringHelper helper) {
        helper
            .add(SHORT_NAME, 10)
            .addValue(10L)