STP	(ZR, ZR), (R0)
	RET

zero_by_16:
	// n greater than 16 bytes, check if the start address is aligned
	NEG	R0, R4
	ANDS	$15, R4, R4
	// Try zeroing using zva if the start address is aligned with 16
	BEQ	try_zva

	// Non-aligned store
	STP	(ZR, ZR), (R0)
	// Make the destination aligned
	SUB	R4, R1, R1
	ADD	R4, R0, R0
	B	try_zva

tail_maybe_long:
	CMP	$64, R1
	BHS	no_zva

tail63:

	y := unsafe.Slice(yb, n)

	if supportsUnaligned || aligned(dstb, xb, yb) {
		xorLoop(words(dst), words(x), words(y))
		if uintptr(n)%wordSize == 0 {
			return
		}
		done := n &^ int(wordSize-1)
		dst = dst[done:]
		x = x[done:]
		y = y[done:]
	}
	xorLoop(dst, x, y)
}

// aligned reports whether dst, x, and y are all word-aligned pointers.
func aligned(dst, x, y *byte) bool {

	CMPQ CX, $8
	JL less_than_8

	MOVQ SI, BX
	ANDQ $7, BX
	JZ aligned

	// Process the first few bytes to 8-byte align the input.

	// BX = 8 - BX. We need to process this many bytes to align.
	SUBQ $1, BX
	XORQ $7, BX

	BTQ $0, BX
	JNC align_2

	CRC32B (SI), AX
	DECQ CX
	INCQ SI

align_2:
	BTQ $1, BX
	JNC align_4

	CRC32W (SI), AX

	SUBQ $2, CX
	ADDQ $2, SI

align_4:

		// this comment should be indented
	case 2:
		x = 0
	// this comment should not be indented, it is aligned with the next case
	case 3:
		x = 0
		/* indented comment
		   aligned
		   aligned
		*/
		// bla
		/* and more */
	case 4:
		x = 0
	/* not indented comment
	   aligned
	   aligned
	*/
	// bla
	/* and more */
	case 5:
	}
}

		// this comment should be indented
	case 2:
		x = 0
	// this comment should not be indented, it is aligned with the next case
	case 3:
		x = 0
		/* indented comment
		   aligned
		   aligned
		*/
		// bla
		/* and more */
	case 4:
		x = 0
	/* not indented comment
	   aligned
	   aligned
	*/
	// bla
	/* and more */
	case 5:
	}
}

var _ = T{0: 0} // not aligned
var _ = T{0: 0, // not aligned
	1: 1, // aligned
	22: 22, // aligned
	333: 333, 1234: 12, 12345: 0, // first on line aligned
}


// test cases form issue 8685
// not aligned
var _ = map[int]string{1: "spring", 2: "summer",
					3:             "autumn", 4: "winter"}

// not aligned
var _ = map[string]string{"a": "spring", "b": "summer",

//     field's size. As with all element types, if the struct is used
//     in an array its size must first be aligned to a multiple of the
//     struct's alignment.
//   - All other types have size WordSize.
//   - Arrays and structs are aligned per spec definition; all other
//     types are naturally aligned with a maximum alignment MaxAlign.
//
// *StdSizes implements Sizes.
type StdSizes struct {

	1:	1,				// aligned
	22:	22,				// aligned
	333:	333, 1234: 12, 12345: 0,	// first on line aligned
}

// test cases form issue 8685
// not aligned
var _ = map[int]string{1: "spring", 2: "summer",
	3:	"autumn", 4: "winter"}

// not aligned
var _ = map[string]string{"a": "spring", "b": "summer",
	"c":	"autumn", "d": "winter"}

// aligned
var _ = map[string]string{"a": "spring",
	"b":	"summer",
	"c":	"autumn",

//     field's size. As with all element types, if the struct is used
//     in an array its size must first be aligned to a multiple of the
//     struct's alignment.
//   - All other types have size WordSize.
//   - Arrays and structs are aligned per spec definition; all other
//     types are naturally aligned with a maximum alignment MaxAlign.
//
// *StdSizes implements Sizes.
type StdSizes struct {

// on entry to any function, but only FreeBSD's C library seems to care.
// The caller was 8-byte aligned, but we push an LR.
// Declare a dummy word ($4, not $0) to make sure the
// frame is 8 bytes and stays 8-byte-aligned.
TEXT runtime·_initcgo(SB),NOSPLIT,$4
	// if there is an _cgo_init, call it.
	MOVW	_cgo_init(SB), R4
	CMP	$0, R4
	B.EQ	nocgo
	MRC     15, 0, R0, C13, C0, 3 	// load TLS base pointer