return c
}

func SubSubNegSimplify(a, b int) int {
	// amd64:"NEGQ"
	// ppc64x:"NEG"
	r := (a - b) - a
	return r
}

func SubAddSimplify(a, b int) int {
	// amd64:-"SUBQ",-"ADDQ"
	// ppc64x:-"SUB",-"ADD"
	r := a + (b - a)
	return r
}

func SubAddSimplify2(a, b, c int) (int, int, int, int, int, int) {
	// amd64:-"ADDQ"
	r := (a + b) - (a + c)
	// amd64:-"ADDQ"

			s2:   []int{1, 2, 3},
			eq: func(a, b int) bool {
				return a == b
			},
			want: true,
		},
		{
			name: "Unequal slices",
			s1:   []int{1, 2, 3},
			s2:   []int{4, 5, 6},
			eq: func(a, b int) bool {
				return a == b
			},
			want: false,
		},
		{
			name: "Empty slices",
			s1:   []int{},
			s2:   []int{},
			eq: func(a, b int) bool {
				return a == b
			},
			want: true,

        }

        where:
        requestedTasks | failingTask | expectedExecutedTasks
        ['a']          | 'c'         | [':c']
        ['a', 'b']     | 'a'         | [any(':d', exact(':c', ':a')), ':b']
        ['a', 'b']     | 'c'         | [any(':c', ':d'), ':b'] // :c and :d might run in parallel with the configuration cache
    }

        models.projects.path == [':', ':a', ':b']
    }

    @TargetGradleVersion(">=6.8")
    def "nested actions that query a project model do not run in parallel when target Gradle version supports it and #args is used"() {
        given:
        setupBuildWithDependencyResolution()

        expect:
        server.expectConcurrent(1, 'root', 'a', 'b')
        def models = withConnection {

                p.afterEvaluate {
                    println "[3] afterEvaluate $p.name"
                }
            }
        '''
        createDirs("a", "b")
        settingsFile << """
            rootProject.name = 'root'
            include 'a', 'b'
        """

        expect:
        def result = fails()
        result.assertHasDescription("A problem occurred evaluating root project 'root'.")

		return Convert_v1alpha1_GroupResource_To_v1_GroupResource(a.(*v1alpha1.GroupResource), b.(*v1.GroupResource), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*v1.GroupResource)(nil), (*v1alpha1.GroupResource)(nil), func(a, b interface{}, scope conversion.Scope) error {

	if a&0x1 != 0 {
		return 1
	}
	return 0
}

func biton64(a, b uint64) (n uint64) {
	// amd64:"BTSQ"
	n += b | (1 << (a & 63))

	// amd64:"BTSQ\t[$]63"
	n += a | (1 << 63)

	// amd64:"BTSQ\t[$]60"
	n += a | (1 << 60)

	// amd64:"ORQ\t[$]1"
	n += a | (1 << 0)

	return n
}

func bitoff64(a, b uint64) (n uint64) {
	// amd64:"BTRQ"
	n += b &^ (1 << (a & 63))

			return +1
		}
	}
samebytes:
	if len(a) < len(b) {
		return -1
	}
	if len(a) > len(b) {
		return +1
	}
	return 0
}

func CompareString(a, b string) int {
	return runtime_cmpstring(a, b)
}

// runtime.cmpstring calls are emitted by the compiler.
//
// runtime.cmpstring should be an internal detail,
// but widely used packages access it using linkname.

KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = DefaultExpressionInfo:
    expression = when {
                a + b > 0 -> break
                a - b > 0 -> break
                else -> consume(0)
            }
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    break,
    break
  ]
  returnValueType = null

		{name: "no object", schema: &schema.Structural{}},
		{name: "list without schema",
			obj: map[string]interface{}{
				"array": []interface{}{"a", "b", "a"},
			},
		},
		{name: "list without items",
			obj: map[string]interface{}{
				"array": []interface{}{"a", "b", "a"},
			},
			schema: &schema.Structural{
				Generic: schema.Generic{
					Type: "object",
				},
				Properties: map[string]schema.Structural{