// ArgNames is the names of the event's arguments in order.
	// This may refer to a globally shared slice. Copy before mutating.
	ArgNames []string

	// Args contains the event's arguments.
	Args []uint64

	// Data is additional unparsed data that is associated with the experimental event.
	// Data is likely to be shared across many ExperimentalEvents, so callers that parse

// there is exactly one *_type per Go type, so that pointer equality
// can be used to test if types are equal. There is one place that
// breaks this assumption: buildmode=shared. In this case a type can
// appear as two different pieces of memory. This is hidden from the
// runtime and reflect package by the per-module typemap built in
// typelinksinit. It uses typesEqual to map types from later modules

// The partial record contains all fields read before the error.
// If there is no data left to be read, Read returns nil, [io.EOF].
// If [Reader.ReuseRecord] is true, the returned slice may be shared
// between multiple calls to Read.
func (r *Reader) Read() (record []string, err error) {
	if r.ReuseRecord {
		record, err = r.readRecord(r.lastRecord)
		r.lastRecord = record
	} else {

			if _, ok := gvkMap[evt.Resource]; ok {
				gvkMap[evt.Resource] |= evt.ActionType
			} else {
				gvkMap[evt.Resource] = evt.ActionType
			}
		}
	}
	return gvkMap
}

// newPodInformer creates a shared index informer that returns only non-terminal pods.
// The PodInformer allows indexers to be added, but note that only non-conflict indexers are allowed.

            new NoInputChangesStep<>(
            new CaptureOutputsAfterExecutionStep<>(buildOperationRunner, buildInvocationScopeId.getId(), outputSnapshotter, NO_FILTER,
            // TODO Use a shared execution pipeline
            new BroadcastChangingOutputsStep<>(outputChangeListener,
            new PreCreateOutputParentsStep<>(
            new TimeoutStep<>(timeoutHandler, currentBuildOperationRef,

	return fi
}

// ReadMultipleReq contains information of multiple files to read from disk.
type ReadMultipleReq struct {
	Bucket       string   // Bucket. Can be empty if multiple buckets.
	Prefix       string   // Shared prefix of all files. Can be empty. Will be joined to filename without modification.
	Files        []string // Individual files to read.
	MaxSize      int64    // Return error if size is exceed.

				},
			},
			policyDecision: []PolicyDecision{
				{
					Action:  ActionDeny,
					Message: "running out of cost budget",
				},
			},
			costBudget: 1, // shared between expression and messageExpression, needs 1 + 1 = 2 in total
		},
		{
			name:    "no match surpresses failure",
			matcher: &fakeCELMatcher{matches: false},
			evaluations: []cel.EvaluationResult{
				{

	eventArr [8]QUICEvent

	started  bool
	signalc  chan struct{}   // handshake data is available to be read
	blockedc chan struct{}   // handshake is waiting for data, closed when done
	cancelc  <-chan struct{} // handshake has been canceled
	cancel   context.CancelFunc

	waitingForDrain bool

	// readbuf is shared between HandleData and the handshake goroutine.

	}
	return 0, false
}

// GetBase determines the base address to subtract from virtual
// address to get symbol table address. For an executable, the base
// is 0. Otherwise, it's a shared library, and the base is the
// address where the mapping starts. The kernel needs special handling.
func GetBase(fh *elf.FileHeader, loadSegment *elf.ProgHeader, stextOffset *uint64, start, limit, offset uint64) (uint64, error) {

                    //triggered through tooling API of Gradle <2.3 - native-platform.dll is shared by tooling client (<2.3) and daemon (current) and it is locked by the client (<2.3 issue)
                    LOGGER.debug("Unable to initialize native-platform. Failure: {}", format(ex));