//
// nosplit to ensure it can be called in as many contexts as possible.
//
//go:nosplit
func worldStarted() {
	if stopped := worldIsStopped.Add(-1); stopped != 0 {
		systemstack(func() {
			print("world stop count=", stopped, "\n")
			throw("released non-stopped world stop")
		})
	}
}

// nosplit to ensure it can be called in as many contexts as possible.
//
//go:nosplit

<img src="/img/tutorial/custom-response/image01.png">

## Available responses

Here are some of the available responses.

Keep in mind that you can use `Response` to return anything else, or even create a custom sub-class.

!!! note "Technical Details"
    You could also use `from starlette.responses import HTMLResponse`.

		include tiny objects as defined by /gc/heap/tiny/allocs:objects,
		only tiny blocks.

	/gc/heap/allocs:bytes
		Cumulative sum of memory allocated to the heap by the
		application.

	/gc/heap/allocs:objects
		Cumulative count of heap allocations triggered by the
		application. Note that this does not include tiny objects as
		defined by /gc/heap/tiny/allocs:objects, only tiny blocks.

		return nil, err
	}

	if missedSchedules == manyMissed {
		recorder.Eventf(cj, corev1.EventTypeWarning, "TooManyMissedTimes", "too many missed start times. Set or decrease .spec.startingDeadlineSeconds or check clock skew")
		logger.Info("too many missed times", "cronjob", klog.KObj(cj))
	}

	return mostRecentTime, err
}

func copyLabels(template *batchv1.JobTemplateSpec) labels.Set {

## About proxies with a stripped path prefix

Keep in mind that a proxy with stripped path prefix is only one of the ways to configure it.

Probably in many cases the default will be that the proxy doesn't have a stripped path prefix.

	user.Pets = append(user.Pets, &pet)
	CheckUser(t, user2, user)

	AssertAssociationCount(t, user, "Pets", 3, "AfterAppend")

	pets2 := []Pet{{Name: "pet-has-many-append-1-1"}, {Name: "pet-has-many-append-1-1"}}

	if err := DB.Model(&user2).Association("Pets").Append(&pets2); err != nil {
		t.Fatalf("Error happened when append pet, got %v", err)
	}

	for _, pet := range pets2 {
		pet := pet
		if pet.ID == 0 {

+
This approach is quick, simple, and works for many Ant-based builds.
You end up with a build that is effectively identical to the original Ant build, except your Ant targets become Gradle tasks.
Even the dependencies between targets are retained.
+
The downside is that you're still using the Ant build, which you must continue to maintain.
You also lose the advantages of Gradle's conventions, many of its plugins, its dependency management, and so on.

One thing to bear in mind is that high level condition statements make builds harder to understand and maintain, similar to the way they complicate object-oriented code.
The same applies to profiles.

...makes the parameter optional, with a default value of `None`, the same as:

```Python
q: str | None = None
```

But it declares it explicitly as being a query parameter.

!!! info
    Keep in mind that the most important part to make a parameter optional is the part:

    ```Python
    = None
    ```

    or the:

    ```Python
    = Query(default=None)
    ```

				if sz.Min < math.MaxUint64 {
					replaceCount.Min = sz.Min + 1
				} else {
					replaceCount.Min = sz.Min
				}
				// Include the length of the shortest possible original string length.
				retainedSz.Min = sz.Min
			} else if toReplaceSz.Max <= replaceWithSz.Min {
				// If the replacement does not make the result shorter, use the original string length.