and kept doubling itself up and straightening itself out again,
so that altogether, for the first minute or two, it was as much
as she could do to hold it.

  As soon as she had made out the proper way of nursing it,
(which was to twist it up into a sort of knot, and then keep
tight hold of its right ear and left foot, so as to prevent its
undoing itself,) she carried it out into the open air.  `IF I

and kept doubling itself up and straightening itself out again,
so that altogether, for the first minute or two, it was as much
as she could do to hold it.

  As soon as she had made out the proper way of nursing it,
(which was to twist it up into a sort of knot, and then keep
tight hold of its right ear and left foot, so as to prevent its
undoing itself,) she carried it out into the open air.  `IF I

almost as volatile as Water, and the Antimony alone as fix'd as Lead? When _Aqua fortis_ dissolves Silver and not Gold, and _Aqua regia_ dissolves Gold and not Silver, may it not be said that _Aqua fortis_ is subtil enough to penetrate Gold as well as Silver, but wants the attractive Force to give it Entrance; and that _Aqua regia_ is subtil enough to penetrate Silver as well as Gold, but wants the attractive Force to give it Entrance? For _Aqua regia_ is nothing else than _Aqua fortis_ mix'd with...

  }

  // Also fold if `input` has a known rank.
  auto input_type = getInput().getType().cast<ShapedType>();
  // Do not fold if rank is zero because the TFLite converter doesn't
  // distinguish between unranked input and scalar input due to b/138865275.
  // TODO(b/138865275): Remove `input_type.getRank() != 0` in the following
  // predicate and fold the op when rank is zero.

                          << range_begin << ", " << range_end
                          << "); actual value: " << axis;
  }

  return success();
}

OpFoldResult PackOp::fold(FoldAdaptor) {
  // Fold pack operation if it computes the input tensor shape:
  //
  //   %shape  = tf.Shape(%arg)                    // [? x ...]
  //   %dim0   = tf.StridedSlice(%shape, 0, 1, 1)  // get unknown dim0 value

// AddNOp
//===----------------------------------------------------------------------===//

OpFoldResult AddNOp::fold(FoldAdaptor adaptor) {
  auto operands = adaptor.getOperands();
  if (operands.size() == 1) return *getInputs().begin();

  // Fold if there is only one single non-zero operand or all operands are zero.
  int non_zero_index = -1;
  auto IsKnownZero = [](Attribute attr) {

		t.Second.goString(indent+2, "Second: "),
		t.Third.goString(indent+2, "Third: "))
}

// Fold is a C++17 fold-expression.  Arg2 is nil for a unary operator.
type Fold struct {
	Left bool
	Op   AST
	Arg1 AST
	Arg2 AST
}

func (f *Fold) print(ps *printState) {
	op, _ := f.Op.(*Operator)
	printOp := func() {
		if op != nil {
			if ps.llvmStyle {

  let summary = "Move transposes pass.";
  let constructor = "TF::CreateMoveTransposesPass()";
  let options = [
    Option<"fold_transpose_in_ops_", "fold-transpose-in-ops", "bool", /*default=*/"true",
           "Whether to fold transposes in ops which can support folding.">,
    Option<"direction_", "direction", "enum MoveTransposeDirection",

    // TF::MulOp is used to fold the constant.
    // TODO(b/139192933): switch to the TFL constant folding
    auto filter_type = mlir::cast<ShapedType>(filter.getType());
    if (filter_type.hasStaticShape()) {
      auto size =
          filter_type.getNumElements() * filter_type.getElementTypeBitWidth();
      // Don't constant fold if the filter is too large for TF to fold.

      Map<? extends K, ? extends V> map) {
    return new HashMap<>(map);
  }

  /**
   * Creates a {@code HashMap} instance, with a high enough "initial capacity" that it <i>should</i>
   * hold {@code expectedSize} elements without growth. This behavior cannot be broadly guaranteed,
   * but it is observed to be true for OpenJDK 1.7. It also can't be guaranteed that the method