auto host_compute = builder.create<mlir::TF::_XlaHostComputeMlirOp>(
      loc, shard_output_types, manual_inputs,
      /*send_key=*/builder.getStringAttr(args_communication_key),
      /*recv_key=*/builder.getStringAttr(retvals_communication_key),
      /*host_mlir_module=*/builder.getStringAttr(serialized_func_module),
      /*manual_sharding=*/builder.getBoolAttr(true));
  host_compute_out_ops.push_back(host_compute);

      metadata_attrs.emplace_back(builder.getStringAttr(metadata->name),
                                  builder.getStringAttr("true"));
      continue;
    }

    std::vector<uint8_t> buffer = model->buffers[metadata->buffer]->data;
    metadata_attrs.emplace_back(
        builder.getStringAttr(metadata->name),
        builder.getStringAttr(llvm::StringRef(

  auto caller = builder.create<TF::StatefulPartitionedCallOp>(
      loc, result_types, operands, symbol,
      /*config=*/builder.getStringAttr(""),
      /*config_proto=*/builder.getStringAttr(""),
      /*executor_type=*/builder.getStringAttr(""));
  caller.setFAttr(symbol);

  // Set an attribute that our inliner will look for when choosing which
  // TF::StatefulPartitionedCallOps to inline.

    target_values.push_back((*max.begin()));
    if (auto tmpAttr = num_bits) {
      target_attrs.emplace_back(rewriter.getStringAttr("num_bits"), tmpAttr);
    }
    if (auto tmpAttr = narrow_range) {
      target_attrs.emplace_back(rewriter.getStringAttr("narrow_range"),
                                tmpAttr);
    }
    ::llvm::SmallVector<Type, 4> target_types;

      output_types = {output_type.clone(elem_type.getStorageType())};
    }

    SmallVector<Value> args = {q_op.getArg(), scale, zero_point};
    FlatSymbolRefAttr func_name =
        FlatSymbolRefAttr::get(rewriter.getStringAttr(kQuantizeFuncName));

    auto quantize_call = rewriter.create<TF::PartitionedCallOp>(
        loc, output_types, args, func_name,
        /*config=*/"", /*config_proto=*/"", /*executor_type=*/"");