public void ordered(Comparator<T> comparator) {
        ordered(true, comparator);
    }

    @Override
    public void ordered(boolean pickLast, Comparator<T> comparator) {
        compatibilityRules.ordered(comparator);
        if (pickLast) {
            disambiguationRules.pickLast(comparator);
        } else {
            disambiguationRules.pickFirst(comparator);
        }
    }

     * compatible.</p>
     *
     * @param pickLast tells if, for disambiguation, we should pick the last value in order instead of the first one
     * @param comparator the comparator to use for compatibility and disambiguation
     */
    void ordered(boolean pickLast, Comparator<T> comparator);

        Action<? super MultipleCandidatesDetails<T>> rule = AttributeMatchingRules.orderedDisambiguation(comparator, true);
        rules.add(rule);
    }

    @Override
    public void pickLast(Comparator<? super T> comparator) {
        Action<? super MultipleCandidatesDetails<T>> rule = AttributeMatchingRules.orderedDisambiguation(comparator, false);
        rules.add(rule);
    }

    @Override

     * value (if multiple candidates have the same attribute value, there will
     * still be an ambiguity).
     *
     * @param comparator the comparator to use
     */
    void pickLast(Comparator<? super T> comparator);

        targetPlatformSchema.getCompatibilityRules().ordered(Ordering.natural());
        targetPlatformSchema.getDisambiguationRules().pickLast(Ordering.natural());
    }

    private static void configureTargetEnvironment(AttributesSchema attributesSchema) {

                    attribute(arch) {
                       disambiguationRules.pickLast { a,b -> a<=>b }
                  }
               }
            }
            project(':c') {
                dependencies.attributesSchema {
                    attribute(arch) {
                       disambiguationRules.pickLast { a,b -> a<=>b }
                    }
                }
            }