}
	}
	t.Logf("For requiredSum=%v, %s classes=%#+v got solution %v, %v", requiredSum, style, classes, allocs, fairProp)
}

// partition64 calls consume n times, passing ints [0,n) and floats that sum to x
func partition64(rands *rand.Rand, n int, x float64, consume func(int, float64)) {
	if n <= 0 {
		return
	}
	divs := make([]float64, n-1)
	for idx := range divs {

      const std::function<bool(Operation *)> &partition = IsFlexDelegate)
      : partition_(partition) {}

  void runOnOperation() override;

 private:
  const std::function<bool(Operation *)> partition_;
};

void PartitionedTopologicalSortPass::runOnOperation() {
  func::FuncOp func = getOperation();
  if (!PartitionedTopologicalSort(func, &func.getBody().front(), partition_)) {
    return signalPassFailure();
  }

// RUN: odml-to-stablehlo-opt %s --tf-stablehlo=skip-partitioned-calls=true | FileCheck %s --check-prefix=CHECK-SKIP
// RUN: odml-to-stablehlo-opt %s --tf-stablehlo=skip-partitioned-calls=false | FileCheck %s --check-prefix=CHECK-NOSKIP

module {
  func.func @partitioned_call(%arg0: tensor<1x2x2x3xf32>) -> (tensor<1x2x2x3xf32>) {
    %0 = "tf.StatefulPartitionedCall"(%arg0) <{
      config = "", config_proto = "", executor_type = "", f = @some_func
    }> {

// RUN: tf-opt %s -tfl-partitioned-topological-sort | FileCheck %s

// CHECK-LABEL: @tf_ops_will_be_partitioned
func.func @tf_ops_will_be_partitioned() -> tensor<1xf32> {
  %const = "tfl.pseudo_const"() {value = dense<[1.0]> : tensor<1xf32>} : () -> tensor<1xf32>
  %tmp1 = "tfl.add"(%const, %const) { fused_activation_function = "NONE" } : (tensor<1xf32>,tensor<1xf32>) -> (tensor<1xf32>)

		},
		{
			name: "with swap enabled, one partition",
			procSwapsContent: `
Filename				Type		Size		Used		Priority
/dev/dm-1               partition	33554428	0		-2
`,
			expectedEnabled: true,
		},
		{
			name: "with swap enabled, 2 partitions",
			procSwapsContent: `
Filename				Type		Size		Used		Priority
/dev/dm-1               partition	33554428	0		-2
/dev/zram0              partition	8388604		0		100
`,

				}
			}
			if len(splitPoints) == 1 {
				continue // no splits, leave equivalence class alone.
			}

			// Move another equivalence class down in place of e.
			partition[i] = partition[len(partition)-1]
			partition = partition[:len(partition)-1]
			i--

			// Add new equivalence classes for the parts of e we found.
			splitPoints = append(splitPoints, len(e))
			for j := 0; j < len(splitPoints)-1; j++ {

		},
		{
			// missing element 2
			vars: []*ir.Name{v1, v2, v3},
			partition: map[*ir.Name][]int{
				v1: []int{0, 1},
				v2: []int{0, 1},
				v3: []int{0, 1},
			},
			experr: true,
		},
		{
			// partitions disagree for v1 vs v2
			vars: []*ir.Name{v1, v2, v3},
			partition: map[*ir.Name][]int{
				v1: []int{0, 1, 2},
				v2: []int{1, 0, 2},
				v3: []int{0, 1, 2},
			},
			experr: true,
		},
	}

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package cmd

import (
	"errors"

	"github.com/zeebo/xxh3"
)

// getFileInfoVersions partitions this object's versions such that,
//   - fivs.Versions has all the non-free versions
//   - fivs.FreeVersions has all the free versions
//

  // [g1, g2, g4, g5, g3]
  auto data = op.input(0);
  auto partitions = op.input(1);
  int32_t num_partitions;
  TF_RETURN_IF_ERROR(
      GetNodeAttr(op.node()->attrs(), "num_partitions", &num_partitions));

  // Note: the shape of the partitions is a prefix of the data shape.
  // shape(partitions) = [5]
  auto partitions_shape = Shape(scope, partitions);
  // We now create a partitions-shaped tensor with integers from

The new [Cookie.Partitioned] field identifies cookies with the Partitioned attribute....