Value value = CreateConstValue<int8_t>(builder, module->getLoc(),
                                         unpacked_shape, unpacked_values);
  Value packed_value = PackOperand(builder, module->getLoc(), value, pack_dim);
  DenseIntElementsAttr packed_value_attr;
  ASSERT_TRUE(matchPattern(packed_value, m_Constant(&packed_value_attr)));

  ShapedType packed_shape_type =
      mlir::dyn_cast<ShapedType>(packed_value.getType());

  auto input_type = mlir::dyn_cast<RankedTensorType>(input.getType());
  if (!input_type) return success();
  int64_t rank = input_type.getRank();

  DenseIntElementsAttr dims_attr;
  if (!matchPattern(dims, m_Constant(&dims_attr))) return success();
  for (const auto &dim_pair : llvm::enumerate(dims_attr)) {
    int64_t cur_dim = dim_pair.value().getSExtValue();

        const_op->getLoc(),
        DenseElementsAttr::get(
            RankedTensorType::get(/*shape=*/{}, element_type),
            splat_elements_attr.getSplatValue<Attribute>()));
    auto broadcast_dims = DenseIntElementsAttr::get(
        RankedTensorType::get(/*shape=*/{0}, op_builder->getI64Type()),
        llvm::SmallVector<int64_t>{});
    mhlo::BroadcastInDimOp broadcast_in_dim_op =
        op_builder->create<mhlo::BroadcastInDimOp>(

    const int ceil_pad_right = pool.kw - remaining_right;
    pad_right = ceil_pad_right - pool.pw;
  }

  return {pool.ph, pad_bottom, pool.pw, pad_right};
}

DenseIntElementsAttr GetPadOpAttr(Builder& builder, CompositeOp op) {
  const TorchAvgPoolData pool = GetTorchAvgPoolData(op);

  const auto values = GetPadOpPaddingValues(pool);

      return;
    }

    op_builder->setInsertionPoint(const_op);
    mlir::arith::ConstantOp fill_shape =
        op_builder->create<mlir::arith::ConstantOp>(
            const_op->getLoc(),
            DenseIntElementsAttr::get(
                tensorflow::GetTypeFromTFTensorShape(
                    {splat_elements_attr.getType().getRank()},
                    op_builder->getI64Type()),

                            converter.quantizeFloatToInt(floatAttr.getValue()));
  }

  return nullptr;
}

/// Converts a real expressed DenseFPElementsAttr to a corresponding
/// DenseElementsAttr (typically DenseIntElementsAttr) containing quantized
/// storage values assuming the given quantizedElementType and converter.
static DenseElementsAttr convertDenseFPElementsAttr(
    DenseFPElementsAttr realFPElementsAttr,

  auto ranked_ty = mlir::dyn_cast<RankedTensorType>(input_ty);
  if (!ranked_ty) return UnrankedTensorType::get(element_ty);
  int64_t rank = ranked_ty.getRank();

  DenseIntElementsAttr indices;
  if (!matchPattern(reduction_indices, m_Constant(&indices))) {
    // Output type is unranked if reduction indices are not constant and reduced
    // dimensions are not kept.

    builder.setInsertionPointToStart(func.addEntryBlock());
    llvm::SmallVector<int> shape{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    builder.create<mlir::arith::ConstantOp>(
        builder.getUnknownLoc(),
        mlir::DenseIntElementsAttr::get(
            mlir::RankedTensorType::get(shape.size(), builder.getI32Type()),
            shape));
    builder.create<mlir::func::ReturnOp>(builder.getUnknownLoc());
  }