// Code generated by conditionalCmpConstGen.go; DO NOT EDIT.

package test

import "testing"

type IntegerConstraint interface {
	int | uint | int8 | uint8 | int16 | uint16 | int32 | uint32 | int64 | uint64
}

type TestCase[T IntegerConstraint] struct {
	cmp1, cmp2                      func(a, b T) bool
	combine                         func(x, y bool) bool
	targetFunc                      func(a, b, c, d T) bool
	cmp1Expr, cmp2Expr, logicalExpr string // String representations for debugging
}

type BoundaryValues[T IntegerConstraint] struct {
	base     T
	variants [3]T
}

func generateTestCases[T IntegerConstraint]() []TestCase[T] {
	return []TestCase[T]{
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a == b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a == b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a == b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a == b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a == b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a == b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a == b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a == b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a == b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a == b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a == b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a == b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a == b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a == b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a == b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a == b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a == b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a == b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a == b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a == b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a == b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a == b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a == b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a == b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a == b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a == b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a == b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a == b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a == b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a == b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a == b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a == b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a == b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a == b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a == b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a == b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a == b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a == b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a == b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a == b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a == b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a == b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a == b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a == b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a == b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a == b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a == b) || !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a == b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a == b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a == b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a == b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a == b) || !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a <= b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a <= b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a <= b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a <= b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a <= b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a <= b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a <= b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a <= b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a <= b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a <= b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a <= b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a <= b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a <= b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a <= b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a <= b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a <= b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a <= b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a <= b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a <= b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a <= b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a <= b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a <= b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a <= b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a <= b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a <= b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a <= b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a <= b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a <= b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a <= b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a <= b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a <= b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a <= b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a <= b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a <= b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a <= b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a <= b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a <= b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a <= b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a <= b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a <= b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a <= b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a <= b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a <= b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a <= b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a <= b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a <= b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a <= b) || !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a <= b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a <= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a <= b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a <= b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a <= b) || !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a < b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a < b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a < b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a < b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a < b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a < b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a < b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a < b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a < b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a < b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a < b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a < b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a < b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a < b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a < b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a < b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a < b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a < b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a < b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a < b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a < b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a < b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a < b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a < b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a < b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a < b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a < b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a < b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a < b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a < b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a < b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a < b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a < b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a < b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a < b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a < b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a < b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a < b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a < b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a < b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a < b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a < b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a < b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a < b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a < b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a < b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a < b) || !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a < b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a < b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a < b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a < b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a < b) || !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a != b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a != b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a != b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a != b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a != b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a != b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a != b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a != b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a != b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a != b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a != b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a != b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a != b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a != b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a != b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a != b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a != b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a != b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a != b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a != b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a != b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a != b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a != b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a != b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a != b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a != b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a != b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a != b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a != b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a != b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a != b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a != b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a != b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a != b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a != b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a != b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a != b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a != b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a != b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a != b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a != b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a != b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a != b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a != b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a != b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a != b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a != b) || !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a != b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a != b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a != b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a != b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a != b) || !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a >= b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a >= b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a >= b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a >= b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a >= b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a >= b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a >= b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a >= b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a >= b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a >= b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a >= b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a >= b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a >= b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a >= b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a >= b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a >= b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a >= b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a >= b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a >= b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a >= b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a >= b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a >= b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a >= b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a >= b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a >= b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a >= b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a >= b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a >= b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a >= b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a >= b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a >= b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a >= b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a >= b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a >= b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a >= b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a >= b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a >= b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a >= b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a >= b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a >= b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a >= b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a >= b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a >= b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a >= b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a >= b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a >= b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a >= b) || !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a >= b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a >= b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a >= b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a >= b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a >= b) || !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a > b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a > b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a > b) && (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a > b) && !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a > b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c == d",
			logicalExpr: "(a > b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || (c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a > b) || (c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a == b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || !(c == d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c == d",
			logicalExpr: "!(a > b) || !(c == d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a > b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a > b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a > b) && (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a > b) && !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a > b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c <= d",
			logicalExpr: "(a > b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || (c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a > b) || (c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a <= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || !(c <= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c <= d",
			logicalExpr: "!(a > b) || !(c <= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a > b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a > b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a > b) && (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a > b) && !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a > b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c < d",
			logicalExpr: "(a > b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || (c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a > b) || (c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a < b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || !(c < d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c < d",
			logicalExpr: "!(a > b) || !(c < d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a > b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a > b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a > b) && (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a > b) && !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a > b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c != d",
			logicalExpr: "(a > b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || (c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a > b) || (c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a != b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || !(c != d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c != d",
			logicalExpr: "!(a > b) || !(c != d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a > b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a > b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a > b) && (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a > b) && !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a > b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c >= d",
			logicalExpr: "(a > b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || (c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a > b) || (c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a >= b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || !(c >= d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c >= d",
			logicalExpr: "!(a > b) || !(c >= d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a > b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a > b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a > b) && (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) && !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) && !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a > b) && !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a > b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return (x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if (a > b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c > d",
			logicalExpr: "(a > b) || !(c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || (y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || (c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a > b) || (c > d)",
		},
		{
			cmp1:    func(a, b T) bool { return a > b },
			cmp2:    func(a, b T) bool { return a > b },
			combine: func(x, y bool) bool { return !(x) || !(y) },
			targetFunc: func(a, b, c, d T) bool {
				if !(a > b) || !(c > d) {
					return true
				}
				return false
			},
			cmp1Expr:    "a > b",
			cmp2Expr:    "c > d",
			logicalExpr: "!(a > b) || !(c > d)",
		},
	}
}

func TestInt8ConditionalCmpConst(t *testing.T) {
	testCases := generateTestCases[int8]()
	base := int8(1 << 6)
	values := [3]int8{base - 1, base, base + 1}

	for _, tc := range testCases {
		a, c := base, base
		for _, b := range values {
			for _, d := range values {
				expected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))
				actual := tc.targetFunc(a, b, c, d)
				if actual != expected {
					t.Errorf("conditional comparison failed:\n"+
						"  type: %T\n"+
						"  condition: %s\n"+
						"  values: a=%v, b=%v, c=%v, d=%v\n"+
						"  cmp1(a,b)=%v (%s)\n"+
						"  cmp2(c,d)=%v (%s)\n"+
						"  expected: combine(%v, %v)=%v\n"+
						"  actual: %v\n"+
						"  logical expression: %s",
						a,
						tc.logicalExpr,
						a, b, c, d,
						tc.cmp1(a, b), tc.cmp1Expr,
						tc.cmp2(c, d), tc.cmp2Expr,
						tc.cmp1(a, b), tc.cmp2(c, d), expected,
						actual,
						tc.logicalExpr)
				}
			}
		}
	}
}

func TestUint8ConditionalCmpConst(t *testing.T) {
	testCases := generateTestCases[uint8]()
	base := uint8(1 << 6)
	values := [3]uint8{base - 1, base, base + 1}

	for _, tc := range testCases {
		a, c := base, base
		for _, b := range values {
			for _, d := range values {
				expected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))
				actual := tc.targetFunc(a, b, c, d)
				if actual != expected {
					t.Errorf("conditional comparison failed:\n"+
						"  type: %T\n"+
						"  condition: %s\n"+
						"  values: a=%v, b=%v, c=%v, d=%v\n"+
						"  cmp1(a,b)=%v (%s)\n"+
						"  cmp2(c,d)=%v (%s)\n"+
						"  expected: combine(%v, %v)=%v\n"+
						"  actual: %v\n"+
						"  logical expression: %s",
						a,
						tc.logicalExpr,
						a, b, c, d,
						tc.cmp1(a, b), tc.cmp1Expr,
						tc.cmp2(c, d), tc.cmp2Expr,
						tc.cmp1(a, b), tc.cmp2(c, d), expected,
						actual,
						tc.logicalExpr)
				}
			}
		}
	}
}

func TestInt16ConditionalCmpConst(t *testing.T) {
	testCases := generateTestCases[int16]()
	base := int16(1 << 14)
	values := [3]int16{base - 1, base, base + 1}

	for _, tc := range testCases {
		a, c := base, base
		for _, b := range values {
			for _, d := range values {
				expected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))
				actual := tc.targetFunc(a, b, c, d)
				if actual != expected {
					t.Errorf("conditional comparison failed:\n"+
						"  type: %T\n"+
						"  condition: %s\n"+
						"  values: a=%v, b=%v, c=%v, d=%v\n"+
						"  cmp1(a,b)=%v (%s)\n"+
						"  cmp2(c,d)=%v (%s)\n"+
						"  expected: combine(%v, %v)=%v\n"+
						"  actual: %v\n"+
						"  logical expression: %s",
						a,
						tc.logicalExpr,
						a, b, c, d,
						tc.cmp1(a, b), tc.cmp1Expr,
						tc.cmp2(c, d), tc.cmp2Expr,
						tc.cmp1(a, b), tc.cmp2(c, d), expected,
						actual,
						tc.logicalExpr)
				}
			}
		}
	}
}

func TestUint16ConditionalCmpConst(t *testing.T) {
	testCases := generateTestCases[uint16]()
	base := uint16(1 << 14)
	values := [3]uint16{base - 1, base, base + 1}

	for _, tc := range testCases {
		a, c := base, base
		for _, b := range values {
			for _, d := range values {
				expected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))
				actual := tc.targetFunc(a, b, c, d)
				if actual != expected {
					t.Errorf("conditional comparison failed:\n"+
						"  type: %T\n"+
						"  condition: %s\n"+
						"  values: a=%v, b=%v, c=%v, d=%v\n"+
						"  cmp1(a,b)=%v (%s)\n"+
						"  cmp2(c,d)=%v (%s)\n"+
						"  expected: combine(%v, %v)=%v\n"+
						"  actual: %v\n"+
						"  logical expression: %s",
						a,
						tc.logicalExpr,
						a, b, c, d,
						tc.cmp1(a, b), tc.cmp1Expr,
						tc.cmp2(c, d), tc.cmp2Expr,
						tc.cmp1(a, b), tc.cmp2(c, d), expected,
						actual,
						tc.logicalExpr)
				}
			}
		}
	}
}

func TestInt32ConditionalCmpConst(t *testing.T) {
	testCases := generateTestCases[int32]()
	base := int32(1 << 30)
	values := [3]int32{base - 1, base, base + 1}

	for _, tc := range testCases {
		a, c := base, base
		for _, b := range values {
			for _, d := range values {
				expected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))
				actual := tc.targetFunc(a, b, c, d)
				if actual != expected {
					t.Errorf("conditional comparison failed:\n"+
						"  type: %T\n"+
						"  condition: %s\n"+
						"  values: a=%v, b=%v, c=%v, d=%v\n"+
						"  cmp1(a,b)=%v (%s)\n"+
						"  cmp2(c,d)=%v (%s)\n"+
						"  expected: combine(%v, %v)=%v\n"+
						"  actual: %v\n"+
						"  logical expression: %s",
						a,
						tc.logicalExpr,
						a, b, c, d,
						tc.cmp1(a, b), tc.cmp1Expr,
						tc.cmp2(c, d), tc.cmp2Expr,
						tc.cmp1(a, b), tc.cmp2(c, d), expected,
						actual,
						tc.logicalExpr)
				}
			}
		}
	}
}

func TestUint32ConditionalCmpConst(t *testing.T) {
	testCases := generateTestCases[uint32]()
	base := uint32(1 << 30)
	values := [3]uint32{base - 1, base, base + 1}

	for _, tc := range testCases {
		a, c := base, base
		for _, b := range values {
			for _, d := range values {
				expected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))
				actual := tc.targetFunc(a, b, c, d)
				if actual != expected {
					t.Errorf("conditional comparison failed:\n"+
						"  type: %T\n"+
						"  condition: %s\n"+
						"  values: a=%v, b=%v, c=%v, d=%v\n"+
						"  cmp1(a,b)=%v (%s)\n"+
						"  cmp2(c,d)=%v (%s)\n"+
						"  expected: combine(%v, %v)=%v\n"+
						"  actual: %v\n"+
						"  logical expression: %s",
						a,
						tc.logicalExpr,
						a, b, c, d,
						tc.cmp1(a, b), tc.cmp1Expr,
						tc.cmp2(c, d), tc.cmp2Expr,
						tc.cmp1(a, b), tc.cmp2(c, d), expected,
						actual,
						tc.logicalExpr)
				}
			}
		}
	}
}

func TestIntConditionalCmpConst(t *testing.T) {
	testCases := generateTestCases[int]()
	base := int(1 << 30)
	values := [3]int{base - 1, base, base + 1}

	for _, tc := range testCases {
		a, c := base, base
		for _, b := range values {
			for _, d := range values {
				expected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))
				actual := tc.targetFunc(a, b, c, d)
				if actual != expected {
					t.Errorf("conditional comparison failed:\n"+
						"  type: %T\n"+
						"  condition: %s\n"+
						"  values: a=%v, b=%v, c=%v, d=%v\n"+
						"  cmp1(a,b)=%v (%s)\n"+
						"  cmp2(c,d)=%v (%s)\n"+
						"  expected: combine(%v, %v)=%v\n"+
						"  actual: %v\n"+
						"  logical expression: %s",
						a,
						tc.logicalExpr,
						a, b, c, d,
						tc.cmp1(a, b), tc.cmp1Expr,
						tc.cmp2(c, d), tc.cmp2Expr,
						tc.cmp1(a, b), tc.cmp2(c, d), expected,
						actual,
						tc.logicalExpr)
				}
			}
		}
	}
}

func TestUintConditionalCmpConst(t *testing.T) {
	testCases := generateTestCases[uint]()
	base := uint(1 << 30)
	values := [3]uint{base - 1, base, base + 1}

	for _, tc := range testCases {
		a, c := base, base
		for _, b := range values {
			for _, d := range values {
				expected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))
				actual := tc.targetFunc(a, b, c, d)
				if actual != expected {
					t.Errorf("conditional comparison failed:\n"+
						"  type: %T\n"+
						"  condition: %s\n"+
						"  values: a=%v, b=%v, c=%v, d=%v\n"+
						"  cmp1(a,b)=%v (%s)\n"+
						"  cmp2(c,d)=%v (%s)\n"+
						"  expected: combine(%v, %v)=%v\n"+
						"  actual: %v\n"+
						"  logical expression: %s",
						a,
						tc.logicalExpr,
						a, b, c, d,
						tc.cmp1(a, b), tc.cmp1Expr,
						tc.cmp2(c, d), tc.cmp2Expr,
						tc.cmp1(a, b), tc.cmp2(c, d), expected,
						actual,
						tc.logicalExpr)
				}
			}
		}
	}
}

func TestInt64ConditionalCmpConst(t *testing.T) {
	testCases := generateTestCases[int64]()
	base := int64(1 << 62)
	values := [3]int64{base - 1, base, base + 1}

	for _, tc := range testCases {
		a, c := base, base
		for _, b := range values {
			for _, d := range values {
				expected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))
				actual := tc.targetFunc(a, b, c, d)
				if actual != expected {
					t.Errorf("conditional comparison failed:\n"+
						"  type: %T\n"+
						"  condition: %s\n"+
						"  values: a=%v, b=%v, c=%v, d=%v\n"+
						"  cmp1(a,b)=%v (%s)\n"+
						"  cmp2(c,d)=%v (%s)\n"+
						"  expected: combine(%v, %v)=%v\n"+
						"  actual: %v\n"+
						"  logical expression: %s",
						a,
						tc.logicalExpr,
						a, b, c, d,
						tc.cmp1(a, b), tc.cmp1Expr,
						tc.cmp2(c, d), tc.cmp2Expr,
						tc.cmp1(a, b), tc.cmp2(c, d), expected,
						actual,
						tc.logicalExpr)
				}
			}
		}
	}
}

func TestUint64ConditionalCmpConst(t *testing.T) {
	testCases := generateTestCases[uint64]()
	base := uint64(1 << 62)
	values := [3]uint64{base - 1, base, base + 1}

	for _, tc := range testCases {
		a, c := base, base
		for _, b := range values {
			for _, d := range values {
				expected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))
				actual := tc.targetFunc(a, b, c, d)
				if actual != expected {
					t.Errorf("conditional comparison failed:\n"+
						"  type: %T\n"+
						"  condition: %s\n"+
						"  values: a=%v, b=%v, c=%v, d=%v\n"+
						"  cmp1(a,b)=%v (%s)\n"+
						"  cmp2(c,d)=%v (%s)\n"+
						"  expected: combine(%v, %v)=%v\n"+
						"  actual: %v\n"+
						"  logical expression: %s",
						a,
						tc.logicalExpr,
						a, b, c, d,
						tc.cmp1(a, b), tc.cmp1Expr,
						tc.cmp2(c, d), tc.cmp2Expr,
						tc.cmp1(a, b), tc.cmp2(c, d), expected,
						actual,
						tc.logicalExpr)
				}
			}
		}
	}
}