cmd/compile: replace conditions to CCMP instructions on ARM64

This change introduces a new SSA pass that converts conditionals
with logical AND into CMP/CCMP instruction sequences on ARM64.

Fixes #71268

Change-Id: I3eba9c05b88ed6eb70350d30f6e805e6a4dddbf1
Reviewed-on: https://go-review.googlesource.com/c/go/+/698099
Reviewed-by: Keith Randall <khr@golang.org>
Auto-Submit: Keith Randall <khr@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Junyang Shao <shaojunyang@google.com>

diff --git a/src/cmd/compile/internal/ssa/compile.go b/src/cmd/compile/internal/ssa/compile.go
index f8cbd1c9a4ac1f07c34df81954bcc02a2862b6b9..8e02da746ea66224083f0c51f871c26dc25e24e3 100644 (file)
--- a/src/cmd/compile/internal/ssa/compile.go
+++ b/src/cmd/compile/internal/ssa/compile.go
@@ -501,7 +501,8 @@ var passes = [...]pass{
        {name: "lowered deadcode", fn: deadcode, required: true},
        {name: "checkLower", fn: checkLower, required: true},
        {name: "late phielim and copyelim", fn: copyelim},
-       {name: "tighten", fn: tighten, required: true}, // move values closer to their uses
+       {name: "tighten", fn: tighten, required: true},                     // move values closer to their uses
+       {name: "merge conditional branches", fn: mergeConditionalBranches}, // generate conditional comparison instructions on ARM64 architecture
        {name: "late deadcode", fn: deadcode},
        {name: "critical", fn: critical, required: true}, // remove critical edges
        {name: "phi tighten", fn: phiTighten},            // place rematerializable phi args near uses to reduce value lifetimes

diff --git a/src/cmd/compile/internal/ssa/merge_conditional_branches.go b/src/cmd/compile/internal/ssa/merge_conditional_branches.go
new file mode 100644 (file)
index 0000000..a057759
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/merge_conditional_branches.go
@@ -0,0 +1,890 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+       "cmd/compile/internal/types"
+)
+
+const (
+       InvalidIndex            = -1 + iota
+       TrueConditionSuccIndex  // Index for true condition successor in block's successor list
+       FalseConditionSuccIndex // Index for false condition successor in block's successor list
+)
+
+// mergeConditionalBranches performs if-conversion optimization on ARM64 by
+// transforming nested conditional branches into conditional comparison instructions.
+//
+// The optimization detects patterns where two consecutive conditional branches
+// implement logical AND/OR operations and replaces them with CCMP/CCMN instructions
+// that execute the second conditionally based on the first comparison result.
+//
+// Transformation Pattern:
+//
+// Original CFG:
+//
+//       if1 (outer condition)
+//       /  \
+//      /    \
+//     /      if2 (inner condition)
+//     |     /   \
+//     |    /     \
+//     |   /       \
+//     b1 (common)  b2 (target)
+//
+// Transformed CFG:
+//
+//      new_if (conditional comparison)
+//       /   \
+//      /     \
+//     /        p (empty plain block)
+//     |         \
+//     |          \
+//     |           \
+//     b1 (common)  b2 (target)
+//
+// Transformation Conditions:
+// - Both if1 and if2 must be ARM64 conditional blocks
+// - if2 must have exactly one predecessor from if1
+// - if2 must not contain memory operations or side effects
+// - The transformation must preserve phi node consistency in successor blocks
+//
+// This optimization eliminates branch mispredictions and improves instruction-level
+// parallelism by leveraging ARM64's conditional execution capabilities.
+// The resulting code uses conditional comparison instructions that test the second
+// condition only if the first condition evaluates to a specific value.
+func mergeConditionalBranches(f *Func) {
+       if f.Config.arch != "arm64" {
+               return
+       }
+
+       // We iterate in postorder to ensure we process inner conditional blocks before
+       // their outer counterparts. This is crucial because:
+       // 1. Transformations create new conditional comparisons that combine inner and outer conditions
+       // 2. Processing inner blocks first ensures we don't miss nested patterns
+       // 3. It maintains the integrity of the CFG during transformations
+       // Reverse order (from leaves to root) allows safe modification without affecting
+       // yet-to-be-processed outer structures.
+       blocks := f.postorder()
+
+       for _, block := range blocks {
+               // outerSuccIndex: index of the outedge from if1 to if2
+               // innerSuccIndex: index of the outedge from if2 to b2
+               outerSuccIndex, innerSuccIndex := detectNestedIfPattern(block)
+
+               if outerSuccIndex != InvalidIndex && innerSuccIndex != InvalidIndex {
+                       transformNestedIfPattern(block, outerSuccIndex, innerSuccIndex)
+               }
+       }
+}
+
+// findFirstNonEmptyPlainBlock finds the first non-empty block in a chain of empty plain blocks
+// starting from the specified child index of the parent block. It skips over empty blocks
+// that serve only as pass-through nodes in the control flow graph.
+func findFirstNonEmptyPlainBlock(parentBlock *Block, childIndex int) *Block {
+       childBlock := parentBlock.Succs[childIndex].Block()
+       for isEmptyPlainBlock(childBlock) {
+               childBlock = childBlock.Succs[0].Block()
+       }
+       return childBlock
+}
+
+// isEmptyPlainBlock checks if a block is empty (contains no values), has exactly one
+// predecessor and is of kind BlockPlain. Such blocks are typically
+// artifacts of previous optimizations and can be safely removed or bypassed.
+func isEmptyPlainBlock(block *Block) bool {
+       return block.Kind == BlockPlain &&
+               len(block.Values) == 0 &&
+               len(block.Preds) == 1
+}
+
+// removeEmptyPlainBlockChain removes a chain of empty plain blocks starting from
+// the specified child index of the parent block. It traverses through consecutive
+// empty blocks and deletes them from the control flow graph, connecting the parent
+// directly to the first non-empty block in the chain.
+func removeEmptyPlainBlockChain(parentBlock *Block, childIndex int) *Block {
+       childBlock := parentBlock.Succs[childIndex].Block()
+       for isEmptyPlainBlock(childBlock) {
+               nextBlock := childBlock.Succs[0].Block()
+               removeEmptyPlainBlock(childBlock)
+               childBlock = nextBlock
+       }
+       return childBlock
+}
+
+// removeEmptyPlainBlock removes a single empty plain block from the control flow graph.
+// It connects the block's predecessor directly to its successor, effectively bypassing
+// the empty block, and then marks the block as invalid for future cleanup.
+func removeEmptyPlainBlock(block *Block) {
+       prevEdge := block.Preds[0]
+       nextEdge := block.Succs[0]
+
+       prevEdge.b.Succs[prevEdge.i] = nextEdge
+       nextEdge.b.Preds[nextEdge.i] = prevEdge
+
+       block.removePred(0)
+       block.removeSucc(0)
+       block.Reset(BlockInvalid)
+}
+
+// detectNestedIfPattern detects nested if patterns that can be transformed to conditional comparisons.
+// It examines the outer block to see if it contains a nested conditional structure that matches
+// the pattern for if-conversion. Returns the outer successor index (which branch contains the
+// nested condition) and internal successor index (which branch of the nested condition leads to
+// the common merge point), or InvalidIndex if no pattern is detected.
+func detectNestedIfPattern(outerBlock *Block) (int, int) {
+       if !isIfBlock(outerBlock) {
+               // outerBlock doesn't contain comparison
+               return InvalidIndex, InvalidIndex
+       }
+
+       // Skip empty blocks to find actual conditional targets
+       // Empty plain blocks are often inserted by previous optimizations
+       thenBlock := findFirstNonEmptyPlainBlock(outerBlock, TrueConditionSuccIndex)
+       elseBlock := findFirstNonEmptyPlainBlock(outerBlock, FalseConditionSuccIndex)
+       if thenBlock == elseBlock {
+               // Both branches lead to the same block, cannot transform
+               return InvalidIndex, InvalidIndex
+       }
+
+       // Check for cyclic patterns where a condition refers back to the original block
+       if thenBlock == outerBlock {
+               // True branch forms a cycle back to outerBlock
+               return detectCyclePattern(outerBlock, FalseConditionSuccIndex)
+       } else if elseBlock == outerBlock {
+               // False branch forms a cycle back to outerBlock
+               return detectCyclePattern(outerBlock, TrueConditionSuccIndex)
+       }
+
+       outerSuccIndex := InvalidIndex
+
+       // Check if the true branch contains a nested conditional that can be moved
+       if len(thenBlock.Preds) == 1 &&
+               isIfBlock(thenBlock) &&
+               canValuesBeMoved(thenBlock) {
+               // True branch contains a valid nested condition
+               outerSuccIndex = TrueConditionSuccIndex
+       } else if len(elseBlock.Preds) == 1 &&
+               isIfBlock(elseBlock) &&
+               canValuesBeMoved(elseBlock) {
+               // False branch contains a valid nested condition
+               outerSuccIndex = FalseConditionSuccIndex
+       } else {
+               // This chain of blocks is not in pattern.
+               return InvalidIndex, InvalidIndex
+       }
+
+       // Tree structure:
+       //
+       //                outerBlock
+       //                 /      \
+       //                /        \
+       //     commonBothBlock   innerBlock
+       //                        /     \
+       //                       /       \
+       //                 thenBlock    elseBlock
+       //
+       // outerBlock: The outer conditional block being examined
+       // innerBlock: The inner conditional block (nested condition)
+       // commonBothBlock: The block reached when the outer condition is not met
+       // thenBlock/elseBlock: Successors of the inner conditional block
+       innerBlock := findFirstNonEmptyPlainBlock(outerBlock, outerSuccIndex)
+       commonBothBlock := findFirstNonEmptyPlainBlock(outerBlock, outerSuccIndex^1)
+       thenBlock = findFirstNonEmptyPlainBlock(innerBlock, TrueConditionSuccIndex)
+       elseBlock = findFirstNonEmptyPlainBlock(innerBlock, FalseConditionSuccIndex)
+
+       // Determine which inner branch leads to the common merge point
+       // This identifies the index to NOT common merge point
+       var innerSuccIndex = InvalidIndex
+       switch commonBothBlock {
+       case elseBlock:
+               // Pattern: (if1 && if2) or (!if1 && if2)
+               // False branch of if2 leads to commonBothBlock,
+               // that means True branch leads to b2 (target)
+               innerSuccIndex = TrueConditionSuccIndex
+       case thenBlock:
+               // Pattern: (if1 && !if2) or (!if1 && !if2)
+               // True branch of if2 leads to commonBothBlock,
+               // that means False branch leads to b2 (target)
+               innerSuccIndex = FalseConditionSuccIndex
+       default:
+               // No pattern are matched
+               return InvalidIndex, InvalidIndex
+       }
+
+       // Critical check: ensure phi nodes in merge blocks have consistent values
+       // This guarantees semantic preservation after transformation
+       outToCommonIndex := outerSuccIndex ^ 1 // index of the outedge from outerBlock to commonBothBlock
+       inToCommonIndex := innerSuccIndex ^ 1  // index of the outedge from innerBlock to commonBothBlock
+       if !checkSameValuesInPhiNodes(outerBlock, innerBlock, outToCommonIndex, inToCommonIndex) {
+               return InvalidIndex, InvalidIndex
+       }
+
+       return outerSuccIndex, innerSuccIndex
+}
+
+// detectCyclePattern detects cyclic patterns where a conditional block's successor
+// refers back to the original block. This handles special cases where the control
+// flow forms a loop-like structure that can still be optimized with conditional comparisons.
+func detectCyclePattern(outerBlock *Block, outSuccIndex int) (int, int) {
+       secondCondBlock := findFirstNonEmptyPlainBlock(outerBlock, outSuccIndex)
+
+       if len(secondCondBlock.Preds) != 1 ||
+               len(secondCondBlock.Succs) != 2 ||
+               !isIfBlock(secondCondBlock) ||
+               !canValuesBeMoved(secondCondBlock) {
+               return InvalidIndex, InvalidIndex
+       }
+
+       thenBlock := findFirstNonEmptyPlainBlock(secondCondBlock, TrueConditionSuccIndex)
+       elseBlock := findFirstNonEmptyPlainBlock(secondCondBlock, FalseConditionSuccIndex)
+
+       if thenBlock == elseBlock {
+               // Both branches pointing to same block indicates degenerate case
+               return InvalidIndex, InvalidIndex
+       }
+
+       // Check if the cycle connects back to the original block and verify phi consistency
+       switch outerBlock {
+       case thenBlock:
+               // True branch of inner condition leads back to outerBlock
+               if !checkSameValuesInPhiNodes(outerBlock, thenBlock, outSuccIndex^1, TrueConditionSuccIndex) {
+                       return InvalidIndex, InvalidIndex
+               }
+               return outSuccIndex, FalseConditionSuccIndex
+       case elseBlock:
+               // False branch of inner condition leads back to outerBlock
+               if !checkSameValuesInPhiNodes(outerBlock, elseBlock, outSuccIndex^1, FalseConditionSuccIndex) {
+                       return InvalidIndex, InvalidIndex
+               }
+               return outSuccIndex, TrueConditionSuccIndex
+       default:
+               // Pattern was not found
+               return InvalidIndex, InvalidIndex
+       }
+}
+
+// checkSameValuesInPhiNodes checks if phi nodes in merge blocks have the same values
+// for the given successor indices. This ensures that after transformation, phi nodes
+// will receive the correct values from both paths. Returns true if all phi nodes
+// have consistent arguments for the specified paths.
+func checkSameValuesInPhiNodes(outerBlock, innerBlock *Block, outToCommonIndex, inToCommonIndex int) bool {
+       // Skip empty blocks to find actual phi-containing merge blocks
+       // Empty blocks don't affect phi nodes but complicate path tracking
+       for isEmptyPlainBlock(outerBlock.Succs[outToCommonIndex].Block()) {
+               outerBlock = outerBlock.Succs[outToCommonIndex].Block()
+               outToCommonIndex = 0 // After empty block, only one path exists
+       }
+
+       for isEmptyPlainBlock(innerBlock.Succs[inToCommonIndex].Block()) {
+               innerBlock = innerBlock.Succs[inToCommonIndex].Block()
+               inToCommonIndex = 0 // After empty block, only one path exists
+       }
+
+       // Both paths must lead to the same merge block for transformation to be valid
+       if outerBlock.Succs[outToCommonIndex].Block() != innerBlock.Succs[inToCommonIndex].Block() {
+               panic("checkSameValuesInPhiNodes: paths do not lead to the same merge block - invalid CFG pattern for if-conversion")
+       }
+
+       argIndex1 := outerBlock.Succs[outToCommonIndex].Index()
+       argIndex2 := innerBlock.Succs[inToCommonIndex].Index()
+
+       resultBlock := outerBlock.Succs[outToCommonIndex].Block()
+       for _, v := range resultBlock.Values {
+               if v.Op != OpPhi {
+                       continue
+               }
+
+               // If phi arguments from different paths don't match,
+               // merging the conditions would produce wrong values
+               if v.Args[argIndex1] != v.Args[argIndex2] {
+                       return false
+               }
+       }
+
+       return true
+}
+
+// canValuesBeMoved checks if all values in a block can be safely moved to another block.
+// This is necessary because during transformation, values from the inner conditional
+// block are moved to the outer block. Values with side effects, memory operations,
+// or phi nodes cannot be moved.
+func canValuesBeMoved(b *Block) bool {
+       for _, v := range b.Values {
+               if !canValueBeMoved(v) {
+                       return false
+               }
+       }
+       return true
+}
+
+// canValueBeMoved checks if a single value can be safely moved to another block.
+// Returns false for values that have side effects, are memory operations, phi nodes,
+// or nil checks, as moving these could change program semantics.
+func canValueBeMoved(v *Value) bool {
+       if v.Op == OpPhi {
+               return false
+       }
+       if v.Type.IsMemory() {
+               return false
+       }
+       if v.Op.HasSideEffects() {
+               return false
+       }
+       if opcodeTable[v.Op].nilCheck {
+               return false
+       }
+       if v.MemoryArg() != nil {
+               return false
+       }
+       return true
+}
+
+// isIfBlock checks if a block is a conditional block that can participate in
+// if-conversion. This includes all ARM64 conditional block kinds (EQ, NE, LT, etc.)
+// and zero/non-zero test blocks (Z, NZ, ZW, NZW).
+func isIfBlock(b *Block) bool {
+       switch b.Kind {
+       case BlockARM64EQ,
+               BlockARM64NE,
+               BlockARM64LT,
+               BlockARM64LE,
+               BlockARM64GT,
+               BlockARM64GE,
+               BlockARM64ULT,
+               BlockARM64ULE,
+               BlockARM64UGT,
+               BlockARM64UGE:
+               return isComparisonOperation(b.Controls[0])
+       case BlockARM64Z,
+               BlockARM64NZ,
+               BlockARM64ZW,
+               BlockARM64NZW:
+               return true
+       default:
+               return false
+       }
+}
+
+// isComparisonOperation checks if a value represents a comparison operation
+// that can be used in conditional execution. Also ensures the value has only
+// one use to prevent unexpected side effects from transformation.
+func isComparisonOperation(value *Value) bool {
+       if value.Uses != 1 {
+               // This value can be transformed to another value.
+               // New value can get another results, not which are expected.
+               // That why we need to check this case.
+               return false
+       }
+
+       switch value.Op {
+       case OpARM64CMP,
+               OpARM64CMPconst,
+               OpARM64CMN,
+               OpARM64CMNconst,
+               OpARM64CMPW,
+               OpARM64CMPWconst,
+               OpARM64CMNW,
+               OpARM64CMNWconst:
+               return true
+       default:
+               return false
+       }
+}
+
+// transformNestedIfPattern transforms a detected nested if pattern into a
+// conditional comparison. This is the main transformation function that
+// coordinates all the steps needed to convert the nested conditionals into
+// a single conditional comparison instruction.
+func transformNestedIfPattern(outerBlock *Block, outSuccIndex, inSuccIndex int) {
+       clearPatternFromEmptyPlainBlocks(outerBlock, outSuccIndex)
+       innerBlock := outerBlock.Succs[outSuccIndex].Block()
+
+       // Transform the control flow step by step:
+       // 1. Transform primary comparison to standard form if needed
+       // 2. Transform dependent comparison to work with conditional execution
+       // 3. Convert to conditional comparison operation (CCMP/CCMN)
+       // 4. Fix comparisons with constants to use constant forms when possible
+       // 5. Set the new control value for the transformed block
+       // 6. Move all values from inner block to outer block
+       // 7. Eliminate the now-redundant nested block
+       transformPrimaryComparisonValue(outerBlock)
+       transformDependentComparisonValue(innerBlock)
+       transformToConditionalComparisonValue(outerBlock, outSuccIndex, inSuccIndex)
+       fixComparisonWithConstant(innerBlock, outSuccIndex)
+       setNewControlValue(outerBlock, innerBlock, outSuccIndex, inSuccIndex)
+       moveAllValues(outerBlock, innerBlock)
+       elimNestedBlock(innerBlock, inSuccIndex)
+}
+
+// clearPatternFromEmptyPlainBlocks removes all empty plain blocks from the
+// detected pattern to simplify the control flow graph before transformation.
+func clearPatternFromEmptyPlainBlocks(outerBlock *Block, outSuccIndex int) {
+       innerBlock := removeEmptyPlainBlockChain(outerBlock, outSuccIndex)
+       removeEmptyPlainBlockChain(outerBlock, outSuccIndex^1)
+
+       removeEmptyPlainBlockChain(innerBlock, TrueConditionSuccIndex)
+       removeEmptyPlainBlockChain(innerBlock, FalseConditionSuccIndex)
+}
+
+// moveAllValues moves all values from the source block to the destination block.
+// This is used to consolidate the computations from the inner conditional block
+// into the outer block as part of the if-conversion process.
+func moveAllValues(dest, src *Block) {
+       for _, value := range src.Values {
+               value.Block = dest
+               dest.Values = append(dest.Values, value)
+       }
+       src.truncateValues(0)
+}
+
+// elimNestedBlock eliminates a nested block that has been incorporated into
+// the outer block through if-conversion. It removes the specified successor
+// edge and updates phi nodes in the target block to remove the corresponding argument.
+func elimNestedBlock(b *Block, index int) {
+       removedEdge := b.Succs[index^1]
+
+       notBothMetBlock := removedEdge.Block()
+       i := removedEdge.Index()
+
+       b.removeSucc(index ^ 1)
+       notBothMetBlock.removePred(i)
+       for _, v := range notBothMetBlock.Values {
+               if v.Op != OpPhi {
+                       continue
+               }
+               notBothMetBlock.removePhiArg(v, i)
+       }
+
+       b.Func.invalidateCFG()
+       b.Reset(BlockPlain)
+       b.Likely = BranchUnknown
+}
+
+// setNewControlValue sets the new control value for the transformed block
+// based on the inner block's control value. It also updates the branch
+// likelihood based on the original block's branch prediction.
+func setNewControlValue(outerBlock, innerBlock *Block, outSuccIndex, inSuccIndex int) {
+       outerBlock.resetWithControl(innerBlock.Kind, innerBlock.Controls[0])
+       if !isBranchLikelyConsistentWithIndex(outerBlock, outSuccIndex) ||
+               !isBranchLikelyConsistentWithIndex(innerBlock, inSuccIndex) {
+               outerBlock.Likely = BranchUnknown
+       }
+}
+
+// isBranchLikelyConsistentWithIndex checks if the branch likelihood matches the expected
+// index. Returns true if the likelihood is consistent with the branch direction.
+func isBranchLikelyConsistentWithIndex(b *Block, index int) bool {
+       if index == TrueConditionSuccIndex && b.Likely == BranchLikely {
+               return true
+       } else if index == FalseConditionSuccIndex && b.Likely == BranchUnlikely {
+               return true
+       }
+       return false
+}
+
+// transformPrimaryComparisonValue transforms special block kinds (Z, NZ, ZW, NZW)
+// into standard comparison operations. These block kinds test for zero/non-zero
+// and need to be converted to explicit comparisons with zero for conditional execution.
+func transformPrimaryComparisonValue(block *Block) {
+       switch block.Kind {
+       case BlockARM64Z:
+               arg0 := block.Controls[0]
+               controlValue := block.NewValue1I(arg0.Pos, OpARM64CMPconst, types.TypeFlags, 0, arg0)
+               block.resetWithControl(BlockARM64EQ, controlValue)
+       case BlockARM64NZ:
+               arg0 := block.Controls[0]
+               controlValue := block.NewValue1I(arg0.Pos, OpARM64CMPconst, types.TypeFlags, 0, arg0)
+               block.resetWithControl(BlockARM64NE, controlValue)
+       case BlockARM64ZW:
+               arg0 := block.Controls[0]
+               controlValue := block.NewValue1I(arg0.Pos, OpARM64CMPWconst, types.TypeFlags, 0, arg0)
+               block.resetWithControl(BlockARM64EQ, controlValue)
+       case BlockARM64NZW:
+               arg0 := block.Controls[0]
+               controlValue := block.NewValue1I(arg0.Pos, OpARM64CMPWconst, types.TypeFlags, 0, arg0)
+               block.resetWithControl(BlockARM64NE, controlValue)
+       default:
+               return
+       }
+}
+
+// transformDependentComparisonValue transforms the comparison in the dependent
+// (inner) block to prepare it for conditional execution. This involves converting
+// constant comparisons to register comparisons and handling special block kinds.
+func transformDependentComparisonValue(block *Block) {
+       typ := &block.Func.Config.Types
+
+       switch block.Kind {
+       case BlockARM64EQ,
+               BlockARM64NE,
+               BlockARM64LT,
+               BlockARM64LE,
+               BlockARM64GT,
+               BlockARM64GE,
+               BlockARM64ULT,
+               BlockARM64ULE,
+               BlockARM64UGT,
+               BlockARM64UGE:
+               value := block.Controls[0]
+
+               switch value.Op {
+               case OpARM64CMPconst:
+                       arg0 := value.Args[0]
+                       auxConstant := auxIntToInt64(value.AuxInt)
+                       value.reset(OpARM64CMP)
+                       constantValue := block.Func.constVal(OpARM64MOVDconst, typ.UInt64, auxConstant, true)
+                       value.AddArg2(arg0, constantValue)
+               case OpARM64CMNconst:
+                       arg0 := value.Args[0]
+                       auxConstant := auxIntToInt64(value.AuxInt)
+                       value.reset(OpARM64CMN)
+                       constantValue := block.Func.constVal(OpARM64MOVDconst, typ.UInt64, auxConstant, true)
+                       value.AddArg2(arg0, constantValue)
+               case OpARM64CMPWconst:
+                       arg0 := value.Args[0]
+                       auxConstant := auxIntToInt32(value.AuxInt)
+                       value.reset(OpARM64CMPW)
+                       constantValue := block.Func.constVal(OpARM64MOVDconst, typ.UInt64, int64(auxConstant), true)
+                       value.AddArg2(arg0, constantValue)
+               case OpARM64CMNWconst:
+                       arg0 := value.Args[0]
+                       auxConstant := auxIntToInt32(value.AuxInt)
+                       value.reset(OpARM64CMNW)
+                       constantValue := block.Func.constVal(OpARM64MOVDconst, typ.UInt64, int64(auxConstant), true)
+                       value.AddArg2(arg0, constantValue)
+               default:
+                       return
+               }
+       case BlockARM64Z:
+               arg0 := block.Controls[0]
+               arg1 := block.Func.constVal(OpARM64MOVDconst, typ.UInt64, 0, true)
+               comparisonValue := block.NewValue2(arg0.Pos, OpARM64CMP, types.TypeFlags, arg0, arg1)
+               block.resetWithControl(BlockARM64EQ, comparisonValue)
+       case BlockARM64NZ:
+               arg0 := block.Controls[0]
+               arg1 := block.Func.constVal(OpARM64MOVDconst, typ.UInt64, 0, true)
+               comparisonValue := block.NewValue2(arg0.Pos, OpARM64CMP, types.TypeFlags, arg0, arg1)
+               block.resetWithControl(BlockARM64NE, comparisonValue)
+       case BlockARM64ZW:
+               arg0 := block.Controls[0]
+               arg1 := block.Func.constVal(OpARM64MOVDconst, typ.UInt64, 0, true)
+               comparisonValue := block.NewValue2(arg0.Pos, OpARM64CMPW, types.TypeFlags, arg0, arg1)
+               block.resetWithControl(BlockARM64EQ, comparisonValue)
+       case BlockARM64NZW:
+               arg0 := block.Controls[0]
+               arg1 := block.Func.constVal(OpARM64MOVDconst, typ.UInt64, 0, true)
+               comparisonValue := block.NewValue2(arg0.Pos, OpARM64CMPW, types.TypeFlags, arg0, arg1)
+               block.resetWithControl(BlockARM64NE, comparisonValue)
+       default:
+               panic("Wrong block kind")
+       }
+}
+
+// fixComparisonWithConstant optimizes conditional comparisons by converting
+// them to constant forms when one operand is a small constant. This generates
+// more efficient CCMPconst/CCMNconst instructions.
+func fixComparisonWithConstant(block *Block, index int) {
+       // Helper function to extract 5-bit immediate from int64 constant (0-31 range)
+       getImm64 := func(auxInt int64) (uint8, bool) {
+               imm := auxIntToInt64(auxInt)
+               if imm&^0x1f == 0 {
+                       return uint8(imm), true
+               }
+               return 0, false
+       }
+
+       // Helper function to extract 5-bit immediate from int32 constant (0-31 range)
+       getImm32 := func(auxInt int64) (uint8, bool) {
+               imm := auxIntToInt32(auxInt)
+               if imm&^0x1f == 0 {
+                       return uint8(imm), true
+               }
+               return 0, false
+       }
+
+       // Helper function to convert conditional comparison to constant form if possible
+       // Algorithm: Check if either operand is a small 5-bit constant (0-31). If found:
+       // 1. Convert operation to constant form (CCMP -> CCMPconst, etc.)
+       // 2. Set the 'ind' flag for immediate mode
+       // 3. When constant is first operand (arg0), swap operands and invert condition
+       tryConvertToConstForm := func(value *Value, newOp Op, getImm func(int64) (uint8, bool)) {
+               params := value.AuxArm64ConditionalParams()
+               arg0 := value.Args[0]
+               arg1 := value.Args[1]
+               arg2 := value.Args[2]
+               // Check second operand for small constant
+               if arg1.Op == OpARM64MOVDconst {
+                       if imm, ok := getImm(arg1.AuxInt); ok {
+                               value.reset(newOp)
+                               params.constValue = imm
+                               params.ind = true
+                               value.AuxInt = arm64ConditionalParamsToAuxInt(params)
+                               value.AddArg2(arg0, arg2)
+                               return
+                       }
+               }
+
+               // Check first operand for small constant
+               if arg0.Op == OpARM64MOVDconst {
+                       if imm, ok := getImm(arg0.AuxInt); ok {
+                               value.reset(newOp)
+                               invertConditionsInBlock(block, &params, index)
+                               params.constValue = imm
+                               params.ind = true
+                               value.AuxInt = arm64ConditionalParamsToAuxInt(params)
+                               value.AddArg2(arg1, arg2)
+                               return
+                       }
+               }
+       }
+
+       // try to convert control value of block to constant form
+       controlValue := block.Controls[0]
+       switch controlValue.Op {
+       case OpARM64CCMP:
+               tryConvertToConstForm(controlValue, OpARM64CCMPconst, getImm64)
+       case OpARM64CCMN:
+               tryConvertToConstForm(controlValue, OpARM64CCMNconst, getImm64)
+       case OpARM64CCMPW:
+               tryConvertToConstForm(controlValue, OpARM64CCMPWconst, getImm32)
+       case OpARM64CCMNW:
+               tryConvertToConstForm(controlValue, OpARM64CCMNWconst, getImm32)
+       default:
+               return
+       }
+}
+
+// invertConditionsInBlock inverts the condition in a block and returns updated
+// conditional parameters. This is used when swapping operands in constant
+// optimizations to maintain correct semantics.
+func invertConditionsInBlock(block *Block, params *arm64ConditionalParams, index int) {
+       invertKind := invertBlockKind(block.Kind)
+       block.Kind = invertKind
+       if index == FalseConditionSuccIndex {
+               invertKind = negateBlockKind(invertKind)
+       }
+       params.nzcv = nzcvByBlockKind(invertKind)
+}
+
+// transformToConditionalComparisonValue transforms the comparison operations
+// to conditional comparison operations (CCMP/CCMN). This is the core transformation
+// that creates the conditional execution pattern by combining the outer and inner
+// conditions into a single conditional comparison instruction.
+func transformToConditionalComparisonValue(outerBlock *Block, outSuccIndex, inSuccIndex int) {
+       innerBlock := outerBlock.Succs[outSuccIndex].Block()
+
+       // Adjust block kinds and successors if needed to match expected pattern
+       if outSuccIndex != inSuccIndex {
+               outerBlock.Kind = negateBlockKind(outerBlock.Kind)
+               outerBlock.swapSuccessors()
+               outSuccIndex ^= 1
+       }
+
+       outerControl := outerBlock.Controls[0]
+       outerKind := outerBlock.Kind
+
+       innerControl := innerBlock.Controls[0]
+       innerKind := innerBlock.Kind
+
+       // Adjust conditions based on successor index
+       if outSuccIndex == FalseConditionSuccIndex {
+               outerKind = negateBlockKind(outerKind)
+               innerKind = negateBlockKind(innerKind)
+       }
+
+       // Get conditional parameters and transform the operation
+       params := createConditionalParamsByBlockKind(outerKind, innerKind)
+
+       innerControl.AddArg(outerControl)
+       innerControl.Op = transformOpToConditionalComparisonOperation(innerControl.Op)
+       innerControl.AuxInt = arm64ConditionalParamsToAuxInt(params)
+}
+
+// transformOpToConditionalComparisonOperation maps standard comparison operations
+// to their conditional comparison counterparts (e.g., CMP -> CCMP, CMN -> CCMN).
+func transformOpToConditionalComparisonOperation(op Op) Op {
+       switch op {
+       case OpARM64CMP:
+               return OpARM64CCMP
+       case OpARM64CMN:
+               return OpARM64CCMN
+       case OpARM64CMPconst:
+               return OpARM64CCMPconst
+       case OpARM64CMNconst:
+               return OpARM64CCMNconst
+       case OpARM64CMPW:
+               return OpARM64CCMPW
+       case OpARM64CMNW:
+               return OpARM64CCMNW
+       case OpARM64CMPWconst:
+               return OpARM64CCMPWconst
+       case OpARM64CMNWconst:
+               return OpARM64CCMNWconst
+       default:
+               panic("Incorrect operation")
+       }
+}
+
+// createConditionalParamsByBlockKind constructs conditional parameters for ARM64 conditional instructions.
+// It combines two block kinds:
+// - outerKind specifies the main condition (e.g., LT, GT) to be evaluated.
+// - innerKind determines the NZCV flag pattern to be used when the main condition is FALSE.
+// The resulting parameters are typically used by conditional comparison operations (CCMP, CCMN).
+func createConditionalParamsByBlockKind(outerKind, innerKind BlockKind) arm64ConditionalParams {
+       cond := condByBlockKind(outerKind) // the condition code for the primary comparison
+       nzcv := nzcvByBlockKind(innerKind) // NZCV flags to apply when the condition is false
+       return arm64ConditionalParamsAuxInt(cond, nzcv)
+}
+
+// condByBlockKind maps block kinds to their corresponding condition codes
+// for ARM64 conditional execution.
+func condByBlockKind(kind BlockKind) Op {
+       switch kind {
+       case BlockARM64EQ:
+               return OpARM64Equal
+       case BlockARM64NE:
+               return OpARM64NotEqual
+       case BlockARM64LT:
+               return OpARM64LessThan
+       case BlockARM64LE:
+               return OpARM64LessEqual
+       case BlockARM64GT:
+               return OpARM64GreaterThan
+       case BlockARM64GE:
+               return OpARM64GreaterEqual
+       case BlockARM64ULT:
+               return OpARM64LessThanU
+       case BlockARM64ULE:
+               return OpARM64LessEqualU
+       case BlockARM64UGT:
+               return OpARM64GreaterThanU
+       case BlockARM64UGE:
+               return OpARM64GreaterEqualU
+       default:
+               panic("Incorrect kind of Block")
+       }
+}
+
+// nzcvByBlockKind returns NZCV flags encoding the *logical opposite* of the specified block condition.
+// The returned flags represent the processor state to be used when the primary comparison condition
+// evaluates to false.
+//
+// Each case constructs the flag pattern for the inverse condition:
+//
+//     EQ -> NE, LT -> GE, GT -> LE, etc.
+func nzcvByBlockKind(kind BlockKind) uint8 {
+       switch kind {
+       case BlockARM64EQ:
+               // Encode NE : Z == 0
+               return packNZCV(false, false, false, false) // N=0,Z=0,C=0,V=0
+       case BlockARM64NE:
+               // Encode EQ : Z == 1
+               return packNZCV(false, true, false, false) // N=0,Z=1,C=0,V=0
+       case BlockARM64LT:
+               // Encode GE : N == V
+               return packNZCV(false, false, false, false) // N=0,Z=0,C=0,V=0
+       case BlockARM64LE:
+               // Encode GT : (Z == 0) && (N == V)
+               return packNZCV(false, false, false, false) // N=0,Z=0,C=0,V=0
+       case BlockARM64GT:
+               // Encode LE : (Z == 1) || (N != V)
+               return packNZCV(false, true, false, false) // N=0,Z=1,C=0,V=0
+       case BlockARM64GE:
+               // Encode LT : N != V
+               return packNZCV(false, false, false, true) // N=0,Z=0,C=0,V=1
+       case BlockARM64ULT:
+               // Encode UGE : C == 1
+               return packNZCV(false, false, true, false) // N=0,Z=0,C=1,V=0
+       case BlockARM64ULE:
+               // Encode UGT : (C == 1) && (Z == 0)
+               return packNZCV(false, false, true, false) // N=0,Z=0,C=1,V=0
+       case BlockARM64UGT:
+               // Encode ULE : (C == 0) || (Z == 1)
+               return packNZCV(false, false, false, false) // N=0,Z=0,C=0,V=0
+       case BlockARM64UGE:
+               // Encode ULT : C == 0
+               return packNZCV(false, false, false, false) // N=0,Z=0,C=0,V=0
+       default:
+               panic("Incorrect kind of Block")
+       }
+}
+
+// packNZCV packs boolean condition flags into a single byte representing
+// the ARM64 NZCV condition flags: Negative, Zero, Carry, Overflow.
+func packNZCV(N, Z, C, V bool) uint8 {
+       var NZCVFlags uint8 = 0
+       if N {
+               NZCVFlags |= 1 << 3
+       }
+       if Z {
+               NZCVFlags |= 1 << 2
+       }
+       if C {
+               NZCVFlags |= 1 << 1
+       }
+       if V {
+               NZCVFlags |= 1
+       }
+       return NZCVFlags
+}
+
+// negateBlockKind returns the logical negation of a block kind
+// (e.g., EQ becomes NE, LT becomes GE).
+func negateBlockKind(kind BlockKind) BlockKind {
+       switch kind {
+       case BlockARM64EQ:
+               return BlockARM64NE
+       case BlockARM64NE:
+               return BlockARM64EQ
+       case BlockARM64LT:
+               return BlockARM64GE
+       case BlockARM64LE:
+               return BlockARM64GT
+       case BlockARM64GT:
+               return BlockARM64LE
+       case BlockARM64GE:
+               return BlockARM64LT
+       case BlockARM64ULT:
+               return BlockARM64UGE
+       case BlockARM64ULE:
+               return BlockARM64UGT
+       case BlockARM64UGT:
+               return BlockARM64ULE
+       case BlockARM64UGE:
+               return BlockARM64ULT
+       default:
+               panic("Incorrect kind of Block")
+       }
+}
+
+// invertBlockKind inverts the operands of a comparison block kind
+// (e.g., LT becomes GT, LE becomes GE).
+func invertBlockKind(kind BlockKind) BlockKind {
+       switch kind {
+       case BlockARM64EQ:
+               return BlockARM64EQ
+       case BlockARM64NE:
+               return BlockARM64NE
+       case BlockARM64LT:
+               return BlockARM64GT
+       case BlockARM64LE:
+               return BlockARM64GE
+       case BlockARM64GT:
+               return BlockARM64LT
+       case BlockARM64GE:
+               return BlockARM64LE
+       case BlockARM64ULT:
+               return BlockARM64UGT
+       case BlockARM64ULE:
+               return BlockARM64UGE
+       case BlockARM64UGT:
+               return BlockARM64ULT
+       case BlockARM64UGE:
+               return BlockARM64ULE
+       default:
+               panic("Incorrect kind of Block")
+       }
+}

diff --git a/src/cmd/compile/internal/ssa/merge_conditional_branches_test.go b/src/cmd/compile/internal/ssa/merge_conditional_branches_test.go
new file mode 100644 (file)
index 0000000..08925a3
--- /dev/null
+++ b/src/cmd/compile/internal/ssa/merge_conditional_branches_test.go
@@ -0,0 +1,282 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package ssa
+
+import (
+       "cmd/compile/internal/types"
+       "testing"
+)
+
+// ARM64Lt specifies BlockARM64LT
+func ARM64Lt(cond, sub, alt string) ctrl {
+       return ctrl{BlockARM64LT, cond, []string{sub, alt}}
+}
+
+// ARM64Gt specifies BlockARM64GT
+func ARM64Gt(cond, sub, alt string) ctrl {
+       return ctrl{BlockARM64GT, cond, []string{sub, alt}}
+}
+
+// ARM64Ne specifies BlockARM64NE
+func ARM64Ne(cond, sub, alt string) ctrl {
+       return ctrl{BlockARM64NE, cond, []string{sub, alt}}
+}
+
+// ARM64Eq specifies BlockARM64EQ
+func ARM64Eq(cond, sub, alt string) ctrl {
+       return ctrl{BlockARM64EQ, cond, []string{sub, alt}}
+}
+
+// isNewConditionCorrect verifies that a block has been correctly transformed
+// to use conditional comparison (CCMP) with the expected parameters.
+// It checks:
+// - The block kind is BlockARM64LT (less than condition)
+// - The control operation is OpARM64CCMPconst (conditional comparison with constant)
+// - The condition code is OpARM64GreaterThan
+// - The NZCV flags are set to 1
+// - The constant value being compared is 4
+// Returns true if all conditions match the expected transformation pattern
+func isNewConditionCorrect(b *Block) bool {
+       if b.Kind != BlockARM64LT {
+               return false
+       }
+
+       v := b.Controls[0]
+       if v.Op != OpARM64CCMPconst {
+               return false
+       }
+
+       params := v.AuxArm64ConditionalParams()
+       if params.Cond() != OpARM64GreaterThan {
+               return false
+       }
+       if params.Nzcv() != 1 {
+               // NZCV flags should be set to 1 for this specific transformation
+               return false
+       }
+       if imm, ok := params.ConstValue(); !ok || imm != 4 {
+               return false
+       }
+
+       return true
+}
+
+// containsOpARM64CCMP checks if a block contains any ARM64 conditional comparison
+// operations (CCMP or CCMPconst). This is used in tests to verify that the
+// if-conversion optimization successfully generated conditional comparison
+// instructions or to ensure they were not generated when inappropriate.
+func containsOpARM64CCMP(b *Block) bool {
+       for _, v := range b.Values {
+               if v.Op == OpARM64CCMP || v.Op == OpARM64CCMPconst {
+                       return true
+               }
+       }
+       return false
+}
+
+// TestMergeConditionalBranchesWithoutPointers tests the if-conversion optimization
+// on a simple case of logical AND (cond1 && cond2) without pointer operations.
+// The test verifies that:
+// - The optimization correctly transforms nested conditionals into CCMP instructions
+// - The block structure is properly simplified (inner block becomes plain and empty)
+// - The resulting control flow uses conditional comparison with correct parameters
+// - No important blocks are accidentally deleted during transformation
+// This represents the ideal case where the optimization should apply successfully.
+func TestMergeConditionalBranchesWithoutPointers(t *testing.T) {
+       t.Run("arm64", func(t *testing.T) {
+               c := testConfigArch(t, "arm64")
+               intType := c.config.Types.Int64
+               fun := c.Fun("entry",
+                       Bloc("entry",
+                               Valu("mem",
+                                       OpInitMem,
+                                       types.TypeMem,
+                                       0, nil,
+                               ),
+                               Valu("a",
+                                       OpArg,
+                                       intType,
+                                       0, c.Temp(intType),
+                               ),
+                               Valu("b",
+                                       OpArg,
+                                       intType,
+                                       1, c.Temp(intType),
+                               ),
+                               Valu("cond1",
+                                       OpARM64CMPconst,
+                                       types.TypeFlags,
+                                       1, nil,
+                                       "a",
+                               ),
+                               ARM64Gt("cond1", "second_comparison", "ret_false"),
+                       ),
+                       Bloc("second_comparison",
+                               Valu("cond2",
+                                       OpARM64CMPconst,
+                                       types.TypeFlags,
+                                       4, nil,
+                                       "b",
+                               ),
+                               ARM64Lt("cond2", "ret_false", "ret_true"),
+                       ),
+                       Bloc("ret_true",
+                               Valu("const1",
+                                       OpARM64MOVDconst,
+                                       intType,
+                                       1, nil,
+                               ),
+                               Valu("true_result",
+                                       OpMakeResult,
+                                       types.TypeMem,
+                                       0, nil,
+                                       "const1", "mem",
+                               ),
+                               Ret("true_result"),
+                       ),
+                       Bloc("ret_false",
+                               Valu("const0",
+                                       OpARM64MOVDconst,
+                                       intType,
+                                       0, nil,
+                               ),
+                               Valu("false_result",
+                                       OpMakeResult,
+                                       types.TypeMem,
+                                       0, nil,
+                                       "const0", "mem",
+                               ),
+                               Ret("false_result"),
+                       ),
+               )
+
+               CheckFunc(fun.f)
+               mergeConditionalBranches(fun.f)
+               CheckFunc(fun.f)
+
+               if len(fun.blocks) != 4 {
+                       t.Errorf("Important block was deleted")
+               }
+
+               entryBlock := fun.blocks["entry"]
+               secondBlock := fun.blocks["second_comparison"]
+
+               if secondBlock.Kind != BlockPlain || len(secondBlock.Values) != 0 {
+                       t.Errorf("Block with second condition wasn't cleaned")
+               }
+
+               if !isNewConditionCorrect(entryBlock) {
+                       t.Errorf("Entry block doesn't contain CCMP opertation")
+               }
+       })
+}
+
+// Test that pointer comparison with memory load doesn't generate CCMP
+func TestNoCCMPWithPointerAndMemoryLoad(t *testing.T) {
+       t.Run("arm64", func(t *testing.T) {
+               c := testConfigArch(t, "arm64")
+               intType := c.config.Types.Int64
+               ptrType := c.config.Types.BytePtr
+
+               fun := c.Fun("entry",
+                       Bloc("entry",
+                               Valu("mem",
+                                       OpInitMem,
+                                       types.TypeMem,
+                                       0, nil,
+                               ),
+                               Valu("ptr",
+                                       OpArg,
+                                       ptrType,
+                                       0, c.Temp(ptrType),
+                               ),
+                               Valu("cond1",
+                                       OpARM64CMPconst,
+                                       types.TypeFlags,
+                                       0, nil, // Compare with nil (0)
+                                       "ptr",
+                               ),
+                               ARM64Ne("cond1", "second_comparison", "ret_false"), // ptr != nil
+                       ),
+                       Bloc("second_comparison",
+                               Valu("load",
+                                       OpLoad,
+                                       intType,
+                                       0, nil,
+                                       "ptr", "mem",
+                               ),
+                               Valu("cond2",
+                                       OpARM64CMPconst,
+                                       types.TypeFlags,
+                                       3, nil, // Compare with 3
+                                       "load",
+                               ),
+                               ARM64Eq("cond2", "ret_true", "ret_false"), // *ptr == 3
+                       ),
+                       Bloc("ret_true",
+                               Valu("const1",
+                                       OpARM64MOVDconst,
+                                       intType,
+                                       1, nil,
+                               ),
+                               Valu("true_result",
+                                       OpMakeResult,
+                                       types.TypeMem,
+                                       0, nil,
+                                       "const1", "mem",
+                               ),
+                               Ret("true_result"),
+                       ),
+                       Bloc("ret_false",
+                               Valu("const0",
+                                       OpARM64MOVDconst,
+                                       intType,
+                                       0, nil,
+                               ),
+                               Valu("false_result",
+                                       OpMakeResult,
+                                       types.TypeMem,
+                                       0, nil,
+                                       "const0", "mem",
+                               ),
+                               Ret("false_result"),
+                       ),
+               )
+
+               CheckFunc(fun.f)
+               mergeConditionalBranches(fun.f)
+               CheckFunc(fun.f)
+
+               // Verify that the second_comparison block still exists (not optimized away)
+               if fun.blocks["second_comparison"] == nil {
+                       t.Errorf("Second comparison block was incorrectly removed")
+               }
+
+               entryBlock := fun.blocks["entry"]
+               secondBlock := fun.blocks["second_comparison"]
+
+               // Verify that entry block doesn't contain CCMP operation
+               if containsOpARM64CCMP(entryBlock) {
+                       t.Errorf("Entry block contains CCMP operation, but shouldn't due to memory load")
+               }
+
+               // Verify that second block contains the load operation
+               hasLoad := false
+               for _, v := range secondBlock.Values {
+                       if v.Op == OpLoad {
+                               hasLoad = true
+                               break
+                       }
+               }
+               if !hasLoad {
+                       t.Errorf("Second comparison block should contain load operation")
+               }
+
+               // The optimization shouldn't merge these blocks because of the memory operation
+               if secondBlock.Kind == BlockPlain {
+                       t.Errorf("Block with memory load was incorrectly cleaned")
+               }
+       })
+}

diff --git a/src/cmd/compile/internal/ssa/rewrite.go b/src/cmd/compile/internal/ssa/rewrite.go
index 04989d93c1e46ecc43100913f5ae9f4bdc3fac96..b0930818849dd8809bbf2b0cc3aef2582147da56 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewrite.go
+++ b/src/cmd/compile/internal/ssa/rewrite.go
@@ -1954,7 +1954,7 @@ func arm64BFWidth(mask, rshift int64) int64 {
        return nto(shiftedMask)
 }
 
-// encodes condition code and NZCV flags into auxint.
+// encodes condition code and NZCV flags into result.
 func arm64ConditionalParamsAuxInt(cond Op, nzcv uint8) arm64ConditionalParams {
        if cond < OpARM64Equal || cond > OpARM64GreaterEqualU {
                panic("Wrong conditional operation")

diff --git a/src/cmd/compile/internal/test/conditionalCmpConst_test.go b/src/cmd/compile/internal/test/conditionalCmpConst_test.go
new file mode 100644 (file)
index 0000000..2f384da
--- /dev/null
+++ b/src/cmd/compile/internal/test/conditionalCmpConst_test.go
@@ -0,0 +1,4408 @@
+// 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)
+                               }
+                       }
+               }
+       }
+}

diff --git a/src/cmd/compile/internal/test/testdata/gen/conditionalCmpConstGen.go b/src/cmd/compile/internal/test/testdata/gen/conditionalCmpConstGen.go
new file mode 100644 (file)
index 0000000..c3e3d7e
--- /dev/null
+++ b/src/cmd/compile/internal/test/testdata/gen/conditionalCmpConstGen.go
@@ -0,0 +1,231 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This program generates tests to verify that conditional comparisons
+// with constants are properly optimized by the compiler through constant folding.
+// The generated test should be compiled with a known working version of Go.
+// Run with `go run conditionalCmpConstGen.go` to generate a file called
+// conditionalCmpConst_test.go in the grandparent directory.
+
+package main
+
+import (
+       "bytes"
+       "fmt"
+       "go/format"
+       "log"
+       "os"
+       "strings"
+)
+
+// IntegerConstraint defines a type constraint for all integer types
+func writeIntegerConstraint(w *bytes.Buffer) {
+       fmt.Fprintf(w, "type IntegerConstraint interface {\n")
+       fmt.Fprintf(w, "\tint | uint | int8 | uint8 | int16 | ")
+       fmt.Fprintf(w, "uint16 | int32 | uint32 | int64 | uint64\n")
+       fmt.Fprintf(w, "}\n\n")
+}
+
+// TestCase describes a parameterized test case with comparison and logical operations
+func writeTestCaseStruct(w *bytes.Buffer) {
+       fmt.Fprintf(w, "type TestCase[T IntegerConstraint] struct {\n")
+       fmt.Fprintf(w, "\tcmp1, cmp2 func(a, b T) bool\n")
+       fmt.Fprintf(w, "\tcombine func(x, y bool) bool\n")
+       fmt.Fprintf(w, "\ttargetFunc func(a, b, c, d T) bool\n")
+       fmt.Fprintf(w, "\tcmp1Expr, cmp2Expr, logicalExpr string // String representations for debugging\n")
+       fmt.Fprintf(w, "}\n\n")
+}
+
+// BoundaryValues contains base value and its variations for edge case testing
+func writeBoundaryValuesStruct(w *bytes.Buffer) {
+       fmt.Fprintf(w, "type BoundaryValues[T IntegerConstraint] struct {\n")
+       fmt.Fprintf(w, "\tbase T\n")
+       fmt.Fprintf(w, "\tvariants [3]T\n")
+       fmt.Fprintf(w, "}\n\n")
+}
+
+// writeTypeDefinitions generates all necessary type declarations
+func writeTypeDefinitions(w *bytes.Buffer) {
+       writeIntegerConstraint(w)
+       writeTestCaseStruct(w)
+       writeBoundaryValuesStruct(w)
+}
+
+// comparisonOperators contains format strings for comparison operators
+var comparisonOperators = []string{
+       "%s == %s", "%s <= %s", "%s < %s",
+       "%s != %s", "%s >= %s", "%s > %s",
+}
+
+// logicalOperators contains format strings for logical combination of boolean expressions
+var logicalOperators = []string{
+       "(%s) && (%s)", "(%s) && !(%s)", "!(%s) && (%s)", "!(%s) && !(%s)",
+       "(%s) || (%s)", "(%s) || !(%s)", "!(%s) || (%s)", "!(%s) || !(%s)",
+}
+
+// writeComparator generates a comparator function based on the comparison operator
+func writeComparator(w *bytes.Buffer, fieldName, operatorFormat string) {
+       expression := fmt.Sprintf(operatorFormat, "a", "b")
+       fmt.Fprintf(w, "\t\t\t%s: func(a, b T) bool { return %s },\n", fieldName, expression)
+}
+
+// writeLogicalCombiner generates a function to combine two boolean values
+func writeLogicalCombiner(w *bytes.Buffer, logicalOperator string) {
+       expression := fmt.Sprintf(logicalOperator, "x", "y")
+       fmt.Fprintf(w, "\t\t\tcombine: func(x, y bool) bool { return %s },\n", expression)
+}
+
+// writeTargetFunction generates the target function with conditional expression
+func writeTargetFunction(w *bytes.Buffer, cmp1, cmp2, logicalOp string) {
+       leftExpr := fmt.Sprintf(cmp1, "a", "b")
+       rightExpr := fmt.Sprintf(cmp2, "c", "d")
+       condition := fmt.Sprintf(logicalOp, leftExpr, rightExpr)
+
+       fmt.Fprintf(w, "\t\t\ttargetFunc: func(a, b, c, d T) bool {\n")
+       fmt.Fprintf(w, "\t\t\t\tif %s {\n", condition)
+       fmt.Fprintf(w, "\t\t\t\t\treturn true\n")
+       fmt.Fprintf(w, "\t\t\t\t}\n")
+       fmt.Fprintf(w, "\t\t\t\treturn false\n")
+       fmt.Fprintf(w, "\t\t\t},\n")
+}
+
+// writeTestCase creates a single test case with given comparison and logical operators
+func writeTestCase(w *bytes.Buffer, cmp1, cmp2, logicalOp string) {
+       fmt.Fprintf(w, "\t\t{\n")
+       writeComparator(w, "cmp1", cmp1)
+       writeComparator(w, "cmp2", cmp2)
+       writeLogicalCombiner(w, logicalOp)
+       writeTargetFunction(w, cmp1, cmp2, logicalOp)
+
+       // Store string representations for debugging
+       cmp1Expr := fmt.Sprintf(cmp1, "a", "b")
+       cmp2Expr := fmt.Sprintf(cmp2, "c", "d")
+       logicalExpr := fmt.Sprintf(logicalOp, cmp1Expr, cmp2Expr)
+
+       fmt.Fprintf(w, "\t\t\tcmp1Expr: %q,\n", cmp1Expr)
+       fmt.Fprintf(w, "\t\t\tcmp2Expr: %q,\n", cmp2Expr)
+       fmt.Fprintf(w, "\t\t\tlogicalExpr: %q,\n", logicalExpr)
+
+       fmt.Fprintf(w, "\t\t},\n")
+}
+
+// generateTestCases creates a slice of all possible test cases
+func generateTestCases(w *bytes.Buffer) {
+       fmt.Fprintf(w, "func generateTestCases[T IntegerConstraint]() []TestCase[T] {\n")
+       fmt.Fprintf(w, "\treturn []TestCase[T]{\n")
+
+       for _, cmp1 := range comparisonOperators {
+               for _, cmp2 := range comparisonOperators {
+                       for _, logicalOp := range logicalOperators {
+                               writeTestCase(w, cmp1, cmp2, logicalOp)
+                       }
+               }
+       }
+
+       fmt.Fprintf(w, "\t}\n")
+       fmt.Fprintf(w, "}\n\n")
+}
+
+// TypeConfig defines a type and its test base value
+type TypeConfig struct {
+       typeName, baseValue string
+}
+
+// typeConfigs contains all integer types to test with their base values
+var typeConfigs = []TypeConfig{
+       {typeName: "int8", baseValue: "1 << 6"},
+       {typeName: "uint8", baseValue: "1 << 6"},
+       {typeName: "int16", baseValue: "1 << 14"},
+       {typeName: "uint16", baseValue: "1 << 14"},
+       {typeName: "int32", baseValue: "1 << 30"},
+       {typeName: "uint32", baseValue: "1 << 30"},
+       {typeName: "int", baseValue: "1 << 30"},
+       {typeName: "uint", baseValue: "1 << 30"},
+       {typeName: "int64", baseValue: "1 << 62"},
+       {typeName: "uint64", baseValue: "1 << 62"},
+}
+
+// writeTypeSpecificTest generates test for a specific integer type
+func writeTypeSpecificTest(w *bytes.Buffer, typeName, baseValue string) {
+       typeTitle := strings.Title(typeName)
+
+       fmt.Fprintf(w, "func Test%sConditionalCmpConst(t *testing.T) {\n", typeTitle)
+
+       fmt.Fprintf(w, "\ttestCases := generateTestCases[%s]()\n", typeName)
+       fmt.Fprintf(w, "\tbase := %s(%s)\n", typeName, baseValue)
+       fmt.Fprintf(w, "\tvalues := [3]%s{base - 1, base, base + 1}\n\n", typeName)
+
+       fmt.Fprintf(w, "\tfor _, tc := range testCases {\n")
+       fmt.Fprintf(w, "\t\ta, c := base, base\n")
+       fmt.Fprintf(w, "\t\tfor _, b := range values {\n")
+       fmt.Fprintf(w, "\t\t\tfor _, d := range values {\n")
+       fmt.Fprintf(w, "\t\t\t\texpected := tc.combine(tc.cmp1(a, b), tc.cmp2(c, d))\n")
+       fmt.Fprintf(w, "\t\t\t\tactual := tc.targetFunc(a, b, c, d)\n")
+       fmt.Fprintf(w, "\t\t\t\tif actual != expected {\n")
+       fmt.Fprintf(w, "\t\t\t\t\tt.Errorf(\"conditional comparison failed:\\n\"+\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\t\"  type: %%T\\n\"+\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\t\"  condition: %%s\\n\"+\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\t\"  values: a=%%v, b=%%v, c=%%v, d=%%v\\n\"+\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\t\"  cmp1(a,b)=%%v (%%s)\\n\"+\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\t\"  cmp2(c,d)=%%v (%%s)\\n\"+\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\t\"  expected: combine(%%v, %%v)=%%v\\n\"+\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\t\"  actual: %%v\\n\"+\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\t\"  logical expression: %%s\",\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\ta,\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\ttc.logicalExpr,\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\ta, b, c, d,\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\ttc.cmp1(a, b), tc.cmp1Expr,\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\ttc.cmp2(c, d), tc.cmp2Expr,\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\ttc.cmp1(a, b), tc.cmp2(c, d), expected,\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\tactual,\n")
+       fmt.Fprintf(w, "\t\t\t\t\t\ttc.logicalExpr)\n")
+       fmt.Fprintf(w, "\t\t\t\t}\n")
+       fmt.Fprintf(w, "\t\t\t}\n")
+       fmt.Fprintf(w, "\t\t}\n")
+       fmt.Fprintf(w, "\t}\n")
+
+       fmt.Fprintf(w, "}\n\n")
+}
+
+// writeAllTests generates tests for all supported integer types
+func writeAllTests(w *bytes.Buffer) {
+       for _, config := range typeConfigs {
+               writeTypeSpecificTest(w, config.typeName, config.baseValue)
+       }
+}
+
+func main() {
+       buffer := new(bytes.Buffer)
+
+       // Header for generated file
+       fmt.Fprintf(buffer, "// Code generated by conditionalCmpConstGen.go; DO NOT EDIT.\n\n")
+       fmt.Fprintf(buffer, "package test\n\n")
+       fmt.Fprintf(buffer, "import \"testing\"\n\n")
+
+       // Generate type definitions
+       writeTypeDefinitions(buffer)
+
+       // Generate test cases
+       generateTestCases(buffer)
+
+       // Generate specific tests for each integer type
+       writeAllTests(buffer)
+
+       // Format generated source code
+       rawSource := buffer.Bytes()
+       formattedSource, err := format.Source(rawSource)
+       if err != nil {
+               // Output raw source for debugging if formatting fails
+               fmt.Printf("%s\n", rawSource)
+               log.Fatal("error formatting generated code: ", err)
+       }
+
+       // Write to output file
+       outputPath := "../../conditionalCmpConst_test.go"
+       if err := os.WriteFile(outputPath, formattedSource, 0666); err != nil {
+               log.Fatal("failed to write output file: ", err)
+       }
+
+       log.Printf("Tests successfully generated to %s", outputPath)
+}

diff --git a/test/codegen/comparisons.go b/test/codegen/comparisons.go
index 330497c656e6e0172b38197092a317abcbe4f5cd..43b95646eb1077f352596252caa5b875214b28ac 100644 (file)
--- a/test/codegen/comparisons.go
+++ b/test/codegen/comparisons.go
@@ -462,7 +462,7 @@ func CmpToZero_ex5(e, f int32, u uint32) int {
 
 func UintLtZero(a uint8, b uint16, c uint32, d uint64) int {
        // amd64: -`(TESTB|TESTW|TESTL|TESTQ|JCC|JCS)`
-       // arm64: -`(CMPW|CMP|BHS|BLO)`
+       // arm64: -`(CMPW|CMP|CCMP|CCMPW|BHS|BLO)`
        if a < 0 || b < 0 || c < 0 || d < 0 {
                return 1
        }
@@ -471,7 +471,7 @@ func UintLtZero(a uint8, b uint16, c uint32, d uint64) int {
 
 func UintGeqZero(a uint8, b uint16, c uint32, d uint64) int {
        // amd64: -`(TESTB|TESTW|TESTL|TESTQ|JCS|JCC)`
-       // arm64: -`(CMPW|CMP|BLO|BHS)`
+       // arm64: -`(CMPW|CMP|CCMP|CCMPW|BLO|BHS)`
        if a >= 0 || b >= 0 || c >= 0 || d >= 0 {
                return 1
        }
@@ -479,7 +479,7 @@ func UintGeqZero(a uint8, b uint16, c uint32, d uint64) int {
 }
 
 func UintGtZero(a uint8, b uint16, c uint32, d uint64) int {
-       // arm64: `(CBN?ZW)`, `(CBN?Z[^W])`, -`(CMPW|CMP|BLS|BHI)`
+       // arm64: `(CMPW|CMP|CCMP|CCMPW|BNE|BEQ)`
        if a > 0 || b > 0 || c > 0 || d > 0 {
                return 1
        }
@@ -487,7 +487,7 @@ func UintGtZero(a uint8, b uint16, c uint32, d uint64) int {
 }
 
 func UintLeqZero(a uint8, b uint16, c uint32, d uint64) int {
-       // arm64: `(CBN?ZW)`, `(CBN?Z[^W])`, -`(CMPW|CMP|BHI|BLS)`
+       // arm64: `(CMPW|CMP|CCMP|CCMPW|BNE|BEQ)`
        if a <= 0 || b <= 0 || c <= 0 || d <= 0 {
                return 1
        }
@@ -495,7 +495,7 @@ func UintLeqZero(a uint8, b uint16, c uint32, d uint64) int {
 }
 
 func UintLtOne(a uint8, b uint16, c uint32, d uint64) int {
-       // arm64: `(CBN?ZW)`, `(CBN?Z[^W])`, -`(CMPW|CMP|BHS|BLO)`
+       // arm64: `(CMPW|CMP|CCMP|CCMPW|BNE|BEQ)`
        if a < 1 || b < 1 || c < 1 || d < 1 {
                return 1
        }
@@ -503,13 +503,45 @@ func UintLtOne(a uint8, b uint16, c uint32, d uint64) int {
 }
 
 func UintGeqOne(a uint8, b uint16, c uint32, d uint64) int {
-       // arm64: `(CBN?ZW)`, `(CBN?Z[^W])`, -`(CMPW|CMP|BLO|BHS)`
+       // arm64: `(CMPW|CMP|CCMP|CCMPW|BNE|BEQ)`
        if a >= 1 || b >= 1 || c >= 1 || d >= 1 {
                return 1
        }
        return 0
 }
 
+func ConditionalCompareUint8(a, b uint8) int {
+       // arm64:"CCMPW EQ, R[0-9]+, [$]1, [$]0"
+       if a == 1 && b == 1 {
+               return 1
+       }
+       return 0
+}
+
+func ConditionalCompareInt16(a, b int16) int {
+       // arm64:"CCMPW LE, R[0-9]+, R[0-9]+, [$]4"
+       if a > 3 || a == b {
+               return 1
+       }
+       return 0
+}
+
+func ConditionalCompareUint32(a, b uint32) int {
+       // arm64:"CCMPW LO, R[0-9]+, [$]28, [$]2"
+       if a > b && a < 28 {
+               return 1
+       }
+       return 0
+}
+
+func ConditionalCompareInt64(a, b int64) int {
+       // arm64:"CCMP GT, R[0-9]+, R[0-9]+, [$]0"
+       if a <= 16 || a != b {
+               return 1
+       }
+       return 0
+}
+
 func CmpToZeroU_ex1(a uint8, b uint16, c uint32, d uint64) int {
        // wasm:"I64Eqz"-"I64LtU"
        if 0 < a {