type T interface{ m[ /* ERROR "must have no type parameters" */ P any]() }

func _(t T) {
	var _ interface{ m[ /* ERROR "must have no type parameters" */ P any](); n() } = t /* ERROR "does not implement" */
}

type S struct{}

func (S) m[ /* ERROR "must have no type parameters" */ P any]() {}

func _(s S) {

					have = append(have, addr.IP.String())
				}
			case *IPAddr:
				if addr.IP.To4() != nil {
					have = append(have, addr.String())
				}
				if addr.IP.To16() != nil && addr.IP.To4() == nil {
					// netsh does not output netmask for ipv6, so ignore ipv6 mask
					have = append(have, addr.IP.String())
				}
			}
		}
		slices.Sort(have)

type FFn[RCT RC[RG], RG any] func() Fn /* ERROR "not enough type arguments for type Fn: have 1, want 2" */ [RCT]

type F[RCT RC[RG], RG any] interface {
	Fn() Fn /* ERROR "not enough type arguments for type Fn: have 1, want 2" */ [RCT]
}

type concreteF[RCT RC[RG], RG any] struct {
	makeFn FFn /* ERROR "not enough type arguments for type FFn: have 1, want 2" */ [RCT]
}

                "tearDownTwo should have been run before tearDownOne", false, tearDownOne.ran);
          }
        };

    final SimpleTearDown tearDownTwo = new SimpleTearDown(callback);
    stack.addTearDown(tearDownTwo);

    assertEquals(false, tearDownOne.ran);
    assertEquals(false, tearDownTwo.ran);

    stack.runTearDown();

    assertEquals("tearDownOne should have run", true, tearDownOne.ran);

* **Uvicorn**:
    * Will have the best performance, as it doesn't have much extra code apart from the server itself.

    * Simple `meshConfig` changes have been approved in the past. Functionality should not be enabled by default.
* For large API changes, 2 members of the TOC must approve the PR before release manager approval in the release branch
  of the istio/api repository. This does not have to wait for the weekly TOC meeting.
    * Risk should be assessed in the PR.
        * Have installs and upgrades affected by this feature?

		}
		// Check for match based on maximized tag.
		for i := range h.haveTags {
			have := h.haveTags[i]
			best.update(have, w, max.ScriptID, max.RegionID, pin)
			if best.conf == Exact {
				for have.nextMax != 0 {
					have = h.haveTags[have.nextMax]
					best.update(have, w, max.ScriptID, max.RegionID, pin)
				}
				return best.have, best.want, best.conf
			}
		}
	}
	if best.conf <= No {
		if len(want) != 0 {

    /**
     * Returns the set of top-level classifier (classes, interfaces, objects, and type-aliases) names in the file.
     *
     * The result may have false-positive entries but cannot have false-negative entries. It should contain all the names in the package but may have some additional names that are not there.
     *
     * @see KaResolveExtensionFile
     */
    public abstract fun getTopLevelClassifierNames(): Set<Name>

       block.
More text.

      Blocks
    can

  have
    blank
      lines.
-- gofmt --
Text.

	A tab-indented
	(no, not eight-space indented)
	code block and haiku.

More text.

	One space
	 is
	  enough
	   to
	    start
	     a
	      block.

More text.

	    Blocks
	  can

	have
	  blank
	    lines.
-- markdown --
Text.

type FFn[RCT RC[RG], RG any] func() Fn[RCT] // ERROR "not enough type arguments for type Fn: have 1, want 2"

type F[RCT RC[RG], RG any] interface {
	Fn() Fn[RCT] // ERROR "not enough type arguments for type Fn: have 1, want 2"
}

type concreteF[RCT RC[RG], RG any] struct {
	makeFn FFn[RCT] // ERROR "not enough type arguments for type FFn: have 1, want 2"
}