// okay since we have to copy the just-created array anyway.
  public static ImmutableIntArray of(int first, int... rest) {
    checkArgument(
        rest.length <= Integer.MAX_VALUE - 1, "the total number of elements must fit in an int");
    int[] array = new int[rest.length + 1];
    array[0] = first;
    System.arraycopy(rest, 0, array, 1, rest.length);
    return new ImmutableIntArray(array);
  }

        // Then
        // The writeBytesWireFormat writes the structure and calculates padding
        // Base structure: 24 bytes, then pad8 alignment, then token: 5 bytes
        // Total bytes written includes padding for 8-byte alignment
        int expectedBytesWritten = 35;
        assertEquals(expectedBytesWritten, bytesWritten);

        // Verify structure

        statsField.setAccessible(true);
        byte[] parsedStats = (byte[]) statsField.get(response);
        assertEquals(12, parsedStats.length); // 12 bytes total for stats
        // The stats array in NodeStatusResponse contains everything after names
        // MAC is at index 0-5, actual stats at 6-11
        byte[] expectedStats = new byte[12];

            assertEquals(0, SMBUtil.readInt2(buffer, 46)); // ReadChannelInfoLength

            // Buffer byte
            assertEquals(0, buffer[48]); // One byte in buffer must be zero

            // Verify total bytes written
            assertEquals(49, bytesWritten);
        }

        @Test
        @DisplayName("Should write default values correctly")
        void testWriteBytesWireFormatDefaults() {

    }

    @Override
    public String toString() {
      return "BY_TO_STRING";
    }

    private Object readResolve() {
      return INSTANCE;
    }
  }

  // Always equal is a valid total ordering. And it works for any Object.
  private static final class AlwaysEqual extends Ordering<@Nullable Object>
      implements Serializable {
    private static final AlwaysEqual INSTANCE = new AlwaysEqual();

            if (fields != null) {
                requestBuilder.setFetchSource(fields, null);
            }
            return true;
        });
    }

    /**
     * Gets the total number of documents that match the specified query.
     *
     * @param searchEngineClient the search engine client to use for the count
     * @param queryBuilder the query to count documents for

</p>

<p>
<b>Requirement 2</b>:
For a given program execution, the mapping <i>W</i>, when limited to synchronizing operations,
must be explainable by some implicit total order of the synchronizing operations
that is consistent with sequencing and the values read and written by those operations.
</p>

<p>

    return this;
  }

  Equivalence<Object> getValueEquivalence() {
    return MoreObjects.firstNonNull(valueEquivalence, getValueStrength().defaultEquivalence());
  }

  /**
   * Sets the minimum total size for the internal hash tables. For example, if the initial capacity
   * is {@code 60}, and the concurrency level is {@code 8}, then eight segments are created, each

            // Verify data is copied
            assertArrayEquals(data, Arrays.copyOfRange(buffer, headerStart + 48, headerStart + 48 + data.length));

            // Verify total bytes written
            assertEquals(48 + data.length, bytesWritten);
        }

        @Test
        @DisplayName("Should handle empty data in wire format")
        void testWriteBytesWireFormatEmptyData() {

			// Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
			const wasmMinDataAddr = 4096 + 8192;
			if (offset >= wasmMinDataAddr) {
				throw new Error("total length of command line and environment variables exceeds limit");
			}

			this._inst.exports.run(argc, argv);
			if (this.exited) {
				this._resolveExitPromise();
			}
			await this._exitPromise;
		}