AREMD
	AREMDU

	/* more 64-bit operations */
	AHRFID
	APOPCNTD
	APOPCNTW
	APOPCNTB
	ACNTTZW
	ACNTTZWCC
	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

    while (lower <= upper) {
      int middle = (lower + upper) >>> 1;
      int c = comparator.compare(key, list.get(middle));
      if (c < 0) {
        upper = middle - 1;
      } else if (c > 0) {
        lower = middle + 1;
      } else {
        return lower
            + presentBehavior.resultIndex(
                comparator, key, list.subList(lower, upper + 1), middle - lower);
      }
    }

    while (lower <= upper) {
      int middle = (lower + upper) >>> 1;
      int c = comparator.compare(key, list.get(middle));
      if (c < 0) {
        upper = middle - 1;
      } else if (c > 0) {
        lower = middle + 1;
      } else {
        return lower
            + presentBehavior.resultIndex(
                comparator, key, list.subList(lower, upper + 1), middle - lower);
      }
    }

			for j := 0; j < 16; j++ {
				f := uint64(sBoxes[s][i][j]) << (4 * (7 - uint(s)))
				f = permuteBlock(f, permutationFunction[:])

				// Row is determined by the 1st and 6th bit.
				// Column is the middle four bits.
				row := uint8(((i & 2) << 4) | i&1)
				col := uint8(j << 1)
				t := row | col

				// The rotation was performed in the feistel rounds, being factored out and now mixed into the feistelBox.

    def explanationBuilder = Stub(AttributeMatchingExplanationBuilder)

    def highest = Attribute.of("highest", String)
    def middle = Attribute.of("middle", String)
    def lowest = Attribute.of("lowest", String)
    // This has no precedence
    def additional = Attribute.of("usage", String)

      "00000010",
      "00000011",
      "END_HEADERS",
      "END_STREAM|END_HEADERS",
      "00000110",
      "00000111",
      "PADDED",
      "END_STREAM|PADDED",
      "00001010",
      "00001011",
      "00001100",
      "END_STREAM|END_HEADERS|PADDED",
      "00001110",
      "00001111",
      "00010000",
      "00010001",
      "00010010",
      "00010011",
      "00010100",

				//   15001:
				//     middle (dest ip):
				//       fallback:
				//         inner (src ip):
				//           fallback: chain
				inner := NewSourceIP()
				inner.OnNoMatch = ToChain("chain")

				middle := NewDestinationIP()
				middle.OnNoMatch = ToMatcher(inner.Matcher)

				root := NewDestinationPort()
				root.Map["15001"] = ToMatcher(middle.Matcher)
				return root
			},

        when:
        middle.attribute(one, "middle")

        then:
        chain.getAttribute(one) == "middle"

        when:
        primary.attributeProvider(one, Providers.of("primary"))

        then:
        chain.getAttribute(one) == "primary"
    }

    def "joined containers are equal if their fallbacks and primaryren are equal"() {
        given:

  init {
    FLAGS[FLAG_NONE] = ""
    FLAGS[FLAG_END_STREAM] = "END_STREAM"

    val prefixFlags = intArrayOf(FLAG_END_STREAM)

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

    FLAGS[FLAG_END_HEADERS] = "END_HEADERS" // Same as END_PUSH_PROMISE.
    FLAGS[FLAG_PRIORITY] = "PRIORITY" // Same as FLAG_COMPRESSED.

                        version("my.middle", "1.0")
                        version("my.middle.bottom", "1.1")
                    }
                }
            }
        """

        buildFile """
            tasks.register("dumpVersions") {
                def first = libs.versions.my.middle.asProvider()
                def second = libs.versions.my.middle.bottom
                doLast {