"application/vnd.oma.bcast.notification+xml",
				"application/vnd.oma.bcast.provisioningtrigger",
				"application/vnd.oma.bcast.sgboot",
				"application/vnd.oma.bcast.sgdd+xml",
				"application/vnd.oma.bcast.sgdu",
				"application/vnd.oma.bcast.simple-symbol-container",
				"application/vnd.oma.bcast.smartcard-trigger+xml",
				"application/vnd.oma.bcast.sprov+xml",
				"application/vnd.oma.bcast.stkm",

(Round(32|64)F ...) => (Copy ...)

// comparisons
(Eq8 x y)  => (SGTU (MOVVconst [1]) (XOR (ZeroExt8to64 x) (ZeroExt8to64 y)))
(Eq16 x y) => (SGTU (MOVVconst [1]) (XOR (ZeroExt16to64 x) (ZeroExt16to64 y)))
(Eq32 x y) => (SGTU (MOVVconst [1]) (XOR (ZeroExt32to64 x) (ZeroExt32to64 y)))
(Eq64 x y) => (SGTU (MOVVconst [1]) (XOR x y))
(EqPtr x y) => (SGTU (MOVVconst [1]) (XOR x y))
(Eq(32|64)F x y) => (FPFlagTrue (CMPEQ(F|D) x y))

	MOVBU	(R3), R6
	ADDU	$1, R3
	MOVBU	(R4), R7
	ADDU	$1, R4
	BEQ	R6, R7 , loop
	// bytes differed
	SGTU	R6, R7, R8
	MOVW	$-1, R6
	CMOVZ	R8, R6, R8
	JMP	cmp_ret
samebytes:
	SGTU	R1, R2, R6
	SGTU	R2, R1, R7
	SUBU	R7, R6, R8
cmp_ret:
	MOVW	R8, ret+16(FP)

(Round(32|64)F ...) => (Copy ...)

// comparisons
(Eq8 x y)  => (SGTU (MOVVconst [1]) (XOR (ZeroExt8to64 x) (ZeroExt8to64 y)))
(Eq16 x y) => (SGTU (MOVVconst [1]) (XOR (ZeroExt16to64 x) (ZeroExt16to64 y)))
(Eq32 x y) => (SGTU (MOVVconst [1]) (XOR (ZeroExt32to64 x) (ZeroExt32to64 y)))
(Eq64 x y) => (SGTU (MOVVconst [1]) (XOR x y))
(EqPtr x y) => (SGTU (MOVVconst [1]) (XOR x y))
(Eq(32|64)F x y) => (FPFlagTrue (CMPEQ(F|D) x y))

	ADDV	R1, R2, R4

	// if less than 16 bytes or no MSA, do words check
	SGTU	$16, R2, R3
	BNE	R3, no_msa
	MOVBU	internal∕cpu·MIPS64X+const_offsetMIPS64XHasMSA(SB), R3
	BEQ	R3, R0, no_msa

	VMOVB	$0, W0

	SGTU	$128, R2, R3
	BEQ	R3, msa_large

	AND	$15, R2, R5
	XOR	R2, R5, R6
	ADDVU	R1, R6

msa_small:
	VMOVB	W0, (R1)
	ADDVU	$16, R1
	SGTU	R6, R1, R3
	BNE	R3, R0, msa_small
	BEQ	R5, R0, done
	VMOVB	W0, -16(R4)

	// amd64:"NEGL","ADCQ","SBBQ","NEGQ"
	// loong64: "ADDV", "SGTU"
	// ppc64x: "ADDC", "ADDE", "ADDZE"
	// s390x:"ADDE","ADDC\t[$]-1,"
	// mips64:"ADDV","SGTU"
	// riscv64: "ADD","SLTU"
	return bits.Add(x, 7, ci)
}

func AddZ(x, y uint) (r, co uint) {
	// arm64:"ADDS","ADC",-"ADCS",-"ADD\t",-"CMP"
	// amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ"
	// loong64: "ADDV", "SGTU"
	// ppc64x: "ADDC", -"ADDE", "ADDZE"

  }
  attr {
    key: "shape"
    value {
      shape {
      }
    }
  }
  attr {
    key: "shared_name"
    value {
      s: "training/SGD/iter"
    }
  }
}
node {
  name: "training/SGD/bn2a_branch1/beta/momentum"
  op: "VarHandleOp"
  device: "/job:localhost/replica:0/task:0/device:GPU:0"
  attr {
    key: "container"
    value {
      s: ""
    }

TEXT runtime·memmove<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-24
	BNE	R6, check
	RET

check:
	SGTU	R4, R5, R7
	BNE	R7, backward

	ADDV	R4, R6, R9 // end pointer

	// if the two pointers are not of same alignments, do byte copying
	SUBVU	R5, R4, R7
	AND	$7, R7
	BNE	R7, out

	// if less than 8 bytes, do byte copying
	SGTU	$8, R6, R7
	BNE	R7, out

	// do one byte at a time until 8-aligned
	AND	$7, R4, R8

	MOVV	from+8(FP), R2
	MOVV	n+16(FP), R3
	BNE	R3, check
	RET

check:
	SGTU	R1, R2, R4
	BNE	R4, backward

	ADDV	R1, R3, R6 // end pointer

	// if the two pointers are not of same alignments, do byte copying
	SUBVU	R2, R1, R4
	AND	$7, R4
	BNE	R4, out

	// if less than 8 bytes, do byte copying
	SGTU	$8, R3, R4
	BNE	R4, out

	// do one byte at a time until 8-aligned
	AND	$7, R1, R5

byte_loop:
	BEQ	R3, R8, samebytes
	MOVBU	(R3), R6
	ADDVU	$1, R3
	MOVBU	(R4), R7
	ADDVU	$1, R4
	BEQ	R6, R7, byte_loop

byte_cmp:
	SGTU	R6, R7, R8 // R8 = 1 if (R6 > R7)
	BNE	R0, R8, ret
	MOVV	$-1, R8
	JMP	ret

samebytes:
	SGTU	R1, R2, R6
	SGTU	R2, R1, R7
	SUBV	R7, R6, R8

ret:
	MOVV	R8, (R9)