} else {
      return UnrankedTensorType::get(builder->getI1Type());
    }
  }

  auto ranked_type = mlir::dyn_cast<RankedTensorType>(result_type);
  if (!ranked_type) return UnrankedTensorType::get(builder->getI1Type());

  return RankedTensorType::get(ranked_type.getShape(), builder->getI1Type());
}

Type InferReductionOpType(Value input, Value reduction_indices,

  auto const_true = builder.create<TF::ConstOp>(
      reduce_dataset.getLoc(),
      DenseIntElementsAttr::get(
          RankedTensorType::get(/*shape=*/{}, builder.getI1Type()), true));

  SmallVector<Value, 4> while_input_values;
  SmallVector<Type, 4> while_input_types;
  while_input_values.push_back(const_true.getResult());
  while_input_types.push_back(const_true.getResult().getType());

      return builder.getIntegerType(64);
    case tflite::TensorType_STRING:
      return mlir::TF::StringType::get(builder.getContext());
    case tflite::TensorType_BOOL:
      return builder.getI1Type();
    case tflite::TensorType_INT16:
      return builder.getIntegerType(16);
    case tflite::TensorType_COMPLEX64:
      return mlir::ComplexType::get(builder.getF32Type());
    case tflite::TensorType_COMPLEX128:

              mlir::Value reduction_indices,
              bool keep_dims = false) -> mlir::Operation* {
             return opb
                 .create<mlir::TF::AnyOp>(loc, opb.getI1Type(), input,
                                          reduction_indices, keep_dims)
                 .getOperation();
           });

  // mlir::TF::ConstOp
  py::class_<mlir::TF::ConstOp>(m, "Tf_ConstOp")

    OpBuilder<(ins "Value":$x, "Value":$y),
    [{
  Type resultType;
  if (x.getType().isa<UnrankedTensorType>() ||
      y.getType().isa<UnrankedTensorType>()) {
    resultType = UnrankedTensorType::get($_builder.getI1Type());
  } else {
    SmallVector<int64_t, 4> resultShape;
    if (!OpTrait::util::getBroadcastedShape(
            x.getType().cast<ShapedType>().getShape(),

      loc, ArrayRef<Type>{}, ArrayRef<Value>{local_var, value});
}

Value AccumulateBuffers(Value a, Value b, OpBuilder builder, Location loc) {
  if (getElementTypeOrSelf(a.getType()) == builder.getI1Type()) {
    return builder.create<TF::LogicalOrOp>(loc, ArrayRef<Type>{a.getType()},
                                           ArrayRef<Value>{a, b});
  }
  return builder.create<TF::AddV2Op>(loc, ArrayRef<Type>{a.getType()},

    if (element_type == "i32_") return builder.getI32Type();
    if (element_type == "i64_") return builder.getI64Type();
    if (element_type == "f32_") return builder.getF32Type();
    if (element_type == "i1_") return builder.getI1Type();
    return {};
  }

  // Adds a tf.Cast op if the tfr.tensor attribute indicated a fixed element
  // type.
  // TODO(fengliuai): This method is required when the operand types are not set

    Type control_type = ControlType::get(parser.getBuilder().getContext());
    result.types.append(2, types[0]);
    result.types.push_back(control_type);
    Type i1_type = parser.getBuilder().getI1Type();
    RankedTensorType predicate_type = RankedTensorType::get({}, i1_type);
    types.push_back(predicate_type);
    types.append(op_infos.size() - 2, control_type);
  }

    if (!const_true)
      const_true = builder.create<TF::ConstOp>(
          op.getLoc(),
          DenseIntElementsAttr::get(
              RankedTensorType::get(/*shape=*/{}, builder.getI1Type()), true));

    op.getIsInitialized().replaceAllUsesWith(const_true);
    op.erase();
  }
}

// Performs store-load forwarding. This effectively removes

        loc, tensorflow::GetTypeFromTFTensorShape({}, shape_dtype), size,
        input_size);
    auto if_cond = rewriter.create<TF::GreaterOp>(
        loc, tensorflow::GetTypeFromTFTensorShape({}, rewriter.getI1Type()),
        size_diff, scalar_zero);

    // Build the argument/result types for if branch function.
    auto input_shape = rewriter.create<TF::ShapeOp>(