};
    return llvm::all_of(op->getOperandTypes(), is_not_variant) &&
           llvm::all_of(op->getResultTypes(), is_not_variant);
  };

  auto is_set_item_legal = [](Operation *op) {
    return op->hasAttr("resize_if_index_out_of_bounds") &&
           op->getAttr("resize_if_index_out_of_bounds")
               .cast<mlir::BoolAttr>()
               .getValue();
  };

  ConversionTarget target(*context);

  return changed;
}

bool ShapeInference::InferShapeForFunctionAttachedToXlaHostCompute(
    XlaHostComputeOp op) {
  const std::string kShapeInferenceGraph = "shape_inference_graph";
  if (!op->hasAttr(kShapeInferenceGraph)) {
    return false;
  }

  ModuleOp module = op->getParentOfType<ModuleOp>();
  func::FuncOp func = module.lookupSymbol<func::FuncOp>(

  // attribute. This provides a hook for the user to represent the variable
  // tensor in the MLIR level.
  if (auto* inst = value.getDefiningOp();
      inst && inst->hasAttr("tfl.is_variable")) {
    is_variable = true;
  }

  bool has_rank = type.hasRank();

  if (shape_signature.empty()) {
    return tflite::CreateTensor(

		if i >= 0 && i < h.sigTParams.Len() && t == h.sigTParams.At(i) {
			return 9173 + 3*uint32(i)
		}
	}
	return h.hashPtr(t.Obj())
}

// hashPtr hashes the pointer identity of ptr. It uses h.ptrMap to ensure that
// pointers values are not dependent on the GC.
func (h Hasher) hashPtr(ptr any) uint32 {
	if hash, ok := h.ptrMap[ptr]; ok {
		return hash
	}
	hash := uint32(reflect.ValueOf(ptr).Pointer())

            rewriter.getStringAttr(sharding_proto.SerializeAsString()));
      } else {
        data_and_token->setAttr(kShardingAttr, op.get_XlaShardingAttr());
      }
    }

    if (op->hasAttr("layouts")) {
      // Append a UnitAttr for the "token" operand of the mhlo.infeed op here to
      // avoid compilation failure when exporting "layouts" attribute of the

		s.writeErrorResponse(w, errInvalidArgument)
		return
	}
	var verifier *BitrotVerifier
	if r.Form.Get(storageRESTBitrotAlgo) != "" {
		hashStr := r.Form.Get(storageRESTBitrotHash)
		var hash []byte
		hash, err = hex.DecodeString(hashStr)
		if err != nil {
			s.writeErrorResponse(w, err)
			return
		}
		verifier = NewBitrotVerifier(BitrotAlgorithmFromString(r.Form.Get(storageRESTBitrotAlgo)), hash)