} else {
			print(" m=nil")
		}
	}
	print(" [", status)
	if isScan {
		print(" (scan)")
	}
	if waitfor >= 1 {
		print(", ", waitfor, " minutes")
	}
	if gp.lockedm != 0 {
		print(", locked to thread")
	}
	print("]:\n")
}

func tracebackothers(me *g) {
	level, _, _ := gotraceback()

	// Show the current goroutine first, if we haven't already.

			// already generated, run through the outboundListenerEntry map and set
			// the locked bit to true.
			// buildSidecarOutboundListener will not add/merge
			// any HTTP/TCP listener if there is already a outboundListenerEntry
			// with locked bit set to true
			for _, e := range listenerMap {
				e.locked = true
			}

			for _, service := range services {
				saddress := service.GetAddressForProxy(node)

				}
			},

			lock : function () {
				this.data.core.locked = true;
				this.get_container().children("ul").addClass("jstree-locked").css("opacity","0.7");
				this.__callback({});
			},
			unlock : function () {
				this.data.core.locked = false;
				this.get_container().children("ul").removeClass("jstree-locked").css("opacity","1");
				this.__callback({});
			},

			startTime := time.Now()
			timeout := c.dispatchTimeoutBudget.takeAvailable()
			c.timer.Reset(timeout)

			// Send event to all blocked watchers. As long as timer is running,
			// `add` will wait for the watcher to unblock. After timeout,
			// `add` will not wait, but immediately close a still blocked watcher.
			// Hence, every watcher gets the chance to unblock itself while timer
			// is running, not only the first ones in the list.

            assert dep.reason == reason
        }

        where:
        reason                                                          | strict
        "dependency was locked to version '1.1'"                        | true
        "dependency was locked to version '1.1' (update/lenient mode)"  | false
    }

    private ResolverResults buildDependenciesResolved() {

    }

    private String getLockReason(boolean strict, String lockedVersion) {
        if (strict) {
            return "dependency was locked to version '" + lockedVersion + "'";
        }
        return "dependency was locked to version '" + lockedVersion + "' (update/lenient mode)";
    }

    @Override
    public DomainObjectContext getDomainObjectContext() {

	{45, "EDEADLK", "deadlock condition if locked"},
	{46, "ENOTREADY", "device not ready"},
	{47, "EWRPROTECT", "write-protected media"},
	{48, "EFORMAT", "unformatted or incompatible media"},
	{49, "ENOLCK", "no locks available"},
	{50, "ENOCONNECT", "cannot Establish Connection"},
	{52, "ESTALE", "missing file or filesystem"},
	{53, "EDIST", "requests blocked by Administrator"},

	{45, "EDEADLK", "deadlock condition if locked"},
	{46, "ENOTREADY", "device not ready"},
	{47, "EWRPROTECT", "write-protected media"},
	{48, "EFORMAT", "unformatted or incompatible media"},
	{49, "ENOLCK", "no locks available"},
	{50, "ENOCONNECT", "cannot Establish Connection"},
	{52, "ESTALE", "missing file or filesystem"},
	{53, "EDIST", "requests blocked by Administrator"},

	// this before waking blocked assists.
	atomic.Store(&gcBlackenEnabled, 0)

	// Notify the CPU limiter that GC assists will now cease.
	gcCPULimiter.startGCTransition(false, now)

	// Wake all blocked assists. These will run when we
	// start the world again.
	gcWakeAllAssists()

	// Likewise, release the transition lock. Blocked
	// workers and assists will run when we start the

// condition.
//
//go:nowritebarrierrec
func gcFlushBgCredit(scanWork int64) {
	if work.assistQueue.q.empty() {
		// Fast path; there are no blocked assists. There's a
		// small window here where an assist may add itself to
		// the blocked queue and park. If that happens, we'll
		// just get it on the next flush.
		gcController.bgScanCredit.Add(scanWork)
		return
	}