loc, GetI64ElementsAttr(new_broadcast_shape, &rewriter));

    auto new_broadcast_to_op = rewriter.create<TFL::BroadcastToOp>(
        loc, RankedTensorType::get(new_broadcast_shape, rewriter.getF32Type()),
        new_inner_reshape_op.getOutput(), new_broadcast_shape_value);

    // Create a new broadcast_op to replace the old broadcast_op.
    rewriter.replaceOp(tfl_broadcast_to_op, new_broadcast_to_op.getResult());

The editing flags specify a sequence of editing operations.

The -fmt flag reformats the go.work file without making other changes.
This reformatting is also implied by any other modifications that use or
rewrite the go.mod file. The only time this flag is needed is if no other
flags are specified, as in 'go work edit -fmt'.

The -godebug=key=value flag adds a godebug key=value line,

	go i.startReflector()
}

func (i *objectCacheItem) startReflector() {
	i.waitGroup.Wait()
	i.waitGroup.Add(1)
	defer i.waitGroup.Done()
	i.reflector.Run(i.stopCh)
}

// cacheStore is in order to rewrite Replace function to mark initialized flag
type cacheStore struct {
	cache.Store
	lock        sync.Mutex
	initialized bool
}

func (c *cacheStore) Replace(list []interface{}, resourceVersion string) error {

      g, slice, slice_inputs, cluster_name, &static_shaped_slice));
  ReplaceTensorFlowSliceWithStaticShapedSlice(g, slice, static_shaped_slice);
  return absl::OkStatus();
}

// Return true if `n` is a slice we should rewrite to have a static shape
// (i.e. have the output shape only depend on the "size" input).
absl::StatusOr<bool> ShouldRewriteSlice(Node* n) {
  if (n->type_string() != "Slice") {
    return false;
  }

			in: &networking.RegexRewrite{
				Match:   "^/service/([^/]+)(/.*)$",
				Rewrite: `\2/instance/\1`,
			},
			valid: true,
		},
		{
			name: "uriRegexRewrite missing match",
			in: &networking.RegexRewrite{
				Rewrite: `\2/instance/\1`,
			},
			valid: false,
		},
		{
			name: "uriRegexRewrite missing rewrite",
			in: &networking.RegexRewrite{
				Match: "^/service/([^/]+)(/.*)$",

  return success();
}

// Records the current live value for a resource variable and whether a read or
// write on the variable occurred.
struct ResourceInfo {
  Value live_value = nullptr;
  bool read = false;
  bool write = false;
};

LogicalResult PromoteResourcesToArguments(
    func::FuncOp function,
    llvm::ArrayRef<std::string> var_handle_shared_names) {

		status = marshalFailure
		return nil, fmt.Errorf("failed to marshal new extension config resource: %w", err)
	}

	// At this point, we are certain that wasm module has been downloaded and config is rewritten.
	// ECDS will be rewritten successfully.
	return nec, nil
}

func convertNetworkWasmConfigFromRemoteToLocal(ec *core.TypedExtensionConfig, wasmNetworkFilterConfig *networkwasm.Wasm, cache Cache) (*anypb.Any, error) {

                << "sequencing rewrite.";
      return;
    } else {
      (*backward_pass_ops.begin())->emitOpError()
          << "embedding backwards pass op with no forwards pass ops.";
      return signalPassFailure();
    }
  }
  LOG(INFO) << "Embedding sequencing rewrite enabled.";

  // Ensure that all ops are in the same region, and have the same replication

            }
        }
    }

    private fun registerProjectServices(project: MockProject) {
        // TODO: rewrite KtResolveExtensionProviderForTest to avoid KtResolveExtensionProvider access before initialized project
        @Suppress("UnstableApiUsage")
        CoreApplicationEnvironment.registerExtensionPoint(

        rewriter.getIntegerAttr(attribute_type, revised_begin_mask),
        rewriter.getIntegerAttr(attribute_type, revised_end_mask),
        /*ellipsis_mask=*/rewriter.getI64IntegerAttr(0),
        rewriter.getIntegerAttr(attribute_type, revised_new_axis_mask),
        rewriter.getIntegerAttr(attribute_type, revised_shrink_axis_mask));

    return success();
  }