this.domain = domain;
        this.serverTypes = serverTypes;
        this.name = "\\PIPE\\LANMAN";

        this.maxParameterCount = 8;
        this.maxDataCount = 16384;
        this.maxSetupCount = (byte) 0x00;
        this.setupCount = 0;
        this.timeout = 5000;
    }


    @Override
    public void reset ( int key, String lastN ) {
        super.reset();
        this.lastName = lastN;
    }

		}
		return false
	}
	var pathErr *os.PathError
	if errors.As(err, &pathErr) {
		var errno syscall.Errno
		if errors.As(pathErr.Err, &errno) {
			// ERROR_PATH_NOT_FOUND
			return errno == 0x03
		}
	}
	return false
}

// Check if the given error corresponds to the specific ERROR_INVALID_HANDLE for windows
func isSysErrHandleInvalid(err error) bool {
	if runtime.GOOS != globalWindowsOSName {

    /**
     * 
     */
    public static final byte FILE_FULL_DIRECTORY_INFO = 0x2;

    /**
     * 
     */
    public static final byte FILE_BOTH_DIRECTORY_INFO = 0x03;

    /**
     * 
     */
    public static final byte FILE_NAMES_INFO = 0x0C;

    /**
     * 
     */
    public static final byte FILE_ID_BOTH_DIRECTORY_INFO = 0x24;

    /**
     * 
     */

                NbtAddress addr;
                char c;

                c = '.';
                ip = i = 0;
                for ( ; i < data.length && c == '.'; i++ ) {
                    int b = 0x00;

                    for ( ; i < data.length && ( c = data[ i ] ) >= 48 && c <= 57; i++ ) {
                        b = b * 10 + c - '0';
                    }
                    ip = ( ip << 8 ) + b;

                    names[_i].decode(_src);
                }
            }
        }
    }
    public static class LsarClose extends DcerpcMessage {

        public int getOpnum() { return 0x00; }

        public int retval;
        public rpc.policy_handle handle;

        public LsarClose(rpc.policy_handle handle) {
            this.handle = handle;
        }

	MOVL	ptr+0(FP), AX
	TESTL	$7, AX
	JZ	2(PC)
	MOVL	0, AX // crash with nil ptr deref
	LEAL	ret_lo+4(FP), BX
	// MOVQ (%EAX), %MM0
	BYTE $0x0f; BYTE $0x6f; BYTE $0x00
	// MOVQ %MM0, 0(%EBX)
	BYTE $0x0f; BYTE $0x7f; BYTE $0x03
	// EMMS
	BYTE $0x0F; BYTE $0x77
	RET

    }

    public final boolean readBoolean() throws SmbException {
        if((read( tmp, 0, 1 )) < 0 ) {
            throw new SmbException( "EOF" );
        }
        return tmp[0] != (byte)0x00;
    }
    public final byte readByte() throws SmbException {
        if((read( tmp, 0, 1 )) < 0 ) {
            throw new SmbException( "EOF" );
        }
        return tmp[0];
    }

      this.terminalBitCount = 0 // Not read.
    }

    /** Construct a terminal node. */
    constructor(symbol: Int, bits: Int) {
      this.children = null
      this.symbol = symbol
      val b = bits and 0x07
      this.terminalBitCount = if (b == 0) 8 else b
    }
  }

 * @author David Beaumont
 * @since 15.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class XmlEscapers {
  private XmlEscapers() {}

  private static final char MIN_ASCII_CONTROL_CHAR = 0x00;
  private static final char MAX_ASCII_CONTROL_CHAR = 0x1F;

  // For each xxxEscaper() method, please add links to external reference pages
  // that are considered authoritative for the behavior of that escaper.

  /**

                    return null;
                }
                return (long) Encdec.dec_uint64le(this.sbuf, 28);
            }

            if ( this.sbuf[ 0 ] == (byte) 0x00 && this.sbuf[ 1 ] == (byte) 0x00 && ( this.sbuf[ 4 ] == (byte) 0xFF ) && this.sbuf[ 5 ] == (byte) 'S'
                    && this.sbuf[ 6 ] == (byte) 'M' && this.sbuf[ 7 ] == (byte) 'B' ) {
                break; /* all good (SMB) */
            }