for (uint64_t i = 0; i < block_rank; i++) {
        int64_t paddings_sum =
            paddings.getValues<APInt>()[{i, 0}].getSExtValue() +
            paddings.getValues<APInt>()[{i, 1}].getSExtValue();
        int64_t block_shape_i =
            block_shape.getValues<APInt>()[i].getSExtValue();
        padded_shape[i + 1] = (paddings_sum + input_shape[i + 1]);
        block_shape_ints.push_back(block_shape_i);
      }

    const int64_t input_zero_point_value =
        uniform_quantize_call_pattern_for_input.GetZeroPointsValueAttr()
            .getSplatValue<APInt>()
            .getSExtValue();

    Value input_value = uniform_quantize_call_pattern_for_input.GetInputValue();
    UniformQuantizedType input_quantized_element_type =
        CreateI8F32UniformQuantizedType(

      SmallVector<int32_t, 4> new_element_shape_values;

      auto int_values = dense_elem_attr.getValues<APInt>();
      for (auto it = int_values.begin(); it != int_values.end(); ++it) {
        auto dim_value = (*it).getSExtValue();
        if (it == int_values.begin() && dim_value == -1) {
          if (!default_to_single_batch_) {
            const char *error_info =
                "requires element_shape to be static during TF Lite "

                                     int *mask) const {
    for (const auto &idx : dense_elem_attr.getValues<APInt>()) {
      val.push_back(idx.getSExtValue());
      padded_val.push_back(idx.getSExtValue());
    }
    int attr_dim_count = val.size();
    int full_dim_count = padding_val.size();
    for (int i = attr_dim_count; i < full_dim_count; ++i) {

        for (const auto& dim :
             llvm::enumerate(shape_attr.getValues<llvm::APInt>())) {
          shape.push_back(builder.getI32IntegerAttr(
              mlir::TFL::ConvertToTfliteSize(dim.value().getSExtValue())));
          ++dim_size;
        }
        auto shape_type = tensorflow::GetTypeFromTFTensorShape(
            {static_cast<int32_t>(dim_size)}, builder.getIntegerType(32));