CMP	R6, $256
	BLT	tail
	CLC	$256, 0(R3), 0(R5)
	BNE	notequal
	SUB	$256, R6
	LA	256(R3), R3
	LA	256(R5), R5
	BR	loop
tail:
	SUB	$1, R6, R8
	EXRL	$memeqbodyclc<>(SB), R8
	BEQ	equal
notequal:
	MOVB	$0, 0(R7)
	RET
equal:
	MOVB	$1, 0(R7)
	RET
tiny:
	MOVD	$0, R2
	CMPBLT	R6, $16, lt16
	MOVD	0(R3), R8
	MOVD	0(R5), R9
	CMPBNE	R8, R9, notequal
	MOVD	8(R3), R8
	MOVD	8(R5), R9

#     }
#     # This means that Number excludes all version-no's NotEqual.
#     ; Number = map:{
#         ; !NotEqual = map:{ $$ALL$$ = list:{ $$VersionNo$$ } }
#     }
#     # This means that Date does not includes NotEqual at all tables.  
#     ; Date = map:{
#         ; NotEqual = map:{}
#     }
# }
#
# *The line that starts with '#' means comment-out.
#
map:{

	MOVW.P	4(R2), R5
	CMP	R4, R5
	B.NE	notequal
	CMP	R0, R6
	B.NE	chunk4_loop
	CMP	R0, R1
	B.EQ	equal		// reached the end
byte_loop:
	MOVBU.P	1(R0), R4
	MOVBU.P	1(R2), R5
	CMP	R4, R5
	B.NE	notequal
	CMP	R0, R1
	B.NE	byte_loop
equal:
	MOVW	$1, R0
	MOVB	R0, (R7)
	RET
one:
	MOVBU	(R0), R4
	MOVBU	(R2), R5
	CMP	R4, R5
	B.EQ	equal
notequal:
	MOVW	$0, R0
	MOVB	R0, (R7)

    // cond
    {
    ^bb0(%condArg0: tensor<*xi32>, %condArg1: tensor<*xf32>):
      %0 = "arith.constant" () {value = dense<0> : tensor<i32>} : () -> tensor<i32> loc("Const")
      %1 = "tf.NotEqual"(%condArg0, %0) : (tensor<*xi32>, tensor<i32>) -> tensor<i1>
      "tf.Yield"(%1) : (tensor<i1>) -> ()
    },
    // body
    {
    ^bb0(%bodyArg0: tensor<*xi32>, %bodyArg1: tensor<*xf32>):

  // CHECK-NEXT:   %[[ADD:.*]] = "tf.Add"(%[[ARG1]], %[[ARG3]]) : (tensor<f32>, tensor<f32>) -> tensor<f32>
  // CHECK-NEXT:   %[[NOT_EQUAL:.*]] = "tf.NotEqual"(%[[IDEN]], %[[ADD]]) : (tensor<f32>, tensor<f32>) -> tensor<i1>
  // CHECK-NEXT:   %[[CONDITION:.*]] = tensor.extract %[[NOT_EQUAL]][] : tensor<i1>
  // CHECK-NEXT:   scf.condition(%[[CONDITION]]) %[[ARG3]], %[[ARG4]] : tensor<f32>, tensor<*xf32>
  // CHECK-NEXT: } do {

	case LessOrUnordered:
		return "LessOrUnordered"
	case GreaterOrEqual:
		return "GreaterOrEqual"
	case GreaterOrUnordered:
		return "GreaterOrUnordered"

	// 3-bit masks
	case NotEqual:
		return "NotEqual"
	case NotLess:
		return "NotLess"
	case NotGreater:
		return "NotGreater"
	case NotUnordered:
		return "NotUnordered"

	// 4-bit mask
	case Always:
		return "Always"
	}

(Eq32F x y) => (Equal (FCMPS x y))
(Eq64F x y) => (Equal (FCMPD x y))

(Neq8   x y) => (NotEqual (CMPW (ZeroExt8to32  x) (ZeroExt8to32  y)))
(Neq16  x y) => (NotEqual (CMPW (ZeroExt16to32 x) (ZeroExt16to32 y)))
(Neq32  x y) => (NotEqual (CMPW  x y))
(Neq64  x y) => (NotEqual (CMP   x y))
(NeqPtr x y) => (NotEqual (CMP   x y))
(Neq(32|64)F x y) => (NotEqual (FCMP(S|D) x y))

    %1 = "tf.Identity"(%arg3) : (tensor<i32>) -> tensor<i32>
    %2 = "tf.Identity"(%arg1) : (tensor<i32>) -> tensor<i32>
    // CHECK-NEXT: %[[RESULT_2:.*]] = "tf.NotEqual"(%[[RESULT_1]], %[[ARG_1]])
    %3 = "tf.NotEqual"(%1, %2) : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "tf.Yield"(%3) : (tensor<i1>) -> ()
  },  {
  ^bb0(%arg3: tensor<i32>, %arg4: tensor<*xf32>):
    %cst = arith.constant dense<1> : tensor<i32>

  // CHECK:      "tf.NotEqual"(%arg0, %arg1)
  // CHECK-SAME:   incompatible_shape_error = false
  %0 = "tf.NotEqual"(%arg0, %arg1) { incompatible_shape_error = false } : (tensor<*xi32>, tensor<i32>) -> tensor<i1>
  func.return %0: tensor<i1>
}

// CHECK-LABEL: func @testScalarForNotEqualOp
func.func @testScalarForNotEqualOp(%arg0: tensor<i32>, %arg1: tensor<i32>) -> tensor<i1> {
  // CHECK:      "tf.NotEqual"(%arg0, %arg1)

	}
	var equal []string
	for i := 0; i < size; i++ {
		equal = append(equal, strconv.Itoa(i))
	}
	var notEqual []string
	for i := 0; i < size; i++ {
		notEqual = append(notEqual, strconv.Itoa(i))
	}
	notEqual[size-1] = "z"

	for n := 0; n < b.N; n++ {
		EqualUnordered(l, equal)
		EqualUnordered(l, notEqual)
	}
}

func TestFilterDuplicates(t *testing.T) {
	tests := []struct {
		name string