logicalOr.right.accept(),
        KaContractBinaryLogicExpression.KaLogicOperation.OR
    )

    override fun visitLogicalAnd(logicalAnd: LogicalAnd, data: Unit): Any = KaContractBinaryLogicExpression(
        logicalAnd.left.accept(),
        logicalAnd.right.accept(),
        KaContractBinaryLogicExpression.KaLogicOperation.AND
    )

    override fun visitLogicalNot(logicalNot: LogicalNot, data: Unit): Any =

  ^bb0(%arg0: tensor<i32>):
    %0 = "tf.Less"(%arg0, %arg0) {device = ""} : (tensor<i32>, tensor<i32>) -> tensor<*xi1>
    %1 = "tf.Less"(%arg0, %arg0) {device = ""} : (tensor<i32>, tensor<i32>) -> tensor<*xi1>
    %2 = "tf.LogicalAnd"(%0, %1) {device = ""} : (tensor<*xi1>, tensor<*xi1>) -> tensor<*xi1>
    "func.return"(%2) : (tensor<*xi1>) -> ()

  %cst = arith.constant dense<true> : tensor<i1>

  // CHECK: %[[LOGICAL_AND:.*]] = "tf.LogicalAnd"
  %0 = "tf.LogicalAnd"(%cst, %arg0) : (tensor<i1>, tensor<i1>) -> tensor<i1>

  // CHECK: return %[[LOGICAL_AND]]
  func.return %0 : tensor<i1>
}

// CHECK-LABEL: func @testLogicalAndDoesntFoldWithConstantFalseBroadcast

 Const 875
 ControlTrigger 5
 Enter 874
 Equal 4
 Exit 69
 ExpandDims 9
 Fill 5
 FloorMod 1
 GreaterEqual 7
 Identity 113
 IsVariableInitialized 1
 IteratorGetNext 1
 IteratorV2 1
 Less 9
 LogicalAnd 3
 LoopCond 8
 Max 4
 Maximum 44
 Merge 145
 Minimum 43
 Mul 8
 NextIteration 136
 RandomUniform 14
 Range 9
 RefSwitch 166
 Reshape 2
 ScatterAdd 4
 Shape 6
 ShapeN 10
 Size 2

  %1 = "tf.Less"(%arg1, %cst) {device = "/job:localhost/replica:0/task:0/device:CPU:0"} : (tensor<i32>, tensor<i32>) -> tensor<i1>
  %2 = "tf.LogicalAnd"(%0, %1) {device = "/job:localhost/replica:0/task:0/device:CPU:0"} : (tensor<i1>, tensor<i1>) -> tensor<i1>
  return %2 : tensor<i1>
}

// CHECK-LABEL: map/while_body

  // CHECK-NEXT:  mhlo.and
  %0 = "tf.LogicalAnd"(%arg0, %arg1) : (tensor<2xi1>, tensor<2xi1>) -> tensor<2xi1>
  func.return %0: tensor<2xi1>
}

// CHECK-LABEL: func @and_unranked
func.func @and_unranked(%arg0: tensor<*xi1>, %arg1: tensor<*xi1>) -> tensor<*xi1> {
  // CHECK: tf.LogicalAnd
  %0 = "tf.LogicalAnd"(%arg0, %arg1) : (tensor<*xi1>, tensor<*xi1>) -> tensor<*xi1>

  // Create loop: while (i > 0 && j > 0) i -= 1
  CreateLoop(
      [](const Scope& s, const std::vector<Output>& inputs, Output* output) {
        *output = ops::LogicalAnd(s, ops::Greater(s, inputs[0], 0.0),
                                  ops::Greater(s, inputs[1], 0.0));
        return s.status();
      },
      [](const Scope& s, const std::vector<Output>& inputs,

    %3 = "tf.Greater"(%arg2, %arg4) {device = ""} : (tensor<i32>, tensor<i32>) -> tensor<i1>
    %4 = "tf.LogicalAnd"(%2, %3) {device = ""} : (tensor<i1>, tensor<i1>) -> tensor<i1>
    %5 = "tf.Less"(%arg2, %arg4) {device = ""} : (tensor<i32>, tensor<i32>) -> tensor<i1>
    %6 = "tf.LogicalAnd"(%1, %5) {device = ""} : (tensor<i1>, tensor<i1>) -> tensor<i1>

//   n = Shape(input)[-1]
//   num_lower_or_m = Select(num_lower < 0, m, num_lower)
//   num_upper_or_n = Select(num_upper < 0, n, num_upper)
//   offset = ExpandDims(Range(0, m), -1) - Range(0, n)
//   indicator = LogicalAnd(offset <= num_lower_or_m, offset >= -num_upper_or_n)
//   return Select(indicator, input, ZerosLike(Input))
// }
def LowerMatrixBandPartOp : Pattern<
  (TF_MatrixBandPartOp $input, $num_lower, $num_upper),

REGISTER_NO_GRADIENT_OP("Greater");
REGISTER_NO_GRADIENT_OP("GreaterEqual");
REGISTER_NO_GRADIENT_OP("Equal");
REGISTER_NO_GRADIENT_OP("ApproximateEqual");
REGISTER_NO_GRADIENT_OP("NotEqual");
REGISTER_NO_GRADIENT_OP("LogicalAnd");
REGISTER_NO_GRADIENT_OP("LogicalOr");
REGISTER_NO_GRADIENT_OP("LogicalNot");
REGISTER_NO_GRADIENT_OP("Floor");

// Conjugate helper function returns the conjugate of an Output if it
// is complex valued.