// FB-SAME:  21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, 31.0,
  // FB-SAME:  32.0, 33.0, 34.0, 35.0, 36.0, 37.0, 38.0, 39.0 ],
  // FB-NEXT:        quantized_dimension: 1
  // FB-NEXT:      }

  // FB-LABEL:     name: "tfl.fully_connected:1",
  // FB-NEXT:      quantization: {
  // FB-EMPTY:
  // FB-NEXT:      }

  // FB-LABEL:      operators: [ {

    TypedValue<TensorType> scales_value,
    TypedValue<TensorType> zero_points_value, FloatType expressed_type,
    int64_t storage_type_min, int64_t storage_type_max,
    int64_t quantized_dimension, PatternRewriter &rewriter) {
  // Check whether the scales operand has constant op.
  DenseFPElementsAttr scales;
  if (!matchPattern(scales_value, m_Constant(&scales))) {

  if (quant_params.scale.size() != 1) {
    return mlir::quant::UniformQuantizedPerAxisType::get(
        flags, storage_type, builder.getF32Type(), scales,
        quant_params.zero_point, quant_params.quantized_dimension, storage_min,
        storage_max);
  }
  return mlir::quant::UniformQuantizedType::get(
      flags, storage_type, builder.getF32Type(), scales[0],
      quant_params.zero_point.at(0), storage_min, storage_max);

        // The dequantize should still be quantized per-channel
        EXPECT_EQ(quant_tensor->quantization()->scale()->size(), 5);
        EXPECT_EQ(quant_tensor->quantization()->quantized_dimension(), 0);
      } else if (i == dequant_output_idx) {
        EXPECT_EQ(quant_tensor->type(), TensorType_FLOAT32);
      } else if (IsModelInputOrOutput(output_model, i)) {

  if (per_axis_qtype) {
    int32_t quantized_dimension = per_axis_qtype.getQuantizedDimension();
    for (int i = 0; i < output_shape.size(); ++i) {
      const APInt perm_val = perm_value_it[i];
      if (perm_val.getSExtValue() == quantized_dimension) {
        quantized_dimension = i;
        break;
      }
    }

        tensorflow::GetTypeFromTFTensorShape(axis_stats_shape, b.getF32Type()),
        min_maxs);
    // TODO(fengliuai): this quantization dimension isn't correct.
    axis = b.getI64IntegerAttr(tensor.quantization->quantized_dimension);
  }
  return b.create<mlir::quantfork::StatisticsOp>(b.getUnknownLoc(), res,
                                                 layer_stats, axis_stats, axis);
}

// Returns true if this is a basic LSTM op.

  auto _details_type = _o->details.type;
  auto _details = _o->details.Pack(_fbb);
  auto _quantized_dimension = _o->quantized_dimension;
  return tflite::CreateQuantizationParameters(
      _fbb,
      _min,
      _max,
      _scale,
      _zero_point,
      _details_type,
      _details,
      _quantized_dimension);
}

      quant::UniformQuantizedPerAxisType::get(
          /*flags=*/QuantizationFlags::Signed, builder_.getI8Type(),
          builder_.getF32Type(),
          /*scales=*/{1.0},
          /*zeroPoints=*/{0}, /*quantizedDimension=*/0, /*storageTypeMin=*/-128,
          /*storageTypeMax=*/127);
  EXPECT_TRUE(IsI8F32UniformQuantizedPerAxisType(qi8_per_axis_type));
  EXPECT_FALSE(IsI8F32UniformQuantizedType(qi8_per_axis_type));
}

      builder_, builder_.CreateVector<float>(mins),
      builder_.CreateVector<float>(maxs), /*scale=*/0, /*zero_point=*/0,
      tflite::QuantizationDetails_NONE, /*details=*/0,
      /*quantized_dimension=*/axis.has_value() ? axis.value() : 0);
}

std::optional<BufferOffset<tflite::SubGraph>> Translator::BuildSubGraph(
    const std::string& name, Region* region, const int index) {

                                                 nudgedZeroPoint, qmin, qmax);
}

quant::UniformQuantizedPerAxisType fakeQuantAttrsToType(
    Location loc, unsigned numBits, int32_t quantizedDimension,
    ArrayRef<double> rmins, ArrayRef<double> rmaxs, bool narrowRange,
    Type expressedType, bool isSigned) {
  size_t axisSize = rmins.size();
  if (axisSize != rmaxs.size()) {