acc.getName().get() + ", " + acc.getRead().get() + ", " + acc.getWrite().get() + "}"
                            );
                            secondaryAccess.get().forEach(it -> {
                                System.out.println("secondaryAccess { " +
                                        it.getName().get() + ", " + it.getRead().get() + ", " + it.getWrite().get() +
                                        "}"

     * Describes if a certain class of users has read access to a file or directory.
     * <p>
     * Read access is the capability to view the contents of a file, or to list the contents of a directory.
     */
    boolean getRead();

    /**
     * Describes if a certain class of users has write access to a file or directory.
     * <p>
     * Write access is the capability to modify or remove the contents of a file,

    String toString() {
        return "[operation $name]"
    }

    Instant getEnd() {
        def instant = end.get()
        if (instant == null) {
            throw new IllegalStateException("Operation '$name' has not completed yet.")
        }
        return instant
    }

    Duration getDuration() {
        return getEnd() - start
    }

    void completed(Instant when) {

            }

            class Bean {
                @InputFiles FileCollection files
            }

            abstract class Test extends DefaultTask {
                @Nested abstract Property<Bean> getBean()
                @TaskAction def test() { assert false }
            }

            tasks.register('test', Test) {
                bean = new Bean().tap {
                    files = configurations.implementation

      }
      is_cpu_read = parsed_name.type == kCpuDeviceType;
      return success();
    }
  }
  is_cpu_read = false;
  return success();
}

// Get the reads to hoist in the `replicate`.
LogicalResult GetReads(FuncOp func, ReplicateOp replicate,
                       llvm::SmallVector<ReadVariableOp, 4>& reads) {
  for (Operation& op : replicate.getBody().front()) {
    if (auto read = llvm::dyn_cast<ReadVariableOp>(&op)) {

     * <p>
     * Read access grants the capability to view the contents of a file,
     * or to list the contents of a directory.
     */
    void setRead(boolean read);

    /**
     * Enables or disables write access to a file or directory for a certain class of users.
     * <p>
     * Write access grants the capability to modify or remove the contents of a file,

            }

            class IncrementAndPrint implements FlowAction<Parameters> {
                interface Parameters extends FlowParameters {
                    @Input Property<Bean> getBean()
                }
                void execute(Parameters parameters) {
                    parameters.with {
                        println("Bean.value = " + bean.get().value.incrementAndGet())
                    }

                @Internal
                Property<String> getUnused()
            }

            abstract class SomeTask extends DefaultTask {
                @Nested
                abstract Bean getBean()

                @Nested
                abstract Bean getUnusedBean()

                @Internal
                abstract Property<String> getValue()

                @Internal

    // Compute rhs = offset - mean * multiplier
    Value rhs = rewriter.create<mhlo::MulOp>(bn_op.getLoc(), multiplier,
                                             bn_op.getMean());
    rhs = rewriter.create<mhlo::SubtractOp>(bn_op.getLoc(), bn_op.getOffset(),
                                            rhs);

    // Broadcast `multiplier` and `rhs`
    Value shape_value;

      result_batch_shape_compile_time_extents);
  auto result_batch_shape = rewriter->create<shape::BroadcastOp>(
      loc, shape_type, lhs_splitted.getHead(), rhs_splitted.getHead(),
      /*error=*/nullptr);
  // Lambda which handles the broadcasting of one side to the common
  // leading-batch dimensions.
  auto broadcast_one_side = [&](Value side, RankedTensorType type,