type Writer struct {
	wr        *bio.Writer
	stringMap map[string]uint32
	off       uint32 // running offset

	b [8]byte // scratch space for writing bytes
}

func NewWriter(wr *bio.Writer) *Writer {
	return &Writer{wr: wr, stringMap: make(map[string]uint32)}
}

func (w *Writer) AddString(s string) {
	if _, ok := w.stringMap[s]; ok {
		return
	}
	w.stringMap[s] = w.off
	w.RawString(s)
}

#include "llvm/ADT/StringMap.h"
#include "mlir/IR/Attributes.h"  // from @llvm-project
#include "mlir/IR/PatternMatch.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/quantization/common/attrs_and_constraints.h"

namespace mlir::quant {

LogicalResult FillAttributesForUniformQuantizedDotOp(
    PatternRewriter& rewriter, Operation* op,
    llvm::StringMap<Attribute>& identifier_to_attr,

func main() {
	if smallInt != smallIntAsm {
		println("smallInt", smallInt, "!=", smallIntAsm)
	}
	if bigInt != bigIntAsm {
		println("bigInt", uint64(bigInt), "!=", bigIntAsm)
	}
	if stringVal != string(stringAsm[:]) {
		println("stringVal", stringVal, "!=", string(stringAsm[:]))
	}
	if longStringVal != string(longStringAsm[:]) {
		println("longStringVal", longStringVal, "!=", string(longStringAsm[:]))
	}

	return []attribute.KeyValue{
		attribute.Stringer("accept", &lazyAccept{req: req}),
		attribute.Stringer("audit-id", &lazyAuditID{req: req}),
		attribute.Stringer("client", &lazyClientIP{req: req}),
		attribute.Stringer("api-group", &lazyAPIGroup{req: req}),
		attribute.Stringer("api-version", &lazyAPIVersion{req: req}),
		attribute.Stringer("name", &lazyName{req: req}),
		attribute.Stringer("subresource", &lazySubresource{req: req}),

        "TPUEmbedding layers");

  op->removeAttr(kTPUEmbeddingAttr);
  return success();
}

LogicalResult FindTPUEmbeddingOps(
    func::FuncOp func_op, llvm::StringMap<Operation*>* enqueue_op_map,
    llvm::StringMap<Operation*>* recv_activation_op_map,
    llvm::StringMap<Operation*>* send_gradient_op_map) {
  auto walk_result = func_op.walk([&](Operation* op) {
    if (llvm::isa<TF::RecvTPUEmbeddingActivationsOp>(op))

// license that can be found in the LICENSE file.package main

package main

type Stringer interface {
	String() string
}

type (
	stringer  struct{}
	stringers [2]stringer
	foo       struct {
		stringers
	}
)

func (stringer) String() string  { return "" }
func toString(s Stringer) string { return s.String() }

func (v stringers) toStrings() []string {

// on stdout, and causes the expected output to not match.

package main

import (
	"fmt"
)

var sink *string

type stringPair struct {
	a, b string
}

type stringPairPair struct {
	x, y stringPair
}

// The goal of this test is to be sure that the call arg/result expander works correctly
// for a corner case of passing a 2-nested struct that fits in registers to/from calls.

// on stdout, and causes the expected output to not match.

package main

import (
	"fmt"
)

var sink *string

type stringPair struct {
	a, b string
}

type stringPairPair struct {
	x, y stringPair
}

// The goal of this test is to be sure that the call arg/result expander works correctly
// for a corner case of passing a 2-nested struct that fits in registers to/from calls.

	case unknownVal:
		return false
	default:
		panic(fmt.Sprintf("%v not a Bool", x))
	}
}

// StringVal returns the Go string value of x, which must be a [String] or an [Unknown].
// If x is [Unknown], the result is "".
func StringVal(x Value) string {
	switch x := x.(type) {
	case *stringVal:
		return x.string()
	case unknownVal:
		return ""
	default:
		panic(fmt.Sprintf("%v not a String", x))
	}

  void CountOp(DenseMap<StringRef, llvm::StringMap<int64_t>> &op_count_map,
               StringRef op_name, StringRef dtype);

 private:
  llvm::StringMap<int64_t> op_with_dialect_count_;
  DenseMap<StringRef, llvm::StringMap<int64_t>> op_dtype_count_;
  llvm::StringMap<int64_t> dialect_count_;
  llvm::StringMap<StringRef> dialect_name_of_;
  llvm::StringMap<StringRef> op_name_of_;