MOVF.NE	(g), F3                                   // 003a9a1d
	MOVD	(g), F3                                   // 003b9aed
	MOVF	0x20(R3), F9       // MOVF 32(R3), F9     // 089a93ed
	MOVD.EQ	0x20(R4), F9       // MOVD.EQ 32(R4), F9  // 089b940d
	MOVF.NE	-0x20(g), F3       // MOVF.NE -32(g), F3  // 083a1a1d
	MOVD	-0x20(g), F3       // MOVD -32(g), F3     // 083b1aed
	MOVF	F9, (R4)                                  // 009a84ed

    static final int FLAGS_NONE = 0x00;
    static final int FLAGS_LOCK_AND_READ_WRITE_AND_UNLOCK = 0x01;
    static final int FLAGS_RECEIVE_BUFFER_POSTED = 0x02;
    static final int FLAGS_PATH_NAMES_CASELESS = 0x08;
    static final int FLAGS_PATH_NAMES_CANONICALIZED = 0x10;
    static final int FLAGS_OPLOCK_REQUESTED_OR_GRANTED = 0x20;
    static final int FLAGS_NOTIFY_OF_MODIFY_ACTION = 0x40;
    static final int FLAGS_RESPONSE = 0x80;

     */
    public static final int SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY = 0x10;

    /**
     * 
     */
    public static final int SMB2_SHARE_CAP_SCALEOUT = 0x20;

    /**
     * 
     */
    public static final int SMB2_SHARE_CAP_CLUSTER = 0x40;

    /**
     * 
     */
    public static final int SMB2_SHARE_CAP_ASYMMETRIC = 0x80;

    private byte shareType;
    private int shareFlags;

  }

  @Test
  fun flagOverlapOn0x20() {
    assertThat(frameLog(true, 3, 10000, TYPE_HEADERS, 0x20))
      .isEqualTo("<< 0x00000003 10000 HEADERS       PRIORITY")
    assertThat(frameLog(true, 3, 10000, TYPE_DATA, 0x20))
      .isEqualTo("<< 0x00000003 10000 DATA          COMPRESSED")
  }

  /**

    public static final int DCERPC_LAST_FRAG       = 0x02; /* Last fragment */
    public static final int DCERPC_PENDING_CANCEL  = 0x04; /* Cancel was pending at sender */
    public static final int DCERPC_RESERVED_1      = 0x08;
    public static final int DCERPC_CONC_MPX        = 0x10; /* supports concurrent multiplexing */
    public static final int DCERPC_DID_NOT_EXECUTE = 0x20;

    public static final int DCERPC_LAST_FRAG = 0x02; /* Last fragment */
    public static final int DCERPC_PENDING_CANCEL = 0x04; /* Cancel was pending at sender */
    public static final int DCERPC_RESERVED_1 = 0x08;
    public static final int DCERPC_CONC_MPX = 0x10; /* supports concurrent multiplexing */
    public static final int DCERPC_DID_NOT_EXECUTE = 0x20;
    public static final int DCERPC_MAYBE = 0x40; /* `maybe' call semantics requested */

     * is queried frequently and exceptions would be rather costly to
     * throw on a regular basis here.
     */

    public synchronized static NbtAddress getByName( String host ) {
        return getByName( new Name( host, 0x20, null ));
    }

    synchronized static NbtAddress getByName( Name name ) {
        NbtAddress result = null;

        try {
            if( FILENAME != null ) {
                File f = new File( FILENAME );

            + "abcdefghijklmnopqrstuvwxyz"
            + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
            + "1234567890";
    assertEquals(s, xmlEscaper.escape(s));

    // Test ASCII control characters.
    for (char ch = 0; ch < 0x20; ch++) {
      if (ch == '\t' || ch == '\n' || ch == '\r') {
        // Only these whitespace chars are permitted in XML,
        if (shouldEscapeWhitespaceChars) {

     * @param host
     * @param tc
     * @return resolved name, null if not found
     */
    public synchronized NbtAddress getByName ( String host, CIFSContext tc ) {
        return getByName(new Name(tc.getConfig(), host, 0x20, null), tc);
    }


    synchronized NbtAddress getByName ( Name name, CIFSContext tc ) {
        NbtAddress result = null;

        try {
            if ( tc.getConfig().getLmHostsFileName() != null ) {

  const val FLAG_END_HEADERS = 0x4 // Used for headers and continuation.
  const val FLAG_END_PUSH_PROMISE = 0x4
  const val FLAG_PADDED = 0x8 // Used for headers and data.
  const val FLAG_PRIORITY = 0x20 // Used for headers.
  const val FLAG_COMPRESSED = 0x20 // Used for data.

  /** Lookup table for valid frame types. */
  private val FRAME_NAMES =
    arrayOf(