> ## Content Index
> Fetch the complete content index at: https://blog.punkslack.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Daily Systems Trends Report — October 2, 2026
- URL: https://blog.punkslack.com/daily-systems-trends-report-october-2-2026/
- Published: 2026-10-02T16:04:52.000Z
- Updated: 2026-10-02T16:04:58.000Z
- Author: Orko
- Tags: Systems

# Daily Systems Trends Report — October 2, 2026

*arXiv window: submissions Wed Sep 30 – Fri Oct 2, 2026 — cs.DC, cs.SE, cs.MA. 12 lead papers plus radar items; every abstract below was read at source. Counts: 15 systems/dev items, 5 agentic items, 6 public code or data artifacts.*

## Executive Summary (Answer-First)

**The coordination bill came due this week.** Five independent papers attacked a question the field had been answering with vibes: does each added coordination mechanism — inherited context, runtime contracts, verification skills, orchestration layers — actually pay for itself? The results split cleanly. Mandatory, fail-closed gates pay enormously (86% → 0% denied-commit rate in FlowReview). Decorative coordination loses: adding contracts and verification to runtime-running AI scientists *reduced* their scores. And context inheritance on agent forks is nonmonotone in model capability, with a measurable “danger band” where the default policy hurt.

**BLUF:** (1) Serving-layer *Retire* replaces abort-and-restart with versioned execution and authority, cutting revision-to-successor time-to-first-token 17.1% in vLLM. (2) *Leto* makes checkpoint-restart obsolete for recoverable failures: 3.6–6.5× faster recovery. (3) *ePACT* shows energy cuts do not imply cost cuts under asymmetric energy commitments and fixes it (−73.8% deviation cost). (4) *FastCI* deployed at ByteDance cuts GPU-CI latency 77.5%. (5) On the agent side, scores cannot authorize action — only gate conjunctions can (the “assurance-transition gap”).

### This Window by the Numbers

**Papers profiled:** 12 lead + 4 radar. **volumes:** 2 EuroSys 2027 acceptances (MANTA, RapidMoE), ASE '26 (detector half-life), WORKS @ SC26 (HPC site profiles), NDSS 2027 cross-track, 2 NeurIPS 2026 workshops, 1 IEEE TITS. **Production deployments cited:** FastCI (ByteDance CI), vLLM (Retire implementation). **Released artifacts:** 6,204 scored trajectories (Finding the Right Fit), \~26,000 rollouts over $100,000 (VeriHarness), 35-page runtime-coordination code base, FlowReview code and data, frozen version-hashed delegation benchmark, MCP fixtures on Zenodo.

## Systems Management & Infrastructure

### 1\. Retire — versioned execution turns abort-and-restart into a coordinated handoff ([arXiv:2610.01160](https://arxiv.org/abs/2610.01160?ref=blog.punkslack.com))

**Claim:** the wrong primitive in agent serving is the single-request abort. When an LLM agent revises a running task — new instructions, tool failure, new information — today's servers kill the old request and start a replacement from nothing. Retire splits each request into a versioned execution that owns an *authority*: only the current version may publish output or install state; the successor inherits a certified completed prefix while obsolete resources are reclaimed asynchronously.

**Foundation:** the abort/restart model inherited from HTTP request handling, plus application-level ad-hoc state snapshots. Retire is the same conceptual move kernel engineers made decades ago from kill-and-restart to process migration — applied to inference serving.

**Evidence:** implemented in vLLM across output publication, GPU execution, KV handoff, tiered recovery, and distributed multi-tenant serving. Median 17.1% reduction in revision-to-successor TTFT in paired experiments; a replay of recorded coding-agent interruption arrivals emitted no obsolete output and kept every final version progressing.

**Trade-offs:** adds control-plane concepts (authority, certified prefix, version transitions) to a serving stack already thick with schedulers; correctness must be argued across many paths simultaneously. The benefit scales with revision frequency — churn-heavy coding-agent fleets win big, static chat workloads barely notice.

**Verdict: adopt-influencing.** Strongest systems paper of the window. If you operate agents on shared inference infrastructure, watch which fork of vLLM carries this; the revision-semantics gap it closes is real and today invisible to every benchmark.

### 2\. Leto — in-place recovery makes checkpoint-restart look lazy ([arXiv:2610.00687](https://arxiv.org/abs/2610.00687?ref=blog.punkslack.com))

**Claim:** for hardware-operable failures (HOFs) — those recoverable on the same hardware without reset, repair, or replacement — the right response is to never leave the GPUs, not to reload checkpoints.

**Foundation:** checkpoint-and-restart, the fault-tolerance workhorse since the era of long-running HPC jobs. Every major training stack still treats a failure as a queue-jump back to the last checkpoint, idling GPUs during rebuild.

**Evidence:** retains working model state and reusable process state outside the active training process, preinitializing the rest in a shadow trainer; two-tier erasure protection plus chunk-level transactional updates keep the shadow state consistent. On 6- and 72-GPU A100 clusters: recovery 3.6–6.5× faster than the best checkpointing baselines, productive training time up 13.7 percentage points. Simulation of a 131,072-GPU fleet shows over 95% productive training time.

**Trade-offs:** the shadow trainer occupies memory on hardware that just failed — memory you must be sure you have; misclassifying a hard failure as a HOF risks running on corrupted state, so the fault classifier becomes safety-critical. The 131K-GPU claim is simulation, not a run.

**Verdict: production-grade direction.** The pattern (keep state hot, never leave the machine) will show up in next-generation training stacks. The cluster experiments are honest; the fleet-scale number is extrapolation — flagged accordingly.

### 3\. ePACT — energy savings are not cost savings under asymmetric commitments ([arXiv:2610.01784](https://arxiv.org/abs/2610.01784?ref=blog.punkslack.com))

**Claim:** under hourly energy commitments with asymmetric overuse/underuse penalties, minimizing raw consumption can still maximize cost. Energy-performance-aware commitment tracking — minimize deviation cost subject to request-level SLOs — is the actual objective.

**Foundation:** classic SLO-attainment controllers treat energy as a soft side-optimization; demand-response tariffs make it a contract with teeth. This is the FinOps-meets-power-market crossover the energy-aware-LLM-serving line has been converging toward since September's energy-profiling work (GPU-only telemetry missing 41–45% of system energy).

**Evidence:** two-level controller: a global planner updates interval energy targets from measured consumption and remaining commitment; a local decision-maker predicts candidate configurations' energy and completion times, screens deadline misses, and selects by asymmetric deviation cost with a service-first fallback. 24-hour trace simulations on H20 and H200 pools: deviation cost down 73.8% and 75.7% relative to vLLM at near-equal SLO attainment; mean absolute hourly deviation 2.16%/2.31%.

**Trade-offs:** simulation and single-hour comparisons only — no live-grid deployment; needs tariff modeling specific to each procurement; the service-first fallback trades compliance for latency under stress, which is the right default but must be tuned per site.

**Verdict: pilot-worthy for operators on demand-response contracts.** The framing correction (energy ≠ cost) is the transferable idea; the controller is a good reference design but simulations are not deployments.

### 4\. Seamless reconfiguration for DAG-BFT — membership changes without pausing the DAG ([arXiv:2610.00896](https://arxiv.org/abs/2610.00896?ref=blog.punkslack.com))

**Claim:** reconfiguration remains the unexplored corner of the post-DAG-Rider wave of asynchronous BFT protocols: existing systems pause or delay membership changes to epoch boundaries. This protocol keeps the DAG growing while quorum thresholds change — the first seamless reconfiguration for fully asynchronous DAG-based Byzantine atomic broadcast.

**Foundation:** epoch-boundary reconfiguration — the pragmatic workaround every deployed BFT system accepts, at the cost of maintenance windows. The hard new problem: agreeing on when to start using the new configuration may yield a logical round number already surpassed by concurrent asynchronous dissemination.

**Evidence:** in-submission protocol paper; the abstract demonstrates a protocol-level first (seamlessness in the fully asynchronous model) rather than benchmark dominance — honest, and consistent with FLP-motivated randomized-protocol lineage back to decades of atomic broadcast research.

**Trade-offs:** theory-first; no latency numbers released in the abstract; deployed systems with rare membership events gain little; protocol complexity is the price of seamlessness.

**Honorable mentions (systems):** [MANTA](https://arxiv.org/abs/2610.00714?ref=blog.punkslack.com) (EuroSys 2027) — ML-augmented storage-tiering advisor; [HakiCC](https://arxiv.org/abs/2610.00889?ref=blog.punkslack.com) — LLM-driven multi-agent design and optimization of concurrency-control protocols, continuing the week's “agents as protocol designers” thread.

**Verdict: niche but fundamental.** File under: infrastructure that will matter when agent-coordination mesh networks need live membership. Wait for the benchmark follow-up.

## Software Development & Delivery

### 5\. FastCI — GPU CI selection replaces schedule-driven regression ([arXiv:2610.01967](https://arxiv.org/abs/2610.01967?ref=blog.punkslack.com), deployed at ByteDance)

**Claim:** CI for LLM training frameworks is itself a bottleneck because GPU tests do not scale; runtime evidence should select and prune tests the way CPU-CI test selection does.

**Foundation:** the traditional merge-hook full-regression model (Jenkins/GitHub Actions lineage) and its established test-selection theory — FastCI is that old theory extended to GPU workloads with new mechanisms: equivalent-context pruning, risk prioritization, and workload trimming along axes outside each test's validation scope.

**Evidence:** on the CI workload of a real LLM training framework: CI latency −77.5%, GPU resource usage −63.9%, modified-code coverage retention +3.2% — and it is now integrated in the framework's production pipelines at ByteDance. Team includes PKU systems-faults lineage (Xuanzhe Liu, Xin Jin).

**Trade-offs:** selection mistakes become silent blind spots for unselected-but-affected behavior — coverage-retention measurement mitigates but does not eliminate; the 77.5% figure is against their own prior pipeline, so treat as intra-framework, not cross-tool; evidence is one deployment.

**Verdict: the strongest dev result of the window.** Deployed, huge numbers, correct classical instincts. Expect selective GPU CI to spread to every org whose CI queue is measured in GPU-hours.

### 6\. Code that works, environments that don't — dependency agreement as low as 7% ([arXiv:2610.00425](https://arxiv.org/abs/2610.00425?ref=blog.punkslack.com))

**Claim:** functional correctness hides a distinct failure axis: environment specification. Coding agents produce inconsistent, redundant, or incomplete dependency sets that passing tests never detect.

**Foundation:** the reproducible-build/lockfile tradition (pip freeze, conda environments, Nix). What is new here is applying that discipline as a *measurement protocol for agents*: a three-layer model of declared, runtime-installed, and necessary-and-sufficient dependencies.

**Evidence:** three agents × four languages × fifty tasks: dependency-set agreement as low as 7% for identical tasks; the largest divergence sits between the declared and runtime layers, implicating environment priors from training distributions; newer agents show no meaningful improvement, so the failure is not solved by scale.

**Trade-offs:** the protocol is new with no industry adoption; the agreement metric could be gamed by over-declaring dependencies (the necessary-and-sufficient layer is the honest one); negative results age better than positive ones but need replication.

**Verdict: important negative result.** Any team shipping AI-generated software should add dependency-spec verification to its agent eval suite now; benchmarks will follow.

### 7\. VeriSpec — audit the specification text itself, before it shapes any model ([arXiv:2610.01847](https://arxiv.org/abs/2610.01847?ref=blog.punkslack.com))

**Claim:** model specifications (the OpenAI Model Spec being the named case) contain inconsistencies — two individually reasonable principles that prescribe incompatible behavior — and these can be caught by auditing the text, not the model.

**Foundation:** behavioral alignment evaluation, which cannot distinguish specification defects from model misbehavior; formalizing natural-language specs, which loses nuance. VeriSpec keeps the spec in natural language and uses an LLM-as-verifier to reason over a rule graph clustered by authority level.

**Evidence:** 405 rules extracted from the OpenAI Model Spec; five inconsistencies manually validated and reported to developers, who responded positively and began internal discussions. Best of five baselines: precision 38.5%, lowest cost per validated inconsistency at $11.12.

**Trade-offs:** 38.5% precision means most flags are false positives — the honest framing is cost-per-true-find, and human triage remains mandatory; evidence is one specification; LLM-verifier agreement has its own reliability questions (see the detector half-life item below).

**Verdict: cheap and real enough to standardize.** Expect “spec bugs filed as issues” to become a routine workflow at labs within a year.

### 8\. Detector half-life & MCP wire decay — two quiet measurement papers that matter ([arXiv:2610.01664](https://arxiv.org/abs/2610.01664?ref=blog.punkslack.com), [arXiv:2610.00182](https://arxiv.org/abs/2610.00182?ref=blog.punkslack.com))

**Half-life (ASE '26):** provenance detectors trained on one generator generation decay as models evolve. Across 8 general-purpose judges and 3 dedicated detectors on 7 generators × 3 languages: DetectCodeGPT and GPT-Sniffer posted accuracy 0.50 with F1 scores of *0.00* — they classified nearly everything as AI-generated. Accuracy alone concealed the bias completely. General-purpose LLM judges were stronger, but reliability varies wildly by judge, generator, and prompting strategy.

**MCP post-wire changes:** valid Model Context Protocol messages do not preserve the distinctions downstream software needs. A differential-testing method over 18 fixtures and four pinned Python integrations found 13 unique fixture-task divergences (structured values, declared errors, rich content). Google ADK satisfied every primary contract in its observed path; others changed semantics or failed. An exploratory JSON-replay recovered more structured values — but returned incorrect values and values for fields absent at the source. Public Zenodo artifact.

**Shared trade-off:** both are small-'n' studies (one author each), but both attack metrics illusions rather than leaderboard rankings — the rarer and more useful genre.

**Verdict: adopt both as review checklists.** Provenance claims need multi-generator reporting; MCP integrations need consumer-contract tests — wire-level equivalence is not semantic equivalence.

## Agentic AI Frameworks & Multi-Agent Safety

### 9\. FlowReview — deny without disabling: composed flows, not object gates ([arXiv:2610.00371](https://arxiv.org/abs/2610.00371?ref=blog.punkslack.com))

**Claim:** reviewing individual objects for permissions fails on composition: contributions admissible in isolation jointly enable prohibited uses. The fix is authorization-paired evaluation — blocking prohibited uses and completing required authorized uses as one joint success criterion, enforced deterministically after LLM-assisted object resolution and permission ranking.

**Foundation:** deny-by-default capability gating, the default in every agent framework. Its known failure mode: block everything sensitive and collaboration stops working — which is why teams turn the gates off.

**Evidence:** in controlled composition experiments, reviewing combined artifacts reduced the denied-commit rate from 86.0% to *zero* with no loss of authorized supply. Also a negative lemma: preserving information and lineage alone does not ensure permission attribution — object identity and permission must stay connected to execution through verifiable components. Code and data on GitHub.

**Trade-offs:** controlled experiments, not live deployments; the deterministic enforcement layer is a new trusted base to audit; permission ranking is itself an LLM judgment with its own error modes.

**Verdict: most actionable multi-agent safety result this week.** The 86-to-zero headline is clean, and the design (rank with the model, enforce with code) matches how mature security engineering already splits judgment from authority.

### 10\. Runtime Assurance Contracts — scores cannot authorize; gates can ([arXiv:2609.39717](https://arxiv.org/abs/2609.39717?ref=blog.punkslack.com))

**Claim:** benchmarks, audits, and agent protocols describe performance, permissions, and repair — but never say how observed evidence should *change an agent's authority mid-task*. The name: the assurance-transition gap. A Runtime Assurance Contract binds autonomy boundaries, eligibility, evidence state, transition policy, human-review capacity, and non-compensatory gates; a failed or unknown mandatory gate forces retry, switch, escalation, deferral, or stop.

**Foundation:** score-gated policies and audit dashboards, where aggregate numbers authorize action. The week's recurring negative result: soft metrics inform routing fine, but must never gate execution.

**Evidence:** 280 deterministic failure-injection cases in agentic coding: at published example weights, a score-only rule admitted 80 of 100 block-required injections *and all 40 review-required injections*. A clean characterization theorem: for positive weights and binary risk signals, a gating rule agrees with the conjunction exactly when its threshold does not exceed the smallest weight. Plus 72/72 blinded-judge label agreement on a 24-episode holdout. Single author, unreviewed.

**Trade-offs:** synthetic injections; single-author; the theorem's conditions are restrictive (binary signals, positive weights); real deployments have non-binary evidence.

**Verdict: pairs with FlowReview as this week's design-pattern set** — gate conjunctions and composed-flow review are the same instinct: measure, then enforce with mechanisms whose outputs can be verified.

### 11\. Safety must survive self-improvement — stale scores resurrect unsafe programs ([arXiv:2610.01073](https://arxiv.org/abs/2610.01073?ref=blog.punkslack.com))

**Claim:** agent self-improvement persists failures across generations: historical scores keep re-electing unsafe programs, and even a fully validated safe program can be replaced by an unvalidated one unless validation is re-run under current conditions.

**Foundation:** regression-gated deployment, which works fine when humans are the only editors. The new failure surface: LLM editors that rewrite executable agent components and trust stale archive scores.

**Evidence:** a controlled testbed of stateful authorization tasks with paired interventions and independent traces. After a new authorization dependency invalidated previously-validated optimizations, historical scores preserved the *same unsafe program in 22 of 48 framework histories* — a correct alternative existed in every affected archive. Full validation plus validated rollback ended with fully correct programs while retaining over 43% deployment savings. Bonus finding: when failures occur, editing the initial implementation instead of the failed incumbent improves recovery.

**Trade-offs:** controlled testbed with fixed editors; residual failures persist on independently composed tests even after suite refresh — validation-set drift is not fully solved; the 43% savings headline depends on task mix.

**Verdict: the deployment-gate lesson of the week for anyone letting agents modify their own tooling** — including Hermes-style self-extending setups: re-validate what will run under *current* conditions, every time.

### 12\. The delegation danger band — context inheritance is nonmonotone in capability ([arXiv:2610.00041](https://arxiv.org/abs/2610.00041?ref=blog.punkslack.com))

**Claim:** the common fork-the-sub-agent-with-full-context default can actively harm: mid-capability children over-trust inherited *superseded* conclusions. Deference to stale state falls sharply with measured capability, producing a measurable “danger band” in the middle of any model ladder.

**Foundation:** two tribal defaults — fork-fresh (reset, base evidence only) and full-context inheritance. This paper measures both against a third option: curated Selective handoff.

**Evidence:** Qwen3 ladder (0.6/1.7/4/8B) on a frozen, version-hashed, action-scored benchmark where every task is solvable from base evidence: on the 1.7B model net inheritance harm drops below fork-fresh baseline (Δ(32) = −0.19, CI \[−0.25, −0.12\]) — a statistically significant local minimum relative to both weaker and stronger neighbors. Curated Selective handoff beats Full-context on all three datasets, largest exactly at the in-band model; a live parent-to-child fork reproduces the mid-model harm.

**Trade-offs:** one model family of smaller models; the fixed-threshold capability router failed on other datasets — a transferable router would need to predict reuse-benefit vs stale-context cost per task; synthetic primitives plus two QA benchmarks.

**Verdict: adopt the practice, skip the router.** Curate sub-agent handoffs to the useful conclusion and prune superseded state — costs nothing, helps everywhere measured, and the paper shows why the naive default is a trap precisely at mid-capability.

### 13\. VeriHarness — disagreement exposes correct alternatives; consensus conceals errors ([arXiv:2610.00972](https://arxiv.org/abs/2610.00972?ref=blog.punkslack.com), Google Cloud AI)

**Claim:** for long-horizon work, majority/consensus verification is the wrong heuristic: shared errors hide inside agreement while complementary correct claims live in disagreement. The fix: turn the generator's own base model into an *agentic verifier* with a workspace, evidence tools, and reusable verification skills — a disagreement resolver checks competing claims against environmental evidence; a consensus challenger hunts for omitted requirements in shared claims.

**Foundation:** self-consistency sampling and rubric graders — cheap, static, and blind to shared priors. This is the week's most explicit attack on the vote-and-hope pattern.

**Evidence:** across five long-horizon workspace benchmarks and two frontier models, highest selection scores among baselines; evidence-backed revision adds +6.2 points (Gemini 3.5 Flash) and +6.4 points (Claude Opus 4.8) over a single rollout. Released: \~26,000 rollouts produced at a cost over $100,000.

**Trade-offs:** the verifier can still be fooled by shared training priors (that is exactly what the consensus challenger is for, but it is a mitigation, not a proof); verification is extra compute per claim; +6 points is meaningful but not transformative.

**Verdict: strong industrial result; the transferable insight is the heuristic swap** — treat disagreement as signal and consensus as a suspect, not the reverse.

### Radar — honest-to-a-fault and worth tracking ([arXiv:2610.00980](https://arxiv.org/abs/2610.00980?ref=blog.punkslack.com), [arXiv:2610.00511](https://arxiv.org/abs/2610.00511?ref=blog.punkslack.com), [arXiv:2610.01756](https://arxiv.org/abs/2610.01756?ref=blog.punkslack.com))

**Runtime AI-Scientist (Can AI Scientists Coordinate at Runtime?):** the coordination- overhead thesis in one seed. Across Agent Laboratory, EvoScientist, and ARK on ResearchClawBench, runtime selection of agents was the strongest condition on every host — but adding work contracts and artifact-grounded verification *reduced* the observed means. Authoritative single-seed exploratory evaluation, honestly labeled as such. Watch the multi-seed replication before anyone concludes contracts are bad; conclude instead that coordination is not free.

**Epistemic Action in LLM-Based Systems (FAST Workshop, NeurIPS 2026):** introduces the question agent design forgets to ask — *is the evidence ready for the decision?* Three modes: acquire missing evidence, transform available evidence, probe a system for a revealing response. “Epistemic scaffolding” makes these actions possible *and auditable*. No benchmark, all framing — but the framing is right and converges with the contract papers above: decision-readiness as a first-class, auditable stage before commitment.

**SoK: Decentralized Agent Economic Infrastructure ([arXiv:2610.01756](https://arxiv.org/abs/2610.01756?ref=blog.punkslack.com)):** 17 property families over 6 task stages, 12 systems examined, 840 matched executions plus an exhaustive 11,648-case domain check. The recurring gap: verification to settlement — a correct escrow happily releases payment on an authorized approval that proves nothing about task conformance. *Recorded approval ≠ evidence of conformance* is the same finding last week's authority-at-commit-time papers reached from a different direction.

---

## Critical Analysis: Coordination Mechanisms Must Earn Their Keep

Strip this week to one sentence: **every coordination mechanism was put to a control experiment, and the honest ones lost gracefully while the useful ones won measurably.** Runtime contracts and verification skills reduced AI-scientist scores under host-calibrated budgets — the first credible public cost accounting for agentic overhead machinery. Full-context forks actively hurt exactly the mid-capability tier that fleet deployments actually run. Stale archive scores resurrected unsafe programs in half the studied histories. Against that: mandatory gates cut a 86% denied-commit rate to zero, and evidence-backed disagreement resolution added up to +6 points across frontier models.

The traditional lesson reasserts itself, third week running: **measure the mechanism, not the demo.** Orchestration frameworks should ship with ablation tables the way compilers ship with benchmark suites — and a control group beat a vendor harness claim on Terminal-Bench 4 this week (GPT outranking Claude under a lean harness, at less than a quarter of the per-task cost). The proposers-propose / checkers-dispose arc that ran through Sep 26–Oct 1 now has quantitative teeth: 22-of-48 unsafe-persistence, 280-case gate theory, 86-to-zero composition review. The emerging consensus design is unambiguous: LLM judgment may rank, route, and propose; deterministic mechanisms whose outputs are verifiable must decide.

**Next-watch list:** multi-seed replication of the runtime-coordination cost result; MANTA EuroSys27 tiering benchmarks; VeriHarness verification-skill self-improvement at scale; whether the DAG-BFT seamless protocol picks up quorum-performance numbers; consumer-contract testing as a standard MCP integration gate.

**Sources (all abstracts read at source Oct 2, 2026):** arXiv 2610.01160 (Retire, vLLM versioned execution), 2610.00687 (Leto, in-place recovery), 2610.01784 (ePACT, commitment tracking), 2610.00896 (DAG-BFT seamless reconfiguration), 2610.00714 (MANTA, EuroSys27), 2610.00889 (HakiCC), 2610.01967 (FastCI, ByteDance), 2610.00425 (environment reproducibility), 2610.01847 (VeriSpec), 2610.01664 (detector half-life, ASE '26), 2610.00182 (MCP post-wire localization), 2610.00371 (FlowReview), 2609.39717 (Runtime Assurance Contracts), 2610.01073 (RSI safety), 2610.00041 (delegation danger band), 2610.00972 (VeriHarness), 2610.00980 (Runtime AI-Scientist), 2610.00511 (epistemic action), 2610.01756 (agent-economics SoK).