interceptor.ruleFields.sort(new Comparator<FieldInfo>() {
                        @Override
                        int compare(FieldInfo o1, FieldInfo o2) {
                            def o1Class = o1.reflection.declaringClass
                            def o2Class = o2.reflection.declaringClass
                            if (o1Class != o2Class) {
                                if (o1Class.isAssignableFrom(o2Class)) {

 */
@NonNullApi
class TaskDetails {
    final static Comparator<TaskDetails> DEFAULT_COMPARATOR = (o1, o2) -> {
        // tasks in higher-up projects first
        int depthCompare = o1.getProjectDepth() - o2.getProjectDepth();
        if (depthCompare != 0) {
            return depthCompare;
        }
        return o1.getPath().compareTo(o2.getPath());
    };

    /**

        def args = transformer.transform(spec)
        args.containsAll(expected)

        where:
        debug | optimize | expected
        true  | false    | ["/Zi"]
        false | true     | ["/O2"]
        true  | true     | ["/Zi", "/O2"]
    }

    def "transforms system header and include args correctly"() {
        def spec = Stub(NativeCompileSpec)
        def includes = [ new File("/foo"), new File("/bar") ]

def _composite_no_op():
  pass


@Composite(
    'TestCompositeOp',
    inputs=['x: T', 'y: T'],
    attrs=['act: {"", "relu"}', 'trans: bool = true'],
    derived_attrs=['T: numbertype'],
    outputs=['o1: T', 'o2: T'])
def _composite_op(x, y, act, trans):
  return x + act, y + trans


class TFRGenTensorTest(test.TestCase):
  """MLIR Generation Tests for MLIR TFR Program."""

  def test_op_reg_gen(self):

        Collections.sort(buildConfigurations, new Comparator<XCBuildConfiguration>() {
            @Override
            public int compare(XCBuildConfiguration o1, XCBuildConfiguration o2) {
                return o1.getName().compareTo(o2.getName());
            }
        });
        s.addField("buildConfigurations", buildConfigurations);

        if (defaultConfigurationName.isPresent()) {

        if (capabilityVersions.size() > 1) {
            Set<Capability> sorted = Sets.newTreeSet((o1, o2) -> {
                VersionNumber v1 = VersionNumber.parse(o1.getVersion());
                VersionNumber v2 = VersionNumber.parse(o2.getVersion());
                return v2.compareTo(v1);
            });
            sorted.addAll(capabilityVersions);
            boolean first = true;

(EqPtr  (OffPtr [o1] (Addr {x} _)) (OffPtr [o2] (Addr {y} _))) => (ConstBool [x == y && o1 == o2])
(NeqPtr (Addr {x} _) (Addr {y} _)) => (ConstBool [x != y])
(NeqPtr (Addr {x} _) (OffPtr [o] (Addr {y} _))) => (ConstBool [x != y || o != 0])
(NeqPtr (OffPtr [o1] (Addr {x} _)) (OffPtr [o2] (Addr {y} _))) => (ConstBool [x != y || o1 != o2])
(EqPtr  (LocalAddr {x} _ _) (LocalAddr {y} _ _)) => (ConstBool [x == y])

            final List<java.util.Map.Entry<String, Object>> list = new ArrayList<>(parent.entrySet());
            Collections.sort(list, (o1, o2) -> {
                final String k1 = o1.getKey();
                if (LANG_KEY.equals(k1)) {
                    return -1;
                }
                final String k2 = o2.getKey();
                if (LANG_KEY.equals(k2)) {
                    return -1;
                }

		v := c.regoff(&p.From)
		o1 = OP_IR(c.opir(ALU12IW), uint32(v>>12), uint32(p.To.Reg))
		o2 = OP_12IRR(c.opirr(AOR), uint32(v), uint32(p.To.Reg), uint32(p.To.Reg))

	case 23: // add $lcon,r1,r2
		v := c.regoff(&p.From)
		o1 = OP_IR(c.opir(ALU12IW), uint32(v>>12), uint32(REGTMP))
		o2 = OP_12IRR(c.opirr(AOR), uint32(v), uint32(REGTMP), uint32(REGTMP))
		r := int(p.Reg)
		if r == 0 {

// clang -gdwarf-5 -O2 -nostdlib

__attribute__((noinline, cold))
static int sum(int i) {
  int j, s;

  s = 0;
  for (j = 0; j < i; j++) {
    s += j * i;
  }
  return s;
}

int main(int argc, char** argv) {
  if (argc == 0) {
    return 0;
  }
  return sum(argc);