*/
    Class<T> getType();

    /**
     * The tag used for the raw model without profile activation
     */
    ModelCacheTag<ModelData> RAW = new ModelCacheTag<ModelData>() {

        @Override
        public String getName() {
            return "raw";
        }

        @Override
        public Class<ModelData> getType() {
            return ModelData.class;
        }
    };

        if (expression.getType() == IncludeType.IDENTIFIER) {
            return new SimpleExpression(expression.getValue(), IncludeType.MACRO);
        }
        if (expression.getType() == IncludeType.TOKEN_CONCATENATION) {
            return new ComplexExpression(IncludeType.EXPAND_TOKEN_CONCATENATION, expression.getValue(), expression.getArguments());
        }

public interface FilterableBytecodeInterceptorFactory {

    BytecodeInterceptorType getType();

    /**
     * A marker interface that indicates that a class is used for generating bytecode upgrades.
     */
    interface BytecodeUpgradeInterceptorFactory extends FilterableBytecodeInterceptorFactory {
        @Override
        default BytecodeInterceptorType getType() {
            return BytecodeInterceptorType.BYTECODE_UPGRADE;
        }
    }

                                     NodeInitializerRegistry nodeInitializerRegistry
    ) {
        ModelType<P> propertyType = property.getType();
        ModelSchema<P> propertySchema = schemaStore.getSchema(propertyType);
        ModelType<T> publicType = bindings.getPublicSchema().getType();

        validateProperty(propertySchema, property, nodeInitializerRegistry);

  "TFL::IsBroadcastableElementsAttrAndType($0.getType(), $1.getType())">>;

def OperandsBroadcastToOutputType : Constraint<CPred<
  "TFL::OperandsBroadcastToOutputType($0.getType(), $1.getType(), "
                                     "$2.getType())">>;

def IsTailOfShape : Constraint<CPred<
  "TFL::IsTailOfShape($0.getType(), $1.getType())">>;

def IsReducedTailOfShape : Constraint<CPred<

  // etc.
  constexpr int64_t kLookupTableFindCostScale = 8;
  constexpr int64_t kLookupTableFindStringKeyCostScale = 16;

  auto value_type = mlir::cast<mlir::TensorType>(op.getValues().getType());
  auto key_type = mlir::cast<mlir::TensorType>(op.getKeys().getType());

  int64_t output_size = InferTensorSize(context, value_type);

  int64_t cost = kLookupTableFindCostScale * output_size;

import org.objectweb.asm.Type;

import static org.objectweb.asm.Type.getType;

/**
 * A collection of common types and method descriptors used when instrumenting bytecode.
 */
@NonNullApi
final class CommonTypes {
    public static final Type OBJECT_TYPE = getType(Object.class);
    public static final Type STRING_TYPE = getType(String.class);
    public static final String[] NO_EXCEPTIONS = new String[0];

            AvPair p = it.next();
            if ( p.getType() == type ) {
                it.remove();
            }
        }
    }


    /**
     * Replace all occurances of the given type
     * 
     * @param pairs
     * @param rep
     */
    public static void replace ( List<AvPair> pairs, AvPair rep ) {
        remove(pairs, rep.getType());
        pairs.add(rep);
    }

    return false;
  }

  auto opr1_type =
      llvm::dyn_cast_or_null<RankedTensorType>(op->getOperand(0).getType());
  auto opr2_type =
      llvm::dyn_cast_or_null<RankedTensorType>(op->getOperand(1).getType());
  auto res_type =
      llvm::dyn_cast_or_null<RankedTensorType>(op->getResult(0).getType());

  if (!(opr1_type && opr2_type && res_type)) {
    return false;
  }

    if (!preceding_cast) {
      return failure();
    }
    Value input = preceding_cast.getArg();
    Type input_type = input.getType();
    Type output_type = cast_op.getType();

    // Preserve quantization information for intermediate tensors.
    auto intermediate_type = preceding_cast.getType();
    if (isQuantizedType(intermediate_type) || isQuantizedType(output_type)) {
      return failure();
    }