// Load 1-15 bytes and corresponding mask.
	// Note: only the low 32-bits of R_LEN are used for the index.
	VLL R_LEN, (R_PTR), V_VAL
	VLL R_LEN, (R_MPTR), V_MASK

	// Compare each byte in input chunk against byte to be counted.
	// Each byte element will be set to either 0 (no match) or 1 (match).
	VCEQB V_CHAR, V_VAL, V_VAL // each byte will be either 0xff or 0x00
	VN    V_MASK, V_VAL, V_VAL // mask out most significant 7 bits

	// Different bytes have different bit masks (i.e: 1, 4, 16, 64)
	MOVD	$0x40100401, R5
	VMOV	R1, V0.B16
	// Work with aligned 32-byte chunks
	BIC	$0x1f, R0, R3
	VMOV	R5, V5.S4
	ANDS	$0x1f, R0, R9
	AND	$0x1f, R2, R10
	BEQ	loop

	// Input string is not 32-byte aligned. We calculate the
	// syndrome value for the aligned 32 bytes block containing
	// the first bytes and mask off the irrelevant part.

        def task2 = task('task2', 'group2')
        def task3 = task('task3', 'group1')

        when:
        def model = modelFor([task1, task2, task3])

        then:
        model.groups == ['group1', 'group2'] as Set
        model.getTasksForGroup('group1')*.path == [pathOf(task1), pathOf(task3)]
        model.getTasksForGroup('group2')*.path == [pathOf(task2)]
    }

        result.assertNotOutput("task1")
        outputContains("Create :task2")
        outputContains("Configure :task2")

        when:
        run("task2")

        then:
        outputContains("Create :task1")
        outputContains("Configure :task1")
        outputContains("Create :task2")
        outputContains("Configure :task2")
    }

        TaskDetails task2 = taskDetails(':task2')
        TaskDetails task3 = taskDetails(':task3', dependencies: [task1])
        RuleDetails rule1 = [getDescription: {'rule1Description'}] as RuleDetails
        RuleDetails rule2 = [getDescription: {'rule2Description'}] as RuleDetails
        List testDefaultTasks = ['task1', 'task2']

        when:
        renderer.showDetail(true)

        model.getTasksForGroup('a') as List == [task1]
        model.getTasksForGroup('other') as List == [task2, task3]
    }

    def groupNamesAreOrderedCaseInsensitive() {
        TaskDetails task1 = taskDetails('task1')
        TaskDetails task2 = taskDetails('task2')
        TaskDetails task3 = taskDetails('task3')
        TaskDetails task4 = taskDetails('task4')

    }
}

tasks.named("task2"){
    println("NAMED TASK2: This is executed during the configuration phase")
    doFirst {
        println("NAMED TASK2 - doFirst: This is executed during the execution phase")
    }
    doLast {
        println("NAMED TASK2 - doLast: This is executed during the execution phase")
    }
}
----
=====

        TaskDetails task2 = taskDetails('task2')
        TaskReportModel project1 = Mock()
        TaskReportModel project2 = Mock()
        _ * project1.groups >> (['group'] as LinkedHashSet)
        _ * project1.getTasksForGroup('group') >> ([task1] as Set)
        _ * project2.groups >> (['group'] as LinkedHashSet)
        _ * project2.getTasksForGroup('group') >> ([task2] as Set)

        def matches = asTasks(result['task1'])

        then:
        matches == [task1, task2]

        and:
        1 * tasks.names >> (['task1', 'task2'] as SortedSet)
        1 * tasks.getByName('task1') >> task1
        1 * childTasks.names >> (['task1', 'task3'] as SortedSet)
        1 * childTasks.getByName('task1') >> task2
        0 * tasks._
        0 * childTasks._
    }

        Task task1 = Mock()
        Task task2 = Mock()
        Task task3 = Mock()

        given:
        store.add(artifact1)
        store.add(artifact2)
        builtBy(artifact1, task1, task2)
        builtBy(artifact2, task1, task3)

        expect:
        set.buildDependencies.getDependencies(null) == [task1, task2, task3] as Set
    }