byte_loop:
	BEQ	R4, R12, samebytes
	MOVBU	(R4), R8
	ADDVU	$1, R4
	MOVBU	(R6), R9
	ADDVU	$1, R6
	BEQ	R8, R9, byte_loop

byte_cmp:
	SGTU	R8, R9, R4 // R12 = 1 if (R8 > R9)
	BNE	R0, R4, ret
	MOVV	$-1, R4
	JMP	ret

samebytes:
	SGTU	R5, R7, R8
	SGTU	R7, R5, R9
	SUBV	R9, R8, R4

ret:

	SGT	$65536, R4, R5		// 1e02001485781200
	SGT	$4096, R4, R5		// 3e00001485781200
	SGT	$65536, R4		// 1e02001484781200
	SGT	$4096, R4		// 3e00001484781200
	SGTU	$65536, R4, R5		// 1e02001485f81200
	SGTU	$4096, R4, R5		// 3e00001485f81200
	SGTU	$65536, R4		// 1e02001484f81200
	SGTU	$4096, R4		// 3e00001484f81200
	ADDU	$65536, R4, R5		// 1e02001485781000
	ADDU	$4096, R4, R5		// 3e00001485781000
	ADDU	$65536, R4		// 1e02001484781000

	ADDV	R4, R5, R6

	// if less than 8 bytes, do one byte at a time
	SGTU	$8, R5, R8
	BNE	R8, out

	// do one byte at a time until 8-aligned
	AND	$7, R4, R8
	BEQ	R8, words
	MOVB	R0, (R4)
	ADDV	$1, R4
	JMP	-4(PC)

words:
	// do 8 bytes at a time if there is room
	ADDV	$-7, R6, R5

	PCALIGN	$16
	SGTU	R5, R4, R8
	BEQ	R8, out
	MOVV	R0, (R4)
	ADDV	$8, R4
	JMP	-4(PC)

out:

	SGT	$74565, R4, R5 			// 5e020014de178d0385781200
	SGT	$4097, R4 			// 3e000014de07800384781200
	SGT	$4097, R4, R5 			// 3e000014de07800385781200
	SGTU	$74565, R4 			// 5e020014de178d0384f81200
	SGTU	$74565, R4, R5 			// 5e020014de178d0385f81200
	SGTU	$4097, R4 			// 3e000014de07800384f81200
	SGTU	$4097, R4, R5 			// 3e000014de07800385f81200
	ADDU	$74565, R4 			// 5e020014de178d0384781000
	ADDU	$74565, R4, R5 			// 5e020014de178d0385781000

  op: "ReadVariableOp"
  input: "training_lossscaleoptimizer_sgd_update_resourceapplykerasmomentum_readvariableop_1_resource"
  device: "/job:localhost/replica:0/task:0/device:GPU:0"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
}
node {

(EqPtr x y) => (SGTUconst [1] (XOR x y))
(Eq(32|64)F x y) => (FPFlagTrue (CMPEQ(F|D) x y))

(Neq8 x y)  => (SGTU (XOR (ZeroExt8to32 x) (ZeroExt8to32 y)) (MOVWconst [0]))
(Neq16 x y) => (SGTU (XOR (ZeroExt16to32 x) (ZeroExt16to32 y)) (MOVWconst [0]))
(Neq32 x y) => (SGTU (XOR x y) (MOVWconst [0]))
(NeqPtr x y) => (SGTU (XOR x y) (MOVWconst [0]))
(Neq(32|64)F x y) => (FPFlagFalse (CMPEQ(F|D) x y))

// memequal(a, b unsafe.Pointer, size uintptr) bool
TEXT runtime·memequal(SB),NOSPLIT|NOFRAME,$0-25
	MOVV	a+0(FP), R1
	MOVV	b+8(FP), R2
	BEQ	R1, R2, eq
	MOVV	size+16(FP), R3
	ADDV	R1, R3, R4

	// chunk size is 16
	SGTU	$16, R3, R8
	BEQ	R0, R8, chunk_entry

byte_loop:
	BNE	R1, R4, byte_test
	MOVV	$1, R1
	MOVB	R1, ret+24(FP)
	RET
byte_test:
	MOVBU	(R1), R6
	ADDV	$1, R1
	MOVBU	(R2), R7
	ADDV	$1, R2

	// match: (IsInBounds idx len)
	// result: (SGTU len idx)
	for {
		idx := v_0
		len := v_1
		v.reset(OpLOONG64SGTU)
		v.AddArg2(len, idx)
		return true
	}
}
func rewriteValueLOONG64_OpIsNonNil(v *Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (IsNonNil ptr)
	// result: (SGTU ptr (MOVVconst [0]))
	for {
		ptr := v_0

	ADDU	R3, R2, R4	// end pointer for source
	ADDU	R3, R1, R5	// end pointer for destination

	// if destination is ahead of source, start at the end of the buffer and go backward.
	SGTU	R1, R2, R6
	BNE	R6, backward

	// if less than 4 bytes, use byte by byte copying
	SGTU	$4, R3, R6
	BNE	R6, f_small_copy

	// align destination to 4 bytes
	AND	$3, R1, R6
	BEQ	R6, f_dest_aligned
	SUBU	R1, R0, R6
	AND	$3, R6
	MOVWHI	0(R2), R7

	// match: (IsInBounds idx len)
	// result: (SGTU len idx)
	for {
		idx := v_0
		len := v_1
		v.reset(OpMIPS64SGTU)
		v.AddArg2(len, idx)
		return true
	}
}
func rewriteValueMIPS64_OpIsNonNil(v *Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (IsNonNil ptr)
	// result: (SGTU ptr (MOVVconst [0]))
	for {
		ptr := v_0