for ( String dialect : this.dialects ) {
            bos.write(0x02);
            try {
                bos.write(Strings.getASCIIBytes(dialect));
            }
            catch ( IOException e ) {
                throw new RuntimeCIFSException(e);
            }
            bos.write(0x0);
        }

        System.arraycopy(bos.toByteArray(), 0, dst, dstIndex, bos.size());

        dstIndex += 2;

        return dstIndex - start;
    }
    int writeBytesWireFormat( byte[] dst, int dstIndex ) {
        int start = dstIndex;

        dst[dstIndex++] = (byte)0x01; /* BufferFormat */
        writeInt2( count, dst, dstIndex ); /* DataLength? */
        dstIndex += 2;
        System.arraycopy( b, off, dst, dstIndex, count );
        dstIndex += count;

        return dstIndex - start;

            int read = 0;
            int readLow = stream.read() & 0xff;
            int readHigh = stream.read() & 0xff;
            read = ( readHigh << 8 ) + readLow;
            if ( read != 0x01 )
                throw new PACDecodingException("Malformed kerberos token");

            ASN1TaggedObject mechToken = ASN1Util.as(ASN1TaggedObject.class, stream.readObject());

	p.append(prog, "", true)
}

// asmData assembles a DATA pseudo-op.
// DATA masks<>+0x00(SB)/4, $0x00000000
func (p *Parser) asmData(operands [][]lex.Token) {
	if len(operands) != 2 {
		p.errorf("expect two operands for DATA")
		return
	}

	// Operand 0 has the general form foo<>+0x04(SB)/4.
	op := operands[0]
	n := len(op)
	if n < 3 || op[n-2].ScanToken != '/' || op[n-1].ScanToken != scanner.Int {

        subCommand = NET_SERVER_ENUM2; // not really true be used by upper logic
        name = "\\PIPE\\LANMAN";

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

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

            assertThat(b).isEqualTo(2.toByte())
          }
        }
      },
    )
  }

  @Test fun dataFrameNotAssociateWithStream() {
    val payload = byteArrayOf(0x01, 0x02)
    writeMedium(frame, payload.size)
    frame.writeByte(Http2.TYPE_DATA)
    frame.writeByte(FLAG_NONE)
    frame.writeInt(0)
    frame.write(payload)
    assertFailsWith<IOException> {

        return dstIndex - start;
    }


    @Override
    protected int writeBytesWireFormat ( byte[] dst, int dstIndex ) {
        int start = dstIndex;

        dst[ dstIndex++ ] = (byte) 0x01; /* BufferFormat */
        SMBUtil.writeInt2(this.count, dst, dstIndex); /* DataLength? */
        dstIndex += 2;
        System.arraycopy(this.b, this.off, dst, dstIndex, this.count);
        dstIndex += this.count;

        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;

    /**
     * 
     */