// AIX does not allow mapping a range that is already mapped.
	// So, call mprotect to change permissions.
	// Note that sysMap is always called with a non-nil pointer
	// since it transitions a Reserved memory region to Prepared,
	// so mprotect is always possible.
	_, err := mprotect(v, n, _PROT_READ|_PROT_WRITE)
	if err == _ENOMEM {
		throw("runtime: out of memory")
	}
	if err != 0 {

                                      llvm::ArrayRef<mlir::Type>(outputs));
           });
  py::class_<mlir::OpBuilder>(m, "OpBuilder")
      .def(py::init<mlir::MLIRContext*>())
      .def(py::init<mlir::Region&>())
      .def(py::init<mlir::Operation*>())
      .def(py::init<mlir::Block*, mlir::Block::iterator>())
      .def("getUnknownLoc", &mlir::OpBuilder::getUnknownLoc)
      .def("setInsertionPoint",

	ntype := strings.Split(value, "~")[0]
	return newOption("nodeType", ntype)
}

func XdsType(value string) Instance {
	return newOption("xds_type", value)
}

func Region(value string) Instance {
	return newOptionOrSkipIfZero("region", value)
}

func Zone(value string) Instance {
	return newOptionOrSkipIfZero("zone", value)
}

func SubZone(value string) Instance {

	}
}

func TestPhysPageSize(t *testing.T) {
	// Mmap fails if the address is not page aligned, so we can
	// use this to test if the page size is the true page size.
	ps := runtime.GetPhysPageSize()

	// Get a region of memory to play with. This should be page-aligned.
	b, err := runtime.Mmap(nil, 2*ps, 0, runtime.MAP_ANON|runtime.MAP_PRIVATE, -1, 0)
	if err != 0 {
		t.Fatalf("Mmap: %v", err)
	}

	if runtime.GOOS == "aix" {

namespace mlir {

namespace {

#define GEN_PASS_DEF_XLAINLINEDEVICEOPSPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_device_passes.h.inc"

// XlaInlineDeviceOps Pass will inline cluster op based in the parent region.
struct XlaInlineDeviceOpsPass
    : public impl::XlaInlineDeviceOpsPassBase<XlaInlineDeviceOpsPass> {
  void runOnOperation() override;
};

void InlineDeviceOp(tf_device::ClusterOp cluster_op) {

	madvise(v, n, _MADV_FREE_REUSABLE)
}

func sysUsedOS(v unsafe.Pointer, n uintptr) {
	// MADV_FREE_REUSE is necessary to keep the kernel's accounting
	// accurate. If called on any memory region that hasn't been
	// MADV_FREE_REUSABLE'd, it's a no-op.
	madvise(v, n, _MADV_FREE_REUSE)
}

func sysHugePageOS(v unsafe.Pointer, n uintptr) {
}

func sysNoHugePageOS(v unsafe.Pointer, n uintptr) {
}

        if (dependency instanceof DefaultDependencyConstraint) {
            ((DefaultDependencyConstraint) dependency).setAttributesFactory(attributesFactory);
        }
    }

    // region DependencyConstraintFactory methods

    @Override
    public DependencyConstraint create(CharSequence dependencyNotation) {

//   case. If successful, the following invariants will hold true:
//   (a) For if/case, any resource type results will be deleted.
//   (b) For while, any resource type results will be unused.
// - Canonicalize region based control flow. Again, any resource outputs are
//   expected to be resolved to be one of the captured resource inputs. Fails
//   if this is not the case. If successful, the following invariants will hold
//   true:

String id=21
	data="start trace"
String id=22
	data="task0"
String id=23
	data="task0 region"
String id=24
	data="unended region"
String id=25
	data="region0"
String id=26
	data="region1"
String id=27
	data="key0"
String id=28
	data="0123456789abcdef"
String id=29
	data="post-existing region"
String id=30
	data="main.main.func1.1"
String id=31

        then:
        ranWithLocale changeLocale
        daemons.daemons.size() == 1
    }

    @Issue("https://github.com/gradle/gradle/issues/4973")
    def "can use a locale without region (#overrideVersion)"() {
        Locale locale = Locale.ENGLISH
        buildScript """
            import org.gradle.util.GradleVersion

            task printLocale {
                doFirst {