Attribute RewriteTFRCallOp::ProcessAttributeValue(Attribute attr,
                                                  StringAttr attr_type) const {
  if (!attr_type) return attr;

  if (attr_type.getValue() == "tensor") {
    if (auto f = mlir::dyn_cast<FloatAttr>(attr)) {
      RankedTensorType type = RankedTensorType::get({}, f.getType());
      return DenseFPElementsAttr::get(type, attr);
    }

                            /*filter_width*/(GetI32At<1> (GetAsVectorAttr<"kernel_size"> $attrs)),
                            /*padding*/(GetAvgPoolOpPadAttr $old_val),
                            /*stride_h*/(GetI32At<0> (GetAsVectorAttr<"stride"> $attrs)),
                            /*stride_w*/(GetI32At<1> (GetAsVectorAttr<"stride"> $attrs)),

    list->add_s(s);
  }
  return {string_list_attr.first, attr_value};
}

impl::NodeMatcherProperties impl::Attr(std::pair<string, AttrValue> attr) {
  impl::NodeMatcherProperties props;
  props.set_attr(std::move(attr));
  return props;
}

impl::NodeMatcherProperties impl::Attr(string name) {
  impl::NodeMatcherProperties props;
  props.set_attr({std::move(name), std::nullopt});
  return props;
}

  for (const NamedAttribute &attr : from->getAttrs())
    if (P(attr)) to->setAttr(attr.getName(), attr.getValue());
}

// Copies attributes whose name begins with an _ from `from` to `to`.
inline void CopyUnderscoredAttributes(Operation *from, Operation *to) {
  CopyAttributes(from, to, [](const NamedAttribute &attr) {
    return attr.getName().strref().front() == '_';
  });
}

    it->second.second.emplace_back(std::move(node_info));
  }
}

// Returns `true` iff node has a given `attr` set to `true`. Returns `false`
// both for the missing attr, and the attr set to `false`.
static bool HasBoolAttr(const NodeDef& node, const char* attr) {
  const auto& it = node.attr().find(attr);
  return it != node.attr().end() && it->second.b();
}

bool CanCreateXlaKernel(const NodeDef& node_def) {

  static Derived get(ArrayRef<StringAttr> attrs, MLIRContext* context) {
    return Base::get(context, attrs);
  }

  static Derived getChecked(ArrayRef<StringAttr> attrs, Location loc) {
    return Base::getChecked(loc, loc.getContext(), attrs);
  }
  static Derived getChecked(function_ref<InFlightDiagnostic()> emitError,
                            MLIRContext* context, ArrayRef<StringAttr> attrs) {

      CHECK-NEXT:      .Attr("T: numbertype")
      CHECK-NEXT:      .Output("o1: T");
      CHECK-EMPTY
      CHECK-LABEL: REGISTER_OP("TestCompositeOp")
      CHECK-NEXT:      .Input("x: T")
      CHECK-NEXT:      .Input("y: T")
      CHECK-NEXT:      .Attr("act: {'', 'relu'}")
      CHECK-NEXT:      .Attr("trans: bool = true")
      CHECK-NEXT:      .Attr("T: numbertype")
      CHECK-NEXT:      .Output("o1: T")

    return mlir::failure();

  int64_t num_results = 0;
  if (succeeded(parser.parseOptionalColon())) {
    mlir::IntegerAttr attr;
    mlir::NamedAttrList attrs;
    if (failed(parser.parseAttribute(attr, "num_results", attrs)))
      return mlir::failure();
    num_results = attr.getValue().getSExtValue();
  }
  if (num_results < 0) return mlir::failure();

  llvm::SmallVector<mlir::Type, 4> operand_types;

	default:
		return nil, EINVAL
	}
	var attrs []NetlinkRouteAttr
	for len(b) >= SizeofRtAttr {
		a, vbuf, alen, err := netlinkRouteAttrAndValue(b)
		if err != nil {
			return nil, err
		}
		ra := NetlinkRouteAttr{Attr: *a, Value: vbuf[:int(a.Len)-SizeofRtAttr]}
		attrs = append(attrs, ra)
		b = b[alen:]
	}
	return attrs, nil
}

            Map<String, String> attrs = dominant.getAttributes();
            List<XmlNode> children = null;

            for (Map.Entry<String, String> attr : recessive.getAttributes().entrySet()) {
                String key = attr.getKey();
                if (isEmpty(attrs.get(key))) {
                    if (attrs == dominant.getAttributes()) {
                        attrs = new HashMap<>(attrs);
                    }