Que quando chamadas, retornam instâncias de classes de mesmo nome.

    Então, você importa `Query`, que é uma função. E quando você a chama, ela retorna uma instância de uma classe também chamada `Query`.

    Estas funções são assim (ao invés de apenas usar as classes diretamente) para que seu editor não acuse erros sobre seus tipos.

          a: String,
          b: String,
        ): Int {
          var i = 4
          val limit = minOf(a.length, b.length)
          while (i < limit) {
            val charA = a[i]
            val charB = b[i]
            if (charA != charB) return if (charA < charB) -1 else 1
            i++
          }
          val lengthA = a.length
          val lengthB = b.length

	tv.tv_usec = int64(x)
}

type sigactiont struct {
	sa_flags   uint32
	sa_handler uintptr
	sa_mask    [2]uint64
	// linux header does not have sa_restorer field,
	// but it is used in setsig(). it is no harm to put it here
	sa_restorer uintptr
}

type siginfoFields struct {
	si_signo int32
	si_code  int32
	si_errno int32
	__pad0   [1]int32
	// below here is a union; si_addr is the only field we use

	tv.tv_usec = x
}

type sigactiont struct {
	sa_flags   uint32
	sa_handler uintptr
	sa_mask    [4]uint32
	// linux header does not have sa_restorer field,
	// but it is used in setsig(). it is no harm to put it here
	sa_restorer uintptr
}

type siginfoFields struct {
	si_signo int32
	si_code  int32
	si_errno int32
	// below here is a union; si_addr is the only field we use
	si_addr uint32
}

 *
 * Note that [java.util.zip.Deflater] is hardcoded to use 15 bits (32 KiB) for
 * `client_max_window_bits` and [java.util.zip.Inflater] is hardcoded to use 15 bits (32 KiB) for
 * `server_max_window_bits`. This harms our ability to support these parameters:
 *
 *  * If `client_max_window_bits` is less than 15, OkHttp must close the web socket with code 1010.
 *    Otherwise it would compress values in a way that servers could not decompress.

}

type sigactiont struct {
	sa_handler uintptr
	sa_flags   uint64
	sa_mask    uint64
	// Linux on riscv64 does not have the sa_restorer field, but the setsig
	// function references it (for x86). Not much harm to include it at the end.
	sa_restorer uintptr
}

type siginfoFields struct {
	si_signo int32
	si_errno int32
	si_code  int32
	// below here is a union; si_addr is the only field we use
	si_addr uint64

// Similarly, we allow slash folding, so that hasPathPrefix("a/b/c", "a\\b") is true.
// We do not allow full Unicode case folding, for fear of causing more confusion
// or harm than good. (For an example of the kinds of things that can go wrong,
// see http://article.gmane.org/gmane.linux.kernel/1853266.)
func hasPathPrefix(s string, t string) bool {
	if len(t) > len(s) {
		return false
	}

var Carian <type 1>;
type <type 12>;
var CaseRanges <type 16 [] <type 12>>;
var Categories <type 17 map [<type -16>] <type 1>>;
var Caucasian_Albanian <type 1>;
var Cc <type 1>;
var Cf <type 1>;
var Chakma <type 1>;
var Cham <type 1>;
var Cherokee <type 1>;
var Co <type 1>;
var Common <type 1>;
var Coptic <type 1>;
var Cs <type 1>;
var Cuneiform <type 1>;
var Cypriot <type 1>;
var Cyrillic <type 1>;

			// Although TrimFilePathPrefix is only case-insensitive in the volume name,
			// what we care about in testing Join is that absolute paths remain
			// absolute and relative paths remaining relative — there is no harm in
			// over-normalizing letters in the comparison, so we use EqualFold.
			joined := filepath.Join(tt.prefix, got)
			if clean := filepath.Clean(tt.s); !strings.EqualFold(joined, clean) {

	benchmarkMutex(b, true, true)
}

func BenchmarkMutexNoSpin(b *testing.B) {
	// This benchmark models a situation where spinning in the mutex should be
	// non-profitable and allows to confirm that spinning does not do harm.
	// To achieve this we create excess of goroutines most of which do local work.
	// These goroutines yield during local work, so that switching from
	// a blocked goroutine to other goroutines is profitable.