int length = decoder.readInt();
        float[] array = new float[length];
        readFloats(decoder, array);
        return array;
    }

    public static void readFloats(Decoder decoder, float[] array) throws IOException {
        for (int i = 0; i < array.length; i++) {
            array[i] = decoder.readFloat();
        }
    }

        require(it >= 0)
        it.toInt()
    }

    override fun readShort(): Short = readContext.readShort()

    override fun readLong(): Long = readContext.readLong()

    override fun readFloat(): Float = readContext.readFloat()

    override fun readDouble(): Double = readContext.readDouble()

    override fun readBoolean(): Boolean = readContext.readBoolean()

    }

    @Override
    public short readShort() throws EOFException, IOException {
        return inputStream.readShort();
    }

    @Override
    public float readFloat() throws EOFException, IOException {
        return inputStream.readFloat();
    }

    @Override
    public double readDouble() throws EOFException, IOException {
        return inputStream.readDouble();
    }

    @Override

            return input.readShort();
        } catch (KryoException e) {
            throw maybeEndOfStream(e);
        }
    }

    @Override
    public float readFloat() throws EOFException, IOException {
        try {
            return input.readFloat();
        } catch (KryoException e) {
            throw maybeEndOfStream(e);
        }
    }

    @Override

            return input.readShort();
        } catch (KryoException e) {
            throw maybeEndOfStream(e);
        }
    }

    @Override
    public float readFloat() throws EOFException, IOException {
        try {
            return input.readFloat();
        } catch (KryoException e) {
            throw maybeEndOfStream(e);
        }
    }

    @Override

     *
     * @throws EOFException when the end of the byte stream is reached before the float value can be fully read.
     * @since 8.7
     */
    float readFloat() throws EOFException, IOException;

    /**
     * Reads a double value that was written with {@link Encoder#writeDouble(double)}
     *

            transientInt = objectInputStream.readInt()
            transientLong = objectInputStream.readLong()
            transientString = objectInputStream.readUTF()
            transientFloat = objectInputStream.readFloat()
            transientDouble = objectInputStream.readDouble()
        }
    }

        }
    }

    private static class FloatSerializer extends AbstractSerializer<Float> {
        @Override
        public Float read(Decoder decoder) throws Exception {
            return decoder.readFloat();
        }

        @Override
        public void write(Encoder encoder, Float value) throws Exception {
            encoder.writeFloat(value);
        }
    }

            undefined()

        override fun readNullableSmallInt(): Int? =
            undefined()

        override fun readShort(): Short =
            undefined()

        override fun readFloat(): Float =
            undefined()

        override fun readDouble(): Double =
            undefined()

        override fun readNullableString(): String? =
            undefined()