if (!req_op) return failure();

    // Create a new func.call op with f32 output.
    auto new_call_op = call_op.clone();
    new_call_op->getResult(0).setType(
        mlir::cast<ShapedType>(call_op.getResult(0).getType())
            .clone(rewriter.getF32Type()));
    rewriter.setInsertionPoint(call_op);
    rewriter.insert(new_call_op);

    private static final Type SYSTEM_TYPE = getType(System.class);
    private static final Type INTEGER_TYPE = getType(Integer.class);
    private static final Type INSTRUMENTED_TYPE = getType(Instrumented.class);
    private static final Type LONG_TYPE = getType(Long.class);
    private static final Type BOOLEAN_TYPE = getType(Boolean.class);
    public static final Type PROPERTIES_TYPE = getType(Properties.class);

  TFRTensorType unconstrainted_type = rewriter.getType<TFRTensorType>();
  SmallVector<Value, 4> new_results;
  for (auto res : llvm::enumerate(call_op.getResultTypes())) {
    Type res_type = res.value();
    if (mlir::dyn_cast<TFRTensorType>(res_type)) {
      Value new_res = new_op->getResult(res.index());
      auto casted = rewriter.create<CastOp>(loc, res_type, new_res);
      new_results.push_back(casted.getOut());

  }

  QuantizationComponent quantization_component = 1;

  // Defines the target bit of the data.
  BitWidth bit_width = 2;

  // Defines the type of data of the quantized component.
  BitType bit_type = 3;

  // Defines whether quantization is done in narrow range.
  bool enable_narrow_range = 4;

  // Defines whether quantiation is done per-channel.
  bool enable_per_channel_quantization = 5;

	binary.LittleEndian.PutUint32(s[:], uint32(len(x)))
	binary.LittleEndian.PutUint32(s[4:], w.stringOff(x))
}

func (s *Sym) SetABI(x uint16)   { binary.LittleEndian.PutUint16(s[8:], x) }
func (s *Sym) SetType(x uint8)   { s[10] = x }
func (s *Sym) SetFlag(x uint8)   { s[11] = x }
func (s *Sym) SetFlag2(x uint8)  { s[12] = x }
func (s *Sym) SetSiz(x uint32)   { binary.LittleEndian.PutUint32(s[13:], x) }

			return n // already visited n.X before wrapping
		}

		ok := match(n)

		ir.EditChildren(n, mark)

		if ok {
			paren := ir.NewParenExpr(n.Pos(), n)
			paren.SetType(n.Type())
			paren.SetTypecheck(n.Typecheck())

			parens = append(parens, paren)
			n = paren
		}

		return n
	}
	ir.EditChildren(fn, mark)

	// Edit until stable.
	for {

                    setType("other-type")
                }
            }

            val adhocConfig by configurations.creating
            configurations.create("for-string-invoke")

            (artifacts) {
                adhocConfig(file("first.txt"))
                adhocConfig(file("second.txt")) {
                    setType("other-type")
                }

    @Override
    public Type visitPrimitive(PrimitiveType t, Void unused) {
        TypeKind kind = t.getKind();
        if (kind == TypeKind.INT) {
            return Type.INT_TYPE;
        }
        if (kind == TypeKind.BYTE) {
            return Type.BYTE_TYPE;
        }
        if (kind == TypeKind.BOOLEAN) {
            return Type.BOOLEAN_TYPE;
        }

      if (out_type.isa<TFRTensorType>()) {
        new_cst = rewriter.create<CastOp>(loc, out_type, new_cst->getResult(0));
      }
      rewriter.replaceOp(cst_tensor_op, new_cst->getResult(0));
      return success();
    }

    TypedAttr scalar;
    if (matchPattern(cst_tensor_op.getArg(), m_Constant(&scalar))) {
      Type new_out_type = RankedTensorType::get({}, scalar.getType());

    for (int i = 0; i < arg_shapes.size(); ++i) {
      auto metadata_arg = metadata_proto.add_args();
      metadata_arg->set_kind(
          tensorflow::tpu::TPUCompileMetadataProto::Arg::PARAMETER);
      metadata_arg->set_dtype(dtype);
    }
    // Set up one dummy retval.
    metadata_proto.add_retvals();
    bool use_tuple_args = true;
    std::vector<tensorflow::tpu::ShardingAndIndex> arg_core_mapping;