}
	}
}

// parseCniLog is tricky because we have known and arbitrary fields in the log, and Go doesn't make that very easy
func parseCniLog(l string) (cniLog, bool) {
	var raw map[string]json.RawMessage
	if err := json.Unmarshal([]byte(l), &raw); err != nil {
		log.Debugf("Failed to unmarshal CNI plugin log entry: %v", err)
		return cniLog{}, false
	}
	var msg cniLog

// whether to make an installation the default.
func PreviousInstallExists(ctx context.Context, client kubernetes.Interface) bool {
	mwhs, err := client.AdmissionregistrationV1().MutatingWebhookConfigurations().List(ctx, metav1.ListOptions{
		LabelSelector: "app=sidecar-injector",
	})
	if err != nil {
		return false
	}

  pos: Int,
  limit: Int,
): ByteArray? {
  val address = ByteArray(16)
  var b = 0
  var compress = -1
  var groupOffset = -1

  var i = pos
  while (i < limit) {
    if (b == address.size) return null // Too many groups.

    // Read a delimiter.
    if (i + 2 <= limit && input.startsWith("::", startIndex = i)) {
      // Compression "::" delimiter, which is anywhere in the input, including its prefix.

    }

    public void bool(BoolCall<PathMappingCQ> boolLambda) {
        bool(boolLambda, null);
    }

    public void bool(BoolCall<PathMappingCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
        PathMappingCQ mustQuery = new PathMappingCQ();
        PathMappingCQ shouldQuery = new PathMappingCQ();
        PathMappingCQ mustNotQuery = new PathMappingCQ();

	if !compareSignatureV2(gotSignature, expectedSignature) {
		return ErrSignatureDoesNotMatch
	}

	r.Form.Del(xhttp.Expires)

	return ErrNone
}

func getReqAccessKeyV2(r *http.Request) (auth.Credentials, bool, APIErrorCode) {
	if accessKey := r.Form.Get(xhttp.AmzAccessKeyID); accessKey != "" {
		return checkKeyValid(r, accessKey)
	}

	// below is V2 Signed Auth header format, splitting on `space` (after the `AWS` string).

	stats.RLock()
	defer stats.RUnlock()

	val, ok := stats.apiStats[api]
	if ok {
		return val
	}

	return 0
}

// Load returns the recorded stats.
func (stats *HTTPAPIStats) Load(toLower bool) map[string]int {
	if stats == nil {
		return map[string]int{}
	}

	stats.RLock()
	defer stats.RUnlock()

	apiStats := make(map[string]int, len(stats.apiStats))
	for k, v := range stats.apiStats {

type Config struct {
	types.NetConf

	// Add plugin-specific flags here
	PluginLogLevel    string   `json:"plugin_log_level"`
	CNIAgentRunDir    string   `json:"cni_agent_run_dir"`
	AmbientEnabled    bool     `json:"ambient_enabled"`
	ExcludeNamespaces []string `json:"exclude_namespaces"`
}

// K8sArgs is the valid CNI_ARGS used for Kubernetes
// The field names need to match exact keys in containerd args for unmarshalling

type SMA struct {
	buf       []float64
	window    int     // len of buf
	idx       int     // current index in buf
	CAvg      float64 // cumulative average
	prevSMA   float64
	filledBuf bool
}

func newSMA(ln int) *SMA {
	if ln <= 0 {
		ln = defaultWindowSize
	}
	return &SMA{
		buf:    make([]float64, ln),
		window: ln,
		idx:    0,
	}
}

	prometheusMergedOutput = "prom-merged"

	defaultProxyAdminPort = 15000
)

var (
	fqdn, direction, subset string
	port                    int
	verboseProxyConfig      bool
	waypointProxyConfig     bool

	address, listenerType, statsType string

	routeName string

	clusterName, status string

	// output format (json, yaml or short)
	outputFormat string

	proxyAdminPort int

	default:
		logger.CriticalIf(GlobalContext, errors.New("Unsupported bitrot algorithm"))
		return nil
	}
}

// Available reports whether the given algorithm is available.
func (a BitrotAlgorithm) Available() bool {
	_, ok := bitrotAlgorithms[a]
	return ok
}

// String returns the string identifier for a given bitrot algorithm.
// If the algorithm is not supported String panics.
func (a BitrotAlgorithm) String() string {