return attrs

    }

    private static FileVisitResult visit(Path path, PathVisitor pathVisitor) throws IOException {
        BasicFileAttributes attrs;
        try {
            attrs = Files.readAttributes(path, BasicFileAttributes.class);
        } catch (IOException e) {
            try {
                attrs = Files.readAttributes(path, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS);
            } catch (IOException next) {

    }

    def "creates and caches resolved dependencies with attributes"() {
        def fromModule = newModule('from')
        def selectedModule = newModule('selected', 'a', '1', selectedByRule(), newVariant('custom', [attr1: 'foo', attr2: 'bar']))
        def variant = newVariant("foo")

        when:
        def dep = factory.createResolvedDependency(selector('requested'), fromModule, selectedModule, variant, false)

	"flag"
	"internal/race"
	"io"
	"log/slog"
	"log/slog/internal"
	"testing"
)

func init() {
	flag.BoolVar(&internal.IgnorePC, "nopc", false, "do not invoke runtime.Callers")
}

// We pass Attrs inline because it affects allocations: building
// up a list outside of the benchmarked code and passing it in with "..."
// reduces measured allocations.

func BenchmarkAttrs(b *testing.B) {
	ctx := context.Background()

			log.Println("forbidden: " + r.URL.Path)
			return
		}

		next.ServeHTTP(w, r)
	})
}

func handleAttrs(attrs map[string]string) func(w http.ResponseWriter, r *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		vars := mux.Vars(r)

		if val, ok := attrs[vars[attrKey]]; ok {
			fmt.Fprint(w, val)
			return
		}

		http.Error(w, http.StatusText(http.StatusNotFound), http.StatusNotFound)

  auto call_target =
      rewriter.getNamedAttr("call_target_name", op->getName().getIdentifier());
  SmallVector<NamedAttribute> attrs{op->getAttrs()};
  attrs.push_back(call_target);
  auto custom_call = rewriter.create<mlir::stablehlo::CustomCallOp>(
      op->getLoc(), op->getResultTypes(), op->getOperands(), attrs);
  rewriter.replaceOp(op, custom_call.getResults());
  return success();
}

}  // namespace

template <typename OpTy>

}

func rebuildAttributes(bm baseMetric, labelValues []LabelValue) ([]attribute.KeyValue, attribute.Set) {
	attrs := make([]attribute.KeyValue, 0, len(bm.attrs)+len(labelValues))
	attrs = append(attrs, bm.attrs...)
	for _, v := range labelValues {
		attrs = append(attrs, v.keyValue)
	}

	set := attribute.NewSet(attrs...)
	return attrs, set

    (TFL_TransposeOp
      (TFL_ResizeBilinearOp
        (TFL_TransposeOp $input,
          (Arith_ConstantOp
            ConstantAttr<RankedI32ElementsAttr<[4]>,"{0, 2, 3, 1}">)),
        (Arith_ConstantOp:$output_size (GetI32DenseAttr (GetAsVectorAttr<"output"> $attrs))),
        (GetCompositeAttributeAs<"align_corners", "BoolAttr"> $attrs),
        ConstBoolAttrTrue,

        RelativePath parentPath,
        @Nullable BasicFileAttributes attrs,
        AtomicBoolean stopFlag,
        FileSystem fileSystem
    ) {
        boolean isDirectory = attrs != null && attrs.isDirectory();
        RelativePath relativePath = parentPath.append(!isDirectory, path.getFileName().toString());
        return getRootFileVisitDetails(path, relativePath, attrs, stopFlag, fileSystem);
    }

    /**

    auto operand_size_attr = builder.getDenseI32ArrayAttr(operand_sizes);
    NamedAttrList attrs(send_op->getAttrs());
    attrs.set(send_op.getOperandSegmentSizeAttr(), operand_size_attr);

    AddOperandAndRewriteAs<XlaSendTPUEmbeddingGradientsOp>(send_op, dedup_op,
                                                           attrs, &builder);
  }
  return success();
}

void RewriteTPUEmbeddingOps::runOnOperation() {