// Generated by Lisette bindgen
// Source: runtime (Go stdlib)
// Go: 1.25.10
// Lisette: 0.2.1

/// AddCleanup attaches a cleanup function to ptr. Some time after ptr is no longer
/// reachable, the runtime will call cleanup(arg) in a separate goroutine.
/// 
/// A typical use is that ptr is an object wrapping an underlying resource (e.g.,
/// a File object wrapping an OS file descriptor), arg is the underlying resource
/// (e.g., the OS file descriptor), and the cleanup function releases the underlying
/// resource (e.g., by calling the close system call).
/// 
/// There are few constraints on ptr. In particular, multiple cleanups may be
/// attached to the same pointer, or to different pointers within the same
/// allocation.
/// 
/// If ptr is reachable from cleanup or arg, ptr will never be collected
/// and the cleanup will never run. As a protection against simple cases of this,
/// AddCleanup panics if arg is equal to ptr.
/// 
/// There is no specified order in which cleanups will run.
/// In particular, if several objects point to each other and all become
/// unreachable at the same time, their cleanups all become eligible to run
/// and can run in any order. This is true even if the objects form a cycle.
/// 
/// Cleanups run concurrently with any user-created goroutines.
/// Cleanups may also run concurrently with one another (unlike finalizers).
/// If a cleanup function must run for a long time, it should create a new goroutine
/// to avoid blocking the execution of other cleanups.
/// 
/// If ptr has both a cleanup and a finalizer, the cleanup will only run once
/// it has been finalized and becomes unreachable without an associated finalizer.
/// 
/// The cleanup(arg) call is not always guaranteed to run; in particular it is not
/// guaranteed to run before program exit.
/// 
/// Cleanups are not guaranteed to run if the size of T is zero bytes, because
/// it may share same address with other zero-size objects in memory. See
/// https://go.dev/ref/spec#Size_and_alignment_guarantees.
/// 
/// It is not guaranteed that a cleanup will run for objects allocated
/// in initializers for package-level variables. Such objects may be
/// linker-allocated, not heap-allocated.
/// 
/// Note that because cleanups may execute arbitrarily far into the future
/// after an object is no longer referenced, the runtime is allowed to perform
/// a space-saving optimization that batches objects together in a single
/// allocation slot. The cleanup for an unreferenced object in such an
/// allocation may never run if it always exists in the same batch as a
/// referenced object. Typically, this batching only happens for tiny
/// (on the order of 16 bytes or less) and pointer-free objects.
/// 
/// A cleanup may run as soon as an object becomes unreachable.
/// In order to use cleanups correctly, the program must ensure that
/// the object is reachable until it is safe to run its cleanup.
/// Objects stored in global variables, or that can be found by tracing
/// pointers from a global variable, are reachable. A function argument or
/// receiver may become unreachable at the last point where the function
/// mentions it. To ensure a cleanup does not get called prematurely,
/// pass the object to the [KeepAlive] function after the last point
/// where the object must remain reachable.
pub fn AddCleanup<T, S>(ptr: Ref<T>, cleanup: fn(S) -> (), arg: S) -> Cleanup

/// BlockProfile returns n, the number of records in the current blocking profile.
/// If len(p) >= n, BlockProfile copies the profile into p and returns n, true.
/// If len(p) < n, BlockProfile does not change p and returns n, false.
/// 
/// Most clients should use the [runtime/pprof] package or
/// the [testing] package's -test.blockprofile flag instead
/// of calling BlockProfile directly.
pub fn BlockProfile(mut p: Slice<BlockProfileRecord>) -> Option<int>

/// Breakpoint executes a breakpoint trap.
pub fn Breakpoint()

/// CPUProfile panics.
/// It formerly provided raw access to chunks of
/// a pprof-format profile generated by the runtime.
/// The details of generating that format have changed,
/// so this functionality has been removed.
/// 
/// Deprecated: Use the [runtime/pprof] package,
/// or the handlers in the [net/http/pprof] package,
/// or the [testing] package's -test.cpuprofile flag instead.
pub fn CPUProfile() -> Slice<byte>

/// Caller reports file and line number information about function invocations on
/// the calling goroutine's stack. The argument skip is the number of stack frames
/// to ascend, with 0 identifying the caller of Caller. (For historical reasons the
/// meaning of skip differs between Caller and [Callers].) The return values report
/// the program counter, the file name (using forward slashes as path separator, even
/// on Windows), and the line number within the file of the corresponding call.
/// The boolean ok is false if it was not possible to recover the information.
pub fn Caller(skip: int) -> Option<(uint, string, int)>

/// Callers fills the slice pc with the return program counters of function invocations
/// on the calling goroutine's stack. The argument skip is the number of stack frames
/// to skip before recording in pc, with 0 identifying the frame for Callers itself and
/// 1 identifying the caller of Callers.
/// It returns the number of entries written to pc.
/// 
/// To translate these PCs into symbolic information such as function
/// names and line numbers, use [CallersFrames]. CallersFrames accounts
/// for inlined functions and adjusts the return program counters into
/// call program counters. Iterating over the returned slice of PCs
/// directly is discouraged, as is using [FuncForPC] on any of the
/// returned PCs, since these cannot account for inlining or return
/// program counter adjustment.
pub fn Callers(skip: int, mut pc: Slice<uint>) -> int

/// CallersFrames takes a slice of PC values returned by [Callers] and
/// prepares to return function/file/line information.
/// Do not change the slice until you are done with the [Frames].
pub fn CallersFrames(callers: Slice<uint>) -> Ref<Frames>

/// FuncForPC returns a *[Func] describing the function that contains the
/// given program counter address, or else nil.
/// 
/// If pc represents multiple functions because of inlining, it returns
/// the *Func describing the innermost function, but with an entry of
/// the outermost function.
pub fn FuncForPC(pc: uint) -> Option<Ref<Func>>

/// GC runs a garbage collection and blocks the caller until the
/// garbage collection is complete. It may also block the entire
/// program.
pub fn GC()

/// GOMAXPROCS sets the maximum number of CPUs that can be executing
/// simultaneously and returns the previous setting. If n < 1, it does not change
/// the current setting.
/// 
/// # Default
/// 
/// If the GOMAXPROCS environment variable is set to a positive whole number,
/// GOMAXPROCS defaults to that value.
/// 
/// Otherwise, the Go runtime selects an appropriate default value from a combination of
///   - the number of logical CPUs on the machine,
///   - the process’s CPU affinity mask,
///   - and, on Linux, the process’s average CPU throughput limit based on cgroup CPU
///     quota, if any.
/// 
/// If GODEBUG=containermaxprocs=0 is set and GOMAXPROCS is not set by the
/// environment variable, then GOMAXPROCS instead defaults to the value of
/// [runtime.NumCPU]. Note that GODEBUG=containermaxprocs=0 is [default] for
/// language version 1.24 and below.
/// 
/// # Updates
/// 
/// The Go runtime periodically updates the default value based on changes to
/// the total logical CPU count, the CPU affinity mask, or cgroup quota. Setting
/// a custom value with the GOMAXPROCS environment variable or by calling
/// GOMAXPROCS disables automatic updates. The default value and automatic
/// updates can be restored by calling [SetDefaultGOMAXPROCS].
/// 
/// If GODEBUG=updatemaxprocs=0 is set, the Go runtime does not perform
/// automatic GOMAXPROCS updating. Note that GODEBUG=updatemaxprocs=0 is
/// [default] for language version 1.24 and below.
/// 
/// # Compatibility
/// 
/// Note that the default GOMAXPROCS behavior may change as the scheduler
/// improves, especially the implementation detail below.
/// 
/// # Implementation details
/// 
/// When computing default GOMAXPROCS via cgroups, the Go runtime computes the
/// "average CPU throughput limit" as the cgroup CPU quota / period. In cgroup
/// v2, these values come from the cpu.max file. In cgroup v1, they come from
/// cpu.cfs_quota_us and cpu.cfs_period_us, respectively. In container runtimes
/// that allow configuring CPU limits, this value usually corresponds to the
/// "CPU limit" option, not "CPU request".
/// 
/// The Go runtime typically selects the default GOMAXPROCS as the minimum of
/// the logical CPU count, the CPU affinity mask count, or the cgroup CPU
/// throughput limit. However, it will never set GOMAXPROCS less than 2 unless
/// the logical CPU count or CPU affinity mask count are below 2.
/// 
/// If the cgroup CPU throughput limit is not a whole number, the Go runtime
/// rounds up to the next whole number.
/// 
/// GOMAXPROCS updates are performed up to once per second, or less if the
/// application is idle.
/// 
/// [default]: https://go.dev/doc/godebug#default
pub fn GOMAXPROCS(n: int) -> int

/// GOROOT returns the root of the Go tree. It uses the
/// GOROOT environment variable, if set at process start,
/// or else the root used during the Go build.
/// 
/// Deprecated: The root used during the Go build will not be
/// meaningful if the binary is copied to another machine.
/// Use the system path to locate the “go” binary, and use
/// “go env GOROOT” to find its GOROOT.
pub fn GOROOT() -> string

/// Goexit terminates the goroutine that calls it. No other goroutine is affected.
/// Goexit runs all deferred calls before terminating the goroutine. Because Goexit
/// is not a panic, any recover calls in those deferred functions will return nil.
/// 
/// Calling Goexit from the main goroutine terminates that goroutine
/// without func main returning. Since func main has not returned,
/// the program continues execution of other goroutines.
/// If all other goroutines exit, the program crashes.
/// 
/// It crashes if called from a thread not created by the Go runtime.
pub fn Goexit()

/// GoroutineProfile returns n, the number of records in the active goroutine stack profile.
/// If len(p) >= n, GoroutineProfile copies the profile into p and returns n, true.
/// If len(p) < n, GoroutineProfile does not change p and returns n, false.
/// 
/// Most clients should use the [runtime/pprof] package instead
/// of calling GoroutineProfile directly.
pub fn GoroutineProfile(mut p: Slice<StackRecord>) -> Option<int>

/// Gosched yields the processor, allowing other goroutines to run. It does not
/// suspend the current goroutine, so execution resumes automatically.
pub fn Gosched()

/// KeepAlive marks its argument as currently reachable.
/// This ensures that the object is not freed, and its finalizer is not run,
/// before the point in the program where KeepAlive is called.
/// 
/// A very simplified example showing where KeepAlive is required:
/// 
/// 	type File struct { d int }
/// 	d, err := syscall.Open("/file/path", syscall.O_RDONLY, 0)
/// 	// ... do something if err != nil ...
/// 	p := &File{d}
/// 	runtime.SetFinalizer(p, func(p *File) { syscall.Close(p.d) })
/// 	var buf [10]byte
/// 	n, err := syscall.Read(p.d, buf[:])
/// 	// Ensure p is not finalized until Read returns.
/// 	runtime.KeepAlive(p)
/// 	// No more uses of p after this point.
/// 
/// Without the KeepAlive call, the finalizer could run at the start of
/// [syscall.Read], closing the file descriptor before syscall.Read makes
/// the actual system call.
/// 
/// Note: KeepAlive should only be used to prevent finalizers from
/// running prematurely. In particular, when used with [unsafe.Pointer],
/// the rules for valid uses of unsafe.Pointer still apply.
pub fn KeepAlive(x: Unknown)

/// LockOSThread wires the calling goroutine to its current operating system thread.
/// The calling goroutine will always execute in that thread,
/// and no other goroutine will execute in it,
/// until the calling goroutine has made as many calls to
/// [UnlockOSThread] as to LockOSThread.
/// If the calling goroutine exits without unlocking the thread,
/// the thread will be terminated.
/// 
/// All init functions are run on the startup thread. Calling LockOSThread
/// from an init function will cause the main function to be invoked on
/// that thread.
/// 
/// A goroutine should call LockOSThread before calling OS services or
/// non-Go library functions that depend on per-thread state.
pub fn LockOSThread()

/// MemProfile returns a profile of memory allocated and freed per allocation
/// site.
/// 
/// MemProfile returns n, the number of records in the current memory profile.
/// If len(p) >= n, MemProfile copies the profile into p and returns n, true.
/// If len(p) < n, MemProfile does not change p and returns n, false.
/// 
/// If inuseZero is true, the profile includes allocation records
/// where r.AllocBytes > 0 but r.AllocBytes == r.FreeBytes.
/// These are sites where memory was allocated, but it has all
/// been released back to the runtime.
/// 
/// The returned profile may be up to two garbage collection cycles old.
/// This is to avoid skewing the profile toward allocations; because
/// allocations happen in real time but frees are delayed until the garbage
/// collector performs sweeping, the profile only accounts for allocations
/// that have had a chance to be freed by the garbage collector.
/// 
/// Most clients should use the runtime/pprof package or
/// the testing package's -test.memprofile flag instead
/// of calling MemProfile directly.
pub fn MemProfile(mut p: Slice<MemProfileRecord>, inuseZero: bool) -> Option<int>

/// MutexProfile returns n, the number of records in the current mutex profile.
/// If len(p) >= n, MutexProfile copies the profile into p and returns n, true.
/// Otherwise, MutexProfile does not change p, and returns n, false.
/// 
/// Most clients should use the [runtime/pprof] package
/// instead of calling MutexProfile directly.
pub fn MutexProfile(mut p: Slice<BlockProfileRecord>) -> Option<int>

/// NumCPU returns the number of logical CPUs usable by the current process.
/// 
/// The set of available CPUs is checked by querying the operating system
/// at process startup. Changes to operating system CPU allocation after
/// process startup are not reflected.
pub fn NumCPU() -> int

/// NumCgoCall returns the number of cgo calls made by the current process.
pub fn NumCgoCall() -> int64

/// NumGoroutine returns the number of goroutines that currently exist.
pub fn NumGoroutine() -> int

/// ReadMemStats populates m with memory allocator statistics.
/// 
/// The returned memory allocator statistics are up to date as of the
/// call to ReadMemStats. This is in contrast with a heap profile,
/// which is a snapshot as of the most recently completed garbage
/// collection cycle.
pub fn ReadMemStats(m: Ref<MemStats>)

/// ReadTrace returns the next chunk of binary tracing data, blocking until data
/// is available. If tracing is turned off and all the data accumulated while it
/// was on has been returned, ReadTrace returns nil. The caller must copy the
/// returned data before calling ReadTrace again.
/// ReadTrace must be called from one goroutine at a time.
pub fn ReadTrace() -> Slice<byte>

/// SetBlockProfileRate controls the fraction of goroutine blocking events
/// that are reported in the blocking profile. The profiler aims to sample
/// an average of one blocking event per rate nanoseconds spent blocked.
/// 
/// To include every blocking event in the profile, pass rate = 1.
/// To turn off profiling entirely, pass rate <= 0.
pub fn SetBlockProfileRate(rate: int)

/// SetCPUProfileRate sets the CPU profiling rate to hz samples per second.
/// If hz <= 0, SetCPUProfileRate turns off profiling.
/// If the profiler is on, the rate cannot be changed without first turning it off.
/// 
/// Most clients should use the [runtime/pprof] package or
/// the [testing] package's -test.cpuprofile flag instead of calling
/// SetCPUProfileRate directly.
pub fn SetCPUProfileRate(hz: int)

/// SetCgoTraceback records three C functions to use to gather
/// traceback information from C code and to convert that traceback
/// information into symbolic information. These are used when printing
/// stack traces for a program that uses cgo.
/// 
/// The traceback and context functions may be called from a signal
/// handler, and must therefore use only async-signal safe functions.
/// The symbolizer function may be called while the program is
/// crashing, and so must be cautious about using memory.  None of the
/// functions may call back into Go.
/// 
/// The context function will be called with a single argument, a
/// pointer to a struct:
/// 
/// 	struct {
/// 		Context uintptr
/// 	}
/// 
/// In C syntax, this struct will be
/// 
/// 	struct {
/// 		uintptr_t Context;
/// 	};
/// 
/// If the Context field is 0, the context function is being called to
/// record the current traceback context. It should record in the
/// Context field whatever information is needed about the current
/// point of execution to later produce a stack trace, probably the
/// stack pointer and PC. In this case the context function will be
/// called from C code.
/// 
/// If the Context field is not 0, then it is a value returned by a
/// previous call to the context function. This case is called when the
/// context is no longer needed; that is, when the Go code is returning
/// to its C code caller. This permits the context function to release
/// any associated resources.
/// 
/// While it would be correct for the context function to record a
/// complete a stack trace whenever it is called, and simply copy that
/// out in the traceback function, in a typical program the context
/// function will be called many times without ever recording a
/// traceback for that context. Recording a complete stack trace in a
/// call to the context function is likely to be inefficient.
/// 
/// The traceback function will be called with a single argument, a
/// pointer to a struct:
/// 
/// 	struct {
/// 		Context    uintptr
/// 		SigContext uintptr
/// 		Buf        *uintptr
/// 		Max        uintptr
/// 	}
/// 
/// In C syntax, this struct will be
/// 
/// 	struct {
/// 		uintptr_t  Context;
/// 		uintptr_t  SigContext;
/// 		uintptr_t* Buf;
/// 		uintptr_t  Max;
/// 	};
/// 
/// The Context field will be zero to gather a traceback from the
/// current program execution point. In this case, the traceback
/// function will be called from C code.
/// 
/// Otherwise Context will be a value previously returned by a call to
/// the context function. The traceback function should gather a stack
/// trace from that saved point in the program execution. The traceback
/// function may be called from an execution thread other than the one
/// that recorded the context, but only when the context is known to be
/// valid and unchanging. The traceback function may also be called
/// deeper in the call stack on the same thread that recorded the
/// context. The traceback function may be called multiple times with
/// the same Context value; it will usually be appropriate to cache the
/// result, if possible, the first time this is called for a specific
/// context value.
/// 
/// If the traceback function is called from a signal handler on a Unix
/// system, SigContext will be the signal context argument passed to
/// the signal handler (a C ucontext_t* cast to uintptr_t). This may be
/// used to start tracing at the point where the signal occurred. If
/// the traceback function is not called from a signal handler,
/// SigContext will be zero.
/// 
/// Buf is where the traceback information should be stored. It should
/// be PC values, such that Buf[0] is the PC of the caller, Buf[1] is
/// the PC of that function's caller, and so on.  Max is the maximum
/// number of entries to store.  The function should store a zero to
/// indicate the top of the stack, or that the caller is on a different
/// stack, presumably a Go stack.
/// 
/// Unlike runtime.Callers, the PC values returned should, when passed
/// to the symbolizer function, return the file/line of the call
/// instruction.  No additional subtraction is required or appropriate.
/// 
/// On all platforms, the traceback function is invoked when a call from
/// Go to C to Go requests a stack trace. On linux/amd64, linux/ppc64le,
/// linux/arm64, and freebsd/amd64, the traceback function is also invoked
/// when a signal is received by a thread that is executing a cgo call.
/// The traceback function should not make assumptions about when it is
/// called, as future versions of Go may make additional calls.
/// 
/// The symbolizer function will be called with a single argument, a
/// pointer to a struct:
/// 
/// 	struct {
/// 		PC      uintptr // program counter to fetch information for
/// 		File    *byte   // file name (NUL terminated)
/// 		Lineno  uintptr // line number
/// 		Func    *byte   // function name (NUL terminated)
/// 		Entry   uintptr // function entry point
/// 		More    uintptr // set non-zero if more info for this PC
/// 		Data    uintptr // unused by runtime, available for function
/// 	}
/// 
/// In C syntax, this struct will be
/// 
/// 	struct {
/// 		uintptr_t PC;
/// 		char*     File;
/// 		uintptr_t Lineno;
/// 		char*     Func;
/// 		uintptr_t Entry;
/// 		uintptr_t More;
/// 		uintptr_t Data;
/// 	};
/// 
/// The PC field will be a value returned by a call to the traceback
/// function.
/// 
/// The first time the function is called for a particular traceback,
/// all the fields except PC will be 0. The function should fill in the
/// other fields if possible, setting them to 0/nil if the information
/// is not available. The Data field may be used to store any useful
/// information across calls. The More field should be set to non-zero
/// if there is more information for this PC, zero otherwise. If More
/// is set non-zero, the function will be called again with the same
/// PC, and may return different information (this is intended for use
/// with inlined functions). If More is zero, the function will be
/// called with the next PC value in the traceback. When the traceback
/// is complete, the function will be called once more with PC set to
/// zero; this may be used to free any information. Each call will
/// leave the fields of the struct set to the same values they had upon
/// return, except for the PC field when the More field is zero. The
/// function must not keep a copy of the struct pointer between calls.
/// 
/// When calling SetCgoTraceback, the version argument is the version
/// number of the structs that the functions expect to receive.
/// Currently this must be zero.
/// 
/// The symbolizer function may be nil, in which case the results of
/// the traceback function will be displayed as numbers. If the
/// traceback function is nil, the symbolizer function will never be
/// called. The context function may be nil, in which case the
/// traceback function will only be called with the context field set
/// to zero.  If the context function is nil, then calls from Go to C
/// to Go will not show a traceback for the C portion of the call stack.
/// 
/// SetCgoTraceback should be called only once, ideally from an init function.
pub fn SetCgoTraceback(
  version: int,
  traceback: Unknown,
  context: Unknown,
  symbolizer: Unknown,
)

/// SetDefaultGOMAXPROCS updates the GOMAXPROCS setting to the runtime
/// default, as described by [GOMAXPROCS], ignoring the GOMAXPROCS
/// environment variable.
/// 
/// SetDefaultGOMAXPROCS can be used to enable the default automatic updating
/// GOMAXPROCS behavior if it has been disabled by the GOMAXPROCS
/// environment variable or a prior call to [GOMAXPROCS], or to force an immediate
/// update if the caller is aware of a change to the total logical CPU count, CPU
/// affinity mask or cgroup quota.
pub fn SetDefaultGOMAXPROCS()

/// SetFinalizer sets the finalizer associated with obj to the provided
/// finalizer function. When the garbage collector finds an unreachable block
/// with an associated finalizer, it clears the association and runs
/// finalizer(obj) in a separate goroutine. This makes obj reachable again,
/// but now without an associated finalizer. Assuming that SetFinalizer
/// is not called again, the next time the garbage collector sees
/// that obj is unreachable, it will free obj.
/// 
/// SetFinalizer(obj, nil) clears any finalizer associated with obj.
/// 
/// New Go code should consider using [AddCleanup] instead, which is much
/// less error-prone than SetFinalizer.
/// 
/// The argument obj must be a pointer to an object allocated by calling
/// new, by taking the address of a composite literal, or by taking the
/// address of a local variable.
/// The argument finalizer must be a function that takes a single argument
/// to which obj's type can be assigned, and can have arbitrary ignored return
/// values. If either of these is not true, SetFinalizer may abort the
/// program.
/// 
/// Finalizers are run in dependency order: if A points at B, both have
/// finalizers, and they are otherwise unreachable, only the finalizer
/// for A runs; once A is freed, the finalizer for B can run.
/// If a cyclic structure includes a block with a finalizer, that
/// cycle is not guaranteed to be garbage collected and the finalizer
/// is not guaranteed to run, because there is no ordering that
/// respects the dependencies.
/// 
/// The finalizer is scheduled to run at some arbitrary time after the
/// program can no longer reach the object to which obj points.
/// There is no guarantee that finalizers will run before a program exits,
/// so typically they are useful only for releasing non-memory resources
/// associated with an object during a long-running program.
/// For example, an [os.File] object could use a finalizer to close the
/// associated operating system file descriptor when a program discards
/// an os.File without calling Close, but it would be a mistake
/// to depend on a finalizer to flush an in-memory I/O buffer such as a
/// [bufio.Writer], because the buffer would not be flushed at program exit.
/// 
/// It is not guaranteed that a finalizer will run if the size of *obj is
/// zero bytes, because it may share same address with other zero-size
/// objects in memory. See https://go.dev/ref/spec#Size_and_alignment_guarantees.
/// 
/// It is not guaranteed that a finalizer will run for objects allocated
/// in initializers for package-level variables. Such objects may be
/// linker-allocated, not heap-allocated.
/// 
/// Note that because finalizers may execute arbitrarily far into the future
/// after an object is no longer referenced, the runtime is allowed to perform
/// a space-saving optimization that batches objects together in a single
/// allocation slot. The finalizer for an unreferenced object in such an
/// allocation may never run if it always exists in the same batch as a
/// referenced object. Typically, this batching only happens for tiny
/// (on the order of 16 bytes or less) and pointer-free objects.
/// 
/// A finalizer may run as soon as an object becomes unreachable.
/// In order to use finalizers correctly, the program must ensure that
/// the object is reachable until it is no longer required.
/// Objects stored in global variables, or that can be found by tracing
/// pointers from a global variable, are reachable. A function argument or
/// receiver may become unreachable at the last point where the function
/// mentions it. To make an unreachable object reachable, pass the object
/// to a call of the [KeepAlive] function to mark the last point in the
/// function where the object must be reachable.
/// 
/// For example, if p points to a struct, such as os.File, that contains
/// a file descriptor d, and p has a finalizer that closes that file
/// descriptor, and if the last use of p in a function is a call to
/// syscall.Write(p.d, buf, size), then p may be unreachable as soon as
/// the program enters [syscall.Write]. The finalizer may run at that moment,
/// closing p.d, causing syscall.Write to fail because it is writing to
/// a closed file descriptor (or, worse, to an entirely different
/// file descriptor opened by a different goroutine). To avoid this problem,
/// call KeepAlive(p) after the call to syscall.Write.
/// 
/// A single goroutine runs all finalizers for a program, sequentially.
/// If a finalizer must run for a long time, it should do so by starting
/// a new goroutine.
/// 
/// In the terminology of the Go memory model, a call
/// SetFinalizer(x, f) “synchronizes before” the finalization call f(x).
/// However, there is no guarantee that KeepAlive(x) or any other use of x
/// “synchronizes before” f(x), so in general a finalizer should use a mutex
/// or other synchronization mechanism if it needs to access mutable state in x.
/// For example, consider a finalizer that inspects a mutable field in x
/// that is modified from time to time in the main program before x
/// becomes unreachable and the finalizer is invoked.
/// The modifications in the main program and the inspection in the finalizer
/// need to use appropriate synchronization, such as mutexes or atomic updates,
/// to avoid read-write races.
pub fn SetFinalizer(obj: Unknown, finalizer: Unknown)

/// SetMutexProfileFraction controls the fraction of mutex contention events
/// that are reported in the mutex profile. On average 1/rate events are
/// reported. The previous rate is returned.
/// 
/// To turn off profiling entirely, pass rate 0.
/// To just read the current rate, pass rate < 0.
/// (For n>1 the details of sampling may change.)
pub fn SetMutexProfileFraction(rate: int) -> int

/// Stack formats a stack trace of the calling goroutine into buf
/// and returns the number of bytes written to buf.
/// If all is true, Stack formats stack traces of all other goroutines
/// into buf after the trace for the current goroutine.
pub fn Stack(mut buf: Slice<byte>, all: bool) -> int

/// StartTrace enables tracing for the current process.
/// While tracing, the data will be buffered and available via [ReadTrace].
/// StartTrace returns an error if tracing is already enabled.
/// Most clients should use the [runtime/trace] package or the [testing] package's
/// -test.trace flag instead of calling StartTrace directly.
pub fn StartTrace() -> Result<(), error>

/// StopTrace stops tracing, if it was previously enabled.
/// StopTrace only returns after all the reads for the trace have completed.
pub fn StopTrace()

/// ThreadCreateProfile returns n, the number of records in the thread creation profile.
/// If len(p) >= n, ThreadCreateProfile copies the profile into p and returns n, true.
/// If len(p) < n, ThreadCreateProfile does not change p and returns n, false.
/// 
/// Most clients should use the runtime/pprof package instead
/// of calling ThreadCreateProfile directly.
pub fn ThreadCreateProfile(mut p: Slice<StackRecord>) -> Option<int>

/// UnlockOSThread undoes an earlier call to LockOSThread.
/// If this drops the number of active LockOSThread calls on the
/// calling goroutine to zero, it unwires the calling goroutine from
/// its fixed operating system thread.
/// If there are no active LockOSThread calls, this is a no-op.
/// 
/// Before calling UnlockOSThread, the caller must ensure that the OS
/// thread is suitable for running other goroutines. If the caller made
/// any permanent changes to the state of the thread that would affect
/// other goroutines, it should not call this function and thus leave
/// the goroutine locked to the OS thread until the goroutine (and
/// hence the thread) exits.
pub fn UnlockOSThread()

/// Version returns the Go tree's version string.
/// It is either the commit hash and date at the time of the build or,
/// when possible, a release tag like "go1.3".
pub fn Version() -> string

/// BlockProfileRecord describes blocking events originated
/// at a particular call sequence (stack trace).
pub struct BlockProfileRecord {
  pub Count: int64,
  pub Cycles: int64,
  pub StackRecord: StackRecord,
}

/// Cleanup is a handle to a cleanup call for a specific object.
pub type Cleanup

/// Error identifies a runtime error used in panic.
/// 
/// The Go runtime triggers panics for a variety of cases, as described by the
/// Go Language Spec, such as out-of-bounds slice/array access, close of nil
/// channels, type assertion failures, etc.
/// 
/// When these cases occur, the Go runtime panics with an error that implements
/// Error. This can be useful when recovering from panics to distinguish between
/// custom application panics and fundamental runtime panics.
/// 
/// Packages outside of the Go standard library should not implement Error.
pub interface Error {
  fn Error() -> string
  fn RuntimeError()
}

/// Frame is the information returned by [Frames] for each call frame.
pub struct Frame {
  pub PC: uint,
  pub Func: Option<Ref<Func>>,
  pub Function: string,
  pub File: string,
  pub Line: int,
  pub Entry: uint,
}

/// Frames may be used to get function/file/line information for a
/// slice of PC values returned by [Callers].
pub type Frames

/// A Func represents a Go function in the running binary.
pub type Func

/// A MemProfileRecord describes the live objects allocated
/// by a particular call sequence (stack trace).
pub struct MemProfileRecord {
  pub AllocBytes: int64,
  pub FreeBytes: int64,
  pub AllocObjects: int64,
  pub FreeObjects: int64,
  // SKIPPED field "Stack0": array-currently-not-representable — fixed-size array cannot currently be represented in Lisette
}

/// A MemStats records statistics about the memory allocator.
pub struct MemStats {
  pub Alloc: uint64,
  pub TotalAlloc: uint64,
  pub Sys: uint64,
  pub Lookups: uint64,
  pub Mallocs: uint64,
  pub Frees: uint64,
  pub HeapAlloc: uint64,
  pub HeapSys: uint64,
  pub HeapIdle: uint64,
  pub HeapInuse: uint64,
  pub HeapReleased: uint64,
  pub HeapObjects: uint64,
  pub StackInuse: uint64,
  pub StackSys: uint64,
  pub MSpanInuse: uint64,
  pub MSpanSys: uint64,
  pub MCacheInuse: uint64,
  pub MCacheSys: uint64,
  pub BuckHashSys: uint64,
  pub GCSys: uint64,
  pub OtherSys: uint64,
  pub NextGC: uint64,
  pub LastGC: uint64,
  pub PauseTotalNs: uint64,
  // SKIPPED field "PauseNs": array-currently-not-representable — fixed-size array cannot currently be represented in Lisette
  // SKIPPED field "PauseEnd": array-currently-not-representable — fixed-size array cannot currently be represented in Lisette
  pub NumGC: uint32,
  pub NumForcedGC: uint32,
  pub GCCPUFraction: float64,
  pub EnableGC: bool,
  pub DebugGC: bool,
  // SKIPPED field "BySize": anonymous-struct — anonymous struct types are not supported
}

/// A PanicNilError happens when code calls panic(nil).
/// 
/// Before Go 1.21, programs that called panic(nil) observed recover returning nil.
/// Starting in Go 1.21, programs that call panic(nil) observe recover returning a *PanicNilError.
/// Programs can change back to the old behavior by setting GODEBUG=panicnil=1.
pub type PanicNilError

/// A Pinner is a set of Go objects each pinned to a fixed location in memory. The
/// [Pinner.Pin] method pins one object, while [Pinner.Unpin] unpins all pinned
/// objects. See their comments for more information.
pub type Pinner

// SKIPPED field "Stack0": array-currently-not-representable — fixed-size array cannot currently be represented in Lisette
/// A StackRecord describes a single execution stack.
pub type StackRecord

/// A TypeAssertionError explains a failed type assertion.
pub type TypeAssertionError

/// Compiler is the name of the compiler toolchain that built the
/// running binary. Known toolchains are:
/// 
/// 	gc      Also known as cmd/compile.
/// 	gccgo   The gccgo front end, part of the GCC compiler suite.
pub const Compiler = "gc"

/// GOARCH is the running program's architecture target:
/// one of 386, amd64, arm, s390x, and so on.
pub const GOARCH = "arm64"

/// GOOS is the running program's operating system target:
/// one of darwin, freebsd, linux, and so on.
/// To view possible combinations of GOOS and GOARCH, run "go tool dist list".
pub const GOOS = "linux"

/// MemProfileRate controls the fraction of memory allocations
/// that are recorded and reported in the memory profile.
/// The profiler aims to sample an average of
/// one allocation per MemProfileRate bytes allocated.
/// 
/// To include every allocated block in the profile, set MemProfileRate to 1.
/// To turn off profiling entirely, set MemProfileRate to 0.
/// 
/// The tools that process the memory profiles assume that the
/// profile rate is constant across the lifetime of the program
/// and equal to the current value. Programs that change the
/// memory profiling rate should do so just once, as early as
/// possible in the execution of the program (for example,
/// at the beginning of main).
pub var MemProfileRate: int

impl BlockProfileRecord {
  /// Stack returns the stack trace associated with the record,
  /// a prefix of r.Stack0.
  fn Stack(self: Ref<BlockProfileRecord>) -> Slice<uint>
}

impl Cleanup {
  /// Stop cancels the cleanup call. Stop will have no effect if the cleanup call
  /// has already been queued for execution (because ptr became unreachable).
  /// To guarantee that Stop removes the cleanup function, the caller must ensure
  /// that the pointer that was passed to AddCleanup is reachable across the call to Stop.
  fn Stop(self)
}

impl Frames {
  /// Next returns a [Frame] representing the next call frame in the slice
  /// of PC values. If it has already returned all call frames, Next
  /// returns a zero [Frame].
  /// 
  /// The more result indicates whether the next call to Next will return
  /// a valid [Frame]. It does not necessarily indicate whether this call
  /// returned one.
  /// 
  /// See the [Frames] example for idiomatic usage.
  fn Next(self: Ref<Frames>) -> (Frame, bool)
}

impl Func {
  /// Entry returns the entry address of the function.
  fn Entry(self: Ref<Func>) -> uint

  /// FileLine returns the file name and line number of the
  /// source code corresponding to the program counter pc.
  /// The result will not be accurate if pc is not a program
  /// counter within f.
  fn FileLine(self: Ref<Func>, pc: uint) -> (string, int)

  /// Name returns the name of the function.
  fn Name(self: Ref<Func>) -> string
}

impl MemProfileRecord {
  /// InUseBytes returns the number of bytes in use (AllocBytes - FreeBytes).
  fn InUseBytes(self: Ref<MemProfileRecord>) -> int64

  /// InUseObjects returns the number of objects in use (AllocObjects - FreeObjects).
  fn InUseObjects(self: Ref<MemProfileRecord>) -> int64

  /// Stack returns the stack trace associated with the record,
  /// a prefix of r.Stack0.
  fn Stack(self: Ref<MemProfileRecord>) -> Slice<uint>
}

impl PanicNilError {
  fn Error(self: Ref<PanicNilError>) -> string

  fn RuntimeError(self: Ref<PanicNilError>)
}

impl Pinner {
  /// Pin pins a Go object, preventing it from being moved or freed by the garbage
  /// collector until the [Pinner.Unpin] method has been called.
  /// 
  /// A pointer to a pinned object can be directly stored in C memory or can be
  /// contained in Go memory passed to C functions. If the pinned object itself
  /// contains pointers to Go objects, these objects must be pinned separately if they
  /// are going to be accessed from C code.
  /// 
  /// The argument must be a pointer of any type or an [unsafe.Pointer].
  /// It's safe to call Pin on non-Go pointers, in which case Pin will do nothing.
  fn Pin(self: Ref<Pinner>, pointer: Unknown)

  /// Unpin unpins all pinned objects of the [Pinner].
  fn Unpin(self: Ref<Pinner>)
}

impl StackRecord {
  /// Stack returns the stack trace associated with the record,
  /// a prefix of r.Stack0.
  fn Stack(self: Ref<StackRecord>) -> Slice<uint>
}

impl TypeAssertionError {
  fn Error(self: Ref<TypeAssertionError>) -> string

  fn RuntimeError(self: Ref<TypeAssertionError>)
}
