if !modload.WillBeEnabled() {
		telemetry.Inc("go/mode:gopath")
	} else if workfile := modload.FindGoWork(base.Cwd()); workfile != "" {
		telemetry.Inc("go/mode:workspace")
	} else {
		telemetry.Inc("go/mode:module")
	}
	telemetry.Inc("go/platform/target/goos:" + cfg.Goos)
	telemetry.Inc("go/platform/target/goarch:" + cfg.Goarch)
	switch cfg.Goarch {
	case "386":
		telemetry.Inc("go/platform/target/go386:" + cfg.GO386)
	case "amd64":

		// We want at least procs*len(ord.coprimes) different pos+inc values
		// before we start repeating.
		for i := 0; i < procs*len(ord.coprimes); i++ {
			enum := ord.start(uint32(i))
			j := enum.pos*uint32(procs) + enum.inc
			if checked[j] {
				println("procs:", procs, "pos:", enum.pos, "inc:", enum.inc)
				panic("duplicate pos+inc during enumeration")
			}
			checked[j] = true
		}
	}

    ],
)

gentbl_cc_library(
    name = "mlrt_ops_inc_gen",
    tbl_outs = [
        (
            ["-gen-op-decls"],
            "mlrt_ops.h.inc",
        ),
        (
            ["-gen-op-defs"],
            "mlrt_ops.cpp.inc",
        ),
    ],
    tblgen = "@llvm-project//mlir:mlir-tblgen",
    td_file = "mlrt_ops.td",
    deps = [":mlrt_td_files"],
)

cc_library(

            ["-gen-op-decls"],
            "tfrt_fallback_sync.h.inc",
        ),
        (
            ["-gen-op-defs"],
            "tfrt_fallback_sync.cpp.inc",
        ),
        (
            [
                "-gen-dialect-decls",
                "-dialect=tfrt_fallback_sync",
            ],
            "tfrt_fallback_sync_dialect.h.inc",
        ),
    ],

package main

type T struct {
	m map[int]int
}

func main() {
	t := T{
		m: make(map[int]int),
	}
	t.Inc(5)
	t.Inc(7)
}

func (s *T) Inc(key int) {
	v := s.m[key] // break, line 16
	v++
	s.m[key] = v // also here

    def "reports task problems in tasks from included build that run in main build"() {
        given:
        settingsFile << """
            includeBuild 'inc'
        """
        file("inc/settings.gradle") << """
            include 'sub'
        """
        file("inc/sub/build.gradle") << """
            gradle.buildFinished { }
            tasks.register('broken') {
                inputs.property('p', project).optional(true)

	metrics.PodResourcesEndpointRequestsTotalCount.WithLabelValues("v1").Inc()
	metrics.PodResourcesEndpointRequestsGetCount.WithLabelValues("v1").Inc()

	if !utilfeature.DefaultFeatureGate.Enabled(kubefeatures.KubeletPodResourcesGet) {
		metrics.PodResourcesEndpointErrorsGetCount.WithLabelValues("v1").Inc()
		return nil, fmt.Errorf("PodResources API Get method disabled")
	}

    tbl_outs = [
        (
            ["-gen-op-decls"],
            "QuantOps.h.inc",
        ),
        (
            ["-gen-op-defs"],
            "QuantOps.cc.inc",
        ),
        (
            [
                "-gen-dialect-decls",
                "-dialect=quantfork",
            ],
            "QuantOpsDialect.h.inc",
        ),
        (
            [
                "-gen-dialect-defs",

		return 0, err
	}
	var (
		counter uint64
		block   [aes.BlockSize]byte
	)
	inc := func() {
		counter++
		if counter == 0 {
			panic("crypto/rand counter wrapped")
		}
		byteorder.LePutUint64(block[:], counter)
	}
	blockCipher.Encrypt(r.key[:aes.BlockSize], block[:])
	inc()
	blockCipher.Encrypt(r.key[aes.BlockSize:], block[:])
	inc()
	r.mu.Unlock()

	n = len(b)
	for len(b) >= aes.BlockSize {

	if seed := godebugSeed(); seed != nil {
		now = uint64(*seed)
	}
	inc := globalInc.Add(1)
	r.state = now
	r.inc = (inc << 1) | 1
	r.step()
	r.state += now
	r.step()
	return r
}

func (r *pcgRand) step() {
	r.state *= multiplier
	r.state += r.inc
}

func (r *pcgRand) save(randState, randInc *uint64) {
	*randState = r.state
	*randInc = r.inc
}

func (r *pcgRand) restore(randState, randInc uint64) {