* @param dst the destination byte array
     * @param di the starting index in the destination array
     * @return the number of bytes written (4)
     */
    public static int enc_floatle(final float f, final byte[] dst, final int di) {
        return enc_uint32le(Float.floatToIntBits(f), dst, di);
    }

    /**
     * Encodes a float value in big-endian byte order.
     *

    }

    /**
     * Retrieve a boolean value. If the property is not found, the value of <code>def</code> is returned.
     *
     * @param props the properties to search in
     * @param key the property key to look up
     * @param def the default value to return if key is not found
     * @return the boolean value of the property or the default value
     */

	return other
}

// Set - sets the value for a column name.
func (r *Record) Set(name string, value *sql.Value) (sql.Record, error) {
	var v any
	if b, ok := value.ToBool(); ok {
		v = b
	} else if f, ok := value.ToFloat(); ok {
		v = f
	} else if i, ok := value.ToInt(); ok {
		v = i
	} else if t, ok := value.ToTimestamp(); ok {
		v = sql.FormatSQLTimestamp(t)
	} else if s, ok := value.ToString(); ok {
		v = s

    return putInBothMaps(key, value, true);
  }

  private @Nullable V putInBothMaps(
      @ParametricNullness K key, @ParametricNullness V value, boolean force) {
    checkKey(key);
    checkValue(value);
    boolean containedKey = containsKey(key);
    if (containedKey && Objects.equals(value, get(key))) {
      return value;
    }
    if (force) {

      fun writeInt(
        value: Int,
        prefixMask: Int,
        bits: Int,
      ) {
        var value = value
        // Write the raw value for a single byte value.
        if (value < prefixMask) {
          out.writeByte(bits or value)
          return
        }

        // Write the mask to start a multibyte value.
        out.writeByte(bits or prefixMask)

         * The value is split by pipe character (|) and each part is trimmed.
         *
         * @param value the configuration value string to parse
         */
        public Config(final String value) {
            values = StreamUtil.split(value, Pattern.quote("|")).get(stream -> stream.map(String::trim).toArray(n -> new String[n]));
        }

        /**

  void remove(Range<K> range);

  /**
   * Merges a value into a part of the map by applying a remapping function.
   *
   * <p>If any parts of the range are already present in this map, those parts are mapped to new
   * values by applying the remapping function. The remapping function accepts the map's existing
   * value for that part of the range and the given value. It returns the value to be associated

		}
		return FromBytes(bs), nil
	case []Value:
		return FromArray(rval), nil
	case nil:
		return FromNull(), nil
	case Missing:
		return FromMissing(), nil
	}
	return nil, fmt.Errorf("Unhandled value type: %T", result)
}

func (e *PrimaryTerm) evalNode(r Record, tableAlias string) (res *Value, err error) {
	switch {
	case e.Value != nil:
		return e.Value.evalNode(r)
	case e.JPathExpr != nil:

            fail();
        } catch (CrawlingAccessException e) {
            // ignore
        }

        value = "ftp://123.123.123.123:9999/";
        ftpInfo = new FtpClient.FtpInfo(value, Constants.UTF_8);
        assertEquals(value, ftpInfo.toUrl());
        assertEquals("123.123.123.123:9999", ftpInfo.getCacheKey());
        assertEquals("123.123.123.123", ftpInfo.getHost());

   * @param value the value to be associated with the specified key
   * @return the value that was previously associated with the key, or {@code null} if there was no
   *     previous entry. (If the bimap contains null values, then {@code forcePut}, like {@code
   *     put}, returns {@code null} both if the key is absent and if it is present with a null
   *     value.)
   */
  @CanIgnoreReturnValue