Pattern.MULTILINE + Pattern.DOTALL);
        Matcher matcher = pattern.matcher(source);

        if (matcher.matches()) {
            String uid = matcher.group(1) == null ? null : matcher.group(1).substring("uid=".length());

    }

    @Override
    public Boolean call(Object... args) {
        return true;
    }

    @Override
    public Boolean call(Object arguments) {
        return true;
    }

    public Boolean doCall() {
        return true;
    }

        val firCall = ktCallExpression.getOrBuildFir(analysisSession.firResolveSession)?.unwrapSafeCall() as? FirCall ?: return emptyList()
        val parameter = firCall.findCorrespondingParameter(ktValueArgumentName.asName) ?: return emptyList()
        return listOfNotNull(parameter.buildSymbol(symbolBuilder))
    }

    private fun FirCall.findCorrespondingParameter(name: Name): FirValueParameter? {

// until NetBSD 10.0, check out https://www.netbsd.org/releases/formal-10/NetBSD-10.0.html
// Therefore we use the pipe to wake up the kevent on NetBSD at this point. Get back here
// and switch to EVFILT_USER when we bump up the minimal requirement of NetBSD to 10.0.
// Alternatively, maybe we can use EVFILT_USER on the NetBSD by checking the kernel version
// via uname(3) and fall back to the pipe if the kernel version is older than 10.0.

// rewrite the graph to use pipelining for better device utilization.
std::unique_ptr<OperationPass<ModuleOp>> CreateEmbeddingSequencingPass();

// This is a strictly sequential and formally correct fallback option for the
// embedding pipelining pass intended for debugging during pipelining
// development.
std::unique_ptr<OperationPass<ModuleOp>> CreateEmbeddingPipeliningPass();

) : Closure<T>(
    trackingProjectAccess(crossProjectModelAccess, referrerProject, delegate.owner),
    trackingProjectAccess(crossProjectModelAccess, referrerProject, delegate.thisObject)
) {
    @Suppress("unused")
    fun doCall(vararg args: Any) {
        val numClosureArgs = delegate.maximumNumberOfParameters

        registryProbe.resetToken()
    }

    @Override
    int getPort() {
        Pattern pattern = Pattern.compile("^.*" + DaemonMessages.ADVERTISING_DAEMON + ".*port:(\\d+).*",
            Pattern.MULTILINE + Pattern.DOTALL);

        Matcher matcher = pattern.matcher(daemonLog.text);
        assert matcher.matches(): "Unable to find daemon address in the daemon log. Daemon: $context"

        try {

	}
	if pos := f.undef[name]; pos != "" {
		panic(fmt.Sprintf("flag %s set at %s before being defined", name, pos))
	}
	if f.formal == nil {
		f.formal = make(map[string]*Flag)
	}
	f.formal[name] = flag
}

// Var defines a flag with the specified name and usage string. The type and
// value of the flag are represented by the first argument, of type [Value], which

        return new BaseMatcher<T>() {
            @Override
            public boolean matches(Object o) {
                return Pattern.compile(pattern, Pattern.DOTALL).matcher((CharSequence) o).matches();
            }

            @Override
            public void describeTo(Description description) {

  let summary = "Rewrite graph for sequential execution of embeddings";
  let constructor = "TFDevice::CreateEmbeddingSequencingPass()";
    let description = [{
    This is a strictly sequential and formally correct fallback option for the
    embedding pipelining pass intended for debugging during pipelining
    development.
  }];
}

def EmbeddingProgramKeyPass : Pass<"tf-embedding-program-key", "mlir::func::FuncOp"> {