StringBuilder reply = new StringBuilder()

        reply.append("Configuration of type: ").append(container.getTypeDisplayName())
        Collection<? extends Configuration> configs = container.getAll()
        configs.each { Configuration c ->
            reply.append("\n  ").append(c.toString())
        }

        return reply.toString()
    }

    void killDaemonOnly() {
        new ProcessFixture(context.pid).kill(false)
    }

    @Override
    String toString() {
        "Daemon with context $context"
    }

    @Override
    String getLog() {
        return daemonLog.text
    }

    @Override
    File getLogFile() {
        return daemonLog.file
    }

            import ${Property.name}
            import ${Internal.name}

            interface Params {
                @Internal
                Property<Boolean> getFlag()
            }
        """
        pluginDir.file("src/main/groovy/SomeTask.groovy") << """
            import ${DefaultTask.name}
            import ${TaskAction.name}
            import ${Nested.name}

			s.Prog(wasm.AI32WrapI64)
		}
		return
	}

	reg := v.Reg()
	getReg(s, reg)
	if reg != wasm.REG_SP {
		s.Prog(wasm.AI32WrapI64)
	}
}

func getValue64(s *ssagen.State, v *ssa.Value) {
	if v.OnWasmStack {
		s.OnWasmStackSkipped--
		ssaGenValueOnStack(s, v, true)
		return
	}

	reg := v.Reg()
	getReg(s, reg)
	if reg == wasm.REG_SP {
		s.Prog(wasm.AI64ExtendI32U)
	}
}

        this.idGenerator = idGenerator;
        this.daemonRegistry = daemonRegistry;
    }

    public void notifyDaemonsAboutChangedPaths(List<String> changedPaths) {
        for (DaemonInfo daemonInfo : daemonRegistry.getAll()) {
            DaemonStateControl.State state = daemonInfo.getState();
            if (state == Idle || state == Busy || state == Canceled) {
                DaemonClientConnection connection = connector.maybeConnect(daemonInfo);

    }

    public String getDisplayName() {
        return displayName;
    }

    @Override
    public String toString() {
        return displayName;
    }

    public static List<Identifier> getAll() {
        return Arrays.asList(getPunctuation(), getNonAscii(), getFileSystemReserved(), getXmlMarkup(), getWhiteSpace());
    }

    public static Identifier getPunctuation() {

org.slf4j.Logger slf4jLogger = org.slf4j.LoggerFactory.getLogger('some-logger')
slf4jLogger.info('An info log message logged using SLF4j')
// END SNIPPET use-slf4j

org.apache.commons.logging.Log jclLogger = org.apache.commons.logging.LogFactory.getLog('some-logger')
jclLogger.info('An info log message logged using JCL')

org.apache.log4j.Logger log4jLogger = org.apache.log4j.Logger.getLogger('some-logger')
log4jLogger.info('An info log message logged using Log4j')

  if (!platform_name.empty()) {
    device_name = absl::StrCat("/device:", platform_name, ":0");
  }
  FunctionLibraryRuntime* flr = pflr->GetFLR(device_name);
  if (flr == nullptr) {
    // Use CPU as the fallback to get the `FunctionLibraryRuntime`.
    flr = pflr->GetFLR("/device:CPU:0");
  }

  TF_ASSIGN_OR_RETURN(
      std::vector<XlaCompiler::Argument> args,

                // Check that given daemon still exists in registry - a daemon registry could be removed and recreated between checks
                List<Long> allDaemonPids = Lists.transform(daemon.getDaemonRegistry().getAll(), new Function<DaemonInfo, Long>() {
                    @Override
                    public Long apply(DaemonInfo info) {
                        return info.getPid();
                    }
                });

  // can backtracked to. Such results will be called "function passthrough". If
  // the result cannot be backtracked to a region argument, returns
  // std::nullopt.
  std::optional<int> GetArg(int result_index) const {
    if (auto arg = mlir::dyn_cast<BlockArgument>(GetValue(result_index)))
      if (arg.getParentBlock() == &region_->front()) return arg.getArgNumber();
    return std::nullopt;
  }

 private: