// to store its `SymbolTable` to `SymbolTableCollection`.
  SymbolTable stablehlo_symbol_table(stablehlo_module);

  Builder builder(context);
  StringAttr main_func_name;
  for (auto func : stablehlo_module.getOps<func::FuncOp>()) {
    const bool is_main_func = func.getSymName() == kStablehloMainFunctionName;
    if (tf_symbol_table.lookup(func.getSymName())) {
      if (failed(stablehlo_symbol_table.renameToUnique(

  for (int i = 0; i < low_pads.size(); ++i) {
    new_low_pads[i] = low_pads[i].getInt() + parent_low_pads[i].getInt();
    new_high_pads[i] = high_pads[i].getInt() + parent_high_pads[i].getInt();
    new_interior_pads[i] =
        interior_pads[i].getInt() + parent_interior_pads[i].getInt();
  }

  // Replace pad_op with a new pad having new attributes, taking the

  for (int i : llvm::seq<int>(1, num_dims - 1)) {
    Value input_size_i = GetDimValue(builder, loc, input_shape_value, i);
    const int stride_i = mlir::cast<IntegerAttr>(strides[i]).getInt();
    const int dilation_i = mlir::cast<IntegerAttr>(dilations[i]).getInt();
    const int filter_i = filter_shape.getDimSize(i - 1);
    Value pad_i_low, pad_i_high;
    GetSamePaddingValues(builder, loc, input_size_i, filter_i, dilation_i,

  ASSERT_TRUE(module_op);

  func::FuncOp main_fn = FindMainFuncOp(*module_op);
  ASSERT_THAT(main_fn, NotNull());

  auto xla_call_module_ops = main_fn.getOps<TF::XlaCallModuleOp>();
  ASSERT_FALSE(xla_call_module_ops.empty());

  // Test that `GetQuantizationMethod` returns a valid `Method` corresponding to
  // `"no_quantization {}"`.
  const absl::StatusOr<Method> method =

      fbb.Float(attr.first.data(), float_attr.getValue().convertToFloat());
    } else if (auto int_attr =
                   mlir::dyn_cast_or_null<IntegerAttr>(attr.second)) {
      fbb.Int(attr.first.data(), int_attr.getInt());
    } else if (auto bool_attr = mlir::dyn_cast_or_null<BoolAttr>(attr.second)) {
      fbb.Bool(attr.first.data(), bool_attr.getValue());
    } else if (auto string_attr =

    "$_builder.getI32IntegerAttr($0.cast<IntegerAttr>().getInt())">;

// Builds a constant bool attribute.
class GetBoolAttr<int value> :
    NativeCodeCall<"$_builder.getBoolAttr(" # value #")">;

// Converts an integer attribute $0 to 64-bit with builder.
def convertIntAttrTo64Bit : NativeCodeCall<
    "$_builder.getI64IntegerAttr($0.cast<IntegerAttr>().getInt())">;

// Extracts the single integer element from $_self.

    fbb.Add(static_cast<int32_t>(
        mlir::dyn_cast<IntegerAttr>(*(hash_seed.getValue().data() + i))
            .getInt()));
  }
  fbb.EndVector(vector_start, /*typed=*/true, /*fixed=*/false);

  auto buckets = mlir::dyn_cast_or_null<IntegerAttr>(attrs.get("buckets"));
  fbb.Int("buckets", buckets.getInt());

  fbb.EndMap(start_map);
  fbb.Finish();

    return success();
  }
  return op->emitOpError() << "module already contains an attribute "
                           << attr_name << "=" << ex_attr_value.getInt()
                           << ", overwritting to a new value "
                           << attr_value.getInt() << " is not allowed.";
}

LogicalResult SetCollectiveInfo(IntegerAttr group_size, IntegerAttr group_key,
                                Operation* op) {

  ArrayAttr stride = mlir::dyn_cast<ArrayAttr>(identifier_to_attr["strides"]);
  const int stride_h = mlir::cast<IntegerAttr>(stride[1]).getInt();
  const int stride_w = mlir::cast<IntegerAttr>(stride[2]).getInt();
  return rewriter.getI64ArrayAttr({stride_h, stride_w});
}

Attribute GetLhsDilationValue(PatternRewriter& rewriter,

                    // create and wire the custom dependencies extension's dependencies to these global configurations
                    api.fromDependencyCollector(getRestricted().getDependencies().getApi());
                    implementation.fromDependencyCollector(getRestricted().getDependencies().getImplementation());
                }
            }
        """