// license that can be found in the LICENSE file.

// Package inspector provides helper functions for traversal over the
// syntax trees of a package, including node filtering by type, and
// materialization of the traversal stack.
//
// During construction, the inspector does a complete traversal and
// builds a list of push/pop events and their node type. Subsequent

  // that is not supported in MHLO will fail conversion. Quantized types are
  // going to handled separately so we don't need to handle those.
  addConversion([](Type ty) { return ty; });

  // This materialization is helpful in cases where we have more refined types
  // after conversion to mhlo compared to the original type in TF. For example,
  // a TF op with result type tensor<*xf32> will have a bounded type after

		{"Num", func(x *Rat) { x.Num() }},
		// {"Denom", func(x *Rat) { x.Denom() }}, TODO(gri) should we change the API? See issue #33792.
	} {
		// A denominator of length 0 is interpreted as 1. Make sure that
		// "materialization" of the denominator doesn't lead to setting
		// the underlying array element 0 to 1.
		r := &Rat{Int{abs: nat{991}}, Int{abs: make(nat, 0, 1)}}
		acc.f(r)
		if d := r.b.abs[:1][0]; d != 0 {

  // memory by at least min_savings. If max_cost >= 0, at most max_cost
  // operations will be re-inserted. For each rematerialization found,
  // ApplyRemat is invoked (which can be used to apply the rematerialization to
  // the higher- level representation, e.g., MLIR, flatbuffer, ...)
  void RunGreedyAlgorithm(int max_cost, int max_block_length,
                          SizeT min_savings);

        // can be replaced with uses of the rematerialized tensor, and the
        // original tensor can be deallocated after its last use before the
        // rematerialization.
        add_dealloc(*std::partition_point(
            tensor.operations.rbegin(), tensor.operations.rend(),
            [&](int i) { return i >= remat.insert; }));
      }
    }
  }

      This allows us to have an IR of the model that is in the same execution order
      as it will have at runtime (provided Flex is the only delegate present); this
      allows us to do optimizations such as rematerialization.
    }];
  let dependentDialects = ["TFL::TensorFlowLiteDialect"];
}

def PinOpsWithSideEffectsPass : Pass<"tfl-pin-ops-with-side-effects", "mlir::func::FuncOp"> {

		}
	}
	return c
}

// copyIntoWithXPos makes a new value identical to v and adds it to the end of b.
// The supplied position is used as the position of the new value.
// Because this is used for rematerialization, check for case that (rematerialized)
// input to value with position 'pos' carried a statement mark, and that the supplied
// position (of the instruction using the rematerialized value) is not marked, and

    this will happen in one of the last steps before emitting the flatbuffer model
    in order to enable optimizations that rely on a fixed order of operations (such
    as rematerialization.)
    The flatbuffer exporter will unwrap the wrapped region and annotate the generated
    model with metadata such that any runtime reorderings will respect the order
    given by the control dependencies.
  }];