slices.Sort(pauses)
	var total uint64
	for _, ns := range pauses {
		total += ns
	}
	// ns/op for this benchmark is average STW time.
	b.ReportMetric(float64(total)/float64(b.N), "ns/op")
	b.ReportMetric(float64(pauses[len(pauses)*95/100]), "p95-ns/STW")
	b.ReportMetric(float64(pauses[len(pauses)*50/100]), "p50-ns/STW")
}

func BenchmarkPoolExpensiveNew(b *testing.B) {

	// Verify that /gc/pauses:seconds is a copy of /sched/pauses/total/gc:seconds
	if !reflect.DeepEqual(gcPauses.Buckets, schedPausesTotalGC.Buckets) {
		t.Errorf("/gc/pauses:seconds buckets %v do not match /sched/pauses/total/gc:seconds buckets %v", gcPauses.Buckets, schedPausesTotalGC.Counts)
	}
	if !reflect.DeepEqual(gcPauses.Counts, schedPausesTotalGC.Counts) {

	/cpu/classes/gc/pause:cpu-seconds
		Estimated total CPU time spent with the application paused by
		the GC. Even if only one thread is running during the pause,
		this is computed as GOMAXPROCS times the pause latency because
		nothing else can be executing. This is the exact sum of samples
		in /sched/pauses/total/gc:seconds if each sample is multiplied
		by GOMAXPROCS at the time it is taken. This metric is an

	// any conversion.
	readGCStats(&stats.Pause)
	n := len(stats.Pause) - 3
	stats.LastGC = time.Unix(0, int64(stats.Pause[n]))
	stats.NumGC = int64(stats.Pause[n+1])
	stats.PauseTotal = stats.Pause[n+2]
	n /= 2 // buffer holds pauses and end times
	stats.Pause = stats.Pause[:n]

	if cap(stats.PauseEnd) < maxPause {
		stats.PauseEnd = make([]time.Time, 0, maxPause)
	}

		// sched.idleTime and sched.totaltime. memstats also include
		// the pause time (work,pauseNS), forcing computation of the
		// total pause time before the pause actually ends.
		//
		// Here we reuse the same now for start the world so that the
		// time added to /sched/pauses/total/gc:seconds will be
		// consistent with the value in memstats.
		startTheWorldWithSema(now, stw)
	})

#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/passes.h.inc"

}  // namespace mlir::quant::stablehlo

#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
#include "mlir/Pass/Pass.h"  // from @llvm-project

namespace mlir::odml {

std::unique_ptr<OperationPass<func::FuncOp>> CreateOutlineCompositesPass();

std::unique_ptr<OperationPass<ModuleOp>> CreateSHLOSimplifyPass();

#define GEN_PASS_REGISTRATION
#include "tensorflow/compiler/mlir/lite/stablehlo/odml_converter/passes.h.inc"

}  // namespace mlir::odml

		exit(0);

	default:
		return FALSE;
	}
}

int main(int argc, char **argv)
{
	int i;
	for (i = 1; i < argc; ++i)
	{
		if (!_stricmp(argv[i], "-v"))
		{
			fprintf(stdout, "pause.c %s\n", VERSION_STRING(VERSION));
			return 0;
		}
	}

	if (SetConsoleCtrlHandler(CtrlHandler, TRUE))
	{
		Sleep(INFINITE);
	}
	else
	{
		printf("\nERROR: Could not set control handler\n");

#include "mlir/Pass/Pass.h"  // from @llvm-project

namespace mlir {
namespace odml {

// Creates a pass which unfuses MHLO batch norm inference op into arithmetic
// ops.
std::unique_ptr<Pass> createUnfuseBatchNormPass();

// Creates a pass which constant folds broadcast_in_dim op conditionally.
std::unique_ptr<Pass> createFoldBroadcastPass();

                             llvm::cl::desc("Enable Cluster Formation pass."),
                             llvm::cl::init(false)};
};

// Propagates the pass manager with the passes involved in transforming or
// optimizing an MLIR graph without any target specialization.
// NOLINTNEXTLINE - MLIR contract is pass by mutable reference.
void CreateTFStandardPipeline(OpPassManager& pm,