// use of an OpInvalid value.

package p

type T struct {
	num int64
}

func foo(vs map[T]struct{}, d T) error {
	_, ok := vs[d]
	if !ok {
		return nil
	}

	switch d.num {
	case 0:
	case 1:
	case 2:
	case 3:
	case 4:
	case 5:
	case 6:
		var num float64
		if num != 0 {
			return nil
		}
	}

	return nil

  public void testIn_compilesWithExplicitSupertype() {
    Collection<Number> nums = ImmutableSet.of();
    Predicate<Number> p1 = Predicates.in(nums);
    Predicate<Object> p2 = Predicates.<Object>in(nums);
    // The next two lines are not expected to compile.
    // Predicate<Integer> p3 = Predicates.in(nums);
    // Predicate<Integer> p4 = Predicates.<Integer>in(nums);
  }

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester

        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        if (num == null) {
            num = fessConfig.getPagingSearchPageSizeAsInteger();
        } else {
            try {
                if (num.intValue() > fessConfig.getPagingSearchPageMaxSizeAsInteger().intValue() || num.intValue() <= 0) {
                    num = fessConfig.getPagingSearchPageMaxSizeAsInteger();
                }

		name            string
		generateFunc    func(num int) (list runtime.Object)
		expectObjectNum int
	}{
		{
			name: "StructReceiverList",
			generateFunc: func(num int) (list runtime.Object) {
				return fakeFooList(num)
			},
			expectObjectNum: fakeObjectItemsNum,
		},
		{
			name: "PointerReceiverList",
			generateFunc: func(num int) (list runtime.Object) {
				return fakeSampleList(num)
			},

	for i := 0; i < num; i++ {
		withNoEscape()
	}

	runtime.ReadMemStats(&stats)
	nowHeapObjects := stats.HeapObjects

	if nowHeapObjects-preHeapObjects >= num {
		fmt.Printf("too many heap objects allocated, pre: %v, now: %v\n", preHeapObjects, nowHeapObjects)
	}

	runtime.ReadMemStats(&stats)
	preHeapObjects = stats.HeapObjects

	for i := 0; i < num; i++ {
		withoutNoEscape()
	}

	_ [0]func() // disallow ==
	// num holds the value for Kinds Int64, Uint64, Float64, Bool and Duration,
	// the string length for KindString, and nanoseconds since the epoch for KindTime.
	num uint64
	// If any is of type Kind, then the value is in num as described above.
	// If any is of type *time.Location, then the Kind is Time and time.Time value
	// can be constructed from the Unix nanos in num and the location (monotonic time

		buf.WriteByte('\n')
	}
	s.bullet = b.Bullet
	s.num = b.Start
	for i, item := range b.Items {
		if i > 0 && b.Loose {
			buf.WriteByte('\n')
		}
		item.printMarkdown(buf, s)
		s.num++
	}
}

func (b *Item) printMarkdown(buf *bytes.Buffer, s mdState) {
	var marker string
	if s.bullet == '.' || s.bullet == ')' {
		marker = fmt.Sprintf("%d%c ", s.num, s.bullet)
	} else {
		marker = fmt.Sprintf("%c ", s.bullet)

  public void testIn_compilesWithExplicitSupertype() {
    Collection<Number> nums = ImmutableSet.of();
    Predicate<Number> p1 = Predicates.in(nums);
    Predicate<Object> p2 = Predicates.<Object>in(nums);
    // The next two lines are not expected to compile.
    // Predicate<Integer> p3 = Predicates.in(nums);
    // Predicate<Integer> p4 = Predicates.<Integer>in(nums);
  }

  @J2ktIncompatible
  @GwtIncompatible // NullPointerTester

	// See https://go.dev/issue/4556 and https://go.dev/issue/54580.
	num2 := func(b []byte) byte { return 10*(b[0]-'0') + (b[1] - '0') }
	switch {
	case b[n0+len("9999")] != '-': // year must be exactly 4 digits wide
		return b, errors.New("year outside of range [0,9999]")
	case b[len(b)-1] != 'Z':
		c := b[len(b)-len("Z07:00")]
		if ('0' <= c && c <= '9') || num2(b[len(b)-len("07:00"):]) >= 24 {

        }

        allowFileSystemAccess(true)
        read(dir)
        def executorService = Executors.newFixedThreadPool(100)

        when:
        (1..1000).each { num ->
            executorService.submit({
                def locationToUpdate = dir.file(num).file("in-dir.txt")
                fileSystemAccess.write([locationToUpdate.absolutePath]) {
                    locationToUpdate.text = "updated"
                }
            })