System.err.println 'this is stderr'

def slf4jLogger = org.slf4j.LoggerFactory.getLogger('some-logger')
slf4jLogger.warn('A warning using SLF4j')

def jclLogger = org.apache.commons.logging.LogFactory.getLog('some-logger')
jclLogger.warn('A warning using JCL')

def log4jLogger = org.apache.log4j.Logger.getLogger('some-logger')
log4jLogger.warn('A warning using Log4j')

org.apache.maven.plugin; public abstract synchronized class AbstractMojo implements Mojo, ContextEnabled { private logging.Log log; private java.util.Map pluginContext; public void AbstractMojo(); public void setLog(logging.Log); public logging.Log getLog(); public java.util.Map getPluginContext(); public void setPluginContext(java.util.Map); } org/apache/maven/plugin/AbstractMojoExecutio.class package org.apache.maven.plugin; public abstract synchronized class AbstractMojoExecutio extends Exception...

; public abstract void release(); public abstract void removeAttribute(String); public abstract void setAttribute(String, Object); public static LogFactory getFactory() throws LogConfigurationExce; public static Log getLog(Class) throws LogConfigurationExce; public static Log getLog(String) throws LogConfigurationExce; public static void release(ClassLoader); public static void releaseAll(); protected static ClassLoader getContextClassLoade() throws LogConfigurationExce; private static LogFactory...

  }
  buffer =
      cutil::SetElement(index_reshape, buffer, elem, builder, write.getLoc());
  cutil::WriteLocalVariable(local_var, buffer, builder, write.getLoc());
  write.getFlowOut().replaceAllUsesWith(write.getFlowIn());
  write.erase();
  return success();
}

LogicalResult HandleTensorArrayConcatV3Op(
    TF::TensorArrayConcatV3Op concat,
    const llvm::SmallDenseMap<Value, TensorArrayStats>& stats) {

            }
            operations << "applying"
            apply plugin: '$appliedBy'
            operations << "applied"

            assert plugins["$detectedBy"]
            assert plugins.getPlugin("$detectedBy")
            assert pluginManager.hasPlugin("$detectedBy")
            assert pluginManager.findPlugin("$detectedBy").id == "$detectedBy"

            task verify {
                doLast {

                            .map(ModelProblem::getException)
                            .filter(pluginArtifactNotFoundException)
                            .map(exc -> ((PluginResolutionException) exc.getCause()).getPlugin())
                            .anyMatch(isPluginPartOfRequestScope);
                })
                .orElse(false);
    }

                PluginModel plugin = config.getPlugin(path);
                writePlugin(path, plugin, true);
            }
            for (String alias : aliases) {
                String childName = leafNodeForAlias(alias);
                if (!classNode.hasChild(childName)) {
                    PluginModel plugin = config.getPlugin(alias);
                    writePlugin(alias, plugin, false);

    }

    @Override
    public <T> Provider<T> provider(Callable<T> value) {
        return providerFactory.provider(value);
    }

    @Override
    public LoggingManager getLogging() {
        return loggingManager;
    }

    @Override
    public Logger getLogger() {
        return LOGGER;
    }

    @Override
    public String toString() {
        return "script";

                    .collect(Collectors.joining(", "));
            PluginIncompatibleException pie = new PluginIncompatibleException(
                    pluginDescriptor.getPlugin(),
                    "The plugin " + pluginDescriptor.getId() + " has unmet prerequisites: " + messages,
                    prerequisiteExceptions.get(0));

        final String defaulModelId = DefaultLifecyclePluginAnalyzer.DEFAULTLIFECYCLEBINDINGS_MODELID;

        List<String> unversionedPlugins = executionPlan.getMojoExecutions().stream()
                .map(MojoExecution::getPlugin)
                .filter(p -> p.getLocation("version") != null
                        && p.getLocation("version").getSource() != null
                        && defaulModelId.equals(