}

    @Override
    public void write(boolean[] b, int start, int length) throws IOException {
        getEncoder().write(b, start, length);
    }

    @Override
    public void write(Boolean[] buf, int offset, int size) throws IOException {
        getEncoder().write(buf, offset, size);
    }

    @Override
    public void write(char[] c, int start, int length) throws IOException {
        getEncoder().write(c, start, length);
    }

    @Override
    public void write(short[] s, int start, int length) throws IOException {
        getEncoder().write(s, start, length);
    }

    @Override
    public void write(int[] i, int start, int length) throws IOException {
        getEncoder().write(i, start, length);
    }

    @Override
    public void write(long[] l, int start, int length) throws IOException {
        getEncoder().write(l, start, length);
    }

    @Override
    public void write(float[] f, int start, int length) throws IOException {
        getEncoder().write(f, start, length);
    }

    @Override
    public void write(double[] d, int start, int length) throws IOException {
        getEncoder().write(d, start, length);
    }

    @Override
    public void write(String[] s, int start, int length) throws IOException {

return getDecoder().read(buf, offset, size);
    }

    @Override
    public int read(char[] c, int start, int length) throws IOException {
        return getDecoder().read(c, start, length);
    }

    @Override
    public int read(short[] s, int start, int length) throws IOException {
        return getDecoder().read(s, start, length);
    }

    @Override
    public int read(int[] i, int start, int length) throws IOException {
        return getDecoder().read(i, start, length);
    }

    @Override
    public int read(long[] l, int start, int length) throws IOException {
        return getDecoder().read(l, start, length);
    }

    @Override
    public int read(float[] f, int start, int length) throws IOException {
        return getDecoder().read(f, start, length);
    }

    @Override
    public int read(double[] d, int start, int length) throws IOException {
        return getDecoder().read(d, start, length);
    }

    @Deprecated

private InputBuffer(int size) {
            data = new byte[size];
            buffer = ByteBuffer.wrap(data);
        }

        /**
         * Sets the byte order of the binary data representation from which we are decoding data.
         *
         * @param order the new byte order
         *
         * @see         #byteOrder()
         * @see         ByteBuffer#order(ByteOrder)
         */
        protected void setByteOrder(ByteOrder order) {
            buffer.order(order);
        }

        /**
         * Returns the current byte order of the binary data representation from which we are decoding.
         *
         * @return the byte order
         *
         * @see    #setByteOrder(ByteOrder)
         * @see    ByteBuffer#order()
         */
        protected ByteOrder byteOrder() {
            return buffer.order();
        }

        private boolean isViewingAs(Class<? extends Buffer> type) {
            if (view == null) {
                return false;
            }
            return type.isAssignableFrom(view.getClass());
        }

        private void assertView(ElementType<?> type) {
            if (!isViewingAs(type.bufferClass())) {
                view = type.asTypedBuffer(buffer);
            }
        }

        private void rewind() {
            buffer.rewind();
            view = null;
        }

        /**
         * Set the number of bytes we can buffer from the input for subsequent retrieval from this buffer. The get
         * methods of this class will be ensured not to fetch data from the input beyond the requested size.
         *
         * @param n    the number of elements we can read and buffer from the input
         * @param size the number of bytes in each elements.
         */
        protected void loadBytes(long n, int size) {

7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8,
            8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
            8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,

protected static boolean incrementPosition(int[] start, int[] current, int[] lengths, int[] steps) {
        for (int i = start.length - 2; i >= 0; i--) {
            if (current[i] - start[i] < lengths[i] - steps[i]) {
                current[i] += steps[i];
                if (start.length - 1 - (i + 1) >= 0) {
                    System.arraycopy(start, i + 1, current, i + 1, start.length - 1 - (i + 1));
                }
                return true;
            }
        }
        return false;
    }

hp = a.get(s00 + ny2);
                /*
                 * diff = 8 * hx slope that would match h0 in neighboring zones
                 */
                diff = hp - hm;
                /*
                 * monotonicity constraints on diff
                 */
                dmax = Math.max(Math.min(hp - h0, h0 - hm), 0) << 2;
                dmin = Math.min(Math.max(hp - h0, h0 - hm), 0) << 2;
                /*
                 * if monotonicity would set slope = 0 then don't change hx. note dmax>=0, dmin<=0.
                 */
                if (dmin < dmax) {
                    diff = Math.max(Math.min(diff, dmax), dmin);
                    /*
                     * Compute change in slope limited to range +/- smax. Careful with rounding negative numbers when
                     * using shift for divide by 8.
                     */
                    s = diff - (a.get(s10) << N03);

}

    /**
     * Returns the name of the physical unit in which images are represented.
     * 
     * @return the standard name of the physical unit in which the image is expressed, e.g. <code>"Jy beam^{-1}"</code>.
     */
    @Override
    public String getBUnit() {
        return super.getBUnit();
    }

    /**
     * Returns the integer value that signifies blank (missing or <code>null</code>) data in an integer image.
     *
     * @return               the integer value used for identifying blank / missing data in integer images.
     * 
     * @throws FitsException if the header does not specify a blanking value or if it is not appropriate for the type of
     *                           imge (that is not an integer type image)
     */
    @Override
    public long getBlankValue() throws FitsException {
        if (getBitpix().getHeaderValue() < 0) {
            throw new FitsException("No integer blanking value in floating-point images.");
        }
        return super.getBlankValue();
    }

    /**
     * Returns the floating-point increment between adjacent integer values in the image. Strictly speaking, only
     * integer-type images should define a quantization scaling, but there is no harm in having this value in
     * floating-point images also -- which may be interpreted as a hint for quantization, perhaps.
     * 
     * @return the floating-point quantum that corresponds to the increment of 1 in the integer data representation.
     * 
     * @see    #getBZero()
     */
    @Override
    public double getBScale() {
        return super.getBScale();
    }

    /**
     * Returns the floating-point value that corresponds to an 0 integer value in the image. Strictly speaking, only
     * integer-type images should define a quantization offset, but there is no harm in having this value in
     * floating-point images also -- which may be interpreted as a hint for quantization, perhaps.
     * 
     * @return the floating point value that correspond to the integer 0 in the image data.
     * 
     * @see    #getBScale()
     */
    @Override
    public double getBZero() {
        return super.getBZero();
    }

private void put(boolean[] b, int start, int length) throws IOException {
        if (length == 1) {
            write(byteForBoolean(b[start]));
            return;
        }

        byte[] ascii = new byte[length];
        for (int i = 0; i < length; i++) {
            ascii[i] = byteForBoolean(b[start + i]);
        }
        write(ascii, 0, length);
    }

    /**
     * Puts a boolean array into the conversion buffer, but with no guarantee of flushing the conversion buffer to the
     * underlying output. The caller may put multiple data object into the conversion buffer before eventually calling
     * {@link OutputBuffer#flush()} to ensure that everything is written to the output. Note, the this call may flush
     * the contents of the conversion buffer to the output if it needs more conversion space than what is avaiable.
     *
     * @param  b           the Java array containing the values
     * @param  start       the offset in the array from where to start converting values.
     * @param  length      the number of values to convert to FITS representation
     *
     * @throws IOException if there was an IO error while trying to flush the conversion buffer to the stream before all
     *                         elements were converted.
     *
     * @see                #byteForBoolean(Boolean)
     * @see                #put(boolean[], int, int)
     * @see                #write(Boolean[], int, int)
     */
    private void put(Boolean[] b, int start, int length) throws IOException {

c.add(HeaderCard.create(Standard.BITPIX, Bitpix.forPrimitiveType(base).getHeaderValue()));

        c.add(HeaderCard.create(Standard.NAXIS, dims.length));
        for (int i = 1; i <= dims.length; i++) {
            c.add(HeaderCard.create(Standard.NAXISn.n(i), dims[dims.length - i]));
        }

        // Just in case!
        c.add(HeaderCard.create(Standard.PCOUNT, 0));

protected synchronized int read(boolean[] b, int start, int length) throws EOFException, IOException {
        if (length == 0) {
            return 0;
        }

        byte[] ascii = new byte[length];
        length = read(ascii, 0, length);

        if (length < 0) {
            throw new EOFException();
        }

        for (int i = 0; i < length; i++) {
            b[start + i] = booleanFor(ascii[i]);

out.writeChar(data[index]);
        }

        @SuppressFBWarnings(value = "RR_NOT_CHECKED", justification = "not exposed and never needed locally")
        @Override
        int read(int from, int n, ArrayDataInput in) throws IOException {
            return in.read(data, from, n);
        }

        @Override
        void write(int from, int n, ArrayDataOutput out) throws IOException {
            out.write(data, from, n);
        }

        @Override

public void fillTableHeader(Header header, int column, int coordinateIndex)
                throws IndexOutOfBoundsException, FitsException {
            if (column < 0) {
                throw new IndexOutOfBoundsException("Invalid Java column index " + column);
            }

            String dims = header.getStringValue(Standard.TDIMn.n(++column));
            if (dims == null) {
                throw new FitsException("Missing TDIM" + column + " in header");
            }

            StringTokenizer tokens = new StringTokenizer(dims, "(, )");
            int n = tokens.countTokens();

headerIterator.add(new HeaderCard(newKey, card.getValue(String.class, ""), card.getComment()));
        }

        @Override
        protected void restoreCard(HeaderCard card, Cursor<String, HeaderCard> headerIterator) throws HeaderCardException {
            String newKey = compressedHeaderKey().n(GenericKey.getN(card.getKey())).key();
            headerIterator.add(new HeaderCard(newKey, card.getValue(String.class, ""), card.getComment()));

c.add(HeaderCard.create(Standard.XTENSION, Standard.XTENSION_ASCIITABLE));
        c.add(HeaderCard.create(Standard.BITPIX, Bitpix.BYTE.getHeaderValue()));
        c.add(HeaderCard.create(Standard.NAXIS, 2));
        c.add(HeaderCard.create(Standard.NAXIS1, rowLen));
        c.add(HeaderCard.create(Standard.NAXIS2, nRows));

byte[] temp = new byte[Math.min(COPY_BLOCK_SIZE, dataToAppend.remaining())];
        while (dataToAppend.hasRemaining()) {
            int nrObBytes = Math.min(temp.length, dataToAppend.remaining());
            dataToAppend.get(temp, 0, nrObBytes);
            buffer.put(temp, 0, nrObBytes);
        }
    }

    @Override
    public ByteBuffer asTypedBuffer(ByteBuffer buffer) {

public byte[] shuffle(byte[] byteArray) {
        byte[] result = new byte[byteArray.length];
        int resultIndex = 0;
        int[] offset = calculateOffsets(byteArray);
        for (int index = 0; index < byteArray.length; index += primitiveSize) {
            for (int primitiveIndex = 0; primitiveIndex < primitiveSize; primitiveIndex++) {
                result[resultIndex + offset[primitiveIndex]] = byteArray[index + primitiveIndex];

6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

while (ndig < ByteFormatter.NUMBER_BASE && pos >= dmax) {
            ndig++;
            dmax *= ByteFormatter.NUMBER_BASE;
        }

        if (val < 0) {
            ndig++;
        }

        // Truncate if necessary.
        if (ndig > len || ndig > buf.length - off) {
            truncationFiller(buf, off, len);
            return off + len;
        }

        // Now insert the actual characters we want -- backwards
        // We use a do{} while() to handle the caByteFormatterse of 0.

        off += ndig;

        int xoff = off - 1;

public void arraycopy(double[] src, int srcPos, byte[] dest, int destPos, int length) {
            for (int index = 0; index < length; index++) {
                dest[index + destPos] = (byte) Math.round(src[index + srcPos]);
            }
        }
    }

    private static final class DoubleToChar extends MultiArrayCopyFactory<double[], char[]> {

public void arraycopy(double[] src, int srcPos, char[] dest, int destPos, int length) {
            for (int index = 0; index < length; index++) {
                dest[index + destPos] = (char) Math.round(src[index + srcPos]);
            }
        }
    }

    private static final class DoubleToFloat extends MultiArrayCopyFactory<double[], float[]> {

public void arraycopy(double[] src, int srcPos, short[] dest, int destPos, int length) {
            for (int index = 0; index < length; index++) {
                dest[index + destPos] = (short) Math.round(src[index + srcPos]);
            }
        }
    }

    private static final class FloatToByte extends MultiArrayCopyFactory<float[], byte[]> {

DateTime(String headerName, SOURCE status, HDU hdu, VALUE valueType, String comment) {
        key = new FitsKey(headerName == null ? name() : headerName, status, hdu, valueType, comment);
        FitsKey.registerStandard(this);
    }

    @Override
    public final FitsKey impl() {
        return key;
    }

MAP_GCOUNT(GCOUNT), MAP_NAXIS(NAXIS), MAP_NAXISn(NAXISn), MAP_PCOUNT(PCOUNT), MAP_ZFORMn(ZFORMn) {

        @Override
        protected void backupCard(HeaderCard card, Cursor<String, HeaderCard> headerIterator) throws HeaderCardException {
            String newKey = uncompressedHeaderKey().n(GenericKey.getN(card.getKey())).key();
            headerIterator.add(new HeaderCard(newKey, card.getValue(String.class, ""), card.getComment()));

public synchronized void readFully(byte[] b, int off, int len) throws EOFException, IOException {
        while (len > 0) {
            int n = read(b, off, len);
            if (n < 0) {
                throw new EOFException();
            }
            off += n;
            len -= n;
        }
    }

    /**
     * Same as {@link RandomAccessFile#readUTF()}.
     *
     * @return             a string
     *
     * @throws IOException if there was an IO error while reading from the file.
     */
    public final synchronized String readUTF() throws IOException {

public HeaderCard(String key, ComplexValue value, String comment) throws HeaderCardException {
        this();

        if (value == null) {
            set(key, null, comment, ComplexValue.class);
            return;
        }

        if (!value.isFinite()) {
            throw new HeaderCardException("Cannot represent " + value + " in FITS headers.");
        }
        set(key, value.toBoundedString(spaceForValue(key)), comment, ComplexValue.class);

CLOCKAPP(STScIExt.CLOCKAPP),

    /**
     * Same as {@link STScIExt#TASSIGN}.
     * 
     * @since 1.20.1
     */
    TASSIGN(STScIExt.TASSIGN),

    /**
     * Same as {@link DateTime#TIMEDEL}.
     * 
     * @since 1.20.1
     */
    TIMEDEL(DateTime.TIMEDEL),

    /**
     * Same as {@link STScIExt#TIMEREF}.
     * 
     * @since 1.20.1
     * 
     * @see   #TIMEREF_LOCAL
     * @see   #TIMEREF_GEOCENTRIC
     * @see   #TIMEREF_HELIOCENTRIC
     * @see   #TIMEREF_SOLARSYSTEM
     */
    TIMEREF(STScIExt.TIMEREF),

    /**
     * Same as {@link STScIExt#TIMEUNIT}.
     * 
     * @since 1.20.1
     */
    TIMEUNIT(STScIExt.TIMEUNIT),

    /**
     * Same as {@link STScIExt#TIMVERSN}.
     * 
     * @since 1.20.1
     */
    TIMVERSN(STScIExt.TIMVERSN),

    /**
     * Same as {@link STScIExt#TIMEZERO}.
     * 
     * @since 1.20.1
     */
    TIMEZERO(STScIExt.TIMEZERO),

    /**
     * Same as {@link STScIExt#TSTART}.
     */
    TSTART(STScIExt.TSTART),

    /**
     * Same as {@link STScIExt#TSTOP}.
     */
    TSTOP(STScIExt.TSTOP),

private static void decimalToInteger(Object from, Object to, Quantizer q) {
        if (from instanceof Object[]) {
            Object[] a = (Object[]) from;
            Object[] b = (Object[]) to;
            for (int i = 0; i < a.length; i++) {

public void arraycopy(double[] src, int srcPos, long[] dest, int destPos, int length) {
            for (int index = 0; index < length; index++) {
                dest[index + destPos] = Math.round(src[index + srcPos]);
            }
        }
    }

    private static final class DoubleToShort extends MultiArrayCopyFactory<double[], short[]> {

getOption().setScale(value.getValue(Double.class, 0.0));
        }
    }

    @Override
    public void setValueInHeader(Header header) throws HeaderCardException {
        int zvalIndex = nextFreeZVal(header);
        header.addValue(Compression.ZNAMEn.n(zvalIndex), getName());
        header.addValue(Compression.ZVALn.n(zvalIndex), getOption().getScale());

public void arraycopy(byte[] src, int srcPos, char[] dest, int destPos, int length) {
            for (int index = 0; index < length; index++) {
                dest[index + destPos] = (char) src[index + srcPos];
            }
        }
    }

    private static final class ByteToDouble extends MultiArrayCopyFactory<byte[], double[]> {

public void arraycopy(char[] src, int srcPos, byte[] dest, int destPos, int length) {
            for (int index = 0; index < length; index++) {
                dest[index + destPos] = (byte) src[index + srcPos];
            }
        }
    }

    private static final class CharToDouble extends MultiArrayCopyFactory<char[], double[]> {

return CompressionLibLoaderProtection.createBZip2Stream(in);
        } catch (IOException e) {
            throw e;
        } catch (Exception e) {
            throw new IOException(e);
        }
    }

    @Override
    public int priority() {
        return PRIORITY;
    }

    @Override
    public boolean provides(int mag1, int mag2) {
        return mag1 == 'B' && mag2 == 'Z';

int nullValue = (int) getNullValue();
        int size = getTileBuffer().getPixelSize();
        for (int index = 0; index < size; index++) {
            if (nullValue == buffer.get(index)) {
                initializedMask(size).put(index, NULL_INDICATOR);
            }
        }
    }

    private void preserveNullLongs() {

DoubleBuffer buffer = (DoubleBuffer) getTileBuffer().getBuffer();
        ByteBuffer nullMask = initializedMask(buffer.remaining());
        for (int index = 0; index < nullMask.capacity(); index++) {
            if (nullMask.get(index) == NULL_INDICATOR) {
                buffer.put(index, Double.NaN);

boolean[] bool = (boolean[]) o;
            byte[] b = new byte[bool.length];
            for (int i = 0; i < bool.length; i++) {
                b[i] = FitsEncoder.byteForBoolean(bool[i]);
            }
            return b;
        }

        if (o instanceof Boolean[]) {

if ((value & BIT_THREE) != ZERO) {
                    b.bitOr(s00 + 1, planeVal);
                }
                if ((value & BIT_FOUR) != ZERO) {
                    b.bitOr(s00, planeVal);
                }
                // b.bitOr(s10+1, ((LONGLONG) ( a[k] & 1)) << bit; b.bitOr(s10 ,
                // ((((LONGLONG)a[k])>>1) & 1) << bit; b.bitOr(s00+1,
                // ((((LONGLONG)a[k])>>2) & 1) << bit; b.bitOr(s00
                // ,((((LONGLONG)a[k])>>3) & 1) << bit;
                s00 += 2;
                /* s10 += 2; */
            }
            if (j < lny) {

int nullValue = (int) getNullValue();
        int size = getTileBuffer().getPixelSize();
        for (int index = 0; index < size; index++) {
            if (nullValue == buffer.get(index)) {
                initializedMask(size).put(index, NULL_INDICATOR);
            }
        }
    }

k = 0; /* k is index of b[i/2,j/2] */
        for (i = 0; i < nx - 1; i += 2) {
            s00 = n * i; /* s00 is index of a[i,j] */
            /*
             * tried using s00+n directly in the statements, but this had no effect on performance
             */
            s10 = s00 + n; /* s10 is index of a[i+1,j] */
            for (j = 0; j < ny - 1; j += 2) {

                b[k] = (byte) ((a.get(s10 + 1) & b0 //

long nullValue = getNullValue();
        int size = getTileBuffer().getPixelSize();
        for (int index = 0; index < size; index++) {
            if (nullValue == buffer.get(index)) {
                initializedMask(size).put(index, NULL_INDICATOR);
            }
        }
    }

public void arraycopy(byte[] src, int srcPos, double[] dest, int destPos, int length) {
            for (int index = 0; index < length; index++) {
                dest[index + destPos] = src[index + srcPos];
            }
        }
    }

    private static final class ByteToFloat extends MultiArrayCopyFactory<byte[], float[]> {

public void arraycopy(byte[] src, int srcPos, long[] dest, int destPos, int length) {
            for (int index = 0; index < length; index++) {
                dest[index + destPos] = src[index + srcPos];
            }
        }
    }

    private static final class ByteToShort extends MultiArrayCopyFactory<byte[], short[]> {

public void setColumnMeta(int index, IFitsHeader key, String value, String comment, boolean after)
            throws HeaderCardException {
        setCurrentColumn(index, after);
        myHeader.addLine(new HeaderCard(key.n(index + 1).key(), value, comment));
    }

    /**
     * Specify column metadata for a given column in a way that allows all of the column metadata for a given column to
     * be organized together.
     *
     * @param  index               The 0-based index of the column
     * @param  key                 The column key. I.e., the keyword will be key+(index+1)
     * @param  value               The value to be placed in the header.
     * @param  comment             The comment for the header
     * @param  after               Should the header card be after the current column metadata block
     *                                 (<code>true</code>), or immediately before the TFORM card (<code>false</code>).
     *
     * @throws HeaderCardException if the header could not be updated
     *
     * @since                      1.16
     */
    public void setColumnMeta(int index, IFitsHeader key, Number value, String comment, boolean after)

protected PrimitiveType(int size, boolean individualSize, Class<?> primitiveClass, Class<?> wrapperClass,
            Class<B> bufferClass, char type, int bitPix) {
        super(size, individualSize, primitiveClass, wrapperClass, bufferClass, type, bitPix);
    }

}