// Test that heavy recursion works. Simple torture test for
// segmented stacks: do math in unary by recursion.

package main

import "runtime"

type Number *Number

// -------------------------------------
// Peano primitives

func zero() *Number {
	return nil
}

func is_zero(x *Number) bool {
	return x == nil
}

func add1(x *Number) *Number {
	e := new(Number)
	*e = x
	return e
}

        }
    }

    @Test
    fun `Peano sanity check`() {

        assertThat(
            Peano.fromInt(0),
            equalTo(Peano.Z)
        )

        assertThat(
            Peano.fromInt(1024).toInt(),
            equalTo(1024)
        )
    }

    sealed class Peano {

        companion object {

            fun fromInt(n: Int): Peano = (0 until n).fold(Z as Peano) { acc, _ -> S(acc) }

// is confused when it encounters a split-stack function
// that needs 0 bytes of stack space.

package main

type Peano *Peano

func makePeano(n int) *Peano {
	if n == 0 {
		return nil
	}
	p := Peano(makePeano(n - 1))
	return &p
}

var countArg Peano
var countResult int

func countPeano() {
	if countArg == nil {
		countResult = 0
		return
	}
	countArg = *countArg

```Python hl_lines="13  15  22  25"
{!../../../docs_src/background_tasks/tutorial002.py!}
```

Neste exemplo, as mensagens serão gravadas no arquivo `log.txt` _após_ o envio da resposta.

Se houver uma consulta na solicitação, ela será gravada no log em uma tarefa em segundo plano.

	"nicard":   0x3c,
	"njiva":    0x64,
	"nulik":    0x3d,
	"osojs":    0x65,
	"oxendict": 0x3e,
	"pahawh2":  0x3f,
	"pahawh3":  0x40,
	"pahawh4":  0x41,
	"pamaka":   0x42,
	"peano":    0x43,
	"petr1708": 0x44,
	"pinyin":   0x45,
	"polyton":  0x46,
	"provenc":  0x47,
	"puter":    0x48,
	"rigik":    0x49,
	"rozaj":    0x4a,
	"rumgr":    0x4b,
	"scotland": 0x4c,

		}

		end, _, nano, p := s.header()
		oldEnd := s.end
		s.end = end

		print("[")
		var tmpbuf [21]byte
		pnano := int64(nano) - runtimeInitTime
		if pnano < 0 {
			// Logged before runtimeInitTime was set.
			pnano = 0
		}
		pnanoBytes := itoaDiv(tmpbuf[:], uint64(pnano), 9)
		print(slicebytetostringtmp((*byte)(noescape(unsafe.Pointer(&pnanoBytes[0]))), len(pnanoBytes)))
		print(" P ", p, "] ")

Telescopes represent Objects so distinct as they do. But were all the Rays of Light equally refrangible, the Error arising only from the Sphericalness of the Figures of Glasses would be many hundred times less. For, if the Object-glass of a Telescope be Plano-convex, and the Plane side be turned towards the Object, and the Diameter of the Sphere, whereof this Glass is a Segment, be called D, and the Semi-diameter of the Aperture of the Glass be called S, and the Sine of Incidence out of Glass into Air,...

Rays of Light equally refrangible, the Error arising only from the
Sphericalness of the Figures of Glasses would be many hundred times
less. For, if the Object-glass of a Telescope be Plano-convex, and the
Plane side be turned towards the Object, and the Diameter of the
Sphere, whereof this Glass is a Segment, be called D, and the
Semi-diameter of the Aperture of the Glass be called S, and the Sine of