diff --git a/test/codegen/memcombine.go b/test/codegen/memcombine.go
index ad42538dcd..0d4e96f862 100644
--- a/test/codegen/memcombine.go
+++ b/test/codegen/memcombine.go
@@ -11,98 +11,94 @@ import (
 	"runtime"
 )
 
-var sink64 uint64
-var sink32 uint32
-var sink16 uint16
-
 // ------------- //
 //    Loading    //
 // ------------- //
 
-func load_le64(b []byte) {
+func load_le64(b []byte) uint64 {
 	// amd64:`MOVQ\s\(.*\),`,-`MOV[BWL]\t[^$]`,-`OR`
 	// s390x:`MOVDBR\s\(.*\),`
 	// arm64:`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`
 	// ppc64le:`MOVD\s`,-`MOV[BHW]Z`
-	sink64 = binary.LittleEndian.Uint64(b)
+	return binary.LittleEndian.Uint64(b)
 }
 
-func load_le64_idx(b []byte, idx int) {
+func load_le64_idx(b []byte, idx int) uint64 {
 	// amd64:`MOVQ\s\(.*\)\(.*\*1\),`,-`MOV[BWL]\t[^$]`,-`OR`
 	// s390x:`MOVDBR\s\(.*\)\(.*\*1\),`
 	// arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BHW]`
 	// ppc64le:`MOVD\s`,-`MOV[BHW]Z\s`
-	sink64 = binary.LittleEndian.Uint64(b[idx:])
+	return binary.LittleEndian.Uint64(b[idx:])
 }
 
-func load_le32(b []byte) {
+func load_le32(b []byte) uint32 {
 	// amd64:`MOVL\s\(.*\),`,-`MOV[BW]`,-`OR`
 	// 386:`MOVL\s\(.*\),`,-`MOV[BW]`,-`OR`
 	// s390x:`MOVWBR\s\(.*\),`
 	// arm64:`MOVWU\s\(R[0-9]+\),`,-`MOV[BH]`
 	// ppc64le:`MOVWZ\s`,-`MOV[BH]Z\s`
-	sink32 = binary.LittleEndian.Uint32(b)
+	return binary.LittleEndian.Uint32(b)
 }
 
-func load_le32_idx(b []byte, idx int) {
+func load_le32_idx(b []byte, idx int) uint32 {
 	// amd64:`MOVL\s\(.*\)\(.*\*1\),`,-`MOV[BW]`,-`OR`
 	// 386:`MOVL\s\(.*\)\(.*\*1\),`,-`MOV[BW]`,-`OR`
 	// s390x:`MOVWBR\s\(.*\)\(.*\*1\),`
 	// arm64:`MOVWU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BH]`
 	// ppc64le:`MOVWZ\s`,-`MOV[BH]Z\s`
-	sink32 = binary.LittleEndian.Uint32(b[idx:])
+	return binary.LittleEndian.Uint32(b[idx:])
 }
 
-func load_le16(b []byte) {
+func load_le16(b []byte) uint16 {
 	// amd64:`MOVWLZX\s\(.*\),`,-`MOVB`,-`OR`
 	// ppc64le:`MOVHZ\s`,-`MOVBZ`
 	// arm64:`MOVHU\s\(R[0-9]+\),`,-`MOVB`
 	// s390x:`MOVHBR\s\(.*\),`
-	sink16 = binary.LittleEndian.Uint16(b)
+	return binary.LittleEndian.Uint16(b)
 }
 
-func load_le16_idx(b []byte, idx int) {
+func load_le16_idx(b []byte, idx int) uint16 {
 	// amd64:`MOVWLZX\s\(.*\),`,-`MOVB`,-`OR`
 	// ppc64le:`MOVHZ\s`,-`MOVBZ`
 	// arm64:`MOVHU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOVB`
 	// s390x:`MOVHBR\s\(.*\)\(.*\*1\),`
-	sink16 = binary.LittleEndian.Uint16(b[idx:])
+	return binary.LittleEndian.Uint16(b[idx:])
 }
 
-func load_be64(b []byte) {
+func load_be64(b []byte) uint64 {
 	// amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR`
 	// amd64/v3:`MOVBEQ`
 	// s390x:`MOVD\s\(.*\),`
 	// arm64:`REV`,`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`,-`REVW`,-`REV16W`
 	// ppc64le:`MOVDBR`,-`MOV[BHW]Z`
-	sink64 = binary.BigEndian.Uint64(b)
+	return binary.BigEndian.Uint64(b)
 }
 
-func load_be64_idx(b []byte, idx int) {
+func load_be64_idx(b []byte, idx int) uint64 {
 	// amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR`
 	// amd64/v3: `MOVBEQ`
 	// s390x:`MOVD\s\(.*\)\(.*\*1\),`
 	// arm64:`REV`,`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[WHB]`,-`REVW`,-`REV16W`
 	// ppc64le:`MOVDBR`,-`MOV[BHW]Z`
-	sink64 = binary.BigEndian.Uint64(b[idx:])
+	return binary.BigEndian.Uint64(b[idx:])
 }
 
-func load_be32(b []byte) {
+func load_be32(b []byte) uint32 {
 	// amd64/v1,amd64/v2:`BSWAPL`,-`MOV[BW]`,-`OR`
 	// amd64/v3: `MOVBEL`
 	// s390x:`MOVWZ\s\(.*\),`
 	// arm64:`REVW`,`MOVWU\s\(R[0-9]+\),`,-`MOV[BH]`,-`REV16W`
 	// ppc64le:`MOVWBR`,-`MOV[BH]Z`
-	sink32 = binary.BigEndian.Uint32(b)
+	return binary.BigEndian.Uint32(b)
 }
 
-func load_be32_idx(b []byte, idx int) {
+func load_be32_idx(b []byte, idx int) uint32 {
 	// amd64/v1,amd64/v2:`BSWAPL`,-`MOV[BW]`,-`OR`
 	// amd64/v3: `MOVBEL`
 	// s390x:`MOVWZ\s\(.*\)\(.*\*1\),`
 	// arm64:`REVW`,`MOVWU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[HB]`,-`REV16W`
 	// ppc64le:`MOVWBR`,-`MOV[BH]Z`
-	sink32 = binary.BigEndian.Uint32(b[idx:])
+	return binary.BigEndian.Uint32(b[idx:])
 }
 
 func load_be16(b []byte) uint16 {
@@ -357,20 +353,20 @@ func safe_point(p, q *[2]*int) {
 //    Storing    //
 // ------------- //
 
-func store_le64(b []byte) {
+func store_le64(b []byte, x uint64) {
 	// amd64:`MOVQ\s.*\(.*\)$`,-`SHR.`
 	// arm64:`MOVD`,-`MOV[WBH]`
 	// ppc64le:`MOVD\s`,-`MOV[BHW]\s`
 	// s390x:`MOVDBR\s.*\(.*\)$`
-	binary.LittleEndian.PutUint64(b, sink64)
+	binary.LittleEndian.PutUint64(b, x)
 }
 
-func store_le64_idx(b []byte, idx int) {
+func store_le64_idx(b []byte, x uint64, idx int) {
 	// amd64:`MOVQ\s.*\(.*\)\(.*\*1\)$`,-`SHR.`
 	// arm64:`MOVD\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BHW]`
 	// ppc64le:`MOVD\s`,-`MOV[BHW]\s`
 	// s390x:`MOVDBR\s.*\(.*\)\(.*\*1\)$`
-	binary.LittleEndian.PutUint64(b[idx:], sink64)
+	binary.LittleEndian.PutUint64(b[idx:], x)
 }
 
 func store_le64_load(b []byte, x *[8]byte) {
@@ -382,63 +378,63 @@ func store_le64_load(b []byte, x *[8]byte) {
 	binary.LittleEndian.PutUint64(b, binary.LittleEndian.Uint64(x[:]))
 }
 
-func store_le32(b []byte) {
+func store_le32(b []byte, x uint32) {
 	// amd64:`MOVL\s`
 	// arm64:`MOVW`,-`MOV[BH]`
 	// ppc64le:`MOVW\s`
 	// s390x:`MOVWBR\s.*\(.*\)$`
-	binary.LittleEndian.PutUint32(b, sink32)
+	binary.LittleEndian.PutUint32(b, x)
 }
 
-func store_le32_idx(b []byte, idx int) {
+func store_le32_idx(b []byte, x uint32, idx int) {
 	// amd64:`MOVL\s`
 	// arm64:`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BH]`
 	// ppc64le:`MOVW\s`
 	// s390x:`MOVWBR\s.*\(.*\)\(.*\*1\)$`
-	binary.LittleEndian.PutUint32(b[idx:], sink32)
+	binary.LittleEndian.PutUint32(b[idx:], x)
 }
 
-func store_le16(b []byte) {
+func store_le16(b []byte, x uint16) {
 	// amd64:`MOVW\s`
 	// arm64:`MOVH`,-`MOVB`
 	// ppc64le:`MOVH\s`
 	// s390x:`MOVHBR\s.*\(.*\)$`
-	binary.LittleEndian.PutUint16(b, sink16)
+	binary.LittleEndian.PutUint16(b, x)
 }
 
-func store_le16_idx(b []byte, idx int) {
+func store_le16_idx(b []byte, x uint16, idx int) {
 	// amd64:`MOVW\s`
 	// arm64:`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOVB`
 	// ppc64le:`MOVH\s`
 	// s390x:`MOVHBR\s.*\(.*\)\(.*\*1\)$`
-	binary.LittleEndian.PutUint16(b[idx:], sink16)
+	binary.LittleEndian.PutUint16(b[idx:], x)
 }
 
-func store_be64(b []byte) {
+func store_be64(b []byte, x uint64) {
 	// amd64/v1,amd64/v2:`BSWAPQ`,-`SHR.`
 	// amd64/v3: `MOVBEQ`
 	// arm64:`MOVD`,`REV`,-`MOV[WBH]`,-`REVW`,-`REV16W`
 	// ppc64le:`MOVDBR`
 	// s390x:`MOVD\s.*\(.*\)$`,-`SRW\s`,-`SRD\s`
-	binary.BigEndian.PutUint64(b, sink64)
+	binary.BigEndian.PutUint64(b, x)
 }
 
-func store_be64_idx(b []byte, idx int) {
+func store_be64_idx(b []byte, x uint64, idx int) {
 	// amd64/v1,amd64/v2:`BSWAPQ`,-`SHR.`
 	// amd64/v3:`MOVBEQ`
 	// arm64:`REV`,`MOVD\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BHW]`,-`REV16W`,-`REVW`
 	// ppc64le:`MOVDBR`
 	// s390x:`MOVD\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s`
-	binary.BigEndian.PutUint64(b[idx:], sink64)
+	binary.BigEndian.PutUint64(b[idx:], x)
 }
 
-func store_be32(b []byte) {
+func store_be32(b []byte, x uint32) {
 	// amd64/v1,amd64/v2:`BSWAPL`,-`SHR.`
 	// amd64/v3:`MOVBEL`
 	// arm64:`MOVW`,`REVW`,-`MOV[BH]`,-`REV16W`
 	// ppc64le:`MOVWBR`
 	// s390x:`MOVW\s.*\(.*\)$`,-`SRW\s`,-`SRD\s`
-	binary.BigEndian.PutUint32(b, sink32)
+	binary.BigEndian.PutUint32(b, x)
 }
 
 func store_be64_load(b, x *[8]byte) {
@@ -453,31 +449,31 @@ func store_be32_load(b, x *[8]byte) {
 	binary.BigEndian.PutUint32(b[:], binary.BigEndian.Uint32(x[:]))
 }
 
-func store_be32_idx(b []byte, idx int) {
+func store_be32_idx(b []byte, x uint32, idx int) {
 	// amd64/v1,amd64/v2:`BSWAPL`,-`SHR.`
 	// amd64/v3:`MOVBEL`
 	// arm64:`REVW`,`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BH]`,-`REV16W`
 	// ppc64le:`MOVWBR`
 	// s390x:`MOVW\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s`
-	binary.BigEndian.PutUint32(b[idx:], sink32)
+	binary.BigEndian.PutUint32(b[idx:], x)
 }
 
-func store_be16(b []byte) {
+func store_be16(b []byte, x uint16) {
 	// amd64/v1,amd64/v2:`ROLW\s\$8`,-`SHR.`
 	// amd64/v3:`MOVBEW`,-`ROLW`
 	// arm64:`MOVH`,`REV16W`,-`MOVB`
 	// ppc64le:`MOVHBR`
 	// s390x:`MOVH\s.*\(.*\)$`,-`SRW\s`,-`SRD\s`
-	binary.BigEndian.PutUint16(b, sink16)
+	binary.BigEndian.PutUint16(b, x)
 }
 
-func store_be16_idx(b []byte, idx int) {
+func store_be16_idx(b []byte, x uint16, idx int) {
 	// amd64/v1,amd64/v2:`ROLW\s\$8`,-`SHR.`
 	// amd64/v3: `MOVBEW`
 	// arm64:`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`MOVB`
 	// ppc64le:`MOVHBR`
 	// s390x:`MOVH\s.*\(.*\)\(.*\*1\)$`,-`SRW\s`,-`SRD\s`
-	binary.BigEndian.PutUint16(b[idx:], sink16)
+	binary.BigEndian.PutUint16(b[idx:], x)
 }
 
 func store_le_byte_2(b []byte, val uint16) {