// into the range of surrogate characters, but if they do we must not test
    // any values in that range. To see why, consider the case where:
    // safeMin <= {hi,lo} <= safeMax
    // where {hi,lo} are characters forming a surrogate pair such that:
    // codePointOf(hi, lo) > safeMax
    // which would result in the surrogate pair being (wrongly) considered safe.
    // If we clip the safe range used during the per-character tests so it is

			Info: madmin.MinioInfo{
				DeploymentID: globalDeploymentID(),
			},
		},
	}

	go fetchHealthInfo(healthCtx, objectAPI, &query, healthInfoCh, healthInfo)

	for {
		select {
		case hi, hasMore := <-healthInfoCh:
			if !hasMore {
				auditOptions := AuditLogOptions{Event: "callhome:diagnostics"}
				// Received all data. Send to SUBNET and return
				err := sendHealthInfo(ctx, healthInfo)

	MOVV	R1, R2		// 00011025
	MOVV	LO, R1		// 00000812
	MOVV	HI, R1		// 00000810
	MOVV	R1, LO		// 00200013
	MOVV	R1, HI		// 00200011


//	LMOVW rreg ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVW	R1, R2		// 00011004
	MOVW	LO, R1		// 00000812
	MOVW	HI, R1		// 00000810
	MOVW	R1, LO		// 00200013
	MOVW	R1, HI		// 00200011
	MOVWU	R14, R27	// 000ed83c001bd83e

//	LMOVH rreg ',' rreg

    char c = 0;
    for (int hi = 0; hi < 256; hi++) {
      for (int lo = 0; lo < 256; lo++) {
        char result = Chars.fromByteArray(new byte[] {(byte) hi, (byte) lo});
        assertWithMessage(
                String.format(
                    Locale.ROOT,
                    "hi=%s, lo=%s, expected=%s, result=%s",
                    hi,
                    lo,
                    (int) c,

    val request = request().post("Hi?".toRequestBody(PLAIN)).build()
    val response = client.newCall(request).execute()
    response.body.close()
    applicationLogs
      .assertLogEqual("--> POST $url")
      .assertLogEqual("Content-Type: text/plain; charset=utf-8")
      .assertLogEqual("Content-Length: 3")
      .assertLogEqual("")
      .assertLogEqual("Hi?")
      .assertLogEqual("--> END POST (3-byte body)")

			// Parse the upper and lower bounds.
			lo := p.registerNumber(tok.String())
			hi := lo
			if p.peek() == '-' {
				p.next()
				hi = p.registerNumber(p.next().String())
			}
			if hi < lo {
				lo, hi = hi, lo
			}
			// Check there are no duplicates in the register list.
			for i := 0; lo <= hi && i < maxReg; i++ {
				if bits&(1<<lo) != 0 {
					p.errorf("register R%d already in list", lo)

		</postConstruct>
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>
			<arg>"gl/protwords.txt"</arg>
		</postConstruct>
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>
			<arg>"hi/protwords.txt"</arg>
		</postConstruct>
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>
			<arg>"hu/protwords.txt"</arg>
		</postConstruct>
		<postConstruct name="addConfigFile">
			<arg>"fess"</arg>

For example, you could declare that something could be a `str` or `None`:

```python
from typing import Union


def say_hi(name: Union[str, None]):
        print(f"Hi {name}!")
```

`typing` also has a shortcut to declare that something could be `None`, with `Optional`.

Here's a tip from my very **subjective** point of view:

* 🚨 Avoid using `Optional[SomeType]`

     */
    public static long readTime(final byte[] src, final int srcIndex) {
        final int low = readInt4(src, srcIndex);
        final int hi = readInt4(src, srcIndex + 4);
        long t = (long) hi << 32L | low & 0xFFFFFFFFL;
        return t / 10000L - SmbConstants.MILLISECONDS_BETWEEN_1970_AND_1601;
    }

    /**
     * Writes a Java time value as a Windows FILETIME

		for hi := len(s) - 1; hi >= 0; hi-- {
			c := s[hi]
			if c >= utf8.RuneSelf {
				return TrimFunc(s[:hi+1], unicode.IsSpace)
			}
			if asciiSpace[c] == 0 {
				// At this point, s[:hi+1] starts and ends with ASCII
				// non-space bytes, so we're done. Non-ASCII cases have
				// already been handled above.
				return s[:hi+1]
			}
		}
	}