}
}
library {
  function {
    signature {
      name: "test_func_name"
      input_arg {
        name: "a_0"
        type: DT_RESOURCE
      }
      input_arg {
        name: "a_1"
        type: DT_RESOURCE
      }
      output_arg {
        name: "a"
        type: DT_RESOURCE
      }
    }
    resource_arg_unique_id {
      key: 0
      value: 0
    }
    resource_arg_unique_id {

      @def_function.function(
          input_signature=[
              tensor_spec.TensorSpec(
                  shape=[10], dtype=dtypes.float32, name='x'
              ),
              tensor_spec.TensorSpec(
                  shape=[10], dtype=dtypes.float32, name='y'
              ),
          ]
      )
      def add(self, x, y):
        res = math_ops.add(x, y)
        return {'output': res}

  static se::DeviceMemoryBase DeviceMemoryFromTensor(const Tensor& tensor);

  // Assign the internal ShapedBuffer to new memory for the given dtype and
  // shape. If a ShapedBuffer exists already (has_shaped_buffer() == true), it
  // is replaced and the managed memory deallocated.
  Status AllocateShapedBuffer(DataType dtype, const xla::Shape& on_device_shape,
                              xla::LocalClient* client, int device_ordinal);

		return true
	default:
		return false
	}
}

type TypeAssert struct {
	Cache   *TypeAssertCache
	Inter   *InterfaceType
	CanFail bool
}
type TypeAssertCache struct {
	Mask    uintptr
	Entries [1]TypeAssertCacheEntry
}
type TypeAssertCacheEntry struct {
	// type of source value (a *runtime._type)
	Typ uintptr
	// itab to use for result (a *runtime.itab)

    key: "index"
    value {
      i: 3
    }
  }
}
node {
  name: "const"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 0.0
      }
    }
  }
}
node {

  input: "input1"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "input0"
  op: "Placeholder"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "input1"
  op: "Placeholder"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
}
versions {
  producer: 27
}

  input: "input0"
  input: "args_0"
  attr {
    key: "Tin"
    value {
      list {
        type: DT_FLOAT
        type: DT_RESOURCE
      }
    }
  }
  attr {
    key: "Tout"
    value {
      list {
        type: DT_FLOAT
        type: DT_RESOURCE
      }
    }
  }
  attr {
    key: "config"
    value {
      s: ""
    }
  }
  attr {

namespace mlir::quant::tensorflow {

bool IsTFQintType(const Type type) {
  return mlir::isa<TF::Qint8Type, TF::Qint16Type, TF::Qint32Type,
                   TF::Quint8Type, TF::Quint16Type>(type);
}

Type GetIntTypeFromTFQint(const Type type) {
  return TypeSwitch<Type, Type>(type)
      .Case<TF::Qint8Type>(
          [&type](Type) { return IntegerType::get(type.getContext(), 8); })
      .Case<TF::Qint16Type>(

  %0 = "tf.ReadVariableOp"(%handle) {_output_shapes = ["tfshape$dim { size: 3 }"], device = "/device:CPU:0", dtype = f32} : (tensor<!tf_type.resource<tensor<3xf32>>>) -> tensor<3xf32>
  %1 = "tf.ReadVariableOp"(%arg1) {_output_shapes = ["tfshape$dim { size: 1 } dim { size: 3 }"], device = "/device:CPU:0", dtype = f32} : (tensor<!tf_type.resource<tensor<1x3xf32>>>) -> tensor<1x3xf32>

  // CHECK-NEXT: [[ready_ch:%.*]] = tfrt.new.chain

  using type = double;
  static constexpr TF_DataType kDType = TF_DOUBLE;
};

struct Int32Type {
  using type = int32_t;
  static constexpr TF_DataType kDType = TF_INT32;
};

struct UINT8Type {
  using type = uint8_t;
  static constexpr TF_DataType kDType = TF_UINT8;
};

struct INT8Type {
  using type = int8_t;
  static constexpr TF_DataType kDType = TF_INT8;
};

struct INT64Type {
  using type = int64_t;