}
    // Use the min/max from the operands and the num_bits and narrow_range
    // attribute to create the quantization parameter for the new quantize op.
    rewriter.setInsertionPointAfter(tf_op.getOperation());
    IntegerAttr num_bits = rewriter.getI64IntegerAttr(tf_op.getNumBits());
    BoolAttr narrow_range = rewriter.getBoolAttr(tf_op.getNarrowRange());
    Type res_type = tf_op.getType();

    if (type.getStorageTypeIntegralWidth() != 32) {
      return false;
    }
  }
  return true;
}

void FoldConstantsToSubgraphPass::runOnOperation() {
  auto module = getOperation();

  for (auto fn : module.getOps<func::FuncOp>()) {
    fn.walk([&](Operation* op) {
      if (!llvm::isa<TFL::ConstOp, TFL::QConstOp, arith::ConstantOp>(op))
        return;

  void runOnOperation() override;

 private:
  const std::function<bool(Operation *)> partition_;
};

void PartitionedTopologicalSortPass::runOnOperation() {
  func::FuncOp func = getOperation();
  if (!PartitionedTopologicalSort(func, &func.getBody().front(), partition_)) {
    return signalPassFailure();
  }
}

}  // namespace

std::unique_ptr<OperationPass<func::FuncOp>>

    registry.insert<mlir::tf_saved_model::TensorFlowSavedModelDialect,
                    ml_program::MLProgramDialect>();
  }
  void runOnOperation() override {
    auto module = getOperation();

    DataFlowSolver solver;
    solver.load<dataflow::DeadCodeAnalysis>();
    solver.load<dataflow::SparseConstantPropagation>();
    TF::LoadResourceDataflowAnalysis(solver);

                      << classes_attr;
  }
  return result;
}

void ConvertReadonlyReferenceVariablesToResourceVariablesPass::
    runOnOperation() {
  func::FuncOp func = getOperation();

  OpBuilder builder(func.getContext());
  SmallVector<VariableV2Op, 4> variable_v2s_to_replace;

  // Checks all the VariableV2 ops is read-only via verifying the heuristic

        }
      }
    )",
                                        &test_tac_filters);
    tac_filters_ = &test_tac_filters;
  }

  if (!tac_filters_) {
    return;
  }

  ModuleOp module = getOperation();
  OpBuilder builder(module);
  std::sort(tac_filters_->mutable_tac_filters()->pointer_begin(),
            tac_filters_->mutable_tac_filters()->pointer_end(),
            [](const TacFilter* a, const TacFilter* b) {

    changed = true;
  }
  return success(changed);
}

void BroadcastFoldPass::runOnOperation() {
  RewritePatternSet patterns(&getContext());
  auto func = getOperation();

  patterns.add<ConvertResultsBroadcastableShapeOp>(func.getContext());
  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
}

}  // namespace

namespace TF {

};

PromoteResourcesToArgsPass::PromoteResourcesToArgsPass(
    llvm::ArrayRef<std::string> functions) {
  functions_ = functions;
}

void PromoteResourcesToArgsPass::runOnOperation() {
  ModuleOp module = getOperation();
  if (llvm::size(functions_) == 0) {
    functions_ = {"main"};
  }
  SymbolTable symbolTable(module);
  for (const std::string& f : functions_) {
    func::FuncOp func = symbolTable.lookup<func::FuncOp>(f);

        // Keras LSTM have 5 outputs.
        // We should make sure only the first or the second output are
        // consumed.
        if (failed(CheckOutputConsumer(op.getOperation(), 5, {0, 1})))
          return WalkResult::interrupt();
      }
      return WalkResult::advance();
    });

    if (result.wasInterrupted()) return failure();
  }

    return type.cloneWith(after_shape, type.getElementType());
  }
};

}  // namespace

void NchwConvolutionToNhwcPass::runOnOperation() {
  func::FuncOp func_op = getOperation();
  MLIRContext& ctx = getContext();

  RewritePatternSet patterns(&ctx);
  patterns.add<RewriteNchwConvolutionToNhwc>(&ctx);

  if (failed(applyPatternsAndFoldGreedily(func_op, std::move(patterns)))) {