final byte b0 = DECODE_TABLE[inData.charAt(inIndex)];
        final byte b1 = DECODE_TABLE[inData.charAt(inIndex + 1)];
        final byte b2 = DECODE_TABLE[inData.charAt(inIndex + 2)];
        final byte b3 = DECODE_TABLE[inData.charAt(inIndex + 3)];
        outData[outIndex] = (byte) (b0 << 2 & 0xfc | b1 >> 4 & 0x3);

    boolean isLoggedInAsGuest;
    byte[] blob = null;

    SmbComSessionSetupAndXResponse( ServerMessageBlock andx ) {
        super( andx );
    }

    int writeParameterWordsWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeBytesWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int readParameterWordsWireFormat( byte[] buffer, int bufferIndex ) {

    }


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


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


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


    @Override

    @Override
    public void write ( int b ) throws SmbException {
        this.tmp[ 0 ] = (byte) b;
        write(this.tmp, 0, 1);
    }


    @Override
    public void write ( byte b[] ) throws SmbException {
        write(b, 0, b.length);
    }


    @Override
    public void write ( byte b[], int off, int len ) throws SmbException {
        if ( len <= 0 ) {
            return;
        }

    public NegTokenTarg () {}


    public NegTokenTarg ( int result, ASN1ObjectIdentifier mechanism, byte[] mechanismToken, byte[] mechanismListMIC ) {
        setResult(result);
        setMechanism(mechanism);
        setMechanismToken(mechanismToken);
        setMechanismListMIC(mechanismListMIC);
    }


    public NegTokenTarg ( byte[] token ) throws IOException {
        parse(token);
    }


    public int getResult () {

def get_items(item_a: str, item_b: int, item_c: float, item_d: bool, item_e: bytes):

    /**
     * 
     * @return start byte offset
     */
    public long getByteOffset () {
        return this.byteOffset;
    }


    /**
     * 
     * @return byte length
     */
    public long getLengthInBytes () {
        return this.lengthInBytes;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override

    // Test reading a single byte while we're in the right state
    assertEquals(-1, counter.read());
    assertEquals(20, counter.getCount());
  }

  public void testReadArrayEOF() throws IOException {
    assertEquals(20, counter.read(new byte[30]));
    assertEquals(20, counter.getCount());
    assertEquals(-1, counter.read(new byte[30]));
    assertEquals(20, counter.getCount());
  }

            )
          } else if (gzippedLength != null) {
            logger.log("--> END ${request.method} (${buffer.size}-byte, $gzippedLength-gzipped-byte body)")
          } else {
            logger.log(buffer.readString(charset))
            logger.log("--> END ${request.method} (${requestBody.contentLength()}-byte body)")
          }
        }
      }

    private int capabilities;
    private byte[] serverGuid = new byte[16];
    private int securityMode;
    private int dialect;


    /**
     * @return the capabilities
     */
    public int getCapabilities () {
        return this.capabilities;
    }


    /**
     * @return the serverGuid
     */
    public byte[] getServerGuid () {
        return this.serverGuid;
    }