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

    /* Decode floating point numbers
     */

    /**
     * Decodes a float value from little-endian byte order.
     *

  // The number of compression rounds.
  private final int c;
  // The number of finalization rounds.
  private final int d;
  // Two 64-bit keys (represent a single 128-bit key).
  private final long k0;
  private final long k1;

  /**
   * @param c the number of compression rounds (must be positive)
   * @param d the number of finalization rounds (must be positive)

     * @param fid the file identifier
     * @param offset the file offset at which to write
     * @param remaining the number of bytes remaining to be written
     * @param b the data buffer containing bytes to write
     * @param off the offset in the buffer where data starts
     * @param len the number of bytes to write
     */

    private int pad;
    private int pad1;
    private boolean parametersDone, dataDone;

    /** Total number of parameter bytes the server is returning */
    protected int totalParameterCount;
    /** Total number of data bytes the server is returning */
    protected int totalDataCount;
    /** Number of parameter bytes in this response */
    protected int parameterCount;

        return this;
    }

    /**
     * Gets the number of fragments.
     *
     * @return the maximum number of highlighted fragments
     */
    public int getNumOfFragments() {
        return numOfFragments;
    }

    /**
     * Sets the number of fragments with fluent interface.
     *
     * @param numOfFragments the maximum number of highlighted fragments

        final byte[] bytes = new byte[8 + sidSize * 4];
        readFully(bytes);
        return new SID(bytes, 0);
    }

    /**
     * Skips the specified number of bytes in the stream.
     * @param n the number of bytes to skip
     * @return the actual number of bytes skipped
     * @throws IOException if an I/O error occurs
     */
    public int skipBytes(final int n) throws IOException {

			Description: "specify compression level of the Kafka cluster",
			Optional:    true,
			Type:        "number",
		},
		config.HelpKV{
			Key:         target.KafkaBatchSize,
			Description: "batch size of the events; used only when queue_dir is set",
			Optional:    true,
			Type:        "number",
		},
		config.HelpKV{
			Key:         target.KafkaBatchCommitTimeout,

        return activeThreadCountLock;
    }

    /**
     * Returns the number of threads.
     * @return The number of threads.
     */
    public int getNumOfThread() {
        return numOfThread;
    }

    /**
     * Sets the number of threads.
     * @param numOfThread The number of threads.
     */
    public void setNumOfThread(final int numOfThread) {

		},
		config.HelpKV{
			Key:         BatchSize,
			Description: "Number of events per HTTP send to webhook target",
			Optional:    true,
			Type:        "number",
		},
		config.HelpKV{
			Key:         QueueSize,
			Description: "configure channel queue size for webhook targets",
			Optional:    true,
			Type:        "number",
		},
		config.HelpKV{
			Key:         QueueDir,

    Ordering<Number> numbers = Ordering.explicit((Number) 1);
    Ordering<Integer> integers = Ordering.explicit(1);

    // Like by like equals like
    Ordering<Number> unusedA = numbers.compound(numbers);

    // The compound takes the more specific type of the two, regardless of order

    Ordering<Number> unusedB = numbers.compound(objects);
    Ordering<Number> unusedC = objects.compound(numbers);