// include `end`. The operations might be across multiple  blocks.
void AddAttributes(Block::iterator begin, Block::iterator end,
                   const NamedAttrList& attrs) {
  if (begin->getBlock() == end->getBlock()) {
    AddAttributesInSameBlock(begin, end, attrs);
  } else {
    Region::iterator begin_block = Region::iterator(begin->getBlock());

  }
};

}  // namespace

// Inserts call to the given function into the 'region'.
void CreateRegionWithCall(func::FuncOp func, Region& region, Location loc) {
  OpBuilder builder(region);
  auto block = builder.createBlock(&region);
  SmallVector<Value, 4> new_operands;
  for (Type t : func.getFunctionType().getInputs())
    new_operands.push_back(block->addArgument(t, loc));

    --project "${PROJECT}" \
    --region "${REGION}" \
    --protocol tcp \
    --region "${REGION}" \
    --load-balancing-scheme internal \
    --health-checks "${MASTER_NAME}-hc"

  gcloud compute forwarding-rules create "${MASTER_NAME}-internal" \
    --project "${PROJECT}" \
    --region "${REGION}" \
    --load-balancing-scheme internal \
    --network "${NETWORK}" \

  SymbolUserMap symbol_map(table, module);

  // Regions that contains ops requiring token input attributes.
  absl::flat_hash_set<Region*> regions_with_token;
  while (!worklist.empty()) {
    Operation* op = worklist.back();
    worklist.pop_back();

    Region* region = op->getParentRegion();
    regions_with_token.insert(region);

  }

  // Checks if a region only consists of ops that are quantizable in a nested
  // region.
  // tf.CustomAggregator op cannot be inserted into region of a StableHLO op,
  // thus calibration is impossible within a nested region. Therefore, when an
  // op involves a region, the op is only quantizable when the region only
  // consists of ops whose quantization parameters can be propagated from

  // Remove the original TPUExecute op.
  execute_launch.erase();

  // Move all regions from old parallel_execute to new parallel_execute.
  for (auto region : llvm::zip(new_parallel_execute_op->getRegions(),
                               parallel_execute_op->getRegions()))
    std::get<0>(region).takeBody(std::get<1>(region));

  // Remove the original parallel_execute.
  parallel_execute_op->dropAllUses();

					},
				},
				Locality: &core.Locality{
					Region: "myregion",
				},
			},
			expected: labels.Instance{
				"k1":                       "v1",
				NodeRegionLabelGA:          "myregion",
				label.TopologyNetwork.Name: "mynetwork",
			},
		},
		{
			name: "region and zone",
			ctl:  testController{},
			proxy: &model.Proxy{
				Labels: labels.Instance{

  return 0;
}

void MoveTpuCompileToFrontPass::runOnOperation() {
  MarkCompilationOps(getOperation());
  getOperation().walk([](Operation* op) {
    for (Region& region : op->getRegions()) {
      for (Block& block : region.getBlocks()) {
        if (block.empty()) continue;
        auto ops = SortBlockTopologically(block, OutsideCompilationOrdering);
        // Replace the block with the reordered block.

			"Chooses beta label",
			&v1.Node{ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{NodeRegionLabel: "beta-region", NodeRegionLabelGA: "ga-region"}}},
			"beta-region",
		},
		{
			"Fallback no beta label defined",
			&v1.Node{ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{NodeRegionLabelGA: "ga-region"}}},
			"ga-region",
		},
		{
			"Only beta label specified",

                             Operation *inline_point, Region *region) const;
};

LogicalResult SimplifySCFIfOp::InlineRegion(Location loc,
                                            PatternRewriter &rewriter,
                                            Operation *inline_point,
                                            Region *region) const {
  InlinerInterface interface(loc.getContext());