rewriter.replaceAllUsesWith(filter_op->getResult(0),
                                quantized_filter_constant_op.getResult());

    // Replace conv op with a new convolution op that has quantized output type.
    // Quantize -> Dequantize following r3.
    auto output_uniform_quantize_call_op = cast<func::CallOp>(
        *combined_scale_multiply_op.getResult().user_begin());

           : recurrent_weights_array->getResult(1);
  Value recurrent_to_cell_weights =
      indy ? mlir::cast<Value>(
                 CreateFlattenOP(recurrent_weights_array->getResult(2),
                                 func_op.getLoc(), builder)
                     .getResult())
           : recurrent_weights_array->getResult(2);
  Value recurrent_to_output_weights =
      indy ? mlir::cast<Value>(

    // Compute inverse of input transpose.
    llvm::SmallVector<int32_t> inverse_perm = InvertPermutation(perm_arr);

    if (tpose_arg.getResult().getType() != op->getResult(0).getType()) {
      // If types are not equal here than the transpose is taking place
      // before an implicit broadcast in the elementwise. We need

    b.setInsertionPoint(op);
    if (auto dq = llvm::dyn_cast<quantfork::DequantizeCastOp>(op)) {
      auto dcast = b.create<DequantizeOp>(dq.getLoc(), dq.getResult().getType(),
                                          dq.getArg());
      dq.getResult().replaceAllUsesWith(dcast);
      if (auto extra_attr = op->getAttr(mlir::quant::kVolatileOpAttrName)) {
        dcast->setAttr(mlir::quant::kVolatileOpAttrName, extra_attr);
      }

  SmallVector<Value, 4> while_input_values;
  SmallVector<Type, 4> while_input_types;
  while_input_values.push_back(const_true.getResult());
  while_input_types.push_back(const_true.getResult().getType());
  for (int i = 1; i < reduce_dataset.getNumOperands(); ++i) {
    while_input_values.push_back(reduce_dataset.getOperand(i));

	l.Put("second", "value")
	resultHashes[l.RootHash()] = true
	getResult, err := l.Get("foo")
	assert.NoError(t, err)
	assert.Equal(t, getResult, "baz")
	getResult, err = l.Get("second")
	assert.NoError(t, err)
	assert.Equal(t, getResult, "value")
	getResult, err = l.GetPreviousValue(firstHash, "foo")
	assert.NoError(t, err)
	assert.Equal(t, getResult, "bar")
	if len(resultHashes) != 3 {
		t.Fatal("Encountered has collision")

    op.setOperand(0, stb_op.getInput());
    op.getResult().setType(bts_op.getResult().getType());
  }

  if (final_op_is_bts) {
    if (bts_op.getInput().getDefiningOp<TF::PadOp>()) {
      bts_op.getResult().replaceAllUsesWith(pad_op.getInput());
    } else {
      bts_op.getResult().replaceAllUsesWith(bts_op.getInput());
    }
  }

  stb_op.getResult().dropAllUses();
  return success();
}

                                arith::ConstantOp op) const {
    for (auto connected_op : op.getResult().getUsers()) {
      auto cast_op = dyn_cast_or_null<CastOp>(connected_op);
      if (!cast_op || cast_op.getResult().use_empty()) continue;

      // Get types
      Type old_result_type = op.getResult().getType();
      ShapedType new_result_type =
          mlir::dyn_cast<ShapedType>(cast_op.getType());

    for (Operation* connected_op : op.getResult().getUsers()) {
      ConvertOp convert_op = dyn_cast_or_null<ConvertOp>(connected_op);
      // Skip if no convert op exists.
      if (!convert_op || convert_op.getResult().use_empty()) continue;

      // Get types.
      const Type old_result_type = op.getResult().getType();
      const ShapedType new_result_type =

  } else if (!converter.isLegal(convert_op.getResult().getType())) {
    if (!convert_op.getResult().hasOneUse()) {
      return false;
    }
    auto other_convert_op = dyn_cast_or_null<OtherConvertOp>(
        *convert_op.getResult().getUsers().begin());
    return other_convert_op &&
           converter.isLegal(other_convert_op.getResult().getType());
  }
  return true;
}