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

  // 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);
  }

		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *BatchJobExpire) Msgsize() (s int) {

										LbPolicy: &networking.LoadBalancerSettings_Simple{Simple: networking.LoadBalancerSettings_LEAST_REQUEST},
									},
									Port:             &networking.PortSelector{Number: 8080},
									Tls:              &networking.ClientTLSSettings{Mode: networking.ClientTLSSettings_DISABLE},

    name: String,
    vararg members: DerAdapter<*>,
    decompose: (T) -> List<*>,
    construct: (List<*>) -> T,
  ): BasicDerAdapter<T> {
    val codec =
      object : BasicDerAdapter.Codec<T> {
        override fun decode(reader: DerReader): T {
          return reader.withTypeHint {
            val list = mutableListOf<Any?>()

            while (list.size < members.size) {

	if !ok {
		return nil
	}
	h.Uid = int(sys.Uid)
	h.Gid = int(sys.Gid)
	if doNameLookups {
		// Best effort at populating Uname and Gname.
		// The os/user functions may fail for any number of reasons
		// (not implemented on that platform, cgo not enabled, etc).
		if u, ok := userMap.Load(h.Uid); ok {
			h.Uname = u.(string)
		} else if u, err := user.LookupId(strconv.Itoa(h.Uid)); err == nil {

  encodedValues: List<String>,
) : RequestBody() {
  private val encodedNames: List<String> = encodedNames.toImmutableList()
  private val encodedValues: List<String> = encodedValues.toImmutableList()

  /** The number of key-value pairs in this form-encoded body. */
  @get:JvmName("size")
  val size: Int
    get() = encodedNames.size

  @JvmName("-deprecated_size")
  @Deprecated(
    message = "moved to val",

</p>

<p>
This rule generalizes the previous rule to buffered channels.
It allows a counting semaphore to be modeled by a buffered channel:
the number of items in the channel corresponds to the number of active uses,
the capacity of the channel corresponds to the maximum number of simultaneous uses,
sending an item acquires the semaphore, and receiving an item releases
the semaphore.
This is a common idiom for limiting concurrency.

    /** The key of the message: Employee Number */
    public static final String LABELS_user_employeeNumber = "{labels.user_employeeNumber}";

    /** The key of the message: Employee Number */
    public static final String LABELS_EMPLOYEE_NUMBER = "{labels.employeeNumber}";

    /** The key of the message: Telephone Number */

  /**
   * @param input the size of the input source
   * @param offset the first argument to {@link ByteSource#slice}
   * @param length the second argument to {@link ByteSource#slice}
   * @param expectRead the number of bytes we expect to read
   */
  private static void assertCorrectSlice(int input, int offset, long length, int expectRead)
      throws IOException {