device: The tensorflow device. eg. "/CPU:0"
    op_attrs: The tensorflow attributes excluding the func attrs.
    op_func_attrs: The func attrs.
    op_name: The tensorflow op name. eg. "tf.AddV2"

    Example:
      %out_ch = tfrt_fallback_async.createop(%in_ch) key(0) device("/CPU:0")
        "some.op"() {attr1 = value, attr2 = value2} {f_attr1 = "fn1", f_attr2 = "fn2"} num_args(1)
  }];

  let arguments = (ins

    device: The tensorflow device. eg. "/CPU:0"
    op_attrs: The tensorflow attributes excluding the func attrs.
    op_name: The tensorflow op name. eg. "tf.AddV2"

    Example:
      tfrt_fallback_sync.createop() key(0) device("/CPU:0")
        "some.op"() {attr1 = value, attr2 = value2} {f_attr1 = "fn1", f_attr2 = "fn2"} num_args(1)
  }];

  let arguments = (ins
    StrAttr:$node_def,

  }
  attr {
    key: "_arg1_attr1"
    value {
      f: 8.0
    }
  }
  attr {
    key: "index"
    value {
      i: 1
    }
  }
}
node {
  name: "arg2"
  op: "_Arg"
  attr {
    key: "T"
    value {
      type: DT_BOOL
    }
  }
  attr {
    key: "index"
    value {
      i: 2
    }
  }
}
node {
  name: "ret0"
  op: "_Retval"
  input: "arg0"
  attr {

        schema.attribute(attr1)
        schema.attribute(attr2)
        producer.attribute(attr2)
        producer.attribute(attr3)

        expect:
        schema.withProducer(producer).selectionSchema.hasAttribute(attr1)
        schema.withProducer(producer).selectionSchema.hasAttribute(attr2)
        schema.withProducer(producer).selectionSchema.hasAttribute(attr3)
    }

      name: "custom_relu"
    }
    attr {
      key: "_implements"
      value {
        func {
          name: "tensorflow.relu"
        }
      }
    }
  }
  function {
    signature {
      name: "custom_embedding_matmul"
    }
    attr {
      key: "_implements"
      value {
        func {
          name: "tensorflow.embedding_matmul"
          attr {
            key: "key1"

			replace:  func([]string, Attr) Attr { return Attr{} },
			attrs:    []Attr{Group("g", Int("a", 1))},
			wantText: "",
			wantJSON: `{}`,
		},
		{
			name: "replace empty 1",
			with: func(h Handler) Handler {
				return h.WithGroup("g").WithAttrs([]Attr{Int("a", 1)})
			},
			replace:  func([]string, Attr) Attr { return Attr{} },
			attrs:    []Attr{Group("h", Int("b", 2))},
			wantText: "",

      new llvm::StringSet<>({"asymmetric_quantize_inputs"});
  return *ops;
}

void CollectAllowedAttrs(CallOp src, NamedAttrList* attrs) {
  for (auto& attr : src->getAttrs()) {
    if (GetAllowedAttributes().contains(attr.getName().strref())) {
      attrs->append(attr);
    }
  }
}

// Adds `attrs` to all the operations between `begin` and `end` in the same
// block. Does not include `end`.

  for (auto attr : kQuantizationAxisAttrs) {
    if (defining_op->hasAttr(attr)) {
      return defining_op->getAttr(attr);
    }
  }
  // Not found.
  return rewriter.getI64IntegerAttr(-1);
}

LogicalResult CheckIfAttrIs8Bit(const std::string& attr, Operation* op,
                                bool& is_8_bit) {
  Type element_type;

		}
	}
	ne := countEmptyGroups(attrs[i:])
	r.back = slices.Grow(r.back, len(attrs[i:])-ne)
	for _, a := range attrs[i:] {
		if !a.Value.isEmptyGroup() {
			r.back = append(r.back, a)
		}
	}
}

// Add converts the args to Attrs as described in [Logger.Log],
// then appends the Attrs to the [Record]'s list of Attrs.
// It omits empty groups.
func (r *Record) Add(args ...any) {

      // will not use this representation.
      mlir::NamedAttrList attrs;
      for (const auto& func_attr : value.func().attr()) {
        TF_ASSIGN_OR_RETURN(auto attr,
                            ConvertAttributeValue(func_attr.second, builder));
        attrs.push_back(builder->getNamedAttr(func_attr.first, attr));
      }
      auto func_attrs = builder->getDictionaryAttr(attrs);