// no need to persist the removal, but the set value should not be persisted too. A placeholder value
                // will keep the key mutated to avoid recording it as an input.
                mutatedSystemProperties[key] = SystemPropertyIgnored
            }
        }

        fun systemPropertiesCleared() {
            systemPropertiesCleared = true

// the filename of the source file, or via the src parameter.
//
// If src != nil, ParseFile parses the source from src and the filename is
// only used when recording position information. The type of the argument
// for the src parameter must be string, []byte, or [io.Reader].
// If src == nil, ParseFile parses the file specified by filename.
//

	offset := port - r.portRange.Base
	return true, offset
}

// Destroy shuts down internal allocator.
func (r *PortAllocator) Destroy() {
	r.alloc.Destroy()
}

// EnableMetrics enables metrics recording.
func (r *PortAllocator) EnableMetrics() {
	registerMetrics()
	r.metrics = &metricsRecorder{}
}

// calculateRangeOffset estimates the offset used on the range for statically allocation based on

	}
	return val
}

func isWildcard(s string) bool {
	rune, size := utf8.DecodeRuneInString(s)
	return size == len(s) && unicode.IsLower(rune)
}

// match reports whether pattern matches val,
// recording wildcard submatches in m.
// If m == nil, match checks whether pattern == val.
func match(m map[string]reflect.Value, pattern, val reflect.Value) bool {
	// Wildcard matches any expression. If it appears multiple

	// Pointer to current package state.
	p *pstate
	// Counter mode.
	cm coverage.CounterMode
}

// pstate records package-level coverage data state:
// - a table of functions (file/fname/literal)
// - a map recording the index/ID of each func encountered so far
// - a table storing execution count for the coverable units in each func
type pstate struct {
	// slice of unique functions
	funcs []fnfile

	}

	// Use the actual Transport code to record what we would send
	// on the wire, but not using TCP.  Use a Transport with a
	// custom dialer that returns a fake net.Conn that waits
	// for the full input (and recording it), and then responds
	// with a dummy response.
	var buf bytes.Buffer // records the output
	pr, pw := io.Pipe()
	defer pr.Close()
	defer pw.Close()
	dr := &delegateReader{c: make(chan io.Reader)}