return (*SECURITY_DESCRIPTOR)(unsafe.Pointer(&dst[0]))
}

// SecurityDescriptorFromString converts an SDDL string describing a security descriptor into a
// self-relative security descriptor object allocated on the Go heap.
func SecurityDescriptorFromString(sddl string) (sd *SECURITY_DESCRIPTOR, err error) {
	var winHeapSD *SECURITY_DESCRIPTOR
	err = convertStringSecurityDescriptorToSecurityDescriptor(sddl, 1, &winHeapSD, nil)

		return true
	}
	switch t.kind {
	case TNIL, TIDEAL:
		return true
	}
	return false
}

// HasPointers reports whether t contains a heap pointer.
// Note that this function ignores pointers to not-in-heap types.
func (t *Type) HasPointers() bool {
	return PtrDataSize(t) > 0
}

var recvType *Type

The command line client now starts with 64MB of heap instead of 1GB.
This may affect builds running directly inside the client VM using `--no-daemon` mode.
We discourage the use of `--no-daemon`, but if you must use it, you can increase the available memory using the `GRADLE_OPTS` environment variable.

The Gradle daemon now starts with 512MB of heap instead of 1GB.

            }
        }

        private File expectGetStatusOf(String path, String status, boolean broken) {
            def file = temporaryFolder.createFile("cheap-${path.replace('/', '_')}.status")
            file.text = status
            if (!broken) {
                server.expectGet("/repo/${path}/status.txt", file)
            } else {

    final Queue<PeekingIterator<T>> queue;

    public MergingIterator(
        Iterable<? extends Iterator<? extends T>> iterators, Comparator<? super T> itemComparator) {
      // A comparator that's used by the heap, allowing the heap
      // to be sorted based on the top of each iterator.
      Comparator<PeekingIterator<T>> heapComparator =
          (PeekingIterator<T> o1, PeekingIterator<T> o2) ->

    final Queue<PeekingIterator<T>> queue;

    public MergingIterator(
        Iterable<? extends Iterator<? extends T>> iterators, Comparator<? super T> itemComparator) {
      // A comparator that's used by the heap, allowing the heap
      // to be sorted based on the top of each iterator.
      Comparator<PeekingIterator<T>> heapComparator =
          (PeekingIterator<T> o1, PeekingIterator<T> o2) ->

	}
	if noCallback {
		fmt.Fprintf(fgo2, "\t_Cgo_no_callback(false)\n")
	}

	// skip _Cgo_use when noescape exist,
	// so that the compiler won't force to escape them to heap.
	if !p.noEscapes[n.C] {
		fmt.Fprintf(fgo2, "\tif _Cgo_always_false {\n")
		if d.Type.Params != nil {
			for i := range d.Type.Params.List {
				fmt.Fprintf(fgo2, "\t\t_Cgo_use(p%d)\n", i)
			}
		}

// ago that all the times we care about will be positive, and then round
// to zero and round down coincide. These presentation routines already
// have to add the zone offset, so adding the translation to the
// alternate epoch is cheap. For example, having a non-negative time t
// means that we can write
//
//	sec = t % 60
//
// instead of
//
//	sec = t % 60
//	if sec < 0 {
//		sec += 60
//	}
//
// everywhere.
//

		// You might be tempted to simplify this by just passing &outBuf to Put,
		// but that would make the local copy of the outBuf slice header escape
		// to the heap, causing an allocation. Instead, we keep around the
		// pointer to the slice header returned by Get, which is already on the
		// heap, and overwrite and return that.
		*outBufPtr = outBuf
		outBufPool.Put(outBufPtr)
	}()

	var n int
	for len(data) > 0 {

	go122.EvGoStatusStack: (*ordering).advanceGoStatus,

	// Experimental events.

	// Experimental heap span events. Added in Go 1.23.
	go122.EvSpan:      (*ordering).advanceAllocFree,
	go122.EvSpanAlloc: (*ordering).advanceAllocFree,
	go122.EvSpanFree:  (*ordering).advanceAllocFree,

	// Experimental heap object events. Added in Go 1.23.
	go122.EvHeapObject:      (*ordering).advanceAllocFree,