return
		}
		z.Type = VersionType(zb0002)
	}
	{
		var zb0003 uint8
		zb0003, err = dc.ReadUint8()
		if err != nil {
			err = msgp.WrapError(err, "Flags")
			return
		}
		z.Flags = xlFlags(zb0003)
	}
	z.EcN, err = dc.ReadUint8()
	if err != nil {
		err = msgp.WrapError(err, "EcN")
		return
	}
	z.EcM, err = dc.ReadUint8()
	if err != nil {

      for (prefixFlag in prefixFlags) {
        FLAGS[prefixFlag or frameFlag] = FLAGS[prefixFlag] + '|'.toString() + FLAGS[frameFlag]
        FLAGS[prefixFlag or frameFlag or FLAG_PADDED] =
          FLAGS[prefixFlag] + '|'.toString() + FLAGS[frameFlag] + "|PADDED"
      }
    }

    for (i in FLAGS.indices) { // Fill in holes with binary representation.
      if (FLAGS[i] == null) FLAGS[i] = BINARY[i]
    }
  }

  /**

	}
	if f&FlagSubroute != 0 {
		res = append(res, "SUB")
	}
	return "[" + strings.Join(res, ",") + "]"
}

// Set one or more flags on f.
func (f *Flags) Set(flags Flags) {
	*f |= flags
}

// Clear one or more flags on f.
func (f *Flags) Clear(flags Flags) {
	*f &^= flags
}

// parse an incoming message.
func (m *message) parse(b []byte) (*subHandlerID, []byte, error) {
	var sub *subHandlerID

    }

    /**
     * Gets the lease flags for this acknowledgment
     * @return the lease flags
     */
    public int getLeaseFlags() {
        return flags;
    }

    /**
     * Sets the lease flags for this acknowledgment
     * @param flags the lease flags to set
     */
    public void setLeaseFlags(int flags) {
        this.flags = flags;
    }

    @Override

    }

    /**
     * Gets the flags field which contains flags in SMB 3.1.1 or encryption algorithm ID in SMB 3.0/3.0.2
     *
     * @return the flags (SMB 3.1.1) or encryption algorithm (SMB 3.0/3.0.2)
     */
    public int getFlags() {
        return this.flags;
    }

    /**
     * Sets the flags field which contains flags in SMB 3.1.1 or encryption algorithm ID in SMB 3.0/3.0.2
     *

     *
     * @param flags The flags to apply to this message.
     * @param suppliedDomain The supplied authentication domain.
     * @param suppliedWorkstation The supplied workstation name.
     */
    public Type1Message(final int flags, final String suppliedDomain, String suppliedWorkstation) {
        setFlags(getDefaultFlags() | flags);
        setSuppliedDomain(suppliedDomain);

        int flags = NegTokenInit.REPLAY_DETECTION | NegTokenInit.SEQUENCE_CHECKING;
        byte[] mic = new byte[] { 0x00, 0x0A, (byte) 0xFF };

        NegTokenInit init = new NegTokenInit(mechs, flags, null, mic);
        String s = init.toString();

        assertTrue(s.contains("flags=" + flags), "toString should include flags");

    private static final int BATCH_LIMIT = Config.getInt("jcifs.smb1.smb.client.OpenAndX.ReadAndX", 1);

    int flags, desiredAccess, searchAttributes, fileAttributes, creationTime, openFunction, allocationSize;

    // flags is NOT the same as flags member

    SmbComOpenAndX(final String fileName, final int access, final int flags, final ServerMessageBlock andx) {
        super(andx);
        this.path = fileName;

	if err != nil {
		t.Fatal(err)
	}
	for i, test := range utf8Tests {
		flags := r.File[i].Flags
		if flags != test.flags {
			t.Errorf("CreateHeader(name=%q comment=%q nonUTF8=%v): flags=%#x, want %#x", test.name, test.comment, test.nonUTF8, flags, test.flags)
		}
	}
}

func TestWriterTime(t *testing.T) {
	var buf bytes.Buffer
	h := &FileHeader{

        pos += 4;

        final int flags = readULong(material, pos);
        setFlags(flags);
        pos += 4;

        if ((flags & NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED) != 0) {
            final byte[] domain = readSecurityBuffer(material, pos);
            setSuppliedDomain(new String(domain, getOEMEncoding()));
        }
        pos += 8;

        if ((flags & NTLMSSP_NEGOTIATE_OEM_WORKSTATION_SUPPLIED) != 0) {