// entities. Use A as a temp var.
        for (int i = 0; i < 16; i++)
            X[i] = (block[offset++] & 0xFF)       |
                   (block[offset++] & 0xFF) <<  8 |
                   (block[offset++] & 0xFF) << 16 |
                   (block[offset++] & 0xFF) << 24;


        int A = context[0];
        int B = context[1];
        int C = context[2];
        int D = context[3];

	if l > len(b) {
		return nil, 0, errors.New("zip: invalid comment length")
	}
	d.comment = string(b[:l])

	// These values mean that the file can be a zip64 file
	if d.directoryRecords == 0xffff || d.directorySize == 0xffff || d.directoryOffset == 0xffffffff {
		p, err := findDirectory64End(r, directoryEndOffset)
		if err == nil && p >= 0 {
			directoryEndOffset = p
			err = readDirectory64End(r, p, d)
		}

    assertThat(converter.convert("0")).isEqualTo((Integer) 0);
    assertThat(converter.convert("-1")).isEqualTo((Integer) (-1));
    assertThat(converter.convert("0xff")).isEqualTo((Integer) 255);
    assertThat(converter.convert("0xFF")).isEqualTo((Integer) 255);
    assertThat(converter.convert("-0xFF")).isEqualTo((Integer) (-255));
    assertThat(converter.convert("#0000FF")).isEqualTo((Integer) 255);

		{"117Gn8rfHL2ACARPAhaFd0AGzic9pUbIA/5OCn5A", 35},
		{"SHØRT", 49},
		{"There are far too many object names, and far too few bucket names!", 8},
		{"a/b/c/", 159},
		{"/a/b/c", 96},
		{string([]byte{0xff, 0xfe, 0xfd}), 147},
	}

	// Tests hashing order to be consistent.
	for i, testCase := range testCases {
		if sipHashElement := hashKey("SIPMOD", testCase.objectName, 200, testUUID); sipHashElement != testCase.sipHash {

   */
  internal const val PAYLOAD_SHORT = 126

  /** Maximum length of a frame payload to be denoted as [PAYLOAD_SHORT]. */
  internal const val PAYLOAD_SHORT_MAX = 0xffffL

  /**
   * Value for [B1_MASK_LENGTH] which indicates the next eight bytes are the unsigned
   * length.
   */
  internal const val PAYLOAD_LONG = 127

        dialectIndex         = readInt2( buffer, bufferIndex ); bufferIndex += 2;
        if( dialectIndex > 10 ) {
            return bufferIndex - start;
        }
        server.securityMode  = buffer[bufferIndex++] & 0xFF;
        server.security      = server.securityMode & 0x01;
        server.encryptedPasswords = ( server.securityMode & 0x02 ) == 0x02;
        server.signaturesEnabled  = ( server.securityMode & 0x04 ) == 0x04;

      return STRIDE_TABLE[3][word & 0xFF]
          ^ STRIDE_TABLE[2][(word >>> 8) & 0xFF]
          ^ STRIDE_TABLE[1][(word >>> 16) & 0xFF]
          ^ STRIDE_TABLE[0][word >>> 24];
    }

    static int combine(int csum, int crc) {
      csum ^= crc;
      for (int i = 0; i < 4; i++) {
        csum = (csum >>> 8) ^ BYTE_TABLE[csum & 0xFF];
      }
      return csum;
    }

                      SamrDomainHandle domainHandle = new SamrDomainHandle(handle, policyHandle, 0x02000000, domSid) ) {
                    MsrpcEnumerateAliasesInDomain rpc = new MsrpcEnumerateAliasesInDomain(domainHandle, 0xFFFF, sam);
                    handle.sendrecv(rpc);
                    if ( rpc.retval != 0 ) {
                        throw new SmbException(rpc.retval, false);
                    }

            return -1;
        }
        if (length < 0)
        {
            throw new EOFException("EOF found when length expected");
        }
        if (0xFF == length)
        {
            throw new IOException("invalid long form definite-length 0xFF");
        }

        int octetsCount = length & 0x7F, octetsPos = 0;

        length = 0;
        do
        {
            int octet = s.read();

 */

package jcifs.dcerpc.ndr;


@SuppressWarnings ( "javadoc" )
public class NdrSmall extends NdrObject {

    public int value;


    public NdrSmall ( int value ) {
        this.value = value & 0xFF;
    }


    @Override
    public void encode ( NdrBuffer dst ) throws NdrException {
        dst.enc_ndr_small(this.value);
    }


    @Override