func gt_65535_uint32(x uint32) bool      { return x > 65535 }
func ge_65535_uint32(x uint32) bool      { return x >= 65535 }
func eq_65535_uint32(x uint32) bool      { return x == 65535 }
func ne_65535_uint32(x uint32) bool      { return x != 65535 }
func lt_65536_uint32(x uint32) bool      { return x < 65536 }
func le_65536_uint32(x uint32) bool      { return x <= 65536 }

DATA ·IEEEConst+3032(SB)/8,$0x000000006b0980bc

	/* x^66624 mod p(x), x^66560 mod p(x) */
DATA ·IEEEConst+3040(SB)/8,$0x00000001ebd85c88
DATA ·IEEEConst+3048(SB)/8,$0x000000008bbba964

	/* x^65600 mod p(x), x^65536 mod p(x) */
DATA ·IEEEConst+3056(SB)/8,$0x000000019ee20bb2
DATA ·IEEEConst+3064(SB)/8,$0x00000001070a5a1e

	/* x^64576 mod p(x), x^64512 mod p(x) */
DATA ·IEEEConst+3072(SB)/8,$0x00000001acabf2d6

						Namespace: "ns",
						Name:      "n",
						Path:      strPtr("https://apis/foo.bar"),
						Port:      65536,
					},
				},
				SideEffects: &unknownSideEffect,
			},
			}, true),
		expectedError: `Invalid value: 65536: port is not valid: must be between 1 and 65535, inclusive`,
	}, {
		name: "timeout seconds cannot be greater than 30",

			wantFirstID:  65536,
			wantRangeLen: 2147483648,
		},
		{
			name:    "multiple lines",
			input:   "0: kubelet 1 2\n1: kubelet 3 4\n",
			wantErr: true,
		},
		{
			name:    "wrong format",
			input:   "0: kubelet 65536",
			wantErr: true,
		},
		{
			name:    "non numeric 1",
			input:   "0: kubelet Foo 65536",
			wantErr: true,
		},
		{

// (as opposed to a zero value received because the channel is closed).
// Select supports a maximum of 65536 cases.
func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool) {
	if len(cases) > 65536 {
		panic("reflect.Select: too many cases (max 65536)")
	}
	// NOTE: Do not trust that caller is not modifying cases data underfoot.

  @Test
  fun invalidPort() {
    val requestBuilder = Request.Builder()
    assertFailsWith<IllegalArgumentException> {
      requestBuilder.url("http://localhost:65536/")
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Invalid URL port: \"65536\"")
    }
  }

  @Test
  fun getReturns500() {
    server.enqueue(MockResponse(code = 500))
    executeSynchronously("/")
      .assertCode(500)

      --project "${NETWORK_PROJECT}" \
      --network "${NETWORK}" \
      --source-ranges "10.0.0.0/8" \
      --allow "tcp:1-65535,udp:1-65535,icmp" \
      --target-tags "${NODE_TAG}"&
  fi

  if ! gcloud compute firewall-rules describe --project "${NETWORK_PROJECT}" "${NETWORK}-default-ssh" &>/dev/null; then
    gcloud compute firewall-rules create "${NETWORK}-default-ssh" \

				Hosts: []string{"uds.cluster.local"},
				Ports: []*networking.ServicePort{
					{Number: 6553, Protocol: "grpc", Name: "grpc-service1"},
				},
				Resolution: networking.ServiceEntry_STATIC,
				Endpoints: []*networking.WorkloadEntry{
					{Address: "unix:///path/to/socket", Ports: map[string]uint32{"grpc-service1": 6553}},
				},
			},
			valid: false,
		},
		{

						}},
					},
				},
			},
			opts: JobValidationOptions{RequirePrefixedLabels: true},
		},
		`spec.successPolicy.rules[0].succeededIndexes: Too long: must have at most 65536 bytes`: {
			job: batch.Job{
				ObjectMeta: validJobObjectMeta,
				Spec: batch.JobSpec{
					Selector:       validGeneratedSelector,
					CompletionMode: completionModePtr(batch.IndexedCompletion),

// If the tool is not installed, or there are no IDs configured, the default mapping is returned.
// The default mapping includes the entire IDs range except IDs below 65536.
func (kl *Kubelet) getKubeletMappings() (uint32, uint32, error) {
	// default mappings to return if there is no specific configuration
	const defaultFirstID = 1 << 16
	const defaultLen = 1<<32 - defaultFirstID