[EarlyCSE] Ensure equal keys have the same hash value

[JosephTremoulet]

Summary

The logic in EarlyCSE that looks through 'not' operations in the
predicate recognizes e.g. that select (not (cmp sgt X, Y)), X, Y is
equivalent to select (cmp sgt X, Y), Y, X. Without this change,
however, only the latter is recognized as a form of smin X, Y, so the
two expressions receive different hash codes. This leads to missed
optimization opportunities when the quadratic probing for the two hashes
doesn't happen to collide, and assertion failures when probing doesn't
collide on insertion but does collide on a subsequent table grow
operation.

This change inverts the order of some of the pattern matching, checking
first for the optional not and then for the min/max/abs patterns, so
that e.g. both expressions above are recognized as a form of smin X, Y.

It also adds an assertion to isEqual verifying that it implies equal
hash codes; this fires when there's a collision during insertion, not
just grow, and so will make it easier to notice if these functions fall
out of sync again.

[spatel]

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

335

formatting: result -> Result

llvm/test/Transforms/EarlyCSE/commute.ll

110–112

For this and the related small tests, please commit them with baseline assertions as a preliminary patch, then rebase to show the improvements from this patch.

645–651

How does this bug manifest? Can we cause an assertion failure without this patch?
cc'ing some more potential reviewers to see if anyone has ideas for a smaller than ~1000 line regression test to reproduce the bug. ( @lebedev.ri @efriedma @craig.topper @arsenm ).

[JosephTremoulet]

llvm/test/Transforms/EarlyCSE/commute.ll

645–651

Yes, this same test reproduces an assertion[1] failure without this patch, but it does so nondeterministically -- I see it about every 20-30 runs. The original compiland I was hitting this on would hit every ~2000 runs. If I revert everything except the new assertion I added in isEqual, this test hits the new assertion something like 4 times out of 5 for me.

Happy for ideas how to trim it down / make it more deterministic.

[1] https://github.com/llvm/llvm-project/blob/590b1aee609d30346aee77a699381d21c538dd56/llvm/include/llvm/ADT/DenseMap.h#L404

[JosephTremoulet]

Fix style, rebase on top of test change

[efriedma]

llvm/test/Transforms/EarlyCSE/commute.ll

645–651

It might make sense to write a unit-test that directly checks the result of hashing/equality on SimpleValue? Granted, that would require exposing the SimpleValue API in a header somewhere, I think.

Alternatively, you could add a debugging flag to early-cse to make it do a linear scan over the hashtable entries after each failed hashtable lookup, to make sure it was supposed to fail.

[JosephTremoulet]

llvm/test/Transforms/EarlyCSE/commute.ll

645–651

I started coding up the debugging flag approach, but the hash table in question is a ScopedHashTable, which doesn't provide a way to enumerate the keys (unless I'm just missing it). I'm not convinced that this test merits changing the ScopedHashTable API surface, but I'm happy to do it if there's reason to think there's other merit in adding key/value pair iteration to ScopedHashTable, or something -- thoughts?

I have similar reservations about exposing SimpleValue just for this test. Do we have other examples of things exposed just for testing that I should follow? E.g. would you expect it to be in EarlyCSE.h, or in some new EarlyCSE-private.h or similar?

I could also be convinced to remove or scale back this test. I had two benefits in mind when I wrote it:

1. It reproduces an assertion failure on current sources
2. It validates that my changes don't just push the problem one level of looking-through-nots deeper

Regarding #1, if the hashes diverge again for the specific pattern this test repeats, then the selects in the other new tests above would not get CSE'd (except by super-rare hash collision), so the test would fail the CHECK lines there. So we're protected against that particular regression regardless of this 1000-line test. And the tests added above fail on current sources, from the same bug, just with a different symptom (missed optimization opportunity rather than assertion failure).

Regarding #2, I could just scale this down to one instance of the 11-line pattern, and add similar CHECK lines, and again have the coverage.

So I'm leaning toward making this test look a lot like the others, just with an extra "not" or two, but could be convinced to take one of the other approaches if someone cares. Thoughts?

[efriedma]

llvm/test/Transforms/EarlyCSE/commute.ll

645–651

If we have some test coverage for the hashing, it isn't that important what we do here, I guess. A debugging flag in EarlyCSE could be helpful to find other issues, but it's probably not worth writing a whole iteration framework for ScopedHashTables just for that.

[JosephTremoulet]

llvm/test/Transforms/EarlyCSE/commute.ll

645–651

Oh, actually, I suppose I could add a flag without changing ScopedHashTable -- since I already have isEqual asserting that the hashes match, it'd be the same effect to have the flag make getHashValue just return a constant (with a touch of refactoring so the assert could still call the "real" hash function).

I'm not sure how to best make use of such a flag .. just use it in the commute.ll test? Other EarlyCSE tests as well? Would it make sense for such a flag to default to "yes run the checks" under #ifdef EXPENSIVE_CHECKS?

[JosephTremoulet]

• Add -earlycse-debug-hash flag, shorten new test

[JosephTremoulet]

llvm/test/Transforms/EarlyCSE/commute.ll

645–651

Updated to add debug flag (passed in the RUN line in commute.ll and left off everywhere else; can be thrown manually when updating the hash logic) and shorten the test.

[spatel]

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

83–86

Since the code has an ifdef guard, do we want the ifdef guard on the option itself?
Or just remove the guard at the use, so we can use/test this option even with a release build?

[JosephTremoulet]

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

83–86

My thinking was:

1. We don't want an ifdef guard on the option itself, because if we had one then running lit on commute.ll with a release build of opt would fail
2. We do want a guard on the use, to avoid the run-time cost of repeatedly checking the static every time we compute a SimpleValue hash in release builds (and returning the const from the hash function in release builds isn't that valuable since the point of doing it is to exercise the assertion in isEqual that won't exist in release builds anyway)

I could be convinced to change it (especially if there's already some convention for debug-only flags in lit tests), but that was my reasoning.

[spatel]

LGTM - but let's wait a ~day to commit in case anyone else has comments.

[nikic]

LGTM as well.

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

155

Either this assignment or the one above it can be dropped.

[JosephTremoulet]

• Remove useless assignment

[fhahn]

It looks like this patch may have caused https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=15236. It would be great if you could have a look.

[uabelho]

In D62644#1543279, @fhahn wrote:

It looks like this patch may have caused https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=15236. It would be great if you could have a look.

That assertion is also seen here:
https://bugs.llvm.org/show_bug.cgi?id=42280

However, as I wrote in that PR, with older opt versions it still crashes now and then, only that it often takes more attempts.
And then we hit a different assertion:

opt: ../include/llvm/ADT/DenseMap.h:404: void llvm::DenseMapBase<llvm::DenseMap<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *, llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *> >, (anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *, llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *> >::moveFromOldBuckets(BucketT *, BucketT *) [DerivedT = llvm::DenseMap<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *, llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *> >, KeyT = (anonymous namespace)::SimpleValue, ValueT = llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *, KeyInfoT = llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, BucketT = llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *>]: Assertion `!FoundVal && "Key already in new map?"' failed.

[JosephTremoulet]

In D62644#1543328, @uabelho wrote:

In D62644#1543279, @fhahn wrote:

It looks like this patch may have caused https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=15236. It would be great if you could have a look.

That assertion is also seen here:
https://bugs.llvm.org/show_bug.cgi?id=42280

However, as I wrote in that PR, with older opt versions it still crashes now and then, only that it often takes more attempts.
And then we hit a different assertion:

opt: ../include/llvm/ADT/DenseMap.h:404: void llvm::DenseMapBase<llvm::DenseMap<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *, llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *> >, (anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *, llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *> >::moveFromOldBuckets(BucketT *, BucketT *) [DerivedT = llvm::DenseMap<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *, llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *> >, KeyT = (anonymous namespace)::SimpleValue, ValueT = llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *, KeyInfoT = llvm::DenseMapInfo<(anonymous namespace)::SimpleValue>, BucketT = llvm::detail::DenseMapPair<(anonymous namespace)::SimpleValue, llvm::ScopedHashTableVal<(anonymous namespace)::SimpleValue, llvm::Value *> *>]: Assertion `!FoundVal && "Key already in new map?"' failed.

Taking a look at both. This change had a bugfix and added more checking. The new checking is meant to do exactly what @uabelho describes -- hash/isEqual mismatch would previously have led, nondeterministically and rarely, to the "Key already in new map?" assertion failure, and would now lead, nondeterministically but less rarely, to the new assertion ("getHashValueImpl(LHS) == getHashValueImpl(RHS)"), and with -earlycse-debug-hash would now lead deterministically to the new assertion (for functions in which earlycse processes two expressions that compare equal but hash differently).

llvm/include/llvm/Analysis/ValueTracking.h

matchSelectPattern(const Value *V, const Value *&LHS, const Value *&RHS,
     Value *L = const_cast<Value*>(LHS);
     Value *R = const_cast<Value*>(RHS);
     auto Result = matchSelectPattern(const_cast<Value*>(V), L, R);
     LHS = L;
     RHS = R;
     return Result;
   }
 
+  /// Determine the pattern that a select with the given compare as its
+  /// predicate and given values as its true/false operands would match.
+  SelectPatternResult matchDecomposedSelectPattern(
+      CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS,
+      Instruction::CastOps *CastOp = nullptr, unsigned Depth = 0);
+
   /// Return the canonical comparison predicate for the specified
   /// minimum/maximum flavor.
   CmpInst::Predicate getMinMaxPred(SelectPatternFlavor SPF,
                                    bool Ordered = false);
 
   /// Return the inverse minimum/maximum flavor of the specified flavor.
   /// For example, signed minimum is the inverse of signed maximum.
   SelectPatternFlavor getInverseMinMaxFlavor(SelectPatternFlavor SPF);

llvm/lib/Analysis/ValueTracking.cpp

if (Depth >= MaxDepth)
     return {SPF_UNKNOWN, SPNB_NA, false};
 
   SelectInst *SI = dyn_cast<SelectInst>(V);
   if (!SI) return {SPF_UNKNOWN, SPNB_NA, false};
 
   CmpInst *CmpI = dyn_cast<CmpInst>(SI->getCondition());
   if (!CmpI) return {SPF_UNKNOWN, SPNB_NA, false};
 
+  Value *TrueVal = SI->getTrueValue();
+  Value *FalseVal = SI->getFalseValue();
+
+  return llvm::matchDecomposedSelectPattern(CmpI, TrueVal, FalseVal, LHS, RHS,
+                                            CastOp, Depth);
+}
+
+SelectPatternResult llvm::matchDecomposedSelectPattern(
+    CmpInst *CmpI, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS,
+    Instruction::CastOps *CastOp, unsigned Depth) {
   CmpInst::Predicate Pred = CmpI->getPredicate();
   Value *CmpLHS = CmpI->getOperand(0);
   Value *CmpRHS = CmpI->getOperand(1);
-  Value *TrueVal = SI->getTrueValue();
-  Value *FalseVal = SI->getFalseValue();
   FastMathFlags FMF;
   if (isa<FPMathOperator>(CmpI))
     FMF = CmpI->getFastMathFlags();
 
   // Bail out early.
   if (CmpI->isEquality())
     return {SPF_UNKNOWN, SPNB_NA, false};
 

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

 DEBUG_COUNTER(CSECounter, "early-cse",
               "Controls which instructions are removed");
 
 static cl::opt<unsigned> EarlyCSEMssaOptCap(
     "earlycse-mssa-optimization-cap", cl::init(500), cl::Hidden,
     cl::desc("Enable imprecision in EarlyCSE in pathological cases, in exchange "
              "for faster compile. Caps the MemorySSA clobbering calls."));
 
 //===----------------------------------------------------------------------===//
 // SimpleValue
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 /// Struct representing the available values in the scoped hash table.
 struct SimpleValue {
   Instruction *Inst;
 
   SimpleValue(Instruction *I) : Inst(I) {
     assert((isSentinel() || canHandle(I)) && "Inst can't be handled!");
template <> struct DenseMapInfo<SimpleValue> {
   }
 
   static unsigned getHashValue(SimpleValue Val);
   static bool isEqual(SimpleValue LHS, SimpleValue RHS);
 };
 
 } // end namespace llvm
 
-/// Match a 'select' including an optional 'not' of the condition.
-static bool matchSelectWithOptionalNotCond(Value *V, Value *&Cond,
-                                           Value *&T, Value *&F) {
-  if (match(V, m_Select(m_Value(Cond), m_Value(T), m_Value(F)))) {
-    // Look through a 'not' of the condition operand by swapping true/false.
-    Value *CondNot;
-    if (match(Cond, m_Not(m_Value(CondNot)))) {
-      Cond = CondNot;
-      std::swap(T, F);
-    }
-    return true;
-  }
-  return false;
-}
+/// Match a 'select' including an optional 'not's of the condition.
+static bool matchSelectWithOptionalNotCond(Value *V, Value *&Cond, Value *&A,
+                                           Value *&B,
+                                           SelectPatternFlavor &Flavor) {
+  // Return false if V is not even a select.
+  if (!match(V, m_Select(m_Value(Cond), m_Value(A), m_Value(B))))
+    return false;
+
+  // Look through a 'not' of the condition operand by swapping A/B.
+    std::swap(A, B);
+
+  // Set flavor if we find a match, or set it to unknown otherwise; in
+  // either case, return true to indicate that this is a select we can
+  // process.
+  Flavor = SPF_UNKNOWN;
+  if (auto *CmpI = dyn_cast<ICmpInst>(Cond))
+    Flavor = matchDecomposedSelectPattern(CmpI, A, B, A, B).Flavor;
+  else
+    Flavor = SPF_UNKNOWN;
+
 
 unsigned DenseMapInfo<SimpleValue>::getHashValue(SimpleValue Val) {
   Instruction *Inst = Val.Inst;
   // Hash in all of the operands as pointers.
   if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(Inst)) {
     Value *LHS = BinOp->getOperand(0);
     Value *RHS = BinOp->getOperand(1);
     if (BinOp->isCommutative() && BinOp->getOperand(0) > BinOp->getOperand(1))
       std::swap(LHS, RHS);
 
     return hash_combine(BinOp->getOpcode(), LHS, RHS);
   }
 
   if (CmpInst *CI = dyn_cast<CmpInst>(Inst)) {
     Value *LHS = CI->getOperand(0);
     Value *RHS = CI->getOperand(1);
     CmpInst::Predicate Pred = CI->getPredicate();
     if (Inst->getOperand(0) > Inst->getOperand(1)) {
       std::swap(LHS, RHS);
       Pred = CI->getSwappedPredicate();
     }
     return hash_combine(Inst->getOpcode(), Pred, LHS, RHS);
   }
 
+  // Hash general selects to allow matching commuted true/false operands.
+  SelectPatternFlavor SPF;
+  Value *Cond, *A, *B;
+  if (matchSelectWithOptionalNotCond(Inst, Cond, A, B, SPF)) {
     // Hash min/max/abs (cmp + select) to allow for commuted operands.
     // Min/max may also have non-canonical compare predicate (eg, the compare for
     // smin may use 'sgt' rather than 'slt'), and non-canonical operands in the
     // compare.
-  Value *A, *B;
-  SelectPatternFlavor SPF = matchSelectPattern(Inst, A, B).Flavor;
     // TODO: We should also detect FP min/max.
     if (SPF == SPF_SMIN || SPF == SPF_SMAX ||
         SPF == SPF_UMIN || SPF == SPF_UMAX) {
       if (A > B)
         std::swap(A, B);
       return hash_combine(Inst->getOpcode(), SPF, A, B);
     }
     if (SPF == SPF_ABS || SPF == SPF_NABS) {
       // ABS/NABS always puts the input in A and its negation in B.
       return hash_combine(Inst->getOpcode(), SPF, A, B);
     }
 
     // Hash general selects to allow matching commuted true/false operands.
-  Value *Cond, *TVal, *FVal;
-  if (matchSelectWithOptionalNotCond(Inst, Cond, TVal, FVal)) {
+
     // If we do not have a compare as the condition, just hash in the condition.
     CmpInst::Predicate Pred;
     Value *X, *Y;
     if (!match(Cond, m_Cmp(Pred, m_Value(X), m_Value(Y))))
-      return hash_combine(Inst->getOpcode(), Cond, TVal, FVal);
+      return hash_combine(Inst->getOpcode(), Cond, A, B);
 
     // Similar to cmp normalization (above) - canonicalize the predicate value:
-    // select (icmp Pred, X, Y), T, F --> select (icmp InvPred, X, Y), F, T
+    // select (icmp Pred, X, Y), A, B --> select (icmp InvPred, X, Y), B, A
     if (CmpInst::getInversePredicate(Pred) < Pred) {
       Pred = CmpInst::getInversePredicate(Pred);
-      std::swap(TVal, FVal);
+      std::swap(A, B);
     }
-    return hash_combine(Inst->getOpcode(), Pred, X, Y, TVal, FVal);
+    return hash_combine(Inst->getOpcode(), Pred, X, Y, A, B);
   }
 
   if (CastInst *CI = dyn_cast<CastInst>(Inst))
     return hash_combine(CI->getOpcode(), CI->getType(), CI->getOperand(0));
 
   if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(Inst))
     return hash_combine(EVI->getOpcode(), EVI->getOperand(0),
                         hash_combine_range(EVI->idx_begin(), EVI->idx_end()));
assert((isa<CallInst>(Inst) || isa<GetElementPtrInst>(Inst) ||
          "Invalid/unknown instruction");
 
   // Mix in the opcode.
   return hash_combine(
       Inst->getOpcode(),
       hash_combine_range(Inst->value_op_begin(), Inst->value_op_end()));
 }
 
-bool DenseMapInfo<SimpleValue>::isEqual(SimpleValue LHS, SimpleValue RHS) {
+static bool isEqualImpl(SimpleValue LHS, SimpleValue RHS) {
   Instruction *LHSI = LHS.Inst, *RHSI = RHS.Inst;
 
   if (LHS.isSentinel() || RHS.isSentinel())
     return LHSI == RHSI;
 
   if (LHSI->getOpcode() != RHSI->getOpcode())
     return false;
   if (LHSI->isIdenticalToWhenDefined(RHSI))
if (CmpInst *LHSCmp = dyn_cast<CmpInst>(LHSI)) {
     // Commuted equality
     return LHSCmp->getOperand(0) == RHSCmp->getOperand(1) &&
            LHSCmp->getOperand(1) == RHSCmp->getOperand(0) &&
            LHSCmp->getSwappedPredicate() == RHSCmp->getPredicate();
   }
 
   // Min/max/abs can occur with commuted operands, non-canonical predicates,
   // and/or non-canonical operands.
-  Value *LHSA, *LHSB;
-  SelectPatternFlavor LSPF = matchSelectPattern(LHSI, LHSA, LHSB).Flavor;
+  // Selects can be non-trivially equivalent via inverted conditions and swaps.
+  SelectPatternFlavor LSPF, RSPF;
+  Value *CondL, *CondR, *LHSA, *RHSA, *LHSB, *RHSB;
+  if (matchSelectWithOptionalNotCond(LHSI, CondL, LHSA, LHSB, LSPF) &&
+      matchSelectWithOptionalNotCond(RHSI, CondR, RHSA, RHSB, RSPF)) {
+    if (LSPF == RSPF) {
       // TODO: We should also detect FP min/max.
       if (LSPF == SPF_SMIN || LSPF == SPF_SMAX ||
-      LSPF == SPF_UMIN || LSPF == SPF_UMAX ||
-      LSPF == SPF_ABS || LSPF == SPF_NABS) {
-    Value *RHSA, *RHSB;
-    SelectPatternFlavor RSPF = matchSelectPattern(RHSI, RHSA, RHSB).Flavor;
-    if (LSPF == RSPF) {
-      // Abs results are placed in a defined order by matchSelectPattern.
-      if (LSPF == SPF_ABS || LSPF == SPF_NABS)
-        return LHSA == RHSA && LHSB == RHSB;
+          LSPF == SPF_UMIN || LSPF == SPF_UMAX)
         return ((LHSA == RHSA && LHSB == RHSB) ||
                 (LHSA == RHSB && LHSB == RHSA));
-    }
+
+      if (LSPF == SPF_ABS || LSPF == SPF_NABS) {
+        // Abs results are placed in a defined order by matchSelectPattern.
+        return LHSA == RHSA && LHSB == RHSB;
       }
 
-  // Selects can be non-trivially equivalent via inverted conditions and swaps.
-  Value *CondL, *CondR, *TrueL, *TrueR, *FalseL, *FalseR;
-  if (matchSelectWithOptionalNotCond(LHSI, CondL, TrueL, FalseL) &&
-      matchSelectWithOptionalNotCond(RHSI, CondR, TrueR, FalseR)) {
-    // select Cond, T, F <--> select not(Cond), F, T
-    if (CondL == CondR && TrueL == TrueR && FalseL == FalseR)
+      // select Cond, A, B <--> select not(Cond), B, A
+      if (CondL == CondR && LHSA == RHSA && LHSB == RHSB)
         return true;
+    }
 
     // If the true/false operands are swapped and the conditions are compares
     // with inverted predicates, the selects are equal:
-    // select (icmp Pred, X, Y), T, F <--> select (icmp InvPred, X, Y), F, T
+    // select (icmp Pred, X, Y), A, B <--> select (icmp InvPred, X, Y), B, A
+    //
+    // This also handles patterns with a double-negation in the sense of not +
+    // inverse, because we looked through a 'not' in the matching function and
+    // swapped A/B:
+    // select (cmp Pred, X, Y), A, B <--> select (not (cmp InvPred, X, Y)), B, A
     //
-    // This also handles patterns with a double-negation because we looked
-    // through a 'not' in the matching function and swapped T/F:
-    // select (cmp Pred, X, Y), T, F <--> select (not (cmp InvPred, X, Y)), T, F
-    if (TrueL == FalseR && FalseL == TrueR) {
+    // This intentionally does NOT handle patterns with a double-negation in
+    // the sense of not + not, because doing so could result in values
+    // comparing
+    // as equal that hash differently in the min/max/abs cases like:
+    // select (cmp slt, X, Y), X, Y <--> select (not (not (cmp slt, X, Y))), X, Y
+    //   ^ hashes as min                  ^ would not hash as min
+    // In the context of the EarlyCSE pass, however, such cases never reach
+    // this code, as we simplify the double-negation before hashing the second
+    // select (and so still succeed at CSEing them).
+    if (LHSA == RHSB && LHSB == RHSA) {
       CmpInst::Predicate PredL, PredR;
       Value *X, *Y;
       if (match(CondL, m_Cmp(PredL, m_Value(X), m_Value(Y))) &&
           match(CondR, m_Cmp(PredR, m_Specific(X), m_Specific(Y))) &&
           CmpInst::getInversePredicate(PredL) == PredR)
         return true;
     }
   }
 
   return false;
 }
 
+bool DenseMapInfo<SimpleValue>::isEqual(SimpleValue LHS, SimpleValue RHS) {
+  // These comparisons are nontrivial, so assert that equality implies
+  // hash equality (DenseMap demands this as an invariant).
+  bool result = isEqualImpl(LHS, RHS);
+  assert(!result || (LHS.isSentinel() && LHS.Inst == RHS.Inst) ||
+         DenseMapInfo::getHashValue(LHS) == DenseMapInfo::getHashValue(RHS));
+  return result;
+}
+
 //===----------------------------------------------------------------------===//
 // CallValue
 //===----------------------------------------------------------------------===//
 
 namespace {
 
 /// Struct representing the available call values in the scoped hash
 /// table.

llvm/test/Transforms/EarlyCSE/commute.ll

;
   %cmp1 = icmp sgt i8 %a, %b
   %cmp2 = icmp slt i8 %a, %b
   %m1 = select i1 %cmp1, i8 %b, i8 %a
   %m2 = select i1 %cmp2, i8 %a, i8 %b
   %r = icmp eq i8 %m2, %m1
   ret i1 %r
 }
 
+; Min/max can also have an inverted predicate and select operands.
+
+define i1 @smin_inverted(i8 %a, i8 %b) {
+; CHECK-LABEL: @smin_inverted(
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = xor i1 [[CMP1]], true
+; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
+; CHECK-NEXT:    ret i1 true
+;
+  %cmp1 = icmp slt i8 %a, %b
+  %cmp2 = xor i1 %cmp1, -1
+  %m1 = select i1 %cmp1, i8 %a, i8 %b
+  %m2 = select i1 %cmp2, i8 %b, i8 %a
+  %r = icmp eq i8 %m1, %m2
+  ret i1 %r
+}
+
 define i8 @smax_commute(i8 %a, i8 %b) {
 ; CHECK-LABEL: @smax_commute(
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
 ; CHECK-NEXT:    ret i8 0
 ;
   %cmp1 = icmp sgt i8 %a, %b
;
   %cmp1 = icmp slt i8 %a, %b
   %cmp2 = icmp sgt i8 %a, %b
   %m1 = select i1 %cmp1, i8 %b, i8 %a
   %m2 = select i1 %cmp2, i8 %a, i8 %b
   %r = sdiv i8 %m1, %m2
   ret i8 %r
 }
 
+define i1 @smax_inverted(i8 %a, i8 %b) {
+; CHECK-LABEL: @smax_inverted(
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = xor i1 [[CMP1]], true
+; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
+; CHECK-NEXT:    ret i1 true
+;
+  %cmp1 = icmp sgt i8 %a, %b
+  %cmp2 = xor i1 %cmp1, -1
+  %m1 = select i1 %cmp1, i8 %a, i8 %b
+  %m2 = select i1 %cmp2, i8 %b, i8 %a
+  %r = icmp eq i8 %m1, %m2
+  ret i1 %r
+}
+
 define i8 @umin_commute(i8 %a, i8 %b) {
 ; CHECK-LABEL: @umin_commute(
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp ult i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
 ; CHECK-NEXT:    ret i8 0
 ;
   %cmp1 = icmp ult i8 %a, %b
;
   %cmp1 = icmp ugt <2 x i8> %a, %b
   %cmp2 = icmp ult <2 x i8> %a, %b
   %m1 = select <2 x i1> %cmp1, <2 x i8> %b, <2 x i8> %a
   %m2 = select <2 x i1> %cmp2, <2 x i8> %a, <2 x i8> %b
   %r = sub <2 x i8> %m2, %m1
   ret <2 x i8> %r
 }
 
+define i1 @umin_inverted(i8 %a, i8 %b) {
+; CHECK-LABEL: @umin_inverted(
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ult i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = xor i1 [[CMP1]], true
+; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
+; CHECK-NEXT:    ret i1 true
+;
+  %cmp1 = icmp ult i8 %a, %b
+  %cmp2 = xor i1 %cmp1, -1
+  %m1 = select i1 %cmp1, i8 %a, i8 %b
+  %m2 = select i1 %cmp2, i8 %b, i8 %a
+  %r = icmp eq i8 %m1, %m2
+  ret i1 %r
+}
+
 define i8 @umax_commute(i8 %a, i8 %b) {
 ; CHECK-LABEL: @umax_commute(
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp ugt i8 [[B]], [[A]]
 ; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
 ; CHECK-NEXT:    ret i8 1
 ;
   %cmp1 = icmp ugt i8 %a, %b
;
   %cmp1 = icmp ult i8 %a, %b
   %cmp2 = icmp ugt i8 %a, %b
   %m1 = select i1 %cmp1, i8 %b, i8 %a
   %m2 = select i1 %cmp2, i8 %a, i8 %b
   %r = add i8 %m2, %m1
   ret i8 %r
 }
 
+define i1 @umax_inverted(i8 %a, i8 %b) {
+; CHECK-LABEL: @umax_inverted(
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp ugt i8 [[A:%.*]], [[B:%.*]]
+; CHECK-NEXT:    [[CMP2:%.*]] = xor i1 [[CMP1]], true
+; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[B]]
+; CHECK-NEXT:    ret i1 true
+;
+  %cmp1 = icmp ugt i8 %a, %b
+  %cmp2 = xor i1 %cmp1, -1
+  %m1 = select i1 %cmp1, i8 %a, i8 %b
+  %m2 = select i1 %cmp2, i8 %b, i8 %a
+  %r = icmp eq i8 %m1, %m2
+  ret i1 %r
+}
+
 ; Min/max may exist with non-canonical operands. Value tracking can match those.
 
 define i8 @smax_nsw(i8 %a, i8 %b) {
 ; CHECK-LABEL: @smax_nsw(
 ; CHECK-NEXT:    [[SUB:%.*]] = sub nsw i8 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A]], [[B]]
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[SUB]], 0
 ; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 0, i8 [[SUB]]
;
   %cmp1 = icmp sgt i8 %a, 0
   %cmp2 = icmp slt i8 %a, 0
   %m1 = select i1 %cmp1, i8 %a, i8 %neg
   %m2 = select i1 %cmp2, i8 %neg, i8 %a
   %r = or i8 %m2, %m1
   ret i8 %r
 }
 
+define i8 @abs_inverted(i8 %a) {
+; CHECK-LABEL: @abs_inverted(
+; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[A:%.*]]
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A]], 0
+; CHECK-NEXT:    [[CMP2:%.*]] = xor i1 [[CMP1]], true
+; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[NEG]]
+; CHECK-NEXT:    ret i8 [[M1]]
+;
+  %neg = sub i8 0, %a
+  %cmp1 = icmp sgt i8 %a, 0
+  %cmp2 = xor i1 %cmp1, -1
+  %m1 = select i1 %cmp1, i8 %a, i8 %neg
+  %m2 = select i1 %cmp2, i8 %neg, i8 %a
+  %r = or i8 %m2, %m1
+  ret i8 %r
+}
+
 define i8 @nabs_swapped(i8 %a) {
 ; CHECK-LABEL: @nabs_swapped(
 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[A:%.*]]
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A]], 0
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp sgt i8 [[A]], 0
 ; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[NEG]]
 ; CHECK-NEXT:    ret i8 0
 ;
   %neg = sub i8 0, %a
   %cmp1 = icmp slt i8 %a, 0
   %cmp2 = icmp sgt i8 %a, 0
   %m1 = select i1 %cmp1, i8 %a, i8 %neg
   %m2 = select i1 %cmp2, i8 %neg, i8 %a
   %r = xor i8 %m2, %m1
   ret i8 %r
 }
 
+define i8 @nabs_inverted(i8 %a) {
+; CHECK-LABEL: @nabs_inverted(
+; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[A:%.*]]
+; CHECK-NEXT:    [[CMP1:%.*]] = icmp slt i8 [[A]], 0
+; CHECK-NEXT:    [[CMP2:%.*]] = xor i1 [[CMP1]], true
+; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[NEG]]
+; CHECK-NEXT:    ret i8 0
+;
+  %neg = sub i8 0, %a
+  %cmp1 = icmp slt i8 %a, 0
+  %cmp2 = xor i1 %cmp1, -1
+  %m1 = select i1 %cmp1, i8 %a, i8 %neg
+  %m2 = select i1 %cmp2, i8 %neg, i8 %a
+  %r = xor i8 %m2, %m1
+  ret i8 %r
+}
+
 ; These two tests make sure we still consider it a match when the RHS of the
 ; compares are different.
 define i8 @abs_different_constants(i8 %a) {
 ; CHECK-LABEL: @abs_different_constants(
 ; CHECK-NEXT:    [[NEG:%.*]] = sub i8 0, [[A:%.*]]
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp sgt i8 [[A]], -1
 ; CHECK-NEXT:    [[CMP2:%.*]] = icmp slt i8 [[A]], 0
 ; CHECK-NEXT:    [[M1:%.*]] = select i1 [[CMP1]], i8 [[A]], i8 [[NEG]]
;
   %invcond = icmp ule i8 %x, %y
   %not = xor i1 %invcond, -1
   %m2 = select i1 %not, i32 %t, i32 %f
   %cond = icmp ugt i8 %x, %y
   %m1 = select i1 %cond, i32 %f, i32 %t
   %r = sub i32 %m2, %m1
   ret i32 %r
 }
+
+
+; This test is a reproducer for a bug involving inverted min/max selects
+; hashing differently but comparing as equal.  It generates several equivalent
+; pairs with the intent that eventually the hash table will fill enough for
+; the probe paths of an equivalent pair to collide and the hash mismatch
+; to be noticed.  It also includes a negation of each negation to check for
+; the same issue one level deeper.
+define void @many_min_max(i32* %px, i32* %py, i32* %pout) {
+
+  %x1 = load volatile i32, i32* %px
+  %y1 = load volatile i32, i32* %py
+  %cmp1a = icmp slt i32 %x1, %y1
+  %cmp1b = xor i1 %cmp1a, -1
+  %cmp1c = xor i1 %cmp1b, -1
+  %r1a = select i1 %cmp1a, i32 %x1, i32 %y1
+  %r1b = select i1 %cmp1b, i32 %y1, i32 %x1
+  %r1c = select i1 %cmp1c, i32 %x1, i32 %y1
+  store volatile i32 %r1a, i32* %pout
+  store volatile i32 %r1b, i32* %pout
+  store volatile i32 %r1c, i32* %pout
+
+  %x2 = load volatile i32, i32* %px
+  %y2 = load volatile i32, i32* %py
+  %cmp2a = icmp sgt i32 %x2, %y2
+  %cmp2b = xor i1 %cmp2a, -1
+  %cmp2c = xor i1 %cmp2b, -1
+  %r2a = select i1 %cmp2a, i32 %x2, i32 %y2
+  %r2b = select i1 %cmp2b, i32 %y2, i32 %x2
+  %r2c = select i1 %cmp2c, i32 %x2, i32 %y2
+  store volatile i32 %r2a, i32* %pout
+  store volatile i32 %r2b, i32* %pout
+  store volatile i32 %r2c, i32* %pout
+
+  %x3 = load volatile i32, i32* %px
+  %y3 = load volatile i32, i32* %py
+  %cmp3a = icmp slt i32 %x3, %y3
+  %cmp3b = xor i1 %cmp3a, -1
+  %cmp3c = xor i1 %cmp3b, -1
+  %r3a = select i1 %cmp3a, i32 %x3, i32 %y3
+  %r3b = select i1 %cmp3b, i32 %y3, i32 %x3
+  %r3c = select i1 %cmp3c, i32 %x3, i32 %y3
+  store volatile i32 %r3a, i32* %pout
+  store volatile i32 %r3b, i32* %pout
+  store volatile i32 %r3c, i32* %pout
+
+  %x4 = load volatile i32, i32* %px
+  %y4 = load volatile i32, i32* %py
+  %cmp4a = icmp sgt i32 %x4, %y4
+  %cmp4b = xor i1 %cmp4a, -1
+  %cmp4c = xor i1 %cmp4b, -1
+  %r4a = select i1 %cmp4a, i32 %x4, i32 %y4
+  %r4b = select i1 %cmp4b, i32 %y4, i32 %x4
+  %r4c = select i1 %cmp4c, i32 %x4, i32 %y4
+  store volatile i32 %r4a, i32* %pout
+  store volatile i32 %r4b, i32* %pout
+  store volatile i32 %r4c, i32* %pout
+
+  %x5 = load volatile i32, i32* %px
+  %y5 = load volatile i32, i32* %py
+  %cmp5a = icmp slt i32 %x5, %y5
+  %cmp5b = xor i1 %cmp5a, -1
+  %cmp5c = xor i1 %cmp5b, -1
+  %r5a = select i1 %cmp5a, i32 %x5, i32 %y5
+  %r5b = select i1 %cmp5b, i32 %y5, i32 %x5
+  %r5c = select i1 %cmp5c, i32 %x5, i32 %y5
+  store volatile i32 %r5a, i32* %pout
+  store volatile i32 %r5b, i32* %pout
+  store volatile i32 %r5c, i32* %pout
+
+  %x6 = load volatile i32, i32* %px
+  %y6 = load volatile i32, i32* %py
+  %cmp6a = icmp sgt i32 %x6, %y6
+  %cmp6b = xor i1 %cmp6a, -1
+  %cmp6c = xor i1 %cmp6b, -1
+  %r6a = select i1 %cmp6a, i32 %x6, i32 %y6
+  %r6b = select i1 %cmp6b, i32 %y6, i32 %x6
+  %r6c = select i1 %cmp6c, i32 %x6, i32 %y6
+  store volatile i32 %r6a, i32* %pout
+  store volatile i32 %r6b, i32* %pout
+  store volatile i32 %r6c, i32* %pout
+
+  %x7 = load volatile i32, i32* %px
+  %y7 = load volatile i32, i32* %py
+  %cmp7a = icmp slt i32 %x7, %y7
+  %cmp7b = xor i1 %cmp7a, -1
+  %cmp7c = xor i1 %cmp7b, -1
+  %r7a = select i1 %cmp7a, i32 %x7, i32 %y7
+  %r7b = select i1 %cmp7b, i32 %y7, i32 %x7
+  %r7c = select i1 %cmp7c, i32 %x7, i32 %y7
+  store volatile i32 %r7a, i32* %pout
+  store volatile i32 %r7b, i32* %pout
+  store volatile i32 %r7c, i32* %pout
+
+  %x8 = load volatile i32, i32* %px
+  %y8 = load volatile i32, i32* %py
+  %cmp8a = icmp sgt i32 %x8, %y8
+  %cmp8b = xor i1 %cmp8a, -1
+  %cmp8c = xor i1 %cmp8b, -1
+  %r8a = select i1 %cmp8a, i32 %x8, i32 %y8
+  %r8b = select i1 %cmp8b, i32 %y8, i32 %x8
+  %r8c = select i1 %cmp8c, i32 %x8, i32 %y8
+  store volatile i32 %r8a, i32* %pout
+  store volatile i32 %r8b, i32* %pout
+  store volatile i32 %r8c, i32* %pout
+
+  %x9 = load volatile i32, i32* %px
+  %y9 = load volatile i32, i32* %py
+  %cmp9a = icmp slt i32 %x9, %y9
+  %cmp9b = xor i1 %cmp9a, -1
+  %cmp9c = xor i1 %cmp9b, -1
+  %r9a = select i1 %cmp9a, i32 %x9, i32 %y9
+  %r9b = select i1 %cmp9b, i32 %y9, i32 %x9
+  %r9c = select i1 %cmp9c, i32 %x9, i32 %y9
+  store volatile i32 %r9a, i32* %pout
+  store volatile i32 %r9b, i32* %pout
+  store volatile i32 %r9c, i32* %pout
+
+  %x10 = load volatile i32, i32* %px
+  %y10 = load volatile i32, i32* %py
+  %cmp10a = icmp sgt i32 %x10, %y10
+  %cmp10b = xor i1 %cmp10a, -1
+  %cmp10c = xor i1 %cmp10b, -1
+  %r10a = select i1 %cmp10a, i32 %x10, i32 %y10
+  %r10b = select i1 %cmp10b, i32 %y10, i32 %x10
+  %r10c = select i1 %cmp10c, i32 %x10, i32 %y10
+  store volatile i32 %r10a, i32* %pout
+  store volatile i32 %r10b, i32* %pout
+  store volatile i32 %r10c, i32* %pout
+
+  %x11 = load volatile i32, i32* %px
+  %y11 = load volatile i32, i32* %py
+  %cmp11a = icmp slt i32 %x11, %y11
+  %cmp11b = xor i1 %cmp11a, -1
+  %cmp11c = xor i1 %cmp11b, -1
+  %r11a = select i1 %cmp11a, i32 %x11, i32 %y11
+  %r11b = select i1 %cmp11b, i32 %y11, i32 %x11
+  %r11c = select i1 %cmp11c, i32 %x11, i32 %y11
+  store volatile i32 %r11a, i32* %pout
+  store volatile i32 %r11b, i32* %pout
+  store volatile i32 %r11c, i32* %pout
+
+  %x12 = load volatile i32, i32* %px
+  %y12 = load volatile i32, i32* %py
+  %cmp12a = icmp sgt i32 %x12, %y12
+  %cmp12b = xor i1 %cmp12a, -1
+  %cmp12c = xor i1 %cmp12b, -1
+  %r12a = select i1 %cmp12a, i32 %x12, i32 %y12
+  %r12b = select i1 %cmp12b, i32 %y12, i32 %x12
+  %r12c = select i1 %cmp12c, i32 %x12, i32 %y12
+  store volatile i32 %r12a, i32* %pout
+  store volatile i32 %r12b, i32* %pout
+  store volatile i32 %r12c, i32* %pout
+
+  %x13 = load volatile i32, i32* %px
+  %y13 = load volatile i32, i32* %py
+  %cmp13a = icmp slt i32 %x13, %y13
+  %cmp13b = xor i1 %cmp13a, -1
+  %cmp13c = xor i1 %cmp13b, -1
+  %r13a = select i1 %cmp13a, i32 %x13, i32 %y13
+  %r13b = select i1 %cmp13b, i32 %y13, i32 %x13
+  %r13c = select i1 %cmp13c, i32 %x13, i32 %y13
+  store volatile i32 %r13a, i32* %pout
+  store volatile i32 %r13b, i32* %pout
+  store volatile i32 %r13c, i32* %pout
+
+  %x14 = load volatile i32, i32* %px
+  %y14 = load volatile i32, i32* %py
+  %cmp14a = icmp sgt i32 %x14, %y14
+  %cmp14b = xor i1 %cmp14a, -1
+  %cmp14c = xor i1 %cmp14b, -1
+  %r14a = select i1 %cmp14a, i32 %x14, i32 %y14
+  %r14b = select i1 %cmp14b, i32 %y14, i32 %x14
+  %r14c = select i1 %cmp14c, i32 %x14, i32 %y14
+  store volatile i32 %r14a, i32* %pout
+  store volatile i32 %r14b, i32* %pout
+  store volatile i32 %r14c, i32* %pout
+
+  %x15 = load volatile i32, i32* %px
+  %y15 = load volatile i32, i32* %py
+  %cmp15a = icmp slt i32 %x15, %y15
+  %cmp15b = xor i1 %cmp15a, -1
+  %cmp15c = xor i1 %cmp15b, -1
+  %r15a = select i1 %cmp15a, i32 %x15, i32 %y15
+  %r15b = select i1 %cmp15b, i32 %y15, i32 %x15
+  %r15c = select i1 %cmp15c, i32 %x15, i32 %y15
+  store volatile i32 %r15a, i32* %pout
+  store volatile i32 %r15b, i32* %pout
+  store volatile i32 %r15c, i32* %pout
+
+  %x16 = load volatile i32, i32* %px
+  %y16 = load volatile i32, i32* %py
+  %cmp16a = icmp sgt i32 %x16, %y16
+  %cmp16b = xor i1 %cmp16a, -1
+  %cmp16c = xor i1 %cmp16b, -1
+  %r16a = select i1 %cmp16a, i32 %x16, i32 %y16
+  %r16b = select i1 %cmp16b, i32 %y16, i32 %x16
+  %r16c = select i1 %cmp16c, i32 %x16, i32 %y16
+  store volatile i32 %r16a, i32* %pout
+  store volatile i32 %r16b, i32* %pout
+  store volatile i32 %r16c, i32* %pout
+
+  %x17 = load volatile i32, i32* %px
+  %y17 = load volatile i32, i32* %py
+  %cmp17a = icmp slt i32 %x17, %y17
+  %cmp17b = xor i1 %cmp17a, -1
+  %cmp17c = xor i1 %cmp17b, -1
+  %r17a = select i1 %cmp17a, i32 %x17, i32 %y17
+  %r17b = select i1 %cmp17b, i32 %y17, i32 %x17
+  %r17c = select i1 %cmp17c, i32 %x17, i32 %y17
+  store volatile i32 %r17a, i32* %pout
+  store volatile i32 %r17b, i32* %pout
+  store volatile i32 %r17c, i32* %pout
+
+  %x18 = load volatile i32, i32* %px
+  %y18 = load volatile i32, i32* %py
+  %cmp18a = icmp sgt i32 %x18, %y18
+  %cmp18b = xor i1 %cmp18a, -1
+  %cmp18c = xor i1 %cmp18b, -1
+  %r18a = select i1 %cmp18a, i32 %x18, i32 %y18
+  %r18b = select i1 %cmp18b, i32 %y18, i32 %x18
+  %r18c = select i1 %cmp18c, i32 %x18, i32 %y18
+  store volatile i32 %r18a, i32* %pout
+  store volatile i32 %r18b, i32* %pout
+  store volatile i32 %r18c, i32* %pout
+
+  %x19 = load volatile i32, i32* %px
+  %y19 = load volatile i32, i32* %py
+  %cmp19a = icmp slt i32 %x19, %y19
+  %cmp19b = xor i1 %cmp19a, -1
+  %cmp19c = xor i1 %cmp19b, -1
+  %r19a = select i1 %cmp19a, i32 %x19, i32 %y19
+  %r19b = select i1 %cmp19b, i32 %y19, i32 %x19
+  %r19c = select i1 %cmp19c, i32 %x19, i32 %y19
+  store volatile i32 %r19a, i32* %pout
+  store volatile i32 %r19b, i32* %pout
+  store volatile i32 %r19c, i32* %pout
+
+  %x20 = load volatile i32, i32* %px
+  %y20 = load volatile i32, i32* %py
+  %cmp20a = icmp sgt i32 %x20, %y20
+  %cmp20b = xor i1 %cmp20a, -1
+  %cmp20c = xor i1 %cmp20b, -1
+  %r20a = select i1 %cmp20a, i32 %x20, i32 %y20
+  %r20b = select i1 %cmp20b, i32 %y20, i32 %x20
+  %r20c = select i1 %cmp20c, i32 %x20, i32 %y20
+  store volatile i32 %r20a, i32* %pout
+  store volatile i32 %r20b, i32* %pout
+  store volatile i32 %r20c, i32* %pout
+
+  %x21 = load volatile i32, i32* %px
+  %y21 = load volatile i32, i32* %py
+  %cmp21a = icmp slt i32 %x21, %y21
+  %cmp21b = xor i1 %cmp21a, -1
+  %cmp21c = xor i1 %cmp21b, -1
+  %r21a = select i1 %cmp21a, i32 %x21, i32 %y21
+  %r21b = select i1 %cmp21b, i32 %y21, i32 %x21
+  %r21c = select i1 %cmp21c, i32 %x21, i32 %y21
+  store volatile i32 %r21a, i32* %pout
+  store volatile i32 %r21b, i32* %pout
+  store volatile i32 %r21c, i32* %pout
+
+  %x22 = load volatile i32, i32* %px
+  %y22 = load volatile i32, i32* %py
+  %cmp22a = icmp sgt i32 %x22, %y22
+  %cmp22b = xor i1 %cmp22a, -1
+  %cmp22c = xor i1 %cmp22b, -1
+  %r22a = select i1 %cmp22a, i32 %x22, i32 %y22
+  %r22b = select i1 %cmp22b, i32 %y22, i32 %x22
+  %r22c = select i1 %cmp22c, i32 %x22, i32 %y22
+  store volatile i32 %r22a, i32* %pout
+  store volatile i32 %r22b, i32* %pout
+  store volatile i32 %r22c, i32* %pout
+
+  %x23 = load volatile i32, i32* %px
+  %y23 = load volatile i32, i32* %py
+  %cmp23a = icmp slt i32 %x23, %y23
+  %cmp23b = xor i1 %cmp23a, -1
+  %cmp23c = xor i1 %cmp23b, -1
+  %r23a = select i1 %cmp23a, i32 %x23, i32 %y23
+  %r23b = select i1 %cmp23b, i32 %y23, i32 %x23
+  %r23c = select i1 %cmp23c, i32 %x23, i32 %y23
+  store volatile i32 %r23a, i32* %pout
+  store volatile i32 %r23b, i32* %pout
+  store volatile i32 %r23c, i32* %pout
+
+  %x24 = load volatile i32, i32* %px
+  %y24 = load volatile i32, i32* %py
+  %cmp24a = icmp sgt i32 %x24, %y24
+  %cmp24b = xor i1 %cmp24a, -1
+  %cmp24c = xor i1 %cmp24b, -1
+  %r24a = select i1 %cmp24a, i32 %x24, i32 %y24
+  %r24b = select i1 %cmp24b, i32 %y24, i32 %x24
+  %r24c = select i1 %cmp24c, i32 %x24, i32 %y24
+  store volatile i32 %r24a, i32* %pout
+  store volatile i32 %r24b, i32* %pout
+  store volatile i32 %r24c, i32* %pout
+
+  %x25 = load volatile i32, i32* %px
+  %y25 = load volatile i32, i32* %py
+  %cmp25a = icmp slt i32 %x25, %y25
+  %cmp25b = xor i1 %cmp25a, -1
+  %cmp25c = xor i1 %cmp25b, -1
+  %r25a = select i1 %cmp25a, i32 %x25, i32 %y25
+  %r25b = select i1 %cmp25b, i32 %y25, i32 %x25
+  %r25c = select i1 %cmp25c, i32 %x25, i32 %y25
+  store volatile i32 %r25a, i32* %pout
+  store volatile i32 %r25b, i32* %pout
+  store volatile i32 %r25c, i32* %pout
+
+  %x26 = load volatile i32, i32* %px
+  %y26 = load volatile i32, i32* %py
+  %cmp26a = icmp sgt i32 %x26, %y26
+  %cmp26b = xor i1 %cmp26a, -1
+  %cmp26c = xor i1 %cmp26b, -1
+  %r26a = select i1 %cmp26a, i32 %x26, i32 %y26
+  %r26b = select i1 %cmp26b, i32 %y26, i32 %x26
+  %r26c = select i1 %cmp26c, i32 %x26, i32 %y26
+  store volatile i32 %r26a, i32* %pout
+  store volatile i32 %r26b, i32* %pout
+  store volatile i32 %r26c, i32* %pout
+
+  %x27 = load volatile i32, i32* %px
+  %y27 = load volatile i32, i32* %py
+  %cmp27a = icmp slt i32 %x27, %y27
+  %cmp27b = xor i1 %cmp27a, -1
+  %cmp27c = xor i1 %cmp27b, -1
+  %r27a = select i1 %cmp27a, i32 %x27, i32 %y27
+  %r27b = select i1 %cmp27b, i32 %y27, i32 %x27
+  %r27c = select i1 %cmp27c, i32 %x27, i32 %y27
+  store volatile i32 %r27a, i32* %pout
+  store volatile i32 %r27b, i32* %pout
+  store volatile i32 %r27c, i32* %pout
+
+  %x28 = load volatile i32, i32* %px
+  %y28 = load volatile i32, i32* %py
+  %cmp28a = icmp sgt i32 %x28, %y28
+  %cmp28b = xor i1 %cmp28a, -1
+  %cmp28c = xor i1 %cmp28b, -1
+  %r28a = select i1 %cmp28a, i32 %x28, i32 %y28
+  %r28b = select i1 %cmp28b, i32 %y28, i32 %x28
+  %r28c = select i1 %cmp28c, i32 %x28, i32 %y28
+  store volatile i32 %r28a, i32* %pout
+  store volatile i32 %r28b, i32* %pout
+  store volatile i32 %r28c, i32* %pout
+
+  %x29 = load volatile i32, i32* %px
+  %y29 = load volatile i32, i32* %py
+  %cmp29a = icmp slt i32 %x29, %y29
+  %cmp29b = xor i1 %cmp29a, -1
+  %cmp29c = xor i1 %cmp29b, -1
+  %r29a = select i1 %cmp29a, i32 %x29, i32 %y29
+  %r29b = select i1 %cmp29b, i32 %y29, i32 %x29
+  %r29c = select i1 %cmp29c, i32 %x29, i32 %y29
+  store volatile i32 %r29a, i32* %pout
+  store volatile i32 %r29b, i32* %pout
+  store volatile i32 %r29c, i32* %pout
+
+  %x30 = load volatile i32, i32* %px
+  %y30 = load volatile i32, i32* %py
+  %cmp30a = icmp sgt i32 %x30, %y30
+  %cmp30b = xor i1 %cmp30a, -1
+  %cmp30c = xor i1 %cmp30b, -1
+  %r30a = select i1 %cmp30a, i32 %x30, i32 %y30
+  %r30b = select i1 %cmp30b, i32 %y30, i32 %x30
+  %r30c = select i1 %cmp30c, i32 %x30, i32 %y30
+  store volatile i32 %r30a, i32* %pout
+  store volatile i32 %r30b, i32* %pout
+  store volatile i32 %r30c, i32* %pout
+
+  %x31 = load volatile i32, i32* %px
+  %y31 = load volatile i32, i32* %py
+  %cmp31a = icmp slt i32 %x31, %y31
+  %cmp31b = xor i1 %cmp31a, -1
+  %cmp31c = xor i1 %cmp31b, -1
+  %r31a = select i1 %cmp31a, i32 %x31, i32 %y31
+  %r31b = select i1 %cmp31b, i32 %y31, i32 %x31
+  %r31c = select i1 %cmp31c, i32 %x31, i32 %y31
+  store volatile i32 %r31a, i32* %pout
+  store volatile i32 %r31b, i32* %pout
+  store volatile i32 %r31c, i32* %pout
+
+  %x32 = load volatile i32, i32* %px
+  %y32 = load volatile i32, i32* %py
+  %cmp32a = icmp sgt i32 %x32, %y32
+  %cmp32b = xor i1 %cmp32a, -1
+  %cmp32c = xor i1 %cmp32b, -1
+  %r32a = select i1 %cmp32a, i32 %x32, i32 %y32
+  %r32b = select i1 %cmp32b, i32 %y32, i32 %x32
+  %r32c = select i1 %cmp32c, i32 %x32, i32 %y32
+  store volatile i32 %r32a, i32* %pout
+  store volatile i32 %r32b, i32* %pout
+  store volatile i32 %r32c, i32* %pout
+
+  %x33 = load volatile i32, i32* %px
+  %y33 = load volatile i32, i32* %py
+  %cmp33a = icmp slt i32 %x33, %y33
+  %cmp33b = xor i1 %cmp33a, -1
+  %cmp33c = xor i1 %cmp33b, -1
+  %r33a = select i1 %cmp33a, i32 %x33, i32 %y33
+  %r33b = select i1 %cmp33b, i32 %y33, i32 %x33
+  %r33c = select i1 %cmp33c, i32 %x33, i32 %y33
+  store volatile i32 %r33a, i32* %pout
+  store volatile i32 %r33b, i32* %pout
+  store volatile i32 %r33c, i32* %pout
+
+  %x34 = load volatile i32, i32* %px
+  %y34 = load volatile i32, i32* %py
+  %cmp34a = icmp sgt i32 %x34, %y34
+  %cmp34b = xor i1 %cmp34a, -1
+  %cmp34c = xor i1 %cmp34b, -1
+  %r34a = select i1 %cmp34a, i32 %x34, i32 %y34
+  %r34b = select i1 %cmp34b, i32 %y34, i32 %x34
+  %r34c = select i1 %cmp34c, i32 %x34, i32 %y34
+  store volatile i32 %r34a, i32* %pout
+  store volatile i32 %r34b, i32* %pout
+  store volatile i32 %r34c, i32* %pout
+
+  %x35 = load volatile i32, i32* %px
+  %y35 = load volatile i32, i32* %py
+  %cmp35a = icmp slt i32 %x35, %y35
+  %cmp35b = xor i1 %cmp35a, -1
+  %cmp35c = xor i1 %cmp35b, -1
+  %r35a = select i1 %cmp35a, i32 %x35, i32 %y35
+  %r35b = select i1 %cmp35b, i32 %y35, i32 %x35
+  %r35c = select i1 %cmp35c, i32 %x35, i32 %y35
+  store volatile i32 %r35a, i32* %pout
+  store volatile i32 %r35b, i32* %pout
+  store volatile i32 %r35c, i32* %pout
+
+  %x36 = load volatile i32, i32* %px
+  %y36 = load volatile i32, i32* %py
+  %cmp36a = icmp sgt i32 %x36, %y36
+  %cmp36b = xor i1 %cmp36a, -1
+  %cmp36c = xor i1 %cmp36b, -1
+  %r36a = select i1 %cmp36a, i32 %x36, i32 %y36
+  %r36b = select i1 %cmp36b, i32 %y36, i32 %x36
+  %r36c = select i1 %cmp36c, i32 %x36, i32 %y36
+  store volatile i32 %r36a, i32* %pout
+  store volatile i32 %r36b, i32* %pout
+  store volatile i32 %r36c, i32* %pout
+
+  %x37 = load volatile i32, i32* %px
+  %y37 = load volatile i32, i32* %py
+  %cmp37a = icmp slt i32 %x37, %y37
+  %cmp37b = xor i1 %cmp37a, -1
+  %cmp37c = xor i1 %cmp37b, -1
+  %r37a = select i1 %cmp37a, i32 %x37, i32 %y37
+  %r37b = select i1 %cmp37b, i32 %y37, i32 %x37
+  %r37c = select i1 %cmp37c, i32 %x37, i32 %y37
+  store volatile i32 %r37a, i32* %pout
+  store volatile i32 %r37b, i32* %pout
+  store volatile i32 %r37c, i32* %pout
+
+  %x38 = load volatile i32, i32* %px
+  %y38 = load volatile i32, i32* %py
+  %cmp38a = icmp sgt i32 %x38, %y38
+  %cmp38b = xor i1 %cmp38a, -1
+  %cmp38c = xor i1 %cmp38b, -1
+  %r38a = select i1 %cmp38a, i32 %x38, i32 %y38
+  %r38b = select i1 %cmp38b, i32 %y38, i32 %x38
+  %r38c = select i1 %cmp38c, i32 %x38, i32 %y38
+  store volatile i32 %r38a, i32* %pout
+  store volatile i32 %r38b, i32* %pout
+  store volatile i32 %r38c, i32* %pout
+
+  %x39 = load volatile i32, i32* %px
+  %y39 = load volatile i32, i32* %py
+  %cmp39a = icmp slt i32 %x39, %y39
+  %cmp39b = xor i1 %cmp39a, -1
+  %cmp39c = xor i1 %cmp39b, -1
+  %r39a = select i1 %cmp39a, i32 %x39, i32 %y39
+  %r39b = select i1 %cmp39b, i32 %y39, i32 %x39
+  %r39c = select i1 %cmp39c, i32 %x39, i32 %y39
+  store volatile i32 %r39a, i32* %pout
+  store volatile i32 %r39b, i32* %pout
+  store volatile i32 %r39c, i32* %pout
+
+  %x40 = load volatile i32, i32* %px
+  %y40 = load volatile i32, i32* %py
+  %cmp40a = icmp sgt i32 %x40, %y40
+  %cmp40b = xor i1 %cmp40a, -1
+  %cmp40c = xor i1 %cmp40b, -1
+  %r40a = select i1 %cmp40a, i32 %x40, i32 %y40
+  %r40b = select i1 %cmp40b, i32 %y40, i32 %x40
+  %r40c = select i1 %cmp40c, i32 %x40, i32 %y40
+  store volatile i32 %r40a, i32* %pout
+  store volatile i32 %r40b, i32* %pout
+  store volatile i32 %r40c, i32* %pout
+
+  %x41 = load volatile i32, i32* %px
+  %y41 = load volatile i32, i32* %py
+  %cmp41a = icmp slt i32 %x41, %y41
+  %cmp41b = xor i1 %cmp41a, -1
+  %cmp41c = xor i1 %cmp41b, -1
+  %r41a = select i1 %cmp41a, i32 %x41, i32 %y41
+  %r41b = select i1 %cmp41b, i32 %y41, i32 %x41
+  %r41c = select i1 %cmp41c, i32 %x41, i32 %y41
+  store volatile i32 %r41a, i32* %pout
+  store volatile i32 %r41b, i32* %pout
+  store volatile i32 %r41c, i32* %pout
+
+  %x42 = load volatile i32, i32* %px
+  %y42 = load volatile i32, i32* %py
+  %cmp42a = icmp sgt i32 %x42, %y42
+  %cmp42b = xor i1 %cmp42a, -1
+  %cmp42c = xor i1 %cmp42b, -1
+  %r42a = select i1 %cmp42a, i32 %x42, i32 %y42
+  %r42b = select i1 %cmp42b, i32 %y42, i32 %x42
+  %r42c = select i1 %cmp42c, i32 %x42, i32 %y42
+  store volatile i32 %r42a, i32* %pout
+  store volatile i32 %r42b, i32* %pout
+  store volatile i32 %r42c, i32* %pout
+
+  %x43 = load volatile i32, i32* %px
+  %y43 = load volatile i32, i32* %py
+  %cmp43a = icmp slt i32 %x43, %y43
+  %cmp43b = xor i1 %cmp43a, -1
+  %cmp43c = xor i1 %cmp43b, -1
+  %r43a = select i1 %cmp43a, i32 %x43, i32 %y43
+  %r43b = select i1 %cmp43b, i32 %y43, i32 %x43
+  %r43c = select i1 %cmp43c, i32 %x43, i32 %y43
+  store volatile i32 %r43a, i32* %pout
+  store volatile i32 %r43b, i32* %pout
+  store volatile i32 %r43c, i32* %pout
+
+  %x44 = load volatile i32, i32* %px
+  %y44 = load volatile i32, i32* %py
+  %cmp44a = icmp sgt i32 %x44, %y44
+  %cmp44b = xor i1 %cmp44a, -1
+  %cmp44c = xor i1 %cmp44b, -1
+  %r44a = select i1 %cmp44a, i32 %x44, i32 %y44
+  %r44b = select i1 %cmp44b, i32 %y44, i32 %x44
+  %r44c = select i1 %cmp44c, i32 %x44, i32 %y44
+  store volatile i32 %r44a, i32* %pout
+  store volatile i32 %r44b, i32* %pout
+  store volatile i32 %r44c, i32* %pout
+
+  %x45 = load volatile i32, i32* %px
+  %y45 = load volatile i32, i32* %py
+  %cmp45a = icmp slt i32 %x45, %y45
+  %cmp45b = xor i1 %cmp45a, -1
+  %cmp45c = xor i1 %cmp45b, -1
+  %r45a = select i1 %cmp45a, i32 %x45, i32 %y45
+  %r45b = select i1 %cmp45b, i32 %y45, i32 %x45
+  %r45c = select i1 %cmp45c, i32 %x45, i32 %y45
+  store volatile i32 %r45a, i32* %pout
+  store volatile i32 %r45b, i32* %pout
+  store volatile i32 %r45c, i32* %pout
+
+  %x46 = load volatile i32, i32* %px
+  %y46 = load volatile i32, i32* %py
+  %cmp46a = icmp sgt i32 %x46, %y46
+  %cmp46b = xor i1 %cmp46a, -1
+  %cmp46c = xor i1 %cmp46b, -1
+  %r46a = select i1 %cmp46a, i32 %x46, i32 %y46
+  %r46b = select i1 %cmp46b, i32 %y46, i32 %x46
+  %r46c = select i1 %cmp46c, i32 %x46, i32 %y46
+  store volatile i32 %r46a, i32* %pout
+  store volatile i32 %r46b, i32* %pout
+  store volatile i32 %r46c, i32* %pout
+
+  %x47 = load volatile i32, i32* %px
+  %y47 = load volatile i32, i32* %py
+  %cmp47a = icmp slt i32 %x47, %y47
+  %cmp47b = xor i1 %cmp47a, -1
+  %cmp47c = xor i1 %cmp47b, -1
+  %r47a = select i1 %cmp47a, i32 %x47, i32 %y47
+  %r47b = select i1 %cmp47b, i32 %y47, i32 %x47
+  %r47c = select i1 %cmp47c, i32 %x47, i32 %y47
+  store volatile i32 %r47a, i32* %pout
+  store volatile i32 %r47b, i32* %pout
+  store volatile i32 %r47c, i32* %pout
+
+  %x48 = load volatile i32, i32* %px
+  %y48 = load volatile i32, i32* %py
+  %cmp48a = icmp sgt i32 %x48, %y48
+  %cmp48b = xor i1 %cmp48a, -1
+  %cmp48c = xor i1 %cmp48b, -1
+  %r48a = select i1 %cmp48a, i32 %x48, i32 %y48
+  %r48b = select i1 %cmp48b, i32 %y48, i32 %x48
+  %r48c = select i1 %cmp48c, i32 %x48, i32 %y48
+  store volatile i32 %r48a, i32* %pout
+  store volatile i32 %r48b, i32* %pout
+  store volatile i32 %r48c, i32* %pout
+
+  %x49 = load volatile i32, i32* %px
+  %y49 = load volatile i32, i32* %py
+  %cmp49a = icmp slt i32 %x49, %y49
+  %cmp49b = xor i1 %cmp49a, -1
+  %cmp49c = xor i1 %cmp49b, -1
+  %r49a = select i1 %cmp49a, i32 %x49, i32 %y49
+  %r49b = select i1 %cmp49b, i32 %y49, i32 %x49
+  %r49c = select i1 %cmp49c, i32 %x49, i32 %y49
+  store volatile i32 %r49a, i32* %pout
+  store volatile i32 %r49b, i32* %pout
+  store volatile i32 %r49c, i32* %pout
+
+  %x50 = load volatile i32, i32* %px
+  %y50 = load volatile i32, i32* %py
+  %cmp50a = icmp sgt i32 %x50, %y50
+  %cmp50b = xor i1 %cmp50a, -1
+  %cmp50c = xor i1 %cmp50b, -1
+  %r50a = select i1 %cmp50a, i32 %x50, i32 %y50
+  %r50b = select i1 %cmp50b, i32 %y50, i32 %x50
+  %r50c = select i1 %cmp50c, i32 %x50, i32 %y50
+  store volatile i32 %r50a, i32* %pout
+  store volatile i32 %r50b, i32* %pout
+  store volatile i32 %r50c, i32* %pout
+
+  %x51 = load volatile i32, i32* %px
+  %y51 = load volatile i32, i32* %py
+  %cmp51a = icmp slt i32 %x51, %y51
+  %cmp51b = xor i1 %cmp51a, -1
+  %cmp51c = xor i1 %cmp51b, -1
+  %r51a = select i1 %cmp51a, i32 %x51, i32 %y51
+  %r51b = select i1 %cmp51b, i32 %y51, i32 %x51
+  %r51c = select i1 %cmp51c, i32 %x51, i32 %y51
+  store volatile i32 %r51a, i32* %pout
+  store volatile i32 %r51b, i32* %pout
+  store volatile i32 %r51c, i32* %pout
+
+  %x52 = load volatile i32, i32* %px
+  %y52 = load volatile i32, i32* %py
+  %cmp52a = icmp sgt i32 %x52, %y52
+  %cmp52b = xor i1 %cmp52a, -1
+  %cmp52c = xor i1 %cmp52b, -1
+  %r52a = select i1 %cmp52a, i32 %x52, i32 %y52
+  %r52b = select i1 %cmp52b, i32 %y52, i32 %x52
+  %r52c = select i1 %cmp52c, i32 %x52, i32 %y52
+  store volatile i32 %r52a, i32* %pout
+  store volatile i32 %r52b, i32* %pout
+  store volatile i32 %r52c, i32* %pout
+
+  %x53 = load volatile i32, i32* %px
+  %y53 = load volatile i32, i32* %py
+  %cmp53a = icmp slt i32 %x53, %y53
+  %cmp53b = xor i1 %cmp53a, -1
+  %cmp53c = xor i1 %cmp53b, -1
+  %r53a = select i1 %cmp53a, i32 %x53, i32 %y53
+  %r53b = select i1 %cmp53b, i32 %y53, i32 %x53
+  %r53c = select i1 %cmp53c, i32 %x53, i32 %y53
+  store volatile i32 %r53a, i32* %pout
+  store volatile i32 %r53b, i32* %pout
+  store volatile i32 %r53c, i32* %pout
+
+  %x54 = load volatile i32, i32* %px
+  %y54 = load volatile i32, i32* %py
+  %cmp54a = icmp sgt i32 %x54, %y54
+  %cmp54b = xor i1 %cmp54a, -1
+  %cmp54c = xor i1 %cmp54b, -1
+  %r54a = select i1 %cmp54a, i32 %x54, i32 %y54
+  %r54b = select i1 %cmp54b, i32 %y54, i32 %x54
+  %r54c = select i1 %cmp54c, i32 %x54, i32 %y54
+  store volatile i32 %r54a, i32* %pout
+  store volatile i32 %r54b, i32* %pout
+  store volatile i32 %r54c, i32* %pout
+
+  %x55 = load volatile i32, i32* %px
+  %y55 = load volatile i32, i32* %py
+  %cmp55a = icmp slt i32 %x55, %y55
+  %cmp55b = xor i1 %cmp55a, -1
+  %cmp55c = xor i1 %cmp55b, -1
+  %r55a = select i1 %cmp55a, i32 %x55, i32 %y55
+  %r55b = select i1 %cmp55b, i32 %y55, i32 %x55
+  %r55c = select i1 %cmp55c, i32 %x55, i32 %y55
+  store volatile i32 %r55a, i32* %pout
+  store volatile i32 %r55b, i32* %pout
+  store volatile i32 %r55c, i32* %pout
+
+  %x56 = load volatile i32, i32* %px
+  %y56 = load volatile i32, i32* %py
+  %cmp56a = icmp sgt i32 %x56, %y56
+  %cmp56b = xor i1 %cmp56a, -1
+  %cmp56c = xor i1 %cmp56b, -1
+  %r56a = select i1 %cmp56a, i32 %x56, i32 %y56
+  %r56b = select i1 %cmp56b, i32 %y56, i32 %x56
+  %r56c = select i1 %cmp56c, i32 %x56, i32 %y56
+  store volatile i32 %r56a, i32* %pout
+  store volatile i32 %r56b, i32* %pout
+  store volatile i32 %r56c, i32* %pout
+
+  %x57 = load volatile i32, i32* %px
+  %y57 = load volatile i32, i32* %py
+  %cmp57a = icmp slt i32 %x57, %y57
+  %cmp57b = xor i1 %cmp57a, -1
+  %cmp57c = xor i1 %cmp57b, -1
+  %r57a = select i1 %cmp57a, i32 %x57, i32 %y57
+  %r57b = select i1 %cmp57b, i32 %y57, i32 %x57
+  %r57c = select i1 %cmp57c, i32 %x57, i32 %y57
+  store volatile i32 %r57a, i32* %pout
+  store volatile i32 %r57b, i32* %pout
+  store volatile i32 %r57c, i32* %pout
+
+  %x58 = load volatile i32, i32* %px
+  %y58 = load volatile i32, i32* %py
+  %cmp58a = icmp sgt i32 %x58, %y58
+  %cmp58b = xor i1 %cmp58a, -1
+  %cmp58c = xor i1 %cmp58b, -1
+  %r58a = select i1 %cmp58a, i32 %x58, i32 %y58
+  %r58b = select i1 %cmp58b, i32 %y58, i32 %x58
+  %r58c = select i1 %cmp58c, i32 %x58, i32 %y58
+  store volatile i32 %r58a, i32* %pout
+  store volatile i32 %r58b, i32* %pout
+  store volatile i32 %r58c, i32* %pout
+
+  %x59 = load volatile i32, i32* %px
+  %y59 = load volatile i32, i32* %py
+  %cmp59a = icmp slt i32 %x59, %y59
+  %cmp59b = xor i1 %cmp59a, -1
+  %cmp59c = xor i1 %cmp59b, -1
+  %r59a = select i1 %cmp59a, i32 %x59, i32 %y59
+  %r59b = select i1 %cmp59b, i32 %y59, i32 %x59
+  %r59c = select i1 %cmp59c, i32 %x59, i32 %y59
+  store volatile i32 %r59a, i32* %pout
+  store volatile i32 %r59b, i32* %pout
+  store volatile i32 %r59c, i32* %pout
+
+  %x60 = load volatile i32, i32* %px
+  %y60 = load volatile i32, i32* %py
+  %cmp60a = icmp sgt i32 %x60, %y60
+  %cmp60b = xor i1 %cmp60a, -1
+  %cmp60c = xor i1 %cmp60b, -1
+  %r60a = select i1 %cmp60a, i32 %x60, i32 %y60
+  %r60b = select i1 %cmp60b, i32 %y60, i32 %x60
+  %r60c = select i1 %cmp60c, i32 %x60, i32 %y60
+  store volatile i32 %r60a, i32* %pout
+  store volatile i32 %r60b, i32* %pout
+  store volatile i32 %r60c, i32* %pout
+
+  %x61 = load volatile i32, i32* %px
+  %y61 = load volatile i32, i32* %py
+  %cmp61a = icmp slt i32 %x61, %y61
+  %cmp61b = xor i1 %cmp61a, -1
+  %cmp61c = xor i1 %cmp61b, -1
+  %r61a = select i1 %cmp61a, i32 %x61, i32 %y61
+  %r61b = select i1 %cmp61b, i32 %y61, i32 %x61
+  %r61c = select i1 %cmp61c, i32 %x61, i32 %y61
+  store volatile i32 %r61a, i32* %pout
+  store volatile i32 %r61b, i32* %pout
+  store volatile i32 %r61c, i32* %pout
+
+  %x62 = load volatile i32, i32* %px
+  %y62 = load volatile i32, i32* %py
+  %cmp62a = icmp sgt i32 %x62, %y62
+  %cmp62b = xor i1 %cmp62a, -1
+  %cmp62c = xor i1 %cmp62b, -1
+  %r62a = select i1 %cmp62a, i32 %x62, i32 %y62
+  %r62b = select i1 %cmp62b, i32 %y62, i32 %x62
+  %r62c = select i1 %cmp62c, i32 %x62, i32 %y62
+  store volatile i32 %r62a, i32* %pout
+  store volatile i32 %r62b, i32* %pout
+  store volatile i32 %r62c, i32* %pout
+
+  %x63 = load volatile i32, i32* %px
+  %y63 = load volatile i32, i32* %py
+  %cmp63a = icmp slt i32 %x63, %y63
+  %cmp63b = xor i1 %cmp63a, -1
+  %cmp63c = xor i1 %cmp63b, -1
+  %r63a = select i1 %cmp63a, i32 %x63, i32 %y63
+  %r63b = select i1 %cmp63b, i32 %y63, i32 %x63
+  %r63c = select i1 %cmp63c, i32 %x63, i32 %y63
+  store volatile i32 %r63a, i32* %pout
+  store volatile i32 %r63b, i32* %pout
+  store volatile i32 %r63c, i32* %pout
+
+  %x64 = load volatile i32, i32* %px
+  %y64 = load volatile i32, i32* %py
+  %cmp64a = icmp sgt i32 %x64, %y64
+  %cmp64b = xor i1 %cmp64a, -1
+  %cmp64c = xor i1 %cmp64b, -1
+  %r64a = select i1 %cmp64a, i32 %x64, i32 %y64
+  %r64b = select i1 %cmp64b, i32 %y64, i32 %x64
+  %r64c = select i1 %cmp64c, i32 %x64, i32 %y64
+  store volatile i32 %r64a, i32* %pout
+  store volatile i32 %r64b, i32* %pout
+  store volatile i32 %r64c, i32* %pout
+
+  %x65 = load volatile i32, i32* %px
+  %y65 = load volatile i32, i32* %py
+  %cmp65a = icmp slt i32 %x65, %y65
+  %cmp65b = xor i1 %cmp65a, -1
+  %cmp65c = xor i1 %cmp65b, -1
+  %r65a = select i1 %cmp65a, i32 %x65, i32 %y65
+  %r65b = select i1 %cmp65b, i32 %y65, i32 %x65
+  %r65c = select i1 %cmp65c, i32 %x65, i32 %y65
+  store volatile i32 %r65a, i32* %pout
+  store volatile i32 %r65b, i32* %pout
+  store volatile i32 %r65c, i32* %pout
+
+  %x66 = load volatile i32, i32* %px
+  %y66 = load volatile i32, i32* %py
+  %cmp66a = icmp sgt i32 %x66, %y66
+  %cmp66b = xor i1 %cmp66a, -1
+  %cmp66c = xor i1 %cmp66b, -1
+  %r66a = select i1 %cmp66a, i32 %x66, i32 %y66
+  %r66b = select i1 %cmp66b, i32 %y66, i32 %x66
+  %r66c = select i1 %cmp66c, i32 %x66, i32 %y66
+  store volatile i32 %r66a, i32* %pout
+  store volatile i32 %r66b, i32* %pout
+  store volatile i32 %r66c, i32* %pout
+
+  %x67 = load volatile i32, i32* %px
+  %y67 = load volatile i32, i32* %py
+  %cmp67a = icmp slt i32 %x67, %y67
+  %cmp67b = xor i1 %cmp67a, -1
+  %cmp67c = xor i1 %cmp67b, -1
+  %r67a = select i1 %cmp67a, i32 %x67, i32 %y67
+  %r67b = select i1 %cmp67b, i32 %y67, i32 %x67
+  %r67c = select i1 %cmp67c, i32 %x67, i32 %y67
+  store volatile i32 %r67a, i32* %pout
+  store volatile i32 %r67b, i32* %pout
+  store volatile i32 %r67c, i32* %pout
+
+  %x68 = load volatile i32, i32* %px
+  %y68 = load volatile i32, i32* %py
+  %cmp68a = icmp sgt i32 %x68, %y68
+  %cmp68b = xor i1 %cmp68a, -1
+  %cmp68c = xor i1 %cmp68b, -1
+  %r68a = select i1 %cmp68a, i32 %x68, i32 %y68
+  %r68b = select i1 %cmp68b, i32 %y68, i32 %x68
+  %r68c = select i1 %cmp68c, i32 %x68, i32 %y68
+  store volatile i32 %r68a, i32* %pout
+  store volatile i32 %r68b, i32* %pout
+  store volatile i32 %r68c, i32* %pout
+
+  %x69 = load volatile i32, i32* %px
+  %y69 = load volatile i32, i32* %py
+  %cmp69a = icmp slt i32 %x69, %y69
+  %cmp69b = xor i1 %cmp69a, -1
+  %cmp69c = xor i1 %cmp69b, -1
+  %r69a = select i1 %cmp69a, i32 %x69, i32 %y69
+  %r69b = select i1 %cmp69b, i32 %y69, i32 %x69
+  %r69c = select i1 %cmp69c, i32 %x69, i32 %y69
+  store volatile i32 %r69a, i32* %pout
+  store volatile i32 %r69b, i32* %pout
+  store volatile i32 %r69c, i32* %pout
+
+  %x70 = load volatile i32, i32* %px
+  %y70 = load volatile i32, i32* %py
+  %cmp70a = icmp sgt i32 %x70, %y70
+  %cmp70b = xor i1 %cmp70a, -1
+  %cmp70c = xor i1 %cmp70b, -1
+  %r70a = select i1 %cmp70a, i32 %x70, i32 %y70
+  %r70b = select i1 %cmp70b, i32 %y70, i32 %x70
+  %r70c = select i1 %cmp70c, i32 %x70, i32 %y70
+  store volatile i32 %r70a, i32* %pout
+  store volatile i32 %r70b, i32* %pout
+  store volatile i32 %r70c, i32* %pout
+
+  %x71 = load volatile i32, i32* %px
+  %y71 = load volatile i32, i32* %py
+  %cmp71a = icmp slt i32 %x71, %y71
+  %cmp71b = xor i1 %cmp71a, -1
+  %cmp71c = xor i1 %cmp71b, -1
+  %r71a = select i1 %cmp71a, i32 %x71, i32 %y71
+  %r71b = select i1 %cmp71b, i32 %y71, i32 %x71
+  %r71c = select i1 %cmp71c, i32 %x71, i32 %y71
+  store volatile i32 %r71a, i32* %pout
+  store volatile i32 %r71b, i32* %pout
+  store volatile i32 %r71c, i32* %pout
+
+  %x72 = load volatile i32, i32* %px
+  %y72 = load volatile i32, i32* %py
+  %cmp72a = icmp sgt i32 %x72, %y72
+  %cmp72b = xor i1 %cmp72a, -1
+  %cmp72c = xor i1 %cmp72b, -1
+  %r72a = select i1 %cmp72a, i32 %x72, i32 %y72
+  %r72b = select i1 %cmp72b, i32 %y72, i32 %x72
+  %r72c = select i1 %cmp72c, i32 %x72, i32 %y72
+  store volatile i32 %r72a, i32* %pout
+  store volatile i32 %r72b, i32* %pout
+  store volatile i32 %r72c, i32* %pout
+
+  ret void
+}