defer t.End()

	trace.Log(ctx, "log2", "do")

	// Create a region and spawn more tasks and more workers.
	trace.WithRegion(ctx, "fanout", func() {
		for i := 0; i < k; i++ {
			go func(i int) {
				trace.WithRegion(ctx, fmt.Sprintf("region%d", i), func() {
					trace.Logf(ctx, "log", "fanout region%d", i)
					if i == 2 {
						do(ctx, 0)
						return
					}
				})
			}(i)
		}
	})

## How to enable Fan-Out Uploads ?

Fan-Out uploads are automatically enabled if `x-minio-fanout-list` form-field is provided with the PostUpload API, to keep things simple higher level APIs are provided in our SDKs for example in `minio-go` SDK:

```

  "z.a"(%arg0) : (f32) -> ()
  func.return %arg0 : f32
}
// CHECK: x.a
// CHECK: y.a
// CHECK: z.a
// CHECK: return
// CHECK-NOT: call
// CHECK: }

// -----

// CHECK-LABEL: @fanout
func.func @fanout(%arg0: f32) -> (f32) attributes {ignore_side_effects_for_testing} {
  %0 = "x.a"(%arg0) : (f32) -> (f32)
  %1 = "y.a"(%0) : (f32) -> (f32)
  %2 = "y.b"(%0) : (f32) -> (f32)
  %3 = "y.c"(%0) : (f32) -> (f32)

// license that can be found in the LICENSE file.

package ssa

// layout orders basic blocks in f with the goal of minimizing control flow instructions.
// After this phase returns, the order of f.Blocks matters and is the order
// in which those blocks will appear in the assembly output.
func layout(f *Func) {
	f.Blocks = layoutOrder(f)
}

func.func @infeed_dequeue_tuple() -> (tensor<1x8x4x4xi32>, tensor<1x100x1xf32>) {
  // CHECK: [[TOKEN:%.*]] = mhlo.create_token : !mhlo.token
  %0 = "mhlo.create_token"() : () -> !mhlo.token

  // CHECK:               [[INFEED:%.*]]:3 = "mhlo.infeed"([[TOKEN]]) <{
  // CHECK-SAME{LITERAL}:   infeed_config = "", layout = [[1, 3, 2, 0], [1, 2, 0]]

        expect:
        def layout = locator.getLayoutFor(currentDir, tmpDir.testDirectory)
        layout.rootDirectory == currentDir
        layout.settingsDir == currentDir
        layout.settingsFile == new File(currentDir, "settings.gradle") // this is the current behaviour
        layout.buildDefinitionMissing
    }

import org.gradle.initialization.layout.BuildLayout

rootProject.name = "services"

// tag::build-layout[]
println("Root Directory: ${settings.layout.rootDirectory}")
println("Settings Directory: ${settings.layout.settingsDirectory}")
// end::build-layout[]

// tag::build-layout-inject[]
abstract class MyBuildLayoutPlugin @Inject constructor(private val buildLayout: BuildLayout) : Plugin<Settings> {
    override fun apply(settings: Settings) {

        when:
        def properties = properties()
        def layout = layout(properties)
        gradleHome.file("gradle.properties") << "foo=bar"

        then:
        converter.convert(properties, layout).properties.foo == null
    }

    def "configures from installation home dir"() {
        when:
        def properties = properties()
        def layout = layout(properties)
        rootDir.file("settings.gradle") << ''

tasks.register<Copy>("copyReportsForArchiving") {
    from(layout.buildDirectory.file("reports/my-report.pdf"), layout.projectDirectory.file("src/docs/manual.pdf"))
    into(layout.buildDirectory.dir("toArchive"))
}
// end::copy-multiple-files-example[]

// tag::copy-multiple-files-with-flat-filter-example[]
tasks.register<Copy>("copyPdfReportsForArchiving") {
    from(layout.buildDirectory.dir("reports"))
    include("*.pdf")

	JSONRouter() *mux.Router

	// Layout is the template used as the primary layout for the topic's HTML content.
	Layout() *template.Template
}

type context struct {
	htmlRouter *mux.Router
	jsonRouter *mux.Router
	layout     *template.Template
}

// NewContext creates a new TopicContext.
func NewContext(htmlRouter *mux.Router, jsonRouter *mux.Router, layout *template.Template) TopicContext {
	return context{