try {
      entry.setValue("four");
      fail("UnsupportedOperationException expected");
    } catch (UnsupportedOperationException expected) {
    }
    @SuppressWarnings("unchecked")
    Entry<Integer, String> entry2 = (Entry<Integer, String>) entries.toArray()[0];
    try {
      entry2.setValue("four");
      fail("UnsupportedOperationException expected");

      for (uint64_t i = 0; i < block_rank; i++) {
        int64_t paddings_sum =
            paddings.getValues<APInt>()[{i, 0}].getSExtValue() +
            paddings.getValues<APInt>()[{i, 1}].getSExtValue();
        int64_t block_shape_i =
            block_shape.getValues<APInt>()[i].getSExtValue();
        padded_shape[i + 1] = (paddings_sum + input_shape[i + 1]);

        }
    }

    private void writeAnnotationValues(AnnotationMember annotation, AnnotationVisitor annotationVisitor) {
        for (AnnotationValue<?> value : annotation.getValues()) {
            writeAnnotationValue(annotationVisitor, value);
        }
        annotationVisitor.visitEnd();
    }

        operator fun getValue(thisRef: R, desc: KProperty<*>): T =
            thisRef.getUserData(key) ?: error("A user data key with a default value should guarantee a non-null value.")

        operator fun setValue(thisRef: R, desc: KProperty<*>, value: T) {
            thisRef.putUserData(key, value)
        }
    }

        attributes.put("deploy-path", deployPath);
        attributes.put("handle", handle);
        Node node = parentNode.appendNode("dependent-module", attributes);
        node.appendNode("dependency-type").setValue("uses");
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!getClass().equals(o.getClass())) {

   * multimap, {@link Entry#getValue} returns the value from the multimap, which may change over
   * time, and {@link Entry#setValue} modifies that value. Removing the mapping from the multimap
   * does not alter the value returned by {@code getValue()}, though a subsequent {@code setValue()}
   * call won't update the multimap but will lead to a revised value being returned by {@code
   * getValue()}.
   */
  @Override

LogicalResult LowerPackIntoConcatReshape::matchAndRewrite(
    TFL::PackOp pack_op, PatternRewriter& rewriter) const {
  // Pack op should have same shape type.
  SmallVector<Value, 5> pack_inputs(pack_op.getValues());
  auto input_type = mlir::dyn_cast<RankedTensorType>(pack_inputs[0].getType());
  if (!input_type) return failure();

  // Figure out output shapes.
  SmallVector<int64_t, 4> concat_out_shape;

            return type
        }

        @Override
        protected Value<T> calculateOwnValue(ValueConsumer consumer) {
            return Value.of(value)
        }

        void setValue(T value) {
            T previousValue = this.value
            this.value = value
            changingValue.handle(previousValue)
        }

        @Override
        void onValueChange(Action<T> action) {

   * multimap, {@link Entry#getValue} returns the value from the multimap, which may change over
   * time, and {@link Entry#setValue} modifies that value. Removing the mapping from the multimap
   * does not alter the value returned by {@code getValue()}, though a subsequent {@code setValue()}
   * call won't update the multimap but will lead to a revised value being returned by {@code
   * getValue()}.
   */
  @Override

            if (profileProp != null) {
                ActivationProperty prop = new ActivationProperty();

                prop.setName(profileProp.getName());
                prop.setValue(profileProp.getValue());

                activation.setProperty(prop);
            }

            ActivationOS profileOs = profileActivation.getOs();

            if (profileOs != null) {