E[] array = (E[]) Iterables.toArray(elements);
    checkElementsNotNull(array);
    Arrays.sort(array, comparator);
    return asImmutableList(array);
  }

  private static <E> List<E> nullCheckedList(Object... array) {
    for (int i = 0, len = array.length; i < len; i++) {
      if (array[i] == null) {
        throw new NullPointerException("at index " + i);

					switch {
					case iconst && jconst && iv > jv,
						jconst && kconst && jv > kv,
						iconst && kconst && iv > kv,
						iconst && base == "array" && iv > Cap,
						jconst && base == "array" && jv > Cap,
						kconst && base == "array" && kv > Cap:
						continue
					}

					expr := base + "[" + i + ":" + j + ":" + k + "]"
					var xbase, xlen, xcap int

// license that can be found in the LICENSE file.

// issue 5820: register clobber when clearfat and 64 bit arithmetic is interleaved.

package main

func main() {
	array := make([][]int, 2)
	index := uint64(1)
	array[index] = nil
	if array[1] != nil {
		panic("array[1] != nil")
	}

          "properties": {
            "enabled": {
              "type": "boolean"
            }
          }
        },
        "tolerations": {
          "type": "array"
        },
        "topologySpreadConstraints": {
          "type": "array"
        },
        "networkGateway": {
          "type": "string"
        },
        "imagePullPolicy": {
          "type": "string",
          "enum": [

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// issue 5609: overflow when calculating array size

package pkg

const Large uint64 = 18446744073709551615

  public void testRetainAll_duplicatesKept() {
    E[] array = createSamplesArray();
    array[1] = e0();
    collection = getSubjectGenerator().create(array);
    assertFalse(
        "containsDuplicates.retainAll(superset) should return false",
        collection.retainAll(MinimalCollection.of(createSamplesArray())));
    expectContents(array);
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)

	g := NewWithT(t)

	// Empty array
	g.Expect(IsExportToAllNamespaces(nil)).To(Equal(true))

	// Array with "*"
	g.Expect(IsExportToAllNamespaces([]string{"*"})).To(Equal(true))

	// Array with "."
	g.Expect(IsExportToAllNamespaces([]string{"."})).To(Equal(false))

	// Array with "." & "*"
	g.Expect(IsExportToAllNamespaces([]string{".", "*"})).To(Equal(true))

	// Array with "bogus"

// ReleaseCFArray iterates through an array, releasing its contents, and then
// releases the array itself. This is necessary because we cannot, easily, set the
// CFArrayCallBacks argument when creating CFArrays.
func ReleaseCFArray(array CFRef) {
	for i := 0; i < CFArrayGetCount(array); i++ {
		ref := CFArrayGetValueAtIndex(array, i)
		CFRelease(ref)
	}
	CFRelease(array)

                    <mxGeometry relative="1" as="geometry">
                        <Array as="points">
                            <mxPoint x="800" y="521"/>
                            <mxPoint x="800" y="560"/>
                        </Array>
                        <mxPoint x="803" y="521" as="sourcePoint"/>
                    </mxGeometry>
                </mxCell>

    if (toLessThanMid == midLessThanFrom) {
      // Either array[to] < array[mid] < array[from] or array[from] <= array[mid] <= array[to].
      swap(array, mid, from);
    } else if (toLessThanMid != toLessThanFrom) {
      // Either array[from] <= array[to] < array[mid] or array[mid] <= array[to] < array[from].
      swap(array, from, to);
    }