Carlos Amedee <******@****.***> 1715265901 -0400

		trace.WithRegion(ctx, "region0", func() {
			// EvUserRegionBegin("region0", start)
			trace.WithRegion(ctx, "region1", func() {
				trace.Log(ctx, "key0", "0123456789abcdef") // EvUserLog("task0", "key0", "0....f")
			})
			// EvUserRegionEnd("region0", end)
		})
	}()
	wg.Wait()

	preExistingRegion.End()
	postExistingRegion := trace.StartRegion(bgctx, "post-existing region")

	// End of traced execution.
	trace.Stop()

// Inserts a `CalibrationStatisticsSaverOp` to the end of the region.
LogicalResult InsertCalibrationStatisticsSaverOp(
    Region& region, MLIRContext& ctx, absl::string_view output_file_path,
    const std::unordered_set<std::string>& aggregator_ops_to_ignore) {
  SmallVector<Value> statistics_outputs;
  SmallVector<StringRef> ids;
  SmallVector<int32_t> calibration_methods;
  FindCustomAggregatorOps(region, aggregator_ops_to_ignore, statistics_outputs,

						// We visit all entries for which the script was not
						// defined, including the ones where the region was not
						// defined. This allows for proper disambiguation within
						// regions.
						if x.flags&scriptInFrom == 0 && t.RegionID.Contains(Region(x.region)) {
							tt.RegionID = Region(x.region)
							tt.setUndefinedScript(Script(x.script))
							goodScript = goodScript && tt.ScriptID == Script(x.script)

	}

	cred.scope.region = credElements[1]
	// Verify if region is valid.
	sRegion := cred.scope.region
	// Region is set to be empty, we use whatever was sent by the
	// request and proceed further. This is a work-around to address
	// an important problem for ListBuckets() getting signed with
	// different regions.
	if region == "" {
		region = sRegion
	}

		}
		return true
	})

	// Check for t.Forbidden() calls within each region r that is a
	// callee in some go r() or a t.Run("name", r).
	//
	// Also considers a special case when r is a go t.Forbidden() call.
	for _, region := range regions {
		ast.Inspect(region, func(n ast.Node) bool {
			if n == region {
				return true // always descend into the region itself.
			} else if asyncs[n] != nil {

	if err = newTestConfig(globalMinioDefaultRegion, objLayer); err != nil {
		t.Fatalf("Init Test config failed")
	}

	if globalSite.Region() != globalMinioDefaultRegion {
		t.Errorf("Expecting region `us-east-1` found %s", globalSite.Region())
	}

	// Set new region and verify.
	config.SetRegion(globalServerConfig, "us-west-1")
	site, err := config.LookupSite(
		globalServerConfig[config.SiteSubSys][config.Default],

  bool IsPotentiallyWritten(Value resource) const;

 private:
  // Analyze the specified region for resource mutating operations, namely
  // TF::AssignVariableOp, if so, set the resource associated as "potentially
  // written".
  LogicalResult AnalyzeRegion(Region& region);

  // If an op is not one of the handled ones, we assume all resource usages
  // within its purview are mutating in nature.

type allSubtags struct{}

// Regions returns the list of supported regions. As all regions are in a
// consecutive range, it simply returns a slice of numbers in increasing order.
// The "undefined" region is not returned.
func (s allSubtags) Regions() []Region {
	reg := make([]Region, language.NumRegions)
	for i := range reg {
		reg[i] = Region{language.Region(i + 1)}
	}
	return reg
}

};

// Return a bitvector that marks all return values that always come from
// the same value.
llvm::BitVector GetInvariantReturns(Region* region, int number_of_results) {
  llvm::BitVector invariant(number_of_results, true);
  std::vector<Value> used_argument(number_of_results, nullptr);
  for (Block& block : region->getBlocks()) {
    for (Operation& op : block.getOperations()) {
      if (!op.hasTrait<OpTrait::ReturnLike>()) continue;