"# Decides between a single digit + spacing (e.g. '8 '), or two digits (e.g. 17)\n" +
            "# This is the value being replaced.\n" +
            "(?:\\d\\s|\\d{2})" +
            "# Capture the tail end of the table\n" +
            "(\\s+\\|)",
            // Replace the value with 11 for consistent testing
            "\$111\$2"
        )

  parallel_execute_op->dropAllUses();
  parallel_execute.erase();
}

// Replaces TPUExecute with TPUExecuteAndUpdateVariables.
void ReplaceExecute(tf_device::LaunchOp execute_launch,
                    tf_device::LaunchOp merged_execute_launch,
                    const VariableAccessesForTPUExecute& var_access_info) {
  // Replace the uses.
  for (int i = 0, end = var_access_info.old_to_new_output_mapping.size();

        eclipseChild2.projectDependencies.collect { it.path } == []
        // jars that replace the project dependencies + the transitive dependency from :a
        eclipseChild2.classpath.collect { it.file.name } == ['child1.jar', 'child1-tests.jar', 'test-1.0.jar']
    }

    def "custom project dependencies are replaced when project is closed"() {
        setup:

stderr '^go: module example.net/missing@v0.1.0 found \(replaced by ./missing\), but does not contain package example.net/missing/subdir$'

go get example.net/missing@v0.1.0


# Getting the subdirectory should continue to fail even if the corresponding
# module is already present in the build list.

! go get example.net/missing/subdir@v0.1.0

def _format_snake_case_op_name(s):
  """Formats the op name to snake case."""
  s = s.replace('2D', '2d').replace('3D', '3d')
  snake_case = ''.join(['_' + i.lower() if i.isupper() else i for i in s
                       ]).lstrip('_')
  return snake_case.replace('mat_mul', 'matmul').replace('bias_add', 'bias')


def _substitute_impl_function_name_template(module: str) -> str:
  """Generates the op-specific implementation function name."""

Module replacement rules allow a build to declare that a legacy library has been replaced by a new one.
A good example when a new library replaced a legacy one is the `google-collections` -> `guava` migration.

    : public PassWrapper<RewriteQuantizedIOPass, OperationPass<ModuleOp>> {
 public:
  StringRef getArgument() const final { return "tfr-rewrite-quantized-io"; }

  StringRef getDescription() const final {
    return "Replaces operands and results that has quantized type with their "
           "storage types.";
  }
  void runOnOperation() override;
};

void RewriteQuantizedIOPass::runOnOperation() {
  ModuleOp module = getOperation();

				Filters: []*listener.Filter{
					{Name: "default-network-filter-replaced"},
				},
			},
			ListenerFilters: []*listener.ListenerFilter{
				{
					Name: "filter-after-replace",
				},
			},
		},
		{
			Name: "another-listener",
		},
		{
			Name: "listener-http-filter-to-be-replaced",
			FilterChains: []*listener.FilterChain{
				{

     * identifier are added, then the value of the replace argument determines the behaviour.
     *
     * If replace is false then any existing repository with the same Id will remain in use. If replace
     * is true the new repository replaces the original.
     *
     * @param repository The repository to add to the internal search chain, must not be {@code null}.

	return int(sz)
}

// replace will add or replace a key/value pair.
func (x *xlMetaInlineData) replace(key string, value []byte) {
	in := x.afterVersion()
	sz, buf, _ := msgp.ReadMapHeaderBytes(in)
	keys := make([][]byte, 0, sz+1)
	vals := make([][]byte, 0, sz+1)

	// Version plus header...
	plSize := 1 + msgp.MapHeaderSize
	replaced := false
	for i := uint32(0); i < sz; i++ {