}

    /**
     * {@literal byte}配列の末尾に{@literal byte}の値を追加した配列を返します。
     *
     * @param array
     *            配列
     * @param value
     *            値
     * @return 値が追加された結果の配列
     */
    public static byte[] add(final byte[] array, final byte value) {
        assertArgumentNotNull("array", array);

        final byte[] newArray = (byte[]) Array.newInstance(byte.class, array.length + 1);

    }


    @Override
    protected int writeBytesWireFormat ( byte[] dst, int dstIndex ) {
        return 0;
    }


    @Override
    protected int readParameterWordsWireFormat ( byte[] buffer, int bufferIndex ) {
        return 0;
    }


    @Override
    protected int readBytesWireFormat ( byte[] buffer, int bufferIndex ) {
        return 0;
    }


    @Override

    If you want this update with the old behavior use [this interceptor][legacy_interceptor].

 *  Fix: Don't crash decompressing web sockets messages. We had a bug where we assumed deflated
    bytes in would always yield deflated bytes out and this isn't always the case!

 *  Fix: Reliably update and invalidate the disk cache on windows. As originally designed our

	tillOffset int64           // Affects the length of data requested in disk.ReadFile depending on Read()'s offset
	buf        []byte          // Holds bit-rot verified data
}

func (b *wholeBitrotReader) ReadAt(buf []byte, offset int64) (n int, err error) {
	if b.buf == nil {
		b.buf = make([]byte, b.tillOffset-offset)
		if _, err := b.disk.ReadFile(context.TODO(), b.volume, b.filePath, offset, b.buf, b.verifier); err != nil {

    }

    int writeSetupWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeParametersWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeDataWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int readSetupWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }

            }
            if (formal == Byte.TYPE && actual == Byte.class) {
                return true;
            }
            if (formal == Short.TYPE && (actual == Short.class || actual == Byte.class)) {
                return true;
            }
            if (formal == Integer.TYPE && (actual == Integer.class || actual == Short.class || actual == Byte.class)) {
                return true;
            }

    /**
     * Channel bindings type
     */
    public static final int MsvAvChannelBindings = 0x0A;

    private final int type;
    private final byte[] raw;


    /**
     * @param type
     * @param raw
     */
    public AvPair ( int type, byte[] raw ) {
        this.type = type;
        this.raw = raw;
    }


    /**
     * @return the type
     */
    public final int getType () {

    private byte oplockLevel;
    private byte[] fileId;


    /**
     * @param config
     */
    public Smb2OplockBreakNotification ( Configuration config ) {
        super(config);
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */
    @Override

public final class Doubles extends DoublesMethodsForWeb {
  private Doubles() {}

  /**
   * The number of bytes required to represent a primitive {@code double} value.
   *
   * <p><b>Java 8+ users:</b> use {@link Double#BYTES} instead.
   *
   * @since 10.0
   */
  public static final int BYTES = Double.SIZE / Byte.SIZE;

  /**
   * Returns a hash code for {@code value}; equal to the result of invoking {@code ((Double)

    @Override
    int writeBodyWireFormat ( byte[] dst, int dstIndex ) {
        int tmp = this.questionName.hexCode;
        this.questionName.hexCode = 0x00; // type has to be 0x00 for node status
        int result = writeQuestionSectionWireFormat(dst, dstIndex);
        this.questionName.hexCode = tmp;
        return result;
    }


    @Override
    int readBodyWireFormat ( byte[] src, int srcIndex ) {
        return 0;
    }