#define ROUND3FIRST(a, b, c, d, index, const, shift) \
	MOVL	d,		R9; \
	XORL	c,		R9; \
	XORL	b,		R9; \
	ADDL	$const,	a; \
	ADDL	R8,		a; \
	MOVL	(index*4)(SI),R8; \
	ADDL	R9,		a; \
	ROLL	$shift,		a; \
	ADDL	b,		a

#define ROUND3(a, b, c, d, index, const, shift) \
	XORL	a,		R9; \
	XORL	b,		R9; \
	ADDL	$const,	a; \
	ADDL	R8,		a; \

 */

package org.gradle.nativeplatform.fixtures.app

class Swift4WithXCTest extends MainWithXCTestSourceElement {
    final Swift4 main
    final XCTestSourceElement test

    Swift4WithXCTest(String projectName) {
        super(projectName)
        this.main = new Swift4(projectName)
        this.test = new XCTestSourceElement(projectName) {
            @Override

		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenerated

        new Swift3WithSwift4XCTest(rootProjectName) | SwiftVersion.SWIFT3          | SwiftVersion.SWIFT4
        new Swift4WithSwift3XCTest(rootProjectName) | SwiftVersion.SWIFT4          | SwiftVersion.SWIFT3
        new Swift5WithSwift4XCTest(rootProjectName) | SwiftVersion.SWIFT5          | SwiftVersion.SWIFT4
    }

		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenerated
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGenerated

}

// Expand 48-bit input to 64-bit, with each 6-bit block padded by extra two bits at the top.
// By doing so, we can have the input blocks (four bits each), and the key blocks (six bits each) well-aligned without
// extra shifts/rotations for alignments.
func unpack(x uint64) uint64 {
	return ((x>>(6*1))&0xff)<<(8*0) |
		((x>>(6*3))&0xff)<<(8*1) |
		((x>>(6*5))&0xff)<<(8*2) |
		((x>>(6*7))&0xff)<<(8*3) |
		((x>>(6*0))&0xff)<<(8*4) |

    --node-image)
      NODE_IMAGE=$2
      shift 2
    ;;
    # Config for enabling different Kubernetes features in KinD (see prow/config{endpointslice.yaml,trustworthy-jwt.yaml}).
    --kind-config)
    KIND_CONFIG=$2
    shift 2
    ;;
    --skip-setup)
      SKIP_SETUP=true
      shift
    ;;
    --skip-cleanup)
      SKIP_CLEANUP=true
      shift
    ;;
    --skip-build)
      SKIP_BUILD=true

	CMPBEQ	R6, R7, end

loop:
	STMY	R2, R5, tmp-16(SP)

	MOVWBR	0(R6), R8
	MOVWZ	R5, R9

#define ROUND1(a, b, c, d, index, const, shift) \
	XOR	c, R9; \
	ADD	$const, a; \
	ADD	R8, a; \
	MOVWBR	(index*4)(R6), R8; \
	AND	b, R9; \
	XOR	d, R9; \
	ADD	R9, a; \
	RLL	$shift, a; \
	MOVWZ	c, R9; \
	ADD	b, a

	ROUND1(R2,R3,R4,R5, 1,0xd76aa478, 7);
	ROUND1(R5,R2,R3,R4, 2,0xe8c7b756,12);

			}
		case lex.LSH:
			p.next()
			shift := p.factor()
			if int64(shift) < 0 {
				p.errorf("negative left shift count")
			}
			return value << shift
		case lex.RSH:
			p.next()
			shift := p.term()
			if int64(shift) < 0 {
				p.errorf("negative right shift count")
			}
			if int64(value) < 0 {
				p.errorf("right shift of value with high bit set")
			}
			value >>= shift

	// badCharSkip[b] is len(pattern).
	//
	// Whenever a mismatch is found with byte b in the text, we can safely
	// shift the matching frame at least badCharSkip[b] until the next time
	// the matching char could be in alignment.
	badCharSkip [256]int

	// goodSuffixSkip[i] defines how far we can shift the matching frame given
	// that the suffix pattern[i+1:] matches, but the byte pattern[i] does
	// not. There are two cases to consider: