diff --git a/compiler/optimizing/instruction_simplifier.cc b/compiler/optimizing/instruction_simplifier.cc
index 10a06a3..c504ded 100644
--- a/compiler/optimizing/instruction_simplifier.cc
+++ b/compiler/optimizing/instruction_simplifier.cc
@@ -66,10 +66,6 @@
   void VisitGreaterThanOrEqual(HGreaterThanOrEqual* condition) OVERRIDE;
   void VisitLessThan(HLessThan* condition) OVERRIDE;
   void VisitLessThanOrEqual(HLessThanOrEqual* condition) OVERRIDE;
-  void VisitBelow(HBelow* condition) OVERRIDE;
-  void VisitBelowOrEqual(HBelowOrEqual* condition) OVERRIDE;
-  void VisitAbove(HAbove* condition) OVERRIDE;
-  void VisitAboveOrEqual(HAboveOrEqual* condition) OVERRIDE;
   void VisitDiv(HDiv* instruction) OVERRIDE;
   void VisitMul(HMul* instruction) OVERRIDE;
   void VisitNeg(HNeg* instruction) OVERRIDE;
@@ -514,36 +510,6 @@
   block->RemoveInstruction(check);
 }
 
-static HCondition* GetOppositeConditionSwapOps(ArenaAllocator* arena, HInstruction* cond) {
-  HInstruction *lhs = cond->InputAt(0);
-  HInstruction *rhs = cond->InputAt(1);
-  switch (cond->GetKind()) {
-    case HInstruction::kEqual:
-      return new (arena) HEqual(rhs, lhs);
-    case HInstruction::kNotEqual:
-      return new (arena) HNotEqual(rhs, lhs);
-    case HInstruction::kLessThan:
-      return new (arena) HGreaterThan(rhs, lhs);
-    case HInstruction::kLessThanOrEqual:
-      return new (arena) HGreaterThanOrEqual(rhs, lhs);
-    case HInstruction::kGreaterThan:
-      return new (arena) HLessThan(rhs, lhs);
-    case HInstruction::kGreaterThanOrEqual:
-      return new (arena) HLessThanOrEqual(rhs, lhs);
-    case HInstruction::kBelow:
-      return new (arena) HAbove(rhs, lhs);
-    case HInstruction::kBelowOrEqual:
-      return new (arena) HAboveOrEqual(rhs, lhs);
-    case HInstruction::kAbove:
-      return new (arena) HBelow(rhs, lhs);
-    case HInstruction::kAboveOrEqual:
-      return new (arena) HBelowOrEqual(rhs, lhs);
-    default:
-      LOG(FATAL) << "Unknown ConditionType " << cond->GetKind();
-  }
-  return nullptr;
-}
-
 void InstructionSimplifierVisitor::VisitEqual(HEqual* equal) {
   HInstruction* input_const = equal->GetConstantRight();
   if (input_const != nullptr) {
@@ -806,47 +772,13 @@
   VisitCondition(condition);
 }
 
-void InstructionSimplifierVisitor::VisitBelow(HBelow* condition) {
-  VisitCondition(condition);
-}
-
-void InstructionSimplifierVisitor::VisitBelowOrEqual(HBelowOrEqual* condition) {
-  VisitCondition(condition);
-}
-
-void InstructionSimplifierVisitor::VisitAbove(HAbove* condition) {
-  VisitCondition(condition);
-}
-
-void InstructionSimplifierVisitor::VisitAboveOrEqual(HAboveOrEqual* condition) {
-  VisitCondition(condition);
-}
+// TODO: unsigned comparisons too?
 
 void InstructionSimplifierVisitor::VisitCondition(HCondition* condition) {
-  // Reverse condition if left is constant. Our code generators prefer constant
-  // on the right hand side.
-  if (condition->GetLeft()->IsConstant() && !condition->GetRight()->IsConstant()) {
-    HBasicBlock* block = condition->GetBlock();
-    HCondition* replacement = GetOppositeConditionSwapOps(block->GetGraph()->GetArena(), condition);
-    // If it is a fp we must set the opposite bias.
-    if (replacement != nullptr) {
-      if (condition->IsLtBias()) {
-        replacement->SetBias(ComparisonBias::kGtBias);
-      } else if (condition->IsGtBias()) {
-        replacement->SetBias(ComparisonBias::kLtBias);
-      }
-      block->ReplaceAndRemoveInstructionWith(condition, replacement);
-      RecordSimplification();
-
-      condition = replacement;
-    }
-  }
+  // Try to fold an HCompare into this HCondition.
 
   HInstruction* left = condition->GetLeft();
   HInstruction* right = condition->GetRight();
-
-  // Try to fold an HCompare into this HCondition.
-
   // We can only replace an HCondition which compares a Compare to 0.
   // Both 'dx' and 'jack' generate a compare to 0 when compiling a
   // condition with a long, float or double comparison as input.
diff --git a/compiler/optimizing/nodes.h b/compiler/optimizing/nodes.h
index cfb7179..c06d164 100644
--- a/compiler/optimizing/nodes.h
+++ b/compiler/optimizing/nodes.h
@@ -2706,8 +2706,6 @@
 
   bool IsGtBias() const { return bias_ == ComparisonBias::kGtBias; }
 
-  bool IsLtBias() const { return bias_ == ComparisonBias::kLtBias; }
-
   void SetBias(ComparisonBias bias) { bias_ = bias; }
 
   bool InstructionDataEquals(HInstruction* other) const OVERRIDE {
@@ -2717,23 +2715,13 @@
   bool IsFPConditionTrueIfNaN() const {
     DCHECK(Primitive::IsFloatingPointType(InputAt(0)->GetType()));
     IfCondition if_cond = GetCondition();
-    if (if_cond == kCondNE) {
-      return true;
-    } else if (if_cond == kCondEQ) {
-      return false;
-    }
-    return ((if_cond == kCondGT) || (if_cond == kCondGE)) && IsGtBias();
+    return IsGtBias() ? ((if_cond == kCondGT) || (if_cond == kCondGE)) : (if_cond == kCondNE);
   }
 
   bool IsFPConditionFalseIfNaN() const {
     DCHECK(Primitive::IsFloatingPointType(InputAt(0)->GetType()));
     IfCondition if_cond = GetCondition();
-    if (if_cond == kCondEQ) {
-      return true;
-    } else if (if_cond == kCondNE) {
-      return false;
-    }
-    return ((if_cond == kCondLT) || (if_cond == kCondLE)) && IsGtBias();
+    return IsGtBias() ? ((if_cond == kCondLT) || (if_cond == kCondLE)) : (if_cond == kCondEQ);
   }
 
  private:
diff --git a/test/458-checker-instruction-simplification/src/Main.java b/test/458-checker-instruction-simplification/src/Main.java
index bc080e9..0fd7801 100644
--- a/test/458-checker-instruction-simplification/src/Main.java
+++ b/test/458-checker-instruction-simplification/src/Main.java
@@ -1332,36 +1332,6 @@
     return ((d > 42.0) != false) ? 13 : 54;
   }
 
-  /// CHECK-START: int Main.intReverseCondition(int) instruction_simplifier (before)
-  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
-  /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
-  /// CHECK-DAG:      <<LE>>            LessThanOrEqual [<<Const42>>,<<Arg>>]
-
-  /// CHECK-START: int Main.intReverseCondition(int) instruction_simplifier (after)
-  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
-  /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
-  /// CHECK-DAG:      <<GE>>            GreaterThanOrEqual [<<Arg>>,<<Const42>>]
-
-  public static int intReverseCondition(int i) {
-    return (42 > i) ? 13 : 54;
-  }
-
-  /// CHECK-START: int Main.intReverseConditionNaN(int) instruction_simplifier (before)
-  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
-  /// CHECK-DAG:      <<Const42:d\d+>>  DoubleConstant 42
-  /// CHECK-DAG:      <<ResDouble>>     InvokeStaticOrDirect [<<Arg>>]
-  /// CHECK-DAG:      <<CMP>>           Compare [<<Const42>>,<<ResDouble>>]
-
-  /// CHECK-START: int Main.intReverseConditionNaN(int) instruction_simplifier (after)
-  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
-  /// CHECK-DAG:      <<Const42:d\d+>>  DoubleConstant 42
-  /// CHECK-DAG:      <<ResDouble>>     InvokeStaticOrDirect [<<Arg>>]
-  /// CHECK-DAG:      <<EQ>>            Equal [<<ResDouble>>,<<Const42>>]
-
-  public static int intReverseConditionNaN(int i) {
-    return (42 != Math.sqrt(i)) ? 13 : 54;
-  }
-
   public static void main(String[] args) {
     int arg = 123456;
 
@@ -1443,8 +1413,6 @@
     assertIntEquals(floatConditionNotEqualOne(43.0f), 13);
     assertIntEquals(doubleConditionEqualZero(6.0), 54);
     assertIntEquals(doubleConditionEqualZero(43.0), 13);
-    assertIntEquals(intReverseCondition(41), 13);
-    assertIntEquals(intReverseConditionNaN(-5), 13);
   }
 
   public static boolean booleanField;