%0 = "tfl.pseudo_qconst"() {qtype = tensor<128x!quant.uniform<i32:f32, 0.7>>, value = dense<0> : tensor<128xi32>} : () -> tensor<128x!quant.uniform<i32:f32, 0.7>>

  // CHECK-NOT: tac.device tac.inference_type
  %1 = "tfl.pseudo_const"() {value = dense<[4, 384, 32]> : tensor<3xi32>} : () -> tensor<3xi32>
  // CHECK: tac.device = "CPU", tac.inference_type = "QUANTIZED_INT8"
  %2 = "tfl.reshape"(%arg0, %0) : (tensor<4x384x32x!quant.uniform<i8:f32, 0.2:-3>>, tensor<4xi32>) -> tensor<1x4x384x32x!quant.uniform<i8:f32, 0.2:-3>>
  // CHECK-NOT: tac.device tac.inference_type

enum InferenceType {
  UNKNOWN = 0,
  FLOAT = 1,
  QUANTIZED_INT8 = 2,
  QUANTIZED_UINT8 = 3,
  HYBRID = 4
};

inline InferenceType GetInferenceTypeEnum(llvm::StringRef inference_type_str) {
  if (inference_type_str == "FLOAT") {
    return FLOAT;
  } else if (inference_type_str == "QUANTIZED_INT8") {
    return QUANTIZED_INT8;
  } else if (inference_type_str == "QUANTIZED_UINT8") {
    return QUANTIZED_UINT8;

      return 0;
    } else if (to_inference_type == QUANTIZED_INT8 ||
               to_inference_type == QUANTIZED_UINT8) {
      // QUANT path.
      return kQuantCost * total_element_count_transferred;
    }
  }

  if (from_inference_type == QUANTIZED_INT8 ||
      from_inference_type == QUANTIZED_UINT8) {
    // Dequant path.

#include "tensorflow/lite/c/c_api_types.h"
#include "tensorflow/lite/model.h"

namespace mlir {
namespace lite {

// Supported resulting types from quantization process.
enum class BufferType { QUANTIZED_INT8, QUANTIZED_FLOAT16 };

// Stores information about how to quantize a user-specified custom operation.
// CustomOpInfo contains info of its corresponding CustomOp registered in the

  if (float_type_observed) {
    if (int8_type_observed || uint8_type_observed) {
      return HYBRID;
    } else {
      return FLOAT;
    }
  }

  if (int8_type_observed) {
    return QUANTIZED_INT8;
  }

  if (uint8_type_observed) {
    return QUANTIZED_UINT8;
  }

  // Default to float inference.
  return FLOAT;
}

}  // namespace tac
}  // namespace TFL

// is just an estimation.
constexpr float kQuantizedInferenceEfficiency = 0.3;

inline float InferenceTypeEfficiency(InferenceType inference_type) {
  if (inference_type == QUANTIZED_INT8 || inference_type == QUANTIZED_UINT8) {
    return kQuantizedInferenceEfficiency;
  }
  return 1.0;
}

// CPU hardware class which handles CPU capabilities in TFLite.