if (auto quant = spec.dyn_cast_or_null<UniformQuantizedType>()) {
    signature->push_back(AnyQuantizedType::get(
        quant.getFlags(), quant.getStorageType(), quant.getExpressedType(),
        quant.getStorageTypeMin(), quant.getStorageTypeMax()));
  } else if (auto any = spec.dyn_cast_or_null<AnyQuantizedType>()) {
    signature->push_back(any);
  } else {  // float

    QType new_qtype;
    if (auto uqtype = qtype.template dyn_cast<quant::UniformQuantizedType>()) {
      new_qtype = quant::UniformQuantizedType::getChecked(
          op.getLoc(), flags, qtype.getStorageType(), qtype.getExpressedType(),
          uqtype.getScale(), uqtype.getZeroPoint() - offset,
          uqtype.getStorageTypeMin() - offset,
          uqtype.getStorageTypeMax() - offset);
    } else if (auto aqtype = qtype.template dyn_cast<

          new_qtype = mlir::quant::UniformQuantizedPerAxisType::get(
              per_axis.getFlags(), per_axis.getStorageType(),
              per_axis.getExpressedType(), per_axis.getScales(),
              per_axis.getZeroPoints(), per_axis.getQuantizedDimension(),
              per_axis.getStorageTypeMin() - 1, per_axis.getStorageTypeMax());
        } else if (auto per_tensor =

      if (!qtype) {
        result_types.push_back(result_type);
        continue;
      }

      result_types.push_back(result_type.clone(qtype.getExpressedType()));
    }

    // Make a copy of the quantized function.
    auto module = call_op->getParentOfType<ModuleOp>();
    SymbolTable symbol_table(module);

                         q_peraxis_type.isSigned());
  } else if (auto q_calibrated_type =
                 mlir::dyn_cast<mlir::quant::CalibratedQuantizedType>(type)) {
    return GetTFLiteType(q_calibrated_type.getExpressedType());
  } else if (mlir::isa<mlir::TF::ResourceType>(type)) {
    return tflite::TensorType_RESOURCE;
  } else if (mlir::isa<mlir::TF::VariantType>(type)) {
    return tflite::TensorType_VARIANT;
  }

        break;
      }
    }
    element_type = quant::UniformQuantizedPerAxisType::get(
        per_axis_qtype.getFlags(), per_axis_qtype.getStorageType(),
        per_axis_qtype.getExpressedType(), per_axis_qtype.getScales(),
        per_axis_qtype.getZeroPoints(), quantized_dimension,
        per_axis_qtype.getStorageTypeMin(), per_axis_qtype.getStorageTypeMax());
  }

  TFL::TransposeOp::build(