rest = after
		} else {
			return nil, data
		}

		var typeLine []byte
		typeLine, rest = getLine(rest)
		if !bytes.HasSuffix(typeLine, pemEndOfLine) {
			continue
		}
		typeLine = typeLine[0 : len(typeLine)-len(pemEndOfLine)]

		p = &Block{
			Headers: make(map[string]string),
			Type:    string(typeLine),
		}

		for {
			// This loop terminates because getLine's second result is

  EXPECT_TRUE(IsTypeLegalizedWithMlir(TypeID::get<TF::ModOp>()));
  EXPECT_FALSE(HasTf2XlaFallback(TypeID::get<TF::ModOp>()));
  EXPECT_FALSE(IsOpAllowedTf2xlaFallback(TypeID::get<TF::ModOp>()));
  EXPECT_FALSE(IsOpAllowedTf2xlaPreferred(TypeID::get<TF::ModOp>()));
}

TEST_F(LegalizationOpConfigTest, ExpectsTrueForTF2XLATypeID) {
  EXPECT_TRUE(HasTf2XlaFallback(TypeID::get<TF::AllOp>()));

  template <typename OpType>
  void Add() {
    ops_type_ids_.insert(TypeID::get<OpType>());
  }

  // Returns the type id of the ops in the TPUEmbeddingOpRegistry.
  const llvm::SmallDenseSet<mlir::TypeID>& GetOpsTypeIds();

  // Returns the global registry.
  static TPUEmbeddingOpsRegistry& Global();

 private:
  llvm::SmallDenseSet<mlir::TypeID> ops_type_ids_{};
};
}  // namespace TF
}  // namespace mlir

package main

import "fmt"

type Kind uint16
type Flag uint16

const (
	allKinds Kind = 1
	TopKind  Kind = (allKinds - 1)
)
type Value interface {
	Kind() Kind
}
type Vertex struct {
	BaseValue Value
	name string
}
func (v *Vertex) Kind() Kind {
	return TopKind
}

func main() {
	vA := &Vertex{name:"vA",}
	vB := &Vertex{name:"vB",}
	vX := &Vertex{name:"vX",}

	}
	dec.r = r
	dec.wireType = make(map[typeId]*wireType)
	dec.decoderCache = make(map[reflect.Type]map[typeId]**decEngine)
	dec.ignorerCache = make(map[typeId]**decEngine)
	dec.countBuf = make([]byte, 9) // counts may be uint64s (unlikely!), require 9 bytes

	return dec
}

// recvType loads the definition of a type.
func (dec *Decoder) recvType(id typeId) {
	// Have we already seen this type? That's an error

#include "mlir/IR/Types.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project
#include "mlir/Support/TypeID.h"  // from @llvm-project

namespace mlir {
namespace TF {

// Returns whether type can be further refined.
bool CanBeRefined(Type type);

class GpuHardware : public TargetHardware {
 public:
  static constexpr char kId[] = "GPU";
  mlir::RewritePatternSet GetTransformations(
      MLIRContext* context) const override;

  mlir::TypeID GetTypeId() const override {
    return mlir::TypeID::get<GpuHardware>();
  }

  double GetHardwareSwitchingCost(const TargetHardware* from,
                                  size_t buffer_size) const override;
};
}  // namespace tac

 public:
  static constexpr char kId[] = "ExampleHardware";

  mlir::RewritePatternSet GetTransformations(
      MLIRContext* context) const override;

  mlir::TypeID GetTypeId() const override {
    return mlir::TypeID::get<ExampleHardware>();
  }

  bool IsNotSupportedOp(mlir::Operation* op) const override { return false; }

  float AdvantageOverCPU() const override { return 5.0; }
};

 public:
  static constexpr char kId[] = "NNAPI";

  mlir::RewritePatternSet GetTransformations(
      MLIRContext* context) const override;

  mlir::TypeID GetTypeId() const override {
    return mlir::TypeID::get<NNAPIHardware>();
  }

  bool IsNotSupportedOp(mlir::Operation* op) const override { return false; }

  float AdvantageOverCPU() const override { return 5.0; }
};

  // A hook may use the public addOperations() method to add additional
  // operations to the dialect. Hooks will only apply to subsequent
  // instantations of the Dialect/MLIRContext.
  static void RegisterAdditionalOperationHook(TypeID uniqueId,
                                              AdditionalOpFunction fn);

  // Re-define publicly the protected addOperations() method from the Dialect
  // class, usually used in a Dialect constructor. This allows hook