fmt.Fprintf(os.Stderr, "usage: asm [options] file.s ...\n")
	fmt.Fprintf(os.Stderr, "Flags:\n")
	flag.PrintDefaults()
	os.Exit(2)
}

func Parse() {
	objabi.Flagparse(Usage)
	if flag.NArg() == 0 {
		flag.Usage()
	}

	// Flag refinement.
	if *OutputFile == "" {
		if flag.NArg() != 1 {
			flag.Usage()
		}
		input := filepath.Base(flag.Arg(0))
		input = strings.TrimSuffix(input, ".s")

                path = readString( buffer, start + pathOffset, len, (flags2 & FLAGS2_UNICODE) != 0);
                if (nodeOffset > 0)
                    node = readString( buffer, start + nodeOffset, len, (flags2 & FLAGS2_UNICODE) != 0);
            } else if( version == 1 ) {
                node = readString( buffer, bufferIndex, len, (flags2 & FLAGS2_UNICODE) != 0);
            }

            return size;
        }

    /**
     * @return the flags
     */
    public final int getFlags () {
        return this.flags;
    }


    /**
     * 
     * @param flag
     */
    public final void addFlags ( int flag ) {
        this.flags |= flag;
    }


    /**
     * 
     * @param flag
     */
    public final void clearFlags ( int flag ) {
        this.flags &= ~flag;
    }

	GOARCH := buildcfg.GOARCH

	flags.Parse()

	architecture := arch.Set(GOARCH, *flags.Shared || *flags.Dynlink)
	if architecture == nil {
		log.Fatalf("unrecognized architecture %s", GOARCH)
	}
	ctxt := obj.Linknew(architecture.LinkArch)
	ctxt.Debugasm = flags.PrintOut
	ctxt.Debugvlog = flags.DebugV
	ctxt.Flag_dynlink = *flags.Dynlink
	ctxt.Flag_linkshared = *flags.Linkshared
	ctxt.Flag_shared = *flags.Shared || *flags.Dynlink

        try {
            int flags = getFlags();
            int size = 8 * 4 + ( ( flags & NTLMSSP_NEGOTIATE_VERSION ) != 0 ? 8 : 0 );

            byte[] domain = new byte[0];
            String suppliedDomainString = getSuppliedDomain();
            if ( ( flags & NTLMSSP_NEGOTIATE_VERSION ) == 0 && suppliedDomainString != null && suppliedDomainString.length() != 0 ) {
                flags |= NTLMSSP_NEGOTIATE_OEM_DOMAIN_SUPPLIED;

	}
	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

    ServerMessageBlock response;

    ServerMessageBlock() {
        flags = (byte)( FLAGS_PATH_NAMES_CASELESS | FLAGS_PATH_NAMES_CANONICALIZED );
        pid = PID;
        batchLevel = 0;
    }

    void reset() {
        flags = (byte)( FLAGS_PATH_NAMES_CASELESS | FLAGS_PATH_NAMES_CANONICALIZED );
        flags2 = 0;
        errorCode = 0;
        received = false;
        digest = null;
    }

    }


    /**
     * @return the flags
     */
    public final byte getFlags () {
        return this.flags;
    }


    /**
     * @param flags
     *            the flags to set
     */
    public final void setFlags ( byte flags ) {
        this.flags = flags;
    }


    /**
     * @return the flags2
     */
    public final int getFlags2 () {

     * to the given Type-1 message in the current environment.
     *
     * @return An <code>int</code> containing the default flags.
     */
    public static int getDefaultFlags(Type1Message type1) {
        if (type1 == null) return DEFAULT_FLAGS;
        int flags = NTLMSSP_NEGOTIATE_NTLM;
        int type1Flags = type1.getFlags();

// and success cases.
func TestCrossDeviceMountPaths(t *testing.T) {
	successCase := `/dev/0 /path/to/0/1 type0 flags 0 0
		/dev/1    /path/to/1   type1	flags 1 1
		/dev/2 /path/to/1/2 type2 flags,1,2=3 2 2
                /dev/3 /path/to/1.1 type3 flags,1,2=3 3 3
		`
	var err error
	dir := t.TempDir()
	mountsPath := filepath.Join(dir, "mounts")