}

  return result;
}

template <typename T>
std::vector<T> BuildSparsityParameterAttribute(
    const std::vector<int>& block_size, const T* dense_buffer, Operation* inst,
    OpBuilder* builder, SparsityParameterAttr* s_param) {
  ElementsAttr attr;
  ShapedType type;
  if (auto cst = dyn_cast<ConstOp>(inst)) {
    attr = cst.getValue();
    type = mlir::cast<ShapedType>(cst.getType());

      "int32_t":$dense_size,
      I32ArrayParameter:$segments,
      I32ArrayParameter:$indices
  );
  let summary = "Dimension metadata.";
  let assemblyFormat = "`<` struct(params) `>`";
}

def SparsityParameterAttr : AttrDef<TFL_Dialect, "SparsityParameter"> {
  let mnemonic = "sparsity_parameter";
  let parameters = (ins
      I32ArrayParameter:$traversal_order,
      I32ArrayParameter:$block_map,

  }];

  let arguments = (ins ElementsAttr:$value,
                   SparsityParameterAttr:$s_param,
                   ElementsAttr:$compressed_data);

  let results = (outs AnyTensor:$output);

  let builders = [
    OpBuilder<(ins "TypedAttr":$value, "SparsityParameterAttr":$s_param,
      "Attribute":$compressed_data),
    [{
      $_state.addTypes(value.getType());

          0, segments, indices);
    } else {
      return errors::Unimplemented("Unsupported dimension metadata type");
    }
  }
  auto s_param = tfl::SparsityParameterAttr::get(
      builder.getContext(), tensor.sparsity->traversal_order,
      tensor.sparsity->block_map, dim_metadata);

  std::vector<char> dense_buffer(

  // Returns a unique name for `val`.
  std::string UniqueName(mlir::Value val);

  BufferOffset<tflite::SparsityParameters> BuildSparsityParameters(
      const mlir::TFL::SparsityParameterAttr& s_attr);

  bool EstimateArithmeticCount(int64_t* count);

  // Check compatibility with GPU delegate and returns the compatibility.
  bool CheckGpuDelegateCompatibility(uint8_t* model_buffer_pointer);