*/
    enum Skip {

        /**
         * Do not skip this test, this is the default.
         */
        DO_NOT_SKIP,

        /**
         * Use this reason on unrolled tests in super classes that fail on some subclasses.
         * Spock doesn't allow to override test methods and annotate them.
         */
        UNROLLED_FAILS_IN_SUBCLASS,

        /**

#include "tensorflow/cc/ops/array_ops.h"
#include "tensorflow/cc/ops/manip_ops.h"
#include "tensorflow/core/lib/core/status_test_util.h"

namespace tensorflow {
namespace {

using ops::Placeholder;
using ops::Roll;

class ManipGradTest : public ::testing::Test {
 protected:
  ManipGradTest() : scope_(Scope::NewRootScope()) {}

  void RunTest(const Output& x, const TensorShape& x_shape, const Output& y,

            parentListEl = parentListEl.parentNode.closest("li");
        }

        // Only scroll if the device is a desktop.
        //
        // Mobile's `docs-navigation` is always at bottom of `content`,
        // so we should not slide down to where `docs-navigation` lays.
        if (desktopMediaQuery.matches) {
            // Scroll to center of the page

        return getXContentBuilderOutputStream((builder, params) -> xContent.toXContent(builder, params), mediaType);
    }

    public static long scroll(final String index, final Function<SearchHit, Boolean> callback) {
        final SearchEngineClient client = ComponentUtil.getSearchEngineClient();

	_ = b[3]             // bounds check
	x := *p              // load a byte
	y := uint32(x)       // zero extend to 32 bits
	b[0] = byte(y >> 24) // compute ROLL
	b[1] = byte(y >> 16)
	b[2] = byte(y >> 8)
	b[3] = byte(y)
	nop()                // spill/restore ROLL
	b[0] = byte(y >> 24) // use ROLL
	b[1] = byte(y >> 16)
	b[2] = byte(y >> 8)
	b[3] = byte(y)
}

//go:noinline
func f64(p *uint8, b []byte) {

		panic("info must not be empty")
	}
	c.cache.Set(keyFunc(dataCtx), transformer, c.ttl)
}

func keyFunc(dataCtx value.Context) string {
	return toString(dataCtx.AuthenticatedData())
}

// toString performs unholy acts to avoid allocations
func toString(b []byte) string {
	// unsafe.SliceData relies on cap whereas we want to rely on len
	if len(b) == 0 {
		return ""
	}
	// Copied from go 1.20.1 strings.Builder.String

  auto shift = op.input(1);
  auto axis = op.input(2);
  auto grad_op = Roll(scope, grad_inputs[0], Neg(scope, shift), axis);
  grad_outputs->push_back(grad_op);
  grad_outputs->push_back(NoGradient());
  grad_outputs->push_back(NoGradient());
  return scope.status();
}
REGISTER_GRADIENT_OP("Roll", RollGrad);

}  // namespace
}  // namespace ops

            "scenario",
            "",
            display = ParameterDisplay.PROMPT,
            allowEmpty = false,
            description = "Which performance test to run. Should be the fully qualified class name dot (unrolled) method name. E.g. org.gradle.performance.regression.java.JavaUpToDatePerformanceTest.up-to-date assemble (parallel true)"
        )

        // we wait for additional text, we assume this row doesn't count as overlapping and use it as a status
        // line. In the opposite case, we want to scroll the progress area one more line. This avoid having an one
        // line gap between the text area and the status area.
        if (buildOutputArea.getWritePosition().col > 0) {
            numberOfOverlappedRows++;
        }

#include "mlir/Pass/PassRegistry.h"  // from @llvm-project
#include "mlir/Support/LLVM.h"  // from @llvm-project
#include "xla/mlir_hlo/mhlo/IR/hlo_ops.h"

namespace mlir {
namespace odml {
namespace {

#define DEBUG_TYPE "unfold-splat-constant-pass"

#define GEN_PASS_DEF_UNFOLDSPLATCONSTANTPASS
#include "tensorflow/compiler/mlir/lite/stablehlo/transforms/passes.h.inc"

// Undo the MHLO::BroadcastInDimOp folding pattern on splat tensor.