inline_point->getResults(), loc,
                          /*shouldCloneInlinedRegion=*/true))) {
    return failure();
  }

  // If the inlining was successful then erase the scf.if op.
  rewriter.eraseOp(inline_point);
  return success();
}

}  // namespace

void populateCanonicalizationPatterns(func::FuncOp func,
                                      RewritePatternSet &patterns) {

    // Erase unused ops in the reverse order.
    rewriter.eraseOp(output_uniform_dequantize_call_op);
    rewriter.eraseOp(output_uniform_quantize_call_op);
    rewriter.eraseOp(combined_scale_multiply_op);
    rewriter.eraseOp(subtract_op);
    rewriter.eraseOp(other_conv_op);
    rewriter.eraseOp(op);
    rewriter.eraseOp(input_i8_to_f32_convert_op);

    rewriter.replaceAllOpUsesWith(output_mul, composite_op);
    // Note these must be erased in reverse topo order to avoid
    // failing in debug mode.
    rewriter.eraseOp(output_mul);
    rewriter.eraseOp(rhs_add);
    rewriter.eraseOp(op);
    rewriter.eraseOp(lhs_mul);
    rewriter.eraseOp(rhs_mul);

    return success();
  }
};

class OutlineCompositesPass

          .replaceAllUsesWith(new_call_op.getResult(0));
      users_to_erase.push_back(user);
    }
    for (auto user : users_to_erase) rewriter.eraseOp(user);
    rewriter.eraseOp(call_op);
    func_op.eraseResult(0);
    func_op.insertResult(0, new_call_op.getResult(0).getType(),
                         /*resultAttrs=*/nullptr);

      id1.replaceAllUsesWith(id1.getInput());
      min = tf_op.getMin();
      rewriter.eraseOp(id1);
    }
    if (auto id2 = dyn_cast_or_null<TF::IdentityOp>(max.getDefiningOp())) {
      id2.replaceAllUsesWith(id2.getInput());
      max = tf_op.getMax();
      rewriter.eraseOp(id2);
    }
    if (!matchPattern(min, m_Constant(&min_value))) return failure();

               PatternRewriter& rewriter) const override {
    // `TF::ConstOp` and `TF::VarHandleOp` are not manually erased.
    // `applyPatternsAndFoldGreedily` performs dead code elimination and unsed
    // ops will be erased during the optimization.
    rewriter.eraseOp(assign_op);
  }
};

void RemoveVariableInitializationByConstPass::runOnOperation() {
  MLIRContext& ctx = getContext();

    // When there are no min and max attributes, remove op.
    if (min == nullptr || max == nullptr) {
      op.getOutput().replaceAllUsesWith(op.getInput());
      rewriter.eraseOp(op);
      return success();
    }

    // The layer stats contain only the first min/max pairs.
    ElementsAttr layer_stats = DenseFPElementsAttr::get(
        RankedTensorType::get({2}, rewriter.getF32Type()),

    rewriter.create<LookupTableImportV2Op>(op.getLoc(), op.getTableHandle(),
                                           key_constant_tensor,
                                           value_constant_tensor);
    rewriter.eraseOp(op);
    return success();
  }

 private:
  StringRef saved_model_dir_;
};

void InitTextFileToImportPass::runOnOperation() {
  RewritePatternSet patterns(&getContext());

    // TODO(jpienaar): Remove once recusive side-effects are supported.
    if (op.use_empty() &&
        (op.getIsStateless() ||
         (IsSideEffectFree(then_func) && IsSideEffectFree(else_func)))) {
      rewriter.eraseOp(op.getOperation());
      return success();
    }

    // Extract the constant cond value.
    DenseElementsAttr cond;
    if (!matchPattern(op.getCond(), m_Constant(&cond))) return failure();

  LogicalResult matchAndRewrite(TFL::QuantizeOp quant_op,
                                PatternRewriter& rewriter) const override {
    if (!quant_op.getResult().use_empty()) return failure();

    rewriter.eraseOp(quant_op);
    return success();
  }
};

void OptimizeQuantizedOpToFloat(func::FuncOp func, MLIRContext* context) {
  RewritePatternSet patterns(func.getContext());
  patterns