</postConstruct>
		<postConstruct name="addDesignJspFileName">
			<arg>"searchOptions"</arg>
			<arg>"searchOptions.jsp"</arg>
		</postConstruct>
		<postConstruct name="addDesignJspFileName">
			<arg>"advance"</arg>
			<arg>"advance.jsp"</arg>
		</postConstruct>
		<postConstruct name="addDesignJspFileName">
			<arg>"help"</arg>
			<arg>"help.jsp"</arg>
		</postConstruct>
		<postConstruct name="addDesignJspFileName">

  auto walk_result = getOperation().walk([&](TF::PartitionedCallOp call_op) {
    if (!call_op.getF().getRootReference().getValue().starts_with(
            kNestedModule))
      return WalkResult::advance();
    // This is a call we need to inline!
    LLVM_DEBUG(llvm::dbgs()
               << "Found call to inline: " << *call_op.getOperation() << "\n");

    auto call_interface = cast<CallOpInterface>(call_op.getOperation());

    StringAttr op_device = op->getAttrOfType<StringAttr>(kDeviceAttr);
    if (should_fold_op_func(op.getOperand(), op_device)) {
      op.replaceAllUsesWith(op.getOperand());
      op.erase();
    }
    return WalkResult::advance();
  });

  func_op.walk([&should_fold_op_func](TF::IdentityNOp op) {
    StringAttr op_device = op->getAttrOfType<StringAttr>(kDeviceAttr);
    bool should_fold = llvm::all_of(

      return WalkResult::advance();
    }

    // Find out the compose function
    auto compose_func_name = GetComposeFuncName(op->getName().getStringRef());
    auto compose_func = table.lookup<TFRFuncOp>(compose_func_name);
    if (!compose_func || compose_func.isExternal()) {
      // There are no decomposition methods defined for this op, skip.
      return WalkResult::advance();
    }

    if (auto var_handle = dyn_cast<VarHandleOp>(op)) {
      // Record VarHandleOp's device attribute.
      StringRef device_attr = GetDeviceAttr(op);
      if (device_attr.empty()) return WalkResult::advance();
      auto res = AddResourceDeviceAndEmitError(var_handle.getResource(),
                                               device_attr, op, result);
      if (failed(res)) return WalkResult::interrupt();

      state = solver.lookupState<Device>(result);
      if (state) break;
    }
    if (!state || !state->hasDevice()) {
      return WalkResult::advance();
    }
    op->setAttr(kDevice, state->getDevice());
    return WalkResult::advance();
  });
}

}  // namespace

std::unique_ptr<OperationPass<ModuleOp>>
CreateColocateTPUCopyWithDynamicShapePass() {

// fresh one will be constructed, seeded with the current real time.
// The clientWG can be `nil` and if not is used to let Run know about
// additional work that has to complete before time can advance.
func NewFake(t time.Time, fuzz time.Duration, r *rand.Rand) (*Fake, counter.GoRoutineCounter) {
	grc := &waitGroupCounter{}

	if r == nil {
		r = rand.New(rand.NewSource(time.Now().UnixNano()))
		r.Uint64()

  cluster->walk([&](Operation* op) {
    if (op == cluster) return WalkResult::advance();
    for (auto operand : op->getOperands()) {
      Operation* scope = operand.getParentBlock()->getParentOp();
      if (scope->isProperAncestor(replicate)) {
        bcasts.insert(operand);
      }
    }
    return WalkResult::advance();
  });
  OpBuilder builder(replicate);

    ModuleOp module, llvm::ArrayRef<SymbolRefAttr> function_list) {
  WalkResult result =
      module.walk([&](stablehlo::CustomCallOp op) {
        if (!IsTfFuncCustomCall(op)) {
          return WalkResult::advance();
        }

        auto backend_config =
            op->getAttrOfType<DictionaryAttr>(kTfBackendConfigAttrName);
        if (!backend_config) {
          op->emitOpError()

	}
	acc.resetTime()
	for {
		// Advance edges to time and time+window.
		mu := (right.advance(time+int64(window)) - left.advance(time)).mean(window)
		if acc.addMU(time, mu, window) {
			break
		}
		if time == endTime {
			break
		}

		// The maximum slope of the windowed mutator
		// utilization function is 1/window, so we can always
		// advance the time by at least (mu - mmu) * window