keywords: List<KtKeywordToken>,
        owner: KaAnnotated,
        keywordsRenderer: KaKeywordsRenderer,
        printer: PrettyPrinter,
    ) {
        val applicableKeywords = keywords.filter { keywordsRenderer.keywordFilter.filter(analysisSession, it, owner) }
        printer.printCollection(applicableKeywords, separator = " ") {
            renderKeyword(analysisSession, it, owner, keywordsRenderer, this)
        }
    }

    override fun execute() {
        fileSystemOperations.copy {
            from(parameters.fileToReverse)
            into(parameters.destinationDir)
            filter { line: String -> line.reversed() }
        }
    }
}
// end::unit-of-work[]

// tag::task-implementation[]
// The WorkerExecutor will be injected by Gradle at runtime

    override fun extractProperties(kClass: KClass<*>, propertyNamePredicate: (String) -> Boolean): Iterable<CollectedPropertyInformation> =
        extensionPropertiesByClass[kClass]?.filter { propertyNamePredicate(it.name) } ?: emptyList()

        extension.enabled.convention(this.name == "main")

        project.dependencies.addProvider(
            annotationProcessorConfigurationName,
            extension.enabled.filter { it }.map { "com.google.errorprone:error_prone_core:2.24.1" }
        )

        project.tasks.named<JavaCompile>(this.compileJavaTaskName) {
            options.errorprone {
                isEnabled = extension.enabled

  }

  subgraph secondLine {
    includeRoot[style="rounded,filled", fillcolor="#bfffbf", label="Compilation include roots"]
  }

  subgraph thirdLine {
    {rank=same sourceFiles compileVariantCpp outputDirectory}
    includeRoot -> compileVariantCpp
    sourceFiles -> compileVariantCpp
    compileVariantCpp -> outputDirectory

    sourceFiles[style="rounded,filled", fillcolor="#bfffbf", label="Source files"]

     * order of their containing scopes, which are sorted according to their indexes in scope tower.
     */
    public fun KaScopeContext.getCompositeScope(filter: (KaScopeKind) -> Boolean = { true }): KaScope = withValidityAssertion {
        val subScopes = scopes.filter { filter(it.kind) }.map { it.scope }
        subScopes.asCompositeScope()

1. Click **Management**.
1. Click **Index Patterns**.
1. Click **Create index pattern** button
1. Input "fess\_log\*" to the textbox of **index pattern**.
1. Click **Next step**.
1. Set "requestedAt" to the **Time Filter field name**.
1. Click **Create index pattern**.
1. Click **Saved Objects**.
1. Click **Import** and select "fess\_log.ndjson" to import example settings.
1. Click **Dashboard**.
1. Select "fess\_log" dashboard.

tree = fileTree(dir: 'src', include: '**/*.java', exclude: '**/*test*/**')
// end::define[]

// tag::use[]
// Iterate over the contents of a tree
tree.each {File file ->
    println file
}

// Filter a tree
FileTree filtered = tree.matching {
    include 'org/gradle/api/**'
}

// Add trees together
FileTree sum = tree + fileTree(dir: 'src/test')

// Visit the elements of the tree
tree.visit {element ->

// RUN: tf-opt -tf-standard-pipeline=enable-inliner %s | FileCheck %s --dump-input=always

// Tests function with argument has no resource subtype but caller operand has a
// resource subtype, and after shape inference, function argument is refined and
// no `tf.Cast` ops are generated.

                             %arg2: tensor<256xf32>,          // batch_norm args
                             %arg3: tensor<7x7x3x64xf32>,    // conv filter #0
                             %arg4: tensor<1x1x64x256xf32>   // conv filter #1
                            ) -> tensor<?x256xf32> {

  // This is a simplified ResNet layer that gets input in NHWC format, converts