text: #include "Simplify_Internal.h"
  
  namespace Halide {
  namespace Internal {
  
  Expr Simplify::visit(const Or *op, ExprInfo *bounds) {
      if (truths.count(op)) {
          return const_true(op->type.lanes());
      }
  
      Expr a = mutate(op->a, nullptr);
      Expr b = mutate(op->b, nullptr);
  
      if (should_commute(a, b)) {
          std::swap(a, b);
      }
  
      auto rewrite = IRMatcher::rewriter(IRMatcher::or_op(a, b), op->type);
  
      if (EVAL_IN_LAMBDA
          (rewrite(x || true, b) ||
           rewrite(x || false, a) ||
           rewrite(x || x, a) ||
  
           rewrite((x || y) || x, a) ||
           rewrite(x || (x || y), b) ||
           rewrite((x || y) || y, a) ||
           rewrite(y || (x || y), b) ||
  
           rewrite(((x || y) || z) || x, a) ||
           rewrite(x || ((x || y) || z), b) ||
           rewrite((z || (x || y)) || x, a) ||
           rewrite(x || (z || (x || y)), b) ||
           rewrite(((x || y) || z) || y, a) ||
           rewrite(y || ((x || y) || z), b) ||
           rewrite((z || (x || y)) || y, a) ||
           rewrite(y || (z || (x || y)), b) ||
  
           rewrite((x && y) || x, b) ||
           rewrite(x || (x && y), a) ||
           rewrite((x && y) || y, b) ||
           rewrite(y || (x && y), a) ||
  
           rewrite(((x || y) || z) || x, a) ||
           rewrite(x || ((x || y) || z), b) ||
           rewrite((z || (x || y)) || x, a) ||
           rewrite(x || (z || (x || y)), b) ||
           rewrite(((x || y) || z) || y, a) ||
           rewrite(y || ((x || y) || z), b) ||
           rewrite((z || (x || y)) || y, a) ||
           rewrite(y || (z || (x || y)), b) ||
  
           rewrite(x != y || x == y, true) ||
           rewrite(x != y || y == x, true) ||
           rewrite((z || x != y) || x == y, true) ||
           rewrite((z || x != y) || y == x, true) ||
           rewrite((x != y || z) || x == y, true) ||
           rewrite((x != y || z) || y == x, true) ||
           rewrite((z || x == y) || x != y, true) ||
           rewrite((z || x == y) || y != x, true) ||
           rewrite((x == y || z) || x != y, true) ||
           rewrite((x == y || z) || y != x, true) ||
           rewrite(x || !x, true) ||
           rewrite(!x || x, true) ||
           rewrite(y <= x || x < y, true) ||
           rewrite(x != c0 || x == c1, a, c0 != c1) ||
           rewrite(x <= c0 || c1 <= x, true, !is_float(x) && c1 <= c0 + 1) ||
           rewrite(c1 <= x || x <= c0, true, !is_float(x) && c1 <= c0 + 1) ||
           rewrite(x <= c0 || c1 < x, true, c1 <= c0) ||
           rewrite(c1 <= x || x < c0, true, c1 <= c0) ||
           rewrite(x < c0 || c1 < x, true, c1 < c0) ||
           rewrite(c1 < x || x < c0, true, c1 < c0) ||
           rewrite(c0 < x || c1 < x, fold(min(c0, c1)) < x) ||
           rewrite(c0 <= x || c1 <= x, fold(min(c0, c1)) <= x) ||
           rewrite(x < c0 || x < c1, x < fold(max(c0, c1))) ||
           rewrite(x <= c0 || x <= c1, x <= fold(max(c0, c1))))) {
          return rewrite.result;
      }
  
      if (rewrite(broadcast(x) || broadcast(y), broadcast(x || y, op->type.lanes())) ||
  
          rewrite((x && (y || z)) || y, (x && z) || y) ||
          rewrite((x && (z || y)) || y, (x && z) || y) ||
          rewrite(y || (x && (y || z)), y || (x && z)) ||
          rewrite(y || (x && (z || y)), y || (x && z)) ||
  
          rewrite(((y || z) && x) || y, (z && x) || y) ||
          rewrite(((z || y) && x) || y, (z && x) || y) ||
          rewrite(y || ((y || z) && x), y || (z && x)) ||
          rewrite(y || ((z || y) && x), y || (z && x)) ||
  
          rewrite((x || (y && z)) || y, x || y) ||
          rewrite((x || (z && y)) || y, x || y) ||
          rewrite(y || (x || (y && z)), y || x) ||
          rewrite(y || (x || (z && y)), y || x) ||
  
          rewrite(((y && z) || x) || y, x || y) ||
          rewrite(((z && y) || x) || y, x || y) ||
          rewrite(y || ((y && z) || x), y || x) ||
          rewrite(y || ((z && y) || x), y || x) ||
  
          rewrite((x && y) || (x && z), x && (y || z)) ||
          rewrite((x && y) || (z && x), x && (y || z)) ||
          rewrite((y && x) || (x && z), x && (y || z)) ||
          rewrite((y && x) || (z && x), x && (y || z)) ||
  
          rewrite(x < y || x < z, x < max(y, z)) ||
          rewrite(y < x || z < x, min(y, z) < x) ||
          rewrite(x <= y || x <= z, x <= max(y, z)) ||
          rewrite(y <= x || z <= x, min(y, z) <= x)) {
  
          return mutate(std::move(rewrite.result), bounds);
      }
  
      if (a.same_as(op->a) &&
          b.same_as(op->b)) {
          return op;
      } else {
          return Or::make(a, b);
      }
  }
  
  }
  }
  