ab.asmand(ctxt, cursym, p, &p.To, &p.From)

			case Zvex:
				ab.asmvex(ctxt, &p.From, p.GetFrom3(), &p.To, o.op[z], o.op[z+1])

			case Zvex_rm_v_r:
				ab.asmvex(ctxt, &p.From, p.GetFrom3(), &p.To, o.op[z], o.op[z+1])
				ab.asmand(ctxt, cursym, p, &p.From, &p.To)

			case Zvex_rm_v_ro:
				ab.asmvex(ctxt, &p.From, p.GetFrom3(), &p.To, o.op[z], o.op[z+1])

type asmFunc struct {
	arch        *asmArch
	size        int // size of all arguments
	vars        map[string]*asmVar
	varByOffset map[int]*asmVar
}

// An asmVar describes a single assembly variable.
type asmVar struct {
	name  string
	kind  asmKind
	typ   string
	off   int
	size  int
	inner []*asmVar
}

var (
	asmArch386      = asmArch{name: "386", bigEndian: false, stack: "SP", lr: false}

	ACNTTZD
	ACNTTZDCC
	ACOPY
	APASTECC
	ADARN
	AMADDHD
	AMADDHDU
	AMADDLD

	/* Vector */
	ALVEBX
	ALVEHX
	ALVEWX
	ALVX
	ALVXL
	ALVSL
	ALVSR
	ASTVEBX
	ASTVEHX
	ASTVEWX
	ASTVX
	ASTVXL
	AVAND
	AVANDC
	AVNAND
	AVOR
	AVORC
	AVNOR
	AVXOR
	AVEQV
	AVADDUM
	AVADDUBM
	AVADDUHM
	AVADDUWM
	AVADDUDM
	AVADDUQM
	AVADDCU

	AFCVTWS
	AFCVTLS
	AFCVTSW
	AFCVTSL
	AFCVTWUS
	AFCVTLUS
	AFCVTSWU
	AFCVTSLU
	AFSGNJS
	AFSGNJNS
	AFSGNJXS
	AFMVXS
	AFMVSX
	AFMVXW
	AFMVWX

	// 11.8: Single-Precision Floating-Point Compare Instructions
	AFEQS
	AFLTS
	AFLES

	// 11.9: Single-Precision Floating-Point Classify Instruction
	AFCLASSS

    }

    public PgpKeyId(String keyId) {
        asLong = toLong(keyId);
        asHex = toHex(asLong);
    }

    @Override
    public boolean equals(Object other) {
        return other instanceof PgpKeyId
            && ((PgpKeyId) other).asHex.equals(this.asHex);
    }

    @Override
    public int hashCode() {
        return asHex.hashCode();
    }

    @Override
    public String toString() {

	case AFMULQ:
		return &inst{0x53, 0x0, 0x0, 352, 0xb}
	case AFMULS:
		return &inst{0x53, 0x0, 0x0, 256, 0x8}
	case AFMVDX:
		return &inst{0x53, 0x0, 0x0, -224, 0x79}
	case AFMVSX:
		return &inst{0x53, 0x0, 0x0, -256, 0x78}
	case AFMVWX:
		return &inst{0x53, 0x0, 0x0, -256, 0x78}
	case AFMVXD:
		return &inst{0x53, 0x0, 0x0, -480, 0x71}
	case AFMVXS:

    protected key(arg) {
        new PgpKeyId(arg)
    }

    def "conversion is symmetrical"() {
        expect:
        key("ABCDABCD").asHex == "ABCDABCD"
    }

    def "conversion"() {
        expect:
        key(hex).asLong == decimal
        key(decimal).asHex == hex

        where:
        hex        | decimal
        "AAAAAAAA" | 2863311530
        "DA124B92" | 3658632082
    }

<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <ItemGroup Label="Filters">
      <Filter Include="Source Files">
        <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
      </Filter>
      <Filter Include="Header Files">
        <!-- if you would like to add more endings to this pattern, make sure to also edit DefaultCppLibrary.java and DefaultCppComponent.java-->

}

// IsARMSTREX reports whether the op (as defined by an arm.A* constant) is
// one of the STREX-like instructions that require special handling.
func IsARMSTREX(op obj.As) bool {
	switch op {
	case arm.ASTREX, arm.ASTREXD, arm.ASWPW, arm.ASWPBU:
		return true
	}
	return false
}

// MCR is not defined by the obj/arm; instead we define it privately here.

        then:
        Node sourceFiles = itemGroup('Filters').Filter.find({it.'@Include' == 'Source Files'}) as Node
        sourceFiles.Extensions[0].text() == 'cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx'

        Node headerFiles = itemGroup('Filters').Filter.find({it.'@Include' == 'Header Files'}) as Node
        headerFiles.Extensions[0].text() == 'h;hpp;h++;hxx;hm;inl;inc;xsd'