public @Nullable V putIfAbsent(K key, V value) {
    return delegate().putIfAbsent(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean remove(@Nullable Object key, @Nullable Object value) {
    return delegate().remove(key, value);
  }

  @CanIgnoreReturnValue
  @Override
  public @Nullable V replace(K key, V value) {
    return delegate().replace(key, value);
  }

  @CanIgnoreReturnValue

						<option value="">
							<la:message key="labels.search_result_select_num" />
						</option>
						<la:option value="10">10</la:option>
						<la:option value="20">20</la:option>
						<la:option value="30">30</la:option>
						<la:option value="40">40</la:option>
						<la:option value="50">50</la:option>
						<la:option value="100">100</la:option>
					</la:select>
				</div>

    }

    /**
     * Stores a parameter value with the specified key.
     *
     * @param key the parameter key, must not be null
     * @param value the parameter value, may be null
     */
    public void put(final String key, final Object value) {
        params.put(key, value);
    }

    /**
     * Retrieves a parameter value by key.
     *
     * @param key the parameter key to look up

```Python
old_dict = {
    "old key": "old value",
    "second old key": "second old value",
}
new_dict = {**old_dict, "new key": "new value"}
```

Здесь `new_dict` будет содержать все пары ключ-значение из `old_dict` плюс новую пару ключ-значение:

```Python
{
    "old key": "old value",
    "second old key": "second old value",
    "new key": "new value",
}
```

 *
 * <ul>
 *   <li>As a method return type, as an alternative to returning {@code null} to indicate that no
 *       value was available
 *   <li>To distinguish between "unknown" (for example, not present in a map) and "known to have no
 *       value" (present in the map, with value {@code Optional.absent()})
 *   <li>To wrap nullable references for storage in a collection that does not support {@code null}

    }
    return value;
  }

  @CanIgnoreReturnValue
  static long checkNonnegative(long value, String name) {
    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);
    }
    return value;
  }

  static void checkPositive(int value, String name) {
    if (value <= 0) {

    protected LocalDateTime toLocalDateTime(final Object value) {
        if (value != null) {
            try {
                final Instant instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(value.toString()));
                return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
            } catch (final DateTimeParseException e) {
                logger.debug("Invalid date format: {}", value, e);
            }
        }

                    "Item": {
                        "title": "Item",
                        "required": ["id", "value"],
                        "type": "object",
                        "properties": {
                            "id": {"title": "Id", "type": "string"},
                            "value": {"title": "Value", "type": "string"},
                        },
                    },
                    "Message": {

        private static final long serialVersionUID = 1L;

        public String name;
        public int value;

        public TestSerializableClass(final String name, final int value) {
            this.name = name;
            this.value = value;
        }
    }

    }

    // Read 1 or more decimal digits for a value in 0..255.
    var value = 0
    val groupOffset = i
    while (i < limit) {
      val c = input[i]
      if (c < '0' || c > '9') break
      if (value == 0 && groupOffset != i) return false // Reject unnecessary leading '0's.
      value = value * 10 + c.code - '0'.code
      if (value > 255) return false // Value out of range.
      i++
    }