auto newAttr = DenseElementsAttr::getFromRawBuffer(
        shaped_type, mlir::cast<DenseElementsAttr>(op.getValue()).getRawData());
    rewriter.replaceOpWithNewOp<arith::ConstantOp>(op, newAttr);

    return success();
  }
};

class SanitizeGatherOpOutputToI4 : public OpRewritePattern<TFL::GatherOp> {
 public:
  using OpRewritePattern<TFL::GatherOp>::OpRewritePattern;

    if (ksizes.size() == 4) {
      rewriter.replaceOpWithNewOp<TF::AvgPoolOp>(
          op, op.getType(), input, rewriter.getI64ArrayAttr(ksizes),
          rewriter.getI64ArrayAttr(kstrides), rewriter.getStringAttr(padding),
          rewriter.getStringAttr(data_format));
      return success();
    } else if (ksizes.size() == 5) {
      rewriter.replaceOpWithNewOp<TF::AvgPool3DOp>(

    // implemented.
    if (params_ty.hasStaticShape() && indices_ty.hasStaticShape()) {
      rewriter.replaceOpWithNewOp<mhlo::GatherOp>(
          op, op.getType(), op.getParams(), op.getIndices(), dims_attr,
          GetI64ElementsAttr(slice_sizes, &rewriter));
    } else {
      rewriter.replaceOpWithNewOp<mhlo::DynamicGatherOp>(
          op, op.getType(), op.getParams(), op.getIndices(), slice_sizes_value,

    // which should be removed. So the replaced PartitionedCall op should keep
    // its original arguments except for the last element.
    SmallVector<Value> args = call_op.getOperands().drop_back();

    rewriter.replaceOpWithNewOp<TF::PartitionedCallOp>(
        call_op, float_func.getResultTypes(), args, f_attr);
    return success();
  }
};

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

  // Finally, create a new while with additional return values.
  hoister.ReplaceOpWithNewOp();
  return success();
}

// Lift resources out of the regions attached to `op`
LogicalResult RegionResourceHoister::ReplaceOpWithNewOp(Operation* op) {
  if (auto while_op = dyn_cast<TF::WhileRegionOp>(op))
    return HoistResourcesOutOfWhileRegion(while_op);

    // this is a forced/hard-coded constraint.
    auto qbarrier = rewriter.create<QuantizeCastOp>(op.getLoc(), quantizedType,
                                                    op.getInputs());
    rewriter.replaceOpWithNewOp<DequantizeCastOp>(op, converter.input_type,
                                                  qbarrier.getResult());

    return false;
  }
};

class ConstFakeQuantRewrite

        mlir::cast<DenseIntOrFPElementsAttr>(input_values)
            .mapValues(FloatType::getF32(rewriter.getContext()),
                       llvm::function_ref<DequantizeFuncType>(dequantize_func));
    rewriter.replaceOpWithNewOp<TFL::ConstOp>(dequant_op, dequant_op.getType(),
                                              dequant_values);

    return success();
  }
};

// If the quant op has no consumer, we will remove them.

                                   /*keep_dims=*/rewriter.getBoolAttr(true));

    if (use_log) {
      Value log = rewriter.create<TF::LogOp>(loc, sum);
      rewriter.replaceOpWithNewOp<TF::SubOp>(op, shifted_logits, log);
    } else {
      rewriter.replaceOpWithNewOp<TF::DivOp>(op, exp, sum);
    }
    return success();
  }
};

}  // namespace

void PopulateLoweringTFPatterns(MLIRContext *context,

                                   op.getInput(), new_reshape_shape);
    TF::ConstOp new_broadcast_shape =
        GetI64ConstantTensor(rewriter, reshape_shape, op.getLoc());
    rewriter.replaceOpWithNewOp<BroadcastToOp>(
        reshape_op, reshape_op.getOutput().getType(), new_reshape,
        new_broadcast_shape);
    return success();
  }
};

#define GEN_PASS_DEF_TENSORFLOWOPTIMIZEPASS

    mlir::ElementsAttr axis_stats;
    mlir::IntegerAttr axis;
    for (auto& stats_op : stats_ops) {
      rewriter.setInsertionPointAfter(stats_op);
      rewriter.replaceOpWithNewOp<quantfork::StatisticsOp>(
          stats_op, stats_op.getArg(), layer_stats, axis_stats, axis);
    }
    return success();
  }
};

template <typename SourceOp>