// Holds a map of recently logged errors.
type logOnceType struct {
	IDMap map[string]onceErr
	sync.Mutex
}

func (l *logOnceType) logOnceConsoleIf(ctx context.Context, subsystem string, err error, id string, errKind ...interface{}) {
	if err == nil {
		return
	}

	nerr := unwrapErrs(err)
	l.Lock()
	shouldLog := true
	prev, ok := l.IDMap[id]
	if !ok {
		l.IDMap[id] = onceErr{
			Err:   nerr,
			Count: 1,
		}

func (intMapType) NewMap() Map {
	return make(intMap)
}

var deadcafe = []byte("\xDE\xAD\xCA\xFE")

type intMap map[int][]byte

func (m intMap) AddItem() {
	s0 := len(m)
	for len(m) == s0 {
		key := rand.Intn(s0 + 1)
		m[key] = make([]byte, rand.Intn(64<<10))
	}
}

func (m intMap) DelItem() {
	for k := range m {
		delete(m, k)
		return
	}
}

func (m intMap) GetItem() {
	key := rand.Intn(len(m))

    @Override
    void afterBuild() {
        Map<String, Map<String, String>> idsMap = idsFile.readLines()
            .collect { line -> new JsonSlurper().parse(new StringReader(line)) as Map<String, Map<String, String>> }
            .collectMany { it.entrySet() }
            .collectEntries { it }
        Map<String, ScopeIds> ids = [:]
        idsMap.each {
            ids[it.key] = new ScopeIds(

func Stats() (*statsapi.RlimitStats, error) {
	rlimit := &statsapi.RlimitStats{}

	taskMax := int64(-1)
	// Calculate the minimum of kernel.pid_max and kernel.threads-max as they both specify the
	// system-wide limit on the number of tasks.
	for _, file := range []string{"/proc/sys/kernel/pid_max", "/proc/sys/kernel/threads-max"} {
		if content, err := os.ReadFile(file); err == nil {

          << "Malformed " << TF::kParallelExecAnnotation << " attribute";
      return failure();
    }
    if (id_pairs.empty()) continue;

    TF::ParallelIdsMap& ids_map = op_to_parallel_ids_map[island];
    for (const auto& [group_id, branch_id] : id_pairs)
      ids_map[group_id] = branch_id;
  }
  return success();
}

// Fills `op_to_parallel_ids_map` from parallel execution attributes in

	isInt(Int(0))
	i = 10
	asInt(*&i)
	isInt(*&i)
	asInt(23)
	asInt(Int(f))
	isInt(Int(f))

	asMap(m)
	isMap(m)
	asMap(nil)
	m = nil
	asMap(make(Map))
	isMap(make(Map))
	asMap(*&m)
	isMap(*&m)
	asMap(Map(nil))
	isMap(Map(nil))
	asMap(Map{})
	isMap(Map{})

	asSlice(slice)
	isSlice(slice)
	asSlice(make(Slice, 5))
	isSlice(make(Slice, 5))
	asSlice([]byte{1, 2, 3})

            boolean isCollection = false;
            boolean isMap = false;
            boolean isProperties = false;
            if (!isArray) {
                try {
                    // assuming Type is available in current ClassLoader
                    isCollection = Collection.class.isAssignableFrom(Class.forName(param.getType()));
                    isMap = Map.class.isAssignableFrom(Class.forName(param.getType()));

// (ref: https://github.com/torvalds/linux/commit/35dfb013149f74c2be1ff9c78f14e6a3cd1539d1)
const IPVSConnReuseModeFixedKernelVersion = "5.9"

// UserNamespacesSupportKernelVersion is the kernel version where idmap for tmpfs support was added
// (ref: https://github.com/torvalds/linux/commit/05e6295f7b5e05f09e369a3eb2882ec5b40fff20)
const UserNamespacesSupportKernelVersion = "6.3"

// > 0 if the first is greater.
func _New[K, V any](compare func(K, K) int) *_Map[K, V] {
	return &_Map[K, V]{compare: compare}
}

// _NewOrdered returns a new map whose key is an ordered type.
// This is like _New, but does not require providing a compare function.
// The map compare function uses the obvious key ordering.
func _NewOrdered[K Ordered, V any]() *_Map[K, V] {
	return _New[K, V](func(k1, k2 K) int {
		switch {
		case k1 < k2:

			Out:  `{"boolkey":true,"floatkey":1,"intkey":1,"nullkey":null}`, // gets alphabetized by Marshal
		},
	}

	for i, tc := range testCases {
		t.Run(fmt.Sprintf("%d_map", i), func(t *testing.T) {
			// decode the input as a map item
			inputJSON := fmt.Sprintf(`{"data":%s}`, tc.In)
			expectedJSON := fmt.Sprintf(`{"data":%s}`, tc.Out)
			m := map[string]interface{}{}