std::vector<int>* traversal_order,
                            std::vector<TfLiteDimensionType>* format,
                            std::vector<int>* b_map, std::vector<int>* b_size) {
  const int dims_count = block_size.size();
  traversal_order->resize(dims_count);
  format->resize(dims_count);
  for (int i = 0; i < dims_count; i++) {
    (*traversal_order)[i] = i;
  }

  // CHECK-LABEL: @sparse_f32

  // CHECK-LABEL: @sparse_f32

  // ..., dn-1),
  //   - if not block sparse, the traversal_order is just a permutation of (d0,
  //     ..., dn-1). For example, a 2-D matrix stored in row-major order would
  //     have traversal_order = (d0, d1).
  //   - if block sparse with a k-dimensional block (0 <= k <= n), the
  //     traversal_order has n + k elements. The first n elements are still a

  // ..., dn-1),
  //   - if not block sparse, the traversal_order is just a permutation of (d0,
  //     ..., dn-1). For example, a 2-D matrix stored in row-major order would
  //     have traversal_order = (d0, d1).
  //   - if block sparse with a k-dimensional block (0 <= k <= n), the
  //     traversal_order has n + k elements. The first n elements are still a

  // ..., dn-1),
  //   - if not block sparse, the traversal_order is just a permutation of (d0,
  //     ..., dn-1). For example, a 2-D matrix stored in row-major order would
  //     have traversal_order = (d0, d1).
  //   - if block sparse with a k-dimensional block (0 <= k <= n), the
  //     traversal_order has n + k elements. The first n elements are still a

  let assemblyFormat = "`<` struct(params) `>`";
}

def SparsityParameterAttr : AttrDef<TFL_Dialect, "SparsityParameter"> {
  let mnemonic = "sparsity_parameter";
  let parameters = (ins
      I32ArrayParameter:$traversal_order,
      I32ArrayParameter:$block_map,
      ArrayRefParameter<"DimensionMetadataAttr">:$dim_metadata
  );
  let summary = "Sparsity parameter.";
  let assemblyFormat = "`<` struct(params) `>`";
}

  (void)_o;
  (void)_resolver;
  { auto _e = traversal_order(); if (_e) { _o->traversal_order.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->traversal_order[_i] = _e->Get(_i); } } else { _o->traversal_order.resize(0); } }

          builder_, tflite::DimensionType_SPARSE_CSR, 0, segments_type,
          array_segments, indices_type, array_indices);
    }
  }

  std::vector<int> traversal_order(dim_size);
  for (int i = 0; i < dim_size; i++) {
    traversal_order[i] = s_attr.getTraversalOrder()[i];
  }
  const int block_map_size = s_attr.getBlockMap().size();
  std::vector<int> block_map(block_map_size);

    } 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(
      value_type.getElementType().getIntOrFloatBitWidth() / CHAR_BIT);
  mlir::TypedAttr dummy_value =