*
     * @param value the value whose presence in this map is to be tested
     * @return true if this map maps one or more keys to the specified value
     */
    @Override
    public boolean containsValue(final Object value) {
        return parent.containsValue(value);
    }

    /**
     * Returns the value to which the specified key is mapped.
     *

    public boolean containsValue(final Object value) {
        return parent.containsValue(value);
    }

    @Override
    public V get(final Object key) {
        final V value = parent.get(key);
        if (value != null) {
            return value;
        }
        return parent.get(toCamelCase(key));
    }

    @Override
    public V put(final K key, final V value) {
        return parent.put(key, value);

    }

    /**
     * Encodes the specified value using the character encoding.
     *
     * @param value the value to encode
     * @return the encoded value
     * @throws CurlException if the encoding is unsupported
     */
    protected String encode(final String value) {
        try {
            return URLEncoder.encode(value, encoding);
        } catch (final UnsupportedEncodingException e) {

    }

    // 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++
    }

        }
    }

    /**
     * Sets the value of the given {@link Field} representing a {@code static} field to the specified new value.
     *
     * @param field the field (must not be {@literal null})
     * @param value the new value for the {@literal static} field
     * @throws IllegalAccessRuntimeException if the field cannot be accessed

   */
  @InlineMe(replacement = "Character.hashCode(value)")
  @InlineMeValidationDisabled(
      "The hash code of a char is the int version of the char itself, so it's simplest to return"
          + " that.")
  public static int hashCode(char value) {
    return value;
  }

  /**
   * Returns the {@code char} value that is equal to {@code value}, if possible.
   *

    public void setCreatedTime(Long value) {
        registerModifiedProperty("createdTime");
        this.createdTime = value;
    }

    public Integer getSortOrder() {
        checkSpecifiedProperty("sortOrder");
        return sortOrder;
    }

    public void setSortOrder(Integer value) {
        registerModifiedProperty("sortOrder");
        this.sortOrder = value;
    }

    return generateListMultimap(key, value);
  }

  @Generates
  static <K, V> ImmutableMultimap<K, V> generateImmutableMultimap(K key, V value) {
    return ImmutableMultimap.of(key, value);
  }

  @Generates
  static <K, V> ListMultimap<K, V> generateListMultimap(@Nullable K key, @Nullable V value) {
    return generateArrayListMultimap(key, value);
  }

  @Generates

// RunWithValue run migration with statement value
func (m Migrator) RunWithValue(value interface{}, fc func(*gorm.Statement) error) error {
	stmt := &gorm.Statement{DB: m.DB}
	if m.DB.Statement != nil {
		stmt.Table = m.DB.Statement.Table
		stmt.TableExpr = m.DB.Statement.TableExpr
	}

	if table, ok := value.(string); ok {
		stmt.Table = table
	} else if err := stmt.ParseWithSpecialTableName(value, stmt.Table); err != nil {
		return err
	}

  private double mean = 0.0; // any finite value will do, we only use it to multiply by zero for sum
  private double sumOfSquaresOfDeltas = 0.0;
  private double min = NaN; // any value will do
  private double max = NaN; // any value will do

  /** Adds the given value to the dataset. */
  public void add(double value) {
    if (count == 0) {
      count = 1;
      mean = value;
      min = value;
      max = value;