new URI("s3://somebucket.au.s3.eu-central-1.amazonaws.com/a/b/file.txt")      | Optional.of(getRegion(Regions.EU_CENTRAL_1))                        | 'somebucket.au' | 'a/b/file.txt'

      replicate_op->getLoc(), new_result_types, replicate_op->getOperands(),
      replicate_op->getAttrs());

  // Move region to the new op.
  new_replicate_op.getRegion().takeBody(replicate_op.getRegion());

  // Replace all old uses with new op results.
  int old_num_results = replicate_op->getNumResults();
  replicate_op->replaceAllUsesWith(

        PropagatePotentiallyWrittenUpFromCallee(func.getRegion(),
                                                call.getArgOperands());
      }
      return;
    }
    if (auto if_op = dyn_cast<TF::IfOp>(op)) {
      for (auto callee : {if_op.then_function(), if_op.else_function()}) {
        PropagatePotentiallyWrittenUpFromCallee(callee.getRegion(),
                                                if_op.getInput());

            String key = matcher.group(4);
            Region derivedRegion;
            if (region.equals("external-1")) {
                derivedRegion = Region.getRegion(Regions.US_EAST_1);
            } else {
                derivedRegion = RegionUtils.getRegion(region);
            }

            this.region = Optional.of(derivedRegion);
            this.bucketName = bucketName;
            this.key = key;

	if err != nil {
		log.Debugf("error in getting aws info for %s : %v", path, err)
		return "", err
	}
	return resp.String(), nil
}

// getRegion returns the Region that the instance is running in.
func getRegion(ipv6 bool, headers map[string]string) string {
	region, _ := getAWSInfo("placement/region", ipv6, headers)
	return region
}

      SetExportedName(other, name);
      module_body.push_front(other);
      other.addEntryBlock();
      OpBuilder builder(other.getRegion());
      auto call_op = builder.create<mlir::func::CallOp>(
          f.getLoc(), f.getFunctionType().getResults(), f.getSymName(),
          other.getRegion().getArguments());
      builder.create<mlir::func::ReturnOp>(f.getLoc(), call_op.getResults());
    }

    Unexport(f);
  }
}

// Prints the analysis result for each resource ops found in `module_op` for
// testing purposes.
void PrintAnalysisResults(const TF::ResourceAnalyzer& analyzer,
                          ModuleOp module_op) {
  module_op.getRegion().walk([&analyzer](Operation* op) {
    if (auto var_handle_op = dyn_cast<TF::VarHandleOp>(op)) {
      const ResourceKey resource_key = GetResourceKey(var_handle_op);
      op->emitRemark(llvm::formatv(

#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"

void init_ops(py::module& m) {
  py::class_<mlir::Operation, std::unique_ptr<mlir::Operation, py::nodelete>>(
      m, "Operation")
      .def("getRegion", &mlir::Operation::getRegion,
           py::return_value_policy::reference)
      .def("getResult", &mlir::Operation::getResult)
      .def("dump", &mlir::Operation::dump)
      .def("getNumResults", &mlir::Operation::getNumResults);

    return WalkResult::advance();
  });
  if (walk_result.wasInterrupted()) return signalPassFailure();
  // Move all remaining nested functions back into the parent module.
  Block &nested_block = nested_module->getRegion(0).front();
  for (func::FuncOp func_op :
       llvm::make_early_inc_range(nested_block.getOps<func::FuncOp>())) {
    if (!symbol_table.lookupSymbolIn(getOperation(), func_op.getName())) {

      // Skip the folding logic if the block argument is not from the function
      // arguments. This can happen when the argument is from a while loop.
      if (block_arg.getParentRegion() != &func_op.getRegion()) {
        return false;
      }
      if (StringAttr attr = func_op.getArgAttrOfType<StringAttr>(
              block_arg.getArgNumber(), kTFDeviceAttr)) {
        return op_device == attr;
      }