}  // namespace tensorflow

#define TF_STATUS_ASSIGN_OR_RETURN(lhs, rexpr, c_status) \
  _TF_STATUS_ASSIGN_OR_RETURN_IMPL(                      \
      _TF_STATUS_CONCAT(_status_or_value, __COUNTER__), lhs, rexpr, c_status);

#define _TF_STATUS_ASSIGN_OR_RETURN_IMPL(statusor, lhs, rexpr, c_status) \
  auto statusor = (rexpr);                                               \

                    lhs = PropertyAccess [indexes: 0..1, line/column: 1/1..1/2, file: test] (
                        name = a
                    )
                    rhs = IntLiteral [indexes: 4..5, line/column: 1/5..1/6, file: test] (1)
                )
                Assignment [indexes: 6..16, line/column: 2/1..2/11, file: test] (

    }

    private static boolean scopeEquals(String lhs, String rhs) {
        if ("COMPILE".equals(lhs)) {
            return Strings.isNullOrEmpty(rhs) || "COMPILE".equals(rhs);
        } else if ("COMPILE".equals(rhs)) {
            return Strings.isNullOrEmpty(lhs);
        } else {
            return Objects.equal(lhs, rhs);
        }
    }

    @Override
    public int hashCode() {

                    is AssignmentResolver.AssignmentAdditionResult.UnresolvedValueUsedInRhs -> "rhs: ${result.value}"
                }
                println("${element.lhs} !:= ${element.rhs} -- unassigned property in $locationString")
            }
            is AssignmentTraceElement.Reassignment -> {
                println("${element.lhs} !:= ${element.rhs} -- reassignment")

// Rsqrt op patterns.
//===----------------------------------------------------------------------===//

// RsqrtGrad(lhs, rhs) = (lhs * lhs * lhs) * (rhs / -2)
def LowerRsqrtGradOp : Pat<
  (TF_RsqrtGradOp $lhs, $rhs),
  (TF_MulOp
    (TF_MulOp
      (TF_MulOp $lhs, $lhs),
      $lhs
    ),
    (TF_DivOp
      $rhs,
      (TF_ConstOp
        (GetScalarOfType<-2> $rhs)
      )
    )
  )>;

// effects to o.out as needed.
// If this is part of an assignment lhs = *np, lhs is given.
// Otherwise lhs == nil. (When lhs != nil it may be possible
// to avoid copying the result of the expression to a temporary.)
// The result of expr MUST be assigned back to n, e.g.
//
//	n.Left = o.expr(n.Left, lhs)
func (o *orderState) expr(n, lhs ir.Node) ir.Node {
	if n == nil {
		return n
	}
	lno := ir.SetPos(n)

    auto lhs = op->getOperand(0);
    auto rhs = op->getOperand(1);
    auto out = op->getResult(0);

    // Calculates symbolic broadcast shape that is only used in types.
    SmallVector<int64_t, 4> symbolic_broadcast_shape;
    // Matches fail when lhs or rhs is unranked tensor.
    // TODO(b/176202543): Support unranked tensor.
    if (!mlir::cast<ShapedType>(lhs.getType()).hasRank() ||

      return llvm::hash_combine_range(val.begin(), val.end());
    }
    static bool isEqual(Signature LHS, Signature RHS) {
      if (RHS == getEmptyKey()) return LHS == getEmptyKey();
      if (RHS == getTombstoneKey()) return LHS == getTombstoneKey();
      if (LHS.size() != RHS.size()) return false;
      for (auto arg : llvm::zip(LHS, RHS)) {
        if (std::get<0>(arg) != std::get<1>(arg)) return false;
      }
      return true;

  // dot_general outputs are always in the
  //   [batch dims, LHS other dims, RHS other dims]
  // layout, so the new concat dim is where the n-th (base-0 counting) LHS other
  // dim appears in the original LHS layout, where:
  //   n = old_concat_dim - batch_dims_count
  uint64_t n = concat.getDimension() - batch_dims_count;

  // Now try to answer where the n-th LHS other dim was originally placed.

      ConversionPatternRewriter &rewriter) const override {
    Value lhs = adaptor.getLhs();

    auto lhs_type = mlir::cast<ShapedType>(lhs.getType());
    if (!lhs_type.hasRank()) {
      return rewriter.notifyMatchFailure(
          op, "Legalization supports cases where only lhs rank known.");
    }

    auto lhs_quant_type = GetUniformQuantizedType(