newb.nobj = 0
			lfnodeValidate(&newb.node)
			if i == 0 {
				b = newb
			} else {
				putempty(newb)
			}
		}
	}
	return b
}

// putempty puts a workbuf onto the work.empty list.
// Upon entry this goroutine owns b. The lfstack.push relinquishes ownership.
//
//go:nowritebarrier
func putempty(b *workbuf) {
	b.checkempty()
	work.empty.push(&b.node)
}

	if s.freeBuf != nil {
		putempty((*workbuf)(unsafe.Pointer(s.freeBuf)))
		s.freeBuf = nil
	}
	return 0, false
}

// addObject adds a stack object at addr of type typ to the set of stack objects.
func (s *stackScanState) addObject(addr uintptr, r *stackObjectRecord) {
	x := s.tail
	if x == nil {
		// initial setup
		x = (*stackObjectBuf)(unsafe.Pointer(getempty()))
		x.next = nil
		s.head = x

					continue
				}
				println("  dead stkobj at", hex(gp.stack.lo+uintptr(obj.off)), "of size", obj.r.size)
				// Note: not necessarily really dead - only reachable-from-ptr dead.
			}
		}
		x.nobj = 0
		putempty((*workbuf)(unsafe.Pointer(x)))
	}
	if state.buf != nil || state.cbuf != nil || state.freeBuf != nil {
		throw("remaining pointer buffers")
	}
	return int64(scannedSize)
}

) {

    private
    val q = ArrayDeque<T>()

    private
    val lock = ReentrantLock()

    private
    val notEmpty = lock.newCondition()

    fun push(element: T) {
        lock.withLock {
            q.addFirst(element)
            if (q.size == 1) {
                notEmpty.signal()
            }
        }
    }

    /**
     * Returns the next group of elements after removing them from the queue.

            versionRef = notEmpty(versionTable.getString("ref"), "version reference", alias);
            require = notEmpty(versionTable.getString("require"), "required version", alias);
            prefer = notEmpty(versionTable.getString("prefer"), "preferred version", alias);
            strictly = notEmpty(versionTable.getString("strictly"), "strict version", alias);

	res1_initial, _, _ := fetchPath(manager1, "application/json", discoveryPath, "")
	res2_initial, _, _ := fetchPath(manager2, "application/json", discoveryPath, "")

	assert.NotEmpty(t, res1_initial.Header.Get("ETag"), "Etag should be populated")
	assert.NotEmpty(t, res2_initial.Header.Get("ETag"), "Etag should be populated")
	assert.Equal(t, res1_initial.Header.Get("ETag"), res2_initial.Header.Get("ETag"), "etag should be deterministic")

                .notEmpty()
                .validInFileName();
        IvyFieldValidator moduleName = field(publication, "module name", identity.getName())
                .notEmpty()
                .validInFileName();
        IvyFieldValidator revision = field(publication, "revision", identity.getVersion())
                .notEmpty()
                .validInFileName();

                .validMavenIdentifier();
        MavenFieldValidator versionValidator = field(publication, "version", publication.getVersion())
                .notEmpty()
                .validInFileName();

        if (!hasParentPom) {
            groupIdValidator.matches(model.getGroupId());
            versionValidator.matches(model.getVersion());
        }
    }

        if (value == null) {
            String message = String.format("%s cannot be null.", name);
            throw failure(message);
        }
        return type.cast(this);
    }

    public T notEmpty() {
        notNull();
        if (value.length() == 0) {
            throw failure(String.format("%s cannot be empty.", name));
        }
        return type.cast(this);
    }

    public T validInFileName() {

        sanityCheckApplicationIds()

        if (notEmpty(initFile)) {
            initScriptAppId = findScriptApplicationId(targetsGradle(), scriptFile(initFile))
        }
        if (hasScript(initFile, scriptFile.name)) {
            initOtherScriptAppId = findScriptApplicationId(targetsGradle(), scriptFile(scriptFile))
        }
        if (notEmpty(settingsFile)) {