XSMSUBMSP:      "xsmsubmsp",
	XSMULSP:        "xsmulsp",
	XSNMADDASP:     "xsnmaddasp",
	XSNMADDMSP:     "xsnmaddmsp",
	XSNMSUBASP:     "xsnmsubasp",
	XSNMSUBMSP:     "xsnmsubmsp",
	XSRESP:         "xsresp",
	XSRSP:          "xsrsp",
	XSRSQRTESP:     "xsrsqrtesp",
	XSSQRTSP:       "xssqrtsp",
	XSSUBSP:        "xssubsp",
	XXLEQV:         "xxleqv",
	XXLNAND:        "xxlnand",
	XXLORC:         "xxlorc",

        ServerMessageBlock2Response resp = (ServerMessageBlock2Response) response;
        synchronized ( resp ) {
            if ( resp.isAsync() && !resp.isAsyncHandled() && resp.getStatus() == NtStatus.NT_STATUS_PENDING && resp.getAsyncId() != 0 ) {
                resp.setAsyncHandled(true);
                boolean first = !req.isAsync();
                req.setAsyncId(resp.getAsyncId());

                Smb2IoctlResponse resumeResp = sh.send(resumeReq);
                SrvRequestResumeKeyResponse rkresp = resumeResp.getOutputData(SrvRequestResumeKeyResponse.class);
                size = sfd.getInitialSize();
                resumeKey = rkresp.getResumeKey();

                // start with some reasonably safe defaults, the server will till us if it does not like it

			if err != nil {
				return err
			}
			origStateIsCurrent = true
			continue
		}

		if len(txnResp.Responses) == 0 || txnResp.Responses[0].GetResponseDeleteRange() == nil {
			return errors.New(fmt.Sprintf("invalid DeleteRange response: %v", txnResp.Responses))
		}
		deleteResp := txnResp.Responses[0].GetResponseDeleteRange()
		if deleteResp.Header == nil {

	forward(resp)
}

func forwardDeltaToEnvoy(con *ProxyConnection, resp *discovery.DeltaDiscoveryResponse) {
	if !model.IsEnvoyType(resp.TypeUrl) && resp.TypeUrl != model.WorkloadType {
		proxyLog.Errorf("Skipping forwarding type url %s to Envoy as is not a valid Envoy type", resp.TypeUrl)
		return
	}

	if r != h.nilResp {
		h.respPool.Put(r)
	}
}

// NewResponse creates a new response.
// Handlers can use this to create a reusable response.
func (h *StreamTypeHandler[Payload, Req, Resp]) NewResponse() Resp {
	return h.respPool.Get().(Resp)
}

func newStreamHandler[Payload, Req, Resp RoundTripper](h HandlerID) *StreamTypeHandler[Payload, Req, Resp] {

        Trans2GetDfsReferralResponse resp = new Trans2GetDfsReferralResponse();
        ipc.send( new Trans2GetDfsReferral( path ), resp );

        if (resp.numReferrals == 0) {
            return null;
        } else if (rn == 0 || resp.numReferrals < rn) {
            rn = resp.numReferrals;
        }

        DfsReferral dr = new DfsReferral();

		ResourceNamesSubscribe: []string{"outbound|80||test-1.default"},
	})
	resp := ads.ExpectResponse()
	if len(resp.Resources) != 1 || resp.Resources[0].Name != "outbound|80||test-1.default" {
		t.Fatalf("received unexpected eds resource %v", resp.Resources)
	}
	if len(resp.RemovedResources) != 0 {
		t.Fatalf("received unexpected removed eds resource %v", resp.RemovedResources)
	}

	ads.Request(&discovery.DeltaDiscoveryRequest{

type Base struct {
	elem [8]*Elem
}

var g_val = 1

func (s *Base) Do() *int {
	resp := &g_val
	for _, e := range s.elem {
		e.Wait(func() {
			*resp = 0
		})
	}
	return resp
}

type Sub struct {
	*Base
}

func main() {
	a := Sub{new(Base)}
	resp := a.Do()
	if resp != nil && *resp != 1 {
		panic("FAIL")
	}

	s.Add(out) // not inlined.
	return out
}

var s T

func main() {
	println("Starting")
	fmt.Sprint(new(int32))
	resp := F(s).(*P)
	println("Before, *resp.V=", *resp.V) // Trashes *resp.V in process of printing.
	println("After,  *resp.V=", *resp.V)
	if got, want := *resp.V, int32(42); got != want {
		fmt.Printf("FAIL, got %v, want %v", got, want)
	}