diff --git a/.gitignore b/.gitignore index 3229614c2..5d6fd7fd8 100644 --- a/.gitignore +++ b/.gitignore @@ -101,8 +101,12 @@ specs/* # Experiment run outputs (telemetry / plots / logs) — generated, not source lib/python/examples/async_cifar10/experiments/run_*/ +lib/python/examples/async_cifar10/experiments/smoke_*/ +lib/python/examples/fwdllm/experiments/ +lib/python/examples/fwdllm/expt_scripts/smoke_logs/ # Parity-checker report outputs — generated by scripts/parity_check.py, not source lib/python/examples/async_cifar10/experiments/parity_*.json +lib/python/examples/async_cifar10/parity_*.json # Stray trainer log + local Claude Code project dir temp_trainer.log .claude/ diff --git a/docs/prerequisites.md b/docs/prerequisites.md index 9244e400b..3e8936e1b 100644 --- a/docs/prerequisites.md +++ b/docs/prerequisites.md @@ -20,7 +20,10 @@ conda activate flame This creates a Python 3.11 conda env named `flame` and installs the flame library plus the `[examples]` and `[dev]` extras (torch, torchvision, -sortedcontainers, wandb, pytest, ...). +sortedcontainers, wandb, pytest, ...). The `[examples]` extra also includes +the NLP forward-mode stack (transformers, adapters, h5py, ...), so a single +env can run the smoke tests for both the vision examples (async_cifar10) and +fwdllm. ### Manual conda diff --git a/docs/quickstart-mac.md b/docs/quickstart-mac.md index 27f57ea7a..36efc611f 100644 --- a/docs/quickstart-mac.md +++ b/docs/quickstart-mac.md @@ -67,8 +67,10 @@ conda activate flame That creates a conda env named `flame` (Python 3.11) and installs the flame library plus the `[examples]` and `[dev]` extras (torch, torchvision, -sortedcontainers, wandb, pytest, ...). It uses the dependency spec in -`lib/python/setup.py`. +sortedcontainers, wandb, pytest, ...). The `[examples]` extra also pulls the +NLP forward-mode stack (transformers, adapters, h5py, ...), so one env runs +the smoke tests for both async_cifar10 and fwdllm. It uses the dependency spec +in `lib/python/setup.py`. ### Running an Example diff --git a/docs/quickstart-ubuntu.md b/docs/quickstart-ubuntu.md index b4c33a93c..454db032d 100644 --- a/docs/quickstart-ubuntu.md +++ b/docs/quickstart-ubuntu.md @@ -73,8 +73,10 @@ conda activate flame That creates a conda env named `flame` (Python 3.11) and installs the flame library plus the `[examples]` and `[dev]` extras (torch, torchvision, -sortedcontainers, wandb, pytest, ...). It uses the dependency spec in -`lib/python/setup.py` — there is no separate `requirements.txt`. +sortedcontainers, wandb, pytest, ...). The `[examples]` extra also pulls the +NLP forward-mode stack (transformers, adapters, h5py, ...), so one env runs +the smoke tests for both async_cifar10 and fwdllm. It uses the dependency spec +in `lib/python/setup.py` — there is no separate `requirements.txt`. ### Running an Example diff --git a/lib/python/README.md b/lib/python/README.md index 3f66da209..b882769c6 100644 --- a/lib/python/README.md +++ b/lib/python/README.md @@ -1 +1,84 @@ -# Python API +# Flame Python library — environment setup & running examples + +This is the single starting point for setting up a dev environment and running +the bundled examples (async_cifar10, async_google_speech, fwdllm). You do **not** +need the SDK / Ubuntu / macOS quickstart docs for this — they cover the same +env setup plus control-plane (Go) bits you don't need just to run examples. + +## 1. Prerequisites + +- Linux with `conda` (miniconda/anaconda) installed. +- Python 3.10+ (3.11 recommended) — created for you in step 2. +- A GPU is recommended for these examples but not required. +- An MQTT broker reachable on `localhost:1883` (the examples use `backend: mqtt`). + `mosquitto` works; see step 3. + +## 2. Set up the environment (one command) + +From the repo root: + +```bash +bash scripts/setup_env.sh flame # creates a py3.11 conda env named "flame" +conda activate flame +``` + +Equivalent manual steps: + +```bash +conda create -n flame python=3.11 -y +conda activate flame +pip install -e lib/python[examples,dev] +``` + +The single `[examples]` extra installs the full stack for **all** bundled +examples — vision (`torch`/`torchvision`), speech (`torchaudio`), and NLP +(`transformers` + the `adapters` add-on + `h5py`/`pandas`/`scikit-learn`). +The dependency source of truth is [`lib/python/setup.py`](setup.py); there is +no `requirements.txt`. + +## 3. Start an MQTT broker + +```bash +pgrep -x mosquitto >/dev/null || mosquitto -d # no-op if one is already running +``` + +## 4. Run an example (10-trainer smoke tests) + +Run from the **repo root** with the env activated. + +### async_cifar10 — vision (YAML launcher) + +```bash +python -m flame.launch.run_experiment \ + lib/python/examples/async_cifar10/expt_scripts_2026/felix_n10_alpha100_syn20_smoke.yaml +``` + +### fwdllm — NLP / DistilBERT forward-mode (YAML launcher) + +Requires the agnews H5 data referenced in the smoke YAML +(`data_file_path` / `partition_file_path`); update those paths for your host +if needed. + +```bash +python -m flame.launch.run_experiment \ + lib/python/examples/fwdllm/expt_scripts/fwdllm_n10_smoke.yaml +# siblings: fwdllm_plus_n10_smoke.yaml, fluxtune_n10_smoke.yaml +``` + +### async_google_speech — speech + +Not yet migrated to the `flame.launch` YAML launcher. Run it via the example's +own scripts under `lib/python/examples/async_google_speech/` (start the +aggregator, then `trainer//exec_100_trainers.sh`). It only needs +the env from step 2 (`torchaudio` is included). + +## Troubleshooting + +| Symptom | Fix | +| :--- | :--- | +| `ModuleNotFoundError: flame` | `pip install -e lib/python` (env not active or not installed) | +| Trainers/aggregator hang at startup | No MQTT broker — run `mosquitto -d` (step 3) | +| fwdllm: `FileNotFoundError` on `*.h5` | Fix the `data_file_path`/`partition_file_path` in the smoke YAML | + +More detail on the launcher and the shared `_metadata/` bundle: +[`examples/README.md`](examples/README.md). diff --git a/lib/python/examples/MIGRATING_TO_LAUNCHER.md b/lib/python/examples/MIGRATING_TO_LAUNCHER.md index 04d33083b..dab469927 100644 --- a/lib/python/examples/MIGRATING_TO_LAUNCHER.md +++ b/lib/python/examples/MIGRATING_TO_LAUNCHER.md @@ -45,7 +45,7 @@ these layers in order (last wins for leaf values): 3. Per-trainer metadata from `_metadata/`: - `taskid` (from registry `task_id`) - `training_delay_s` (from registry, 4–18 s range for the 300-trainer pool) - - `trainer_indices_list` (from dataset splits; for non-CIFAR examples see §6) + - `trainer_indices_list` (from dataset splits; for non-CIFAR examples see §9) - **All five availability traces pre-injected**: `avl_events_syn_0`, `avl_events_syn_20`, `avl_events_syn_50`, `avl_events_mobiperf_2st`, `avl_events_mobiperf_3st_50`, `avl_events_mobiperf_3st_75` — trainer selects at runtime via @@ -56,6 +56,32 @@ these layers in order (last wins for leaf values): All five traces are pre-injected so the trainer never has to be re-spawned to switch availability modes within a batch. +### `dataset.name`/`num_trainers` must be threaded through, not defaulted + +`ConfigGenerator.generate_trainer_config(trainer_id, alpha, availability_mode, +dataset_name="cifar10", num_trainers=300, ...)` selects which +`_alpha_n.yaml` split file step 3 above reads. Until this was +fixed, **no caller in the launcher passed `dataset_name`/`num_trainers`** — +`runner.py`'s call into `TrainerSpawner.spawn_all()` → `spawn_trainer()` → +`generate_trainer_config()` dropped both on the floor, so every experiment +silently read the **300-trainer, cifar10** split file regardless of its real +`trainer.dataset.name`/`trainer.num_trainers`. This didn't corrupt any +existing CIFAR-10 run only because the split-generation script happens to +assign each `trainer_NNN` the same indices independent of the file's total +`N` (verified: every entry in `cifar10_alpha0.1_n48.yaml` is byte-identical +to its counterpart in `cifar10_alpha0.1_n300.yaml`) — but the code's behavior +contradicted its own naming scheme, and a future split file generated by a +different (genuinely N-dependent) method would have silently handed every +trainer the wrong partition. **Now fixed**: `runner.py` passes +`dataset_name=exp.trainer.dataset.name, num_trainers=exp.trainer.num_trainers` +into `spawn_all()`, which forwards both all the way through. Regression test: +`tests/launch/test_config_generator.py::TestTrainerSpawnerForwardsDatasetIdentity`. + +This is the same bug *shape* as the `agg_goal` issue below (§4) — a real +config value with a plausible-looking default several call-frames deep, +silently never reached by the actual caller. See that section's checklist +before adding a new field anywhere in the trainer or aggregator config path. + ### Adding a new dataset's data 1. **Index-style splits** (e.g., CIFAR-10). Generate @@ -66,7 +92,7 @@ switch availability modes within a batch. `dataset_splits` YAML cannot hold per-trainer index lists; instead, store `data_file_path`, `partition_file_path`, and `client_idx` directly in `trainer_base.yaml` as placeholders, and inject them via - `experiment.trainer.config_overrides.hyperparameters`. See §6 for the + `experiment.trainer.config_overrides.hyperparameters`. See §9 for the fwdllm-specific guidance. 3. **Trainer population.** If the new example needs a different `N` or device timing, extend `trainer_registry.yaml` (or add a parallel registry and point @@ -111,6 +137,91 @@ switch availability modes within a batch. `selection` (selected trainer IDs, scores, round) and `aggregation` (aggregation time, staleness stats). See §5 for the full telemetry contract. +6. **Per-example aggregator config template**: Create + `/configs/aggregator_base.json` (or `.yaml`). Do not put + example-specific fields (model hyperparameters, NLP config, etc.) into + `_metadata/aggregator_base.json` — that is a generic FL stub reused by all + examples. Reference it as `config_template: configs/aggregator_base.json` + in your smoke YAMLs. The runner accepts `.json` or `.yaml` + (extension-sniffed). + +7. **CPU partitioning and watchdog (handled by the runner, no example code + needed)**: `flame/launch/runner.py` reserves + `min(8, max(2, len(all_cores) // 8))` CPU cores for the aggregator before + spawning anything, so the 300 pinned trainers (see §3) don't time-slice + the single message-processing-bound aggregator process — + `AggregatorSpawner.spawn(..., cpu_cores=reserved_cores)` pins it via + `os.sched_setaffinity` and sets `OMP/MKL/OPENBLAS/NUMEXPR_NUM_THREADS` to + the reserved core count. The runner also no longer blocks forever on the + aggregator: it computes a watchdog budget from the aggregator's own + `hyperparameters.{max_runtime_s, sim_wall_ceiling_s}` (+1200s grace) and + calls `AggregatorSpawner.wait(timeout=watchdog_s)`; if the aggregator is + still running past that (deadlock), the runner hard-`terminate()`s it + instead of hanging the whole batch. + +8. **Running the launcher**: `python -m flame.launch.run_experiment + [--example-dir DIR] [--metadata-dir DIR]` + (`flame/launch/run_experiment.py:main()`). `--example-dir` and + `--metadata-dir` are optional — if omitted, the example dir is + autodetected by walking up the YAML path's parents until + `parent.parent.name == "examples"`, and metadata defaults to + `/metadata`. + +### Gotchas found the hard way (custom `TopAggregator` subclasses especially) + +These surfaced migrating fwdllm (a custom `TopAggregator` subclass, not the +generic swappable `asyncfl`/`syncfl` hierarchy — see §9) at real +duration/scale, not in a quick smoke test. If your aggregator overrides +methods rather than just configuring the generic stack, don't assume you +inherit these protections — check the equivalent code path in your own +override. + +- **`channel.recv_fifo()` defaults to `timeout=None` — blocks forever.** + Any aggregator method that waits for a trainer response should pass an + explicit `timeout` (`asyncfl/top_aggregator.py`'s `_aggregate_weights` + uses `RECV_TIMEOUT_WAIT_S=30`; reuse that constant). Without it, one + quiet trainer can block the whole composer loop indefinitely — and since + early-stop checks (`max_runtime_s`/`max_data_id_progress`, see §9) + typically run from the *other* side of the put/aggregate loop, a blocked + aggregate call means the run can silently exceed its configured + wall-clock budget with no self-recovery, needing a manual kill. A + subclass with its own aggregate method doesn't get this for free just by + extending a base class that has it right elsewhere. +- **A selector's timeout-based reclaim (e.g. "a selected trainer that never + responds in N seconds becomes selectable again") is easy to get wrong two + ways**: (a) *ordering* — if the reclaim block runs after an early-return + short-circuit, the reclaim code can never execute once the resource it + frees is fully exhausted (the unlock is gated behind the very lock it's + meant to release); (b) *completeness* — freeing a stale entry must clear + every related accounting structure together (e.g. both a `selected_ends` + set and an `all_selected` dict), not just one, or the slot stays + "occupied" from the other structure's point of view. This class of bug is + invisible at a 10-trainer/10-minute smoke test and only manifests once + concurrency saturates and enough wall-clock passes for the timeout window + to matter — **validate a new selector at longer duration and higher + trainer count than the default smoke test**, not just "it ran without + crashing." +- **A per-cycle "has this trainer already contributed" dedup guard should + be independent of the selector's own slot accounting** (defense in + depth), especially in an async aggregator. Fixing a selector-level + reclaim bug (above) can newly expose a duplicate-contribution race that + was previously unreachable only because the broken reclaim never let a + slot reopen. +- **If an aggregator caches its selected set across multiple aggregation + sub-cycles** (e.g. picks once per outer round and reuses that set for + every inner cycle, instead of reselecting fresh each time), **pruning + that cache for departed trainers is a separate concern from the + selector's own departure handling** — the aggregator's cache and the + selector's internal bookkeeping are different state that can drift out of + sync. A trainer the selector has correctly forgotten can still be stuck + in the aggregator's own cache, and the round stalls waiting for a + contribution that will never arrive. Also: caching does not, by itself, + create a way to replace a trainer that's still connected but stuck (never + finished initializing, etc.) — only explicit departure (disconnect/ + `UN_AVL`) triggers most departure-handling paths, so a merely-slow trainer + in a small cached set can single-handedly throttle progress at scale + (open in fwdllm's own case — see §9's pending list). + --- ## 3. Trainer-side changes @@ -120,7 +231,7 @@ The trainer is spawned with `--config-json`; everything per-trainer arrives in - `trainer_indices_list` — dataset sample indices (from `dataset_splits`). For path-style datasets, use `data_file_path` + `partition_file_path` + - `client_idx` instead (§6). + `client_idx` instead (§9). - `training_delay_s` — per-trainer delay (from registry). - `training_delay_enabled` — bool gate on delay (from config_overrides or trainer_base.yaml default). @@ -152,6 +263,19 @@ JSON). The trainer reads it from `sys.argv` alongside the config. Two modes: Set `time_mode` in the experiment YAML under `trainer.time_mode`. The spawner passes it as `--time_mode` to each trainer subprocess. +### CPU pinning (handled by the launcher, on by default) + +`TrainerSpawner(cpu_pinning=True, reserved_cores=...)` (`flame/launch/spawner.py`) +round-robin-pins each trainer process to a single CPU core via +`os.sched_setaffinity` (respecting cgroup/Slurm affinity) and sets +`OMP_NUM_THREADS=MKL_NUM_THREADS=OPENBLAS_NUM_THREADS=NUMEXPR_NUM_THREADS=1` +to prevent thread oversubscription on a 1-core process. `reserved_cores` (the +cores the runner set aside for the aggregator — see §2) are excluded from the +trainer pool. Pinning silently disables itself on non-Linux platforms where +`os.sched_getaffinity`/`os.sched_setaffinity` aren't available. No example +code needs to opt in or out — this is launcher-side spawning behavior, not a +config the trainer reads. + ### Data streaming (optional) By default a trainer loads its **entire** partition at init and reuses it on every @@ -225,6 +349,78 @@ The launcher resolves `aggregator_main` from the baseline (an experiment may not override it) and **fails fast on a selector/stack mismatch** — async selectors (`async_oort`, `async_random`, `fedbuff`) must run on the asyncfl stack; everything else on a sync stack (`flame/launch/runner.py:_validate_stack`). +The check is a regex over the aggregator main file's import line +(`from flame\.mode\.horizontal\.(\w+)\.top_aggregator import`, defaulting to +`syncfl` if no match), compared against `_ASYNC_STACKS = {asyncfl, +coord_asyncfl}` and `_ASYNC_SELECTORS = {async_oort, async_random, fedbuff}` +— it raises `ValueError` before any process is spawned if the selector's +async-ness doesn't match the stack's. + +**If the aggregator entrypoint imports only a subclass of `TopAggregator` (not +`TopAggregator` itself), the regex won't match and `_validate_stack` silently +falls back to `stack="syncfl"`.** Add a marker import to the entrypoint so the +regex hits: + +```python +from flame.mode.horizontal.syncfl.fwdllm_aggregator import TopAggregator # noqa: F401 +``` + +See `fwdllm/aggregator/main_fedfwd_agg.py` for the pattern. Always test +`_validate_stack` against the real entrypoint file, not synthetic text — +synthetic-only tests can pass while the real file is never matched. + +For stacks where sync/async is selector-driven (the `selector.kwargs.is_async` +kwarg), not fixed by module path, `_validate_stack` reads that kwarg directly +instead of using set membership — see the fwdllm handling in `runner.py`. + +### `experiment.aggregator` block: real config vs. descriptive labels + +`experiment.aggregator` (an `AggregatorConfig`, `experiment_config.py`) mixes +two kinds of field that look alike but are not: + +- **Real config**: `config_template`, `config_overrides`, `log_to_wandb`, + `wandb_run_name`. These are the only inputs to the merge in + `runner.py:_build_aggregator_config` (template → baseline.aggregator → + config_overrides) that produces `agg_cfg`, the actual JSON sent to the + spawned aggregator process. +- **Descriptive labels**: `selector`, `tracking_mode` are used only for the + log filename and `snapshot.yaml`/`execution_config.yaml` records — never + merged into `agg_cfg`. The runner validates `selector` against the real + merged value (`_validate_selector_label`) and raises on mismatch, so a + stale label can't silently mislabel every record of a run. `tracking_mode` + has no single canonical real-config equivalent to validate against (it + summarizes a combination of `trackTrainerAvail`/`client_notify` fields), so + keep it accurate by hand. +- **`agg_goal`** is the one exception that *is* real, but indirectly: when + set, the runner fans it into **every** runtime consumer as the final, + highest-precedence merge layer — `hyperparameters.aggGoal` (the + aggregator's own wait-for-N-contributions threshold) **and** + `selector.kwargs.aggGoal` **and** `selector.kwargs.aggr_num` (two + differently-named kwargs for the same "how many to select/aggregate" + concept across selector families: `fedbuff`/`async_random`/`async_oort`/ + `oracle` read `aggGoal`; `oort`/`refl_oort`/`feddance` read `aggr_num`). + **Set `agg_goal` once, at the top level — do not also set + `config_overrides.hyperparameters.aggGoal` or + `config_overrides.selector.kwargs.{aggGoal,aggr_num}`**; if you do, the + top-level `agg_goal` wins anyway (it merges last), so a duplicate is at + best redundant and at worst a misleading dead value if it's ever edited + out of sync. Leave `agg_goal` unset (`None`, the default) to fall through + to whatever `config_template`/baseline/`config_overrides` already produce. + + This exists because, before this fix, `agg_goal` was *also* purely + cosmetic — silently never reaching `agg_cfg` — so editing it had no effect + on the run while looking like the obvious way to control it. If you're + touching aggregator config in a new example, this is the trap to avoid: + any field meant to affect the real run must appear inside + `config_template`/baseline/`config_overrides`, or be explicitly fanned out + by the runner like `agg_goal` is. + +**Debugging multi-layer merges**: `flame/launch/baselines.py` also has +`merge_with_provenance(layers)` / `format_provenance(name, provenance)`, +which track which layer (config template / baseline / experiment override) +contributed each leaf key when building the aggregator or trainer config, and +print a per-layer summary. Useful when a value isn't what you expect and you +need to know which of the merge layers in §1/§2 last touched it. --- @@ -255,22 +451,107 @@ line is a JSON object with at least `{"event": "", "ts": , ...}`. | `selection` | `round`, `selected_ids`, `scores` | Which trainers were chosen | | `aggregation` | `round`, `agg_time_s`, `staleness_stats` | Aggregation timing | -### Post-run analysis scripts +### Post-run analysis: `scripts/analysis/analyze_run.py` -The runner calls analysis best-effort after experiment completion. Two scripts are -available in `async_cifar10/scripts/`: +The main analyzer (`scripts/analysis/analyze_run.py`, not run automatically +by the launcher — invoke it yourself) reads a run's `telemetry/` directory +and produces plots under `/plots/` across 8 categories +(performance, sanity, selection, selection/why, insights, system, +availability, aggregation) plus a `summary.txt` event-count/sanity report: -- **`analyze_send_recv_lag.py`**: parses `[SEND_RECV_LAG]` log entries from the - aggregator log; reports per-trainer median/p95/max lag. Run manually: - ```bash - python scripts/analyze_send_recv_lag.py /*_aggregator.log [--warn-threshold-s 5.0] - ``` -- **`compare_parity.py`**: compares two experiment runs (e.g., real vs simulated - time_mode) for trajectory parity. +```bash +python3 scripts/analysis/analyze_run.py /telemetry +``` + +It was originally written for async_cifar10 and generalized since (see +below) — `scripts/analysis/README.md` has the full plot-category reference, +the manifest schema, a step-by-step "wiring telemetry for a new example" +checklist, and known gotchas; **read it before onboarding a new example's +telemetry**, this section only summarizes. + +Two smaller, standalone scripts also exist in `async_cifar10/scripts/`: +`analyze_send_recv_lag.py` (parses `[SEND_RECV_LAG]` aggregator-log entries +for per-trainer median/p95/max lag) and `compare_parity.py` (compares two +runs, e.g. real vs. simulated `time_mode`, for trajectory parity). -For full telemetry plot generation, point a post-processing script at the -`telemetry/` directory. The JSONL files are append-only and line-buffered, so -`tail -f` works during a live run. +The JSONL files are append-only and line-buffered, so `tail -f` works +during a live run. + +### Per-example telemetry manifest (`telemetry_manifest.yaml`) — for +non-round-granular progress or a non-default model size + +`analyze_run.py` originally assumed two things true of async_cifar10 but +not necessarily of every example: that `round` is the only progress unit +and that it's fine-grained (advances every aggregation), and that there's +one fixed, full-model comm size. An example that violates either should +declare `/telemetry_manifest.yaml` (optional — absent means +async_cifar10-shaped defaults, unchanged behavior): + +```yaml +model_param_count: # params actually put on the wire per exchange -- + # not necessarily the full model (e.g. a + # gradient/perturbation-based scheme that only + # ever transmits a trainable subset) + +progress_hierarchy: # sub-round fields, ordered major->minor, each + - field: data_id # with a `bound` used as that level's mixed- + bound: 150 # radix multiplier (must exceed the field's + - field: iteration_per_data_id # real max value or ordering breaks + bound: 15 # across round boundaries) + +event_categories: # which of the 8 plot categories this example's + performance: populated # telemetry actually populates, and why -- + ... # values: populated | partial | not_populated. + # analyze_run.py cross-checks this against what + # actually got written and flags MISMATCH/DRIFT. +``` + +The consuming mechanism is `progress_key(record)` in `analyze_run.py`: an +ordinal that folds the declared sub-round fields into a single composite +value (mixed-radix), used as the x-axis/grouping key everywhere a plot +would otherwise collapse onto one point (e.g. a run that sits at `round==1` +for hundreds of events because round only advances once every sub-unit +finishes). Every plot bucketed this way uses the shared `PROGRESS_AXIS_LABEL` +constant so the axis reads as "progress," not misleadingly as plain round. +`progress_key()` is only safe for single-stream groupings, or for joining +two streams that both carry the declared hierarchy's fields — see its +docstring before reusing it for a new join. + +### Telemetry gotchas + +- **A trainer-role `selection` event's `"selector"` field can be a + channel-implementation artifact, not the real FL selector.** Every role + (aggregator *and* trainer) constructs its own local `Selector` for its + channel from `self._config.selector.sort`/`.kwargs`. If a baseline's + `trainer:` block in `baselines.yaml` never overrides `selector` (checked: + none currently do, across every example), the trainer's channel-local + selector silently stays on whatever placeholder + `/configs/trainer_base.yaml` hardcodes — confirmed launcher-wide, + not specific to any one example. Usually functionally benign (a trainer's + channel to its aggregator has exactly 1 candidate, so selection is + trivial regardless of selector class), but it means a trainer-side + `selection` event's `selector` field does **not** reflect the real + FL-level selection algorithm. Read which selector a run really used from + the **aggregator**'s config/telemetry, never the trainer's. +- **An aggregator subclass that overrides its own aggregation method(s) + must wire its own `telemetry.emit()` calls** — it is not inherited for + free just because a shared base class (e.g. `asyncfl/top_aggregator.py`) + already emits `agg_eval`/`agg_round`/`utility_belief`. A subclass with + its own complete aggregation cycle method needs the equivalent calls + added explicitly, wrapped in + `if telemetry.is_enabled(): try: ... except Exception: logger.debug(...)` + (telemetry must never be able to break training). Without this, + `plots/performance/` (and anything else needing `agg_eval`/`agg_round`) + is structurally empty regardless of any analyzer fix — not a plotting + bug, a missing-emission bug. +- **`analyze_run.py`'s empty-data plots render a literal "NO DATA" + placeholder PDF, not nothing.** (`plot_helpers.no_data_plot` — deliberate, + so a missing plot reads as "confirmed absent" rather than "did the code + crash?".) This means an incomplete telemetry field set produces a + `plots/` directory that *looks* fully populated at a glance but isn't — + always spot-check a few real plots' underlying data (or read + `summary.txt`'s event counts / manifest cross-check), not just that the + files exist. ### Output directory structure @@ -290,218 +571,471 @@ experiments/run_YYYYMMDD_HHMMSS_/ --- -## 6. fwdllm-specific migration notes +## 6. Execution snapshots and reproducibility -fwdllm differs from async_cifar10 in two key areas: (a) its dataset is stored as -H5 partitions on disk (not index lists injected by the spawner), and (b) its -existing trainer/aggregator already use `flame.config.Config` and have partial -availability support. This makes the port narrower than a greenfield migration. +The runner writes two reproducibility files into every experiment's output +directory (see the §5 directory layout) — no example code is involved. -### What's already compatible - -- Trainer (`trainer/fl_main.py`) and aggregator (`aggregator/fl_main.py`) both - use `flame.config.Config`. Only the config-loading call needs to change. -- Availability notification thread and `client_notify` struct are already present. -- Oracular tracking (`track_trainer_avail`) is already implemented in - `FedSGDAggregator.py`. - -### What must change - -**1. Config intake** (trainer and aggregator) +- **`snapshot.yaml`** (`flame/launch/snapshot.py:ExperimentSnapshot.create_snapshot()`): + ```yaml + snapshot_version: "1.0" + timestamp: + hostname: + experiment: + name: ... + description: ... + trainer: {num_trainers, start_id, dataset: {name, dirichlet_alpha}, + availability: {mode}, battery_threshold, time_mode} + aggregator: {config_template, selector, tracking_mode, agg_goal} + execution: {num_gpus, sleep_between_spawns, aggregator_warmup_time} + spawn_commands: + aggregator: [...] # full argv used to spawn the aggregator + trainers: [...] # representative trainer argv + git_info: {commit, branch, clean, uncommitted_changes} # or {error: ...} if not a git repo + metadata_location: + metadata_checksums: + trainer_registry: + dataset_splits: {: , ...} + availability_traces: {: , ...} + aggregator_config: + ``` + It also copies the merged aggregator config to + `/aggregator_config.json` if it wasn't already written there. + Load a saved snapshot with `ExperimentSnapshot.load_snapshot(path)`. + +- **`execution_config.yaml`** (`flame/launch/execution_config_generator.py:create_execution_config()` + + `save_execution_config()`): a more compact companion record that references + metadata **by key** instead of embedding it — e.g. + `metadata_refs.dataset_split_key = f"cifar10_alpha{alpha}_n{num_trainers}"` + and `metadata_refs.availability_trace_key = ` — plus + `git_info`, the resolved aggregator selector/tracking/goal, the trainer's + `trainer_id_range`, and (if provided) the same `spawn_commands` as the + snapshot. `save_execution_config()` prints a one-line summary (file size, + git hash, metadata keys) when it writes the file. + +## 7. Resource monitoring + +Optional background monitoring of RAM and GPU memory during a run, configured +under `execution.monitoring` in the experiment YAML (`MonitoringConfig` in +`flame/launch/experiment_config.py`): -Replace: -```python -parser.add_argument("--config", required=True) -config = Config(args.config) -``` -with: -```python -from flame.launch.cli import load_config_from_argv -config = load_config_from_argv() -``` -Also add `--time_mode` as a side-channel CLI arg (not in config JSON) if you want -simulated mode support: -```python -import argparse, sys -_p = argparse.ArgumentParser(add_help=False) -_p.add_argument("--time_mode", default="real") -_known, _ = _p.parse_known_args() -time_mode = _known.time_mode +```yaml +execution: + monitoring: + enabled: true # default true + check_interval_seconds: 30 + ram_warning_percent: 80.0 + ram_critical_percent: 90.0 + gpu_warning_percent: 80.0 + gpu_critical_percent: 90.0 ``` -**2. trainer_base.yaml for fwdllm** - -Create `fwdllm/configs/trainer_base.yaml`. Unlike async_cifar10, the dataset -fields cannot come from `_metadata/dataset_splits/` (H5 paths are not index -lists). Put the dataset fields in the base template with placeholder comments, and -let experiments override them via `config_overrides.hyperparameters`: +When enabled, the runner calls `create_monitor_from_config()` +(`flame/launch/resource_monitor.py`) to build a `ResourceMonitor`, which runs +on a background thread and writes lines like +`RAM: X.XGB / Y.YGB (Z.Z%) | Swap: A.AGB (B.B%) | GPU0: C.CGB/D.DGB (E.E%) Util:F% Temp:G°C` +to `/*_resources.log` at `check_interval_seconds`, escalating to +WARNING/CRITICAL log lines past the configured thresholds. RAM tracking uses +`psutil`; GPU tracking uses `pynvml` (via `nvidia-smi`) if available and is +skipped otherwise. `create_monitor_from_config` (and the whole feature) is a +no-op import-time fallback if `psutil` isn't installed. + +## 8. Batch mode: running multiple experiments in one launch + +The top-level experiment YAML is always an `experiments:` list (see the §1 +injection example and `README.md`); it isn't restricted to one entry — adding +more entries makes `flame.launch.run_experiment` run them **sequentially in +one process**, via `ExperimentRunner.run_experiment_batch()` +(`flame/launch/runner.py`): + +- Before the batch starts, and again after **every** experiment (success or + failure, via `finally`), the runner calls `_sweep_stragglers()`: it + `pkill -9 -f`s any lingering `trainer/pytorch/main.py` / + `aggregator/pytorch/main_*` processes (never the batch runner itself) and + polls for GPU memory to drain (up to 45s) before continuing, so a hung + process from one experiment can't poison the next. +- On an experiment failure, the default behavior is to prompt + `continue? (y/n):` on stdin. For unattended runs (overnight/CI), set + `auto_continue` is implied when **either** stdin is not a TTY **or** the + env var `FLAME_BATCH_CONTINUE_ON_ERROR` is set to anything other than + `""`, `"0"`, or `"false"` — in that case the runner logs the failure and + moves on to the next experiment instead of blocking on input. + +### Gotchas in a per-example run script (e.g. `run_sequential.sh`-style) + +- **Control `PYTHONPATH` explicitly.** If the active environment's + `pip install -e` editable install could point at a different clone (e.g. + a scratch/experiment checkout), export + `PYTHONPATH="/lib/python:$PYTHONPATH"` at the top of the + script so this checkout always wins regardless of what else is + installed — otherwise the script silently runs whatever code the + editable install resolves to, which may be missing recent changes + entirely (including `flame.launch` itself). +- **Poll spawned trainer processes concurrently against one shared + deadline when waiting for them to finish, not sequentially per-trainer.** + A sequential "wait up to N seconds, then force-kill" loop multiplies N by + trainer count in the worst case (every trainer independently timing out); + polling all of them together against one shared deadline caps the total + wait at N regardless of trainer count. +- **`channel.await_join()` only catches peers already joined at broadcast + time and has no timeout of its own** — a trainer whose fetch/upload call + lands a moment after the aggregator has broadcast end-of-training and + left can hang forever waiting for a peer that's already gone. Known, + currently-unfixed limitation of the shared channel/trainer shutdown + protocol; the concurrent-polling force-kill above bounds the cost but + doesn't eliminate the race. A proper fix needs a timeout inside + `await_join()` itself (or the trainer's own fetch/send methods) — shared + code, a separate change from any one example's migration. +- **If a stack has separate sync/async `compose()` branches** (or any other + copy-pasted tasklet-chain variants), diff them against each other when + you touch one — it's easy for a rewrite of one branch to silently drop a + step the other still has (e.g. forgetting `inform_end_of_training` in a + sync-mode rebuild that an async-mode rebuild still broadcasts), leaving + trainers with no way to learn the aggregator is done. + +## 9. fwdllm-specific migration notes + +fwdllm (FedFwd text-classification on agnews/DistilBERT) is now migrated and +serves as the reference for NLP/H5-path-style examples. It differs from +async_cifar10 in several ways that recur in similar examples. + +### H5 path-style dataset (not index splits) + +fwdllm stores training data as H5 partitions on disk. The spawner cannot inject +a `trainer_indices_list` from `_metadata/dataset_splits/`. Instead, +`data_file_path` and `partition_file_path` live in `configs/trainer_base.yaml` +with placeholder values; experiments inject the real paths via +`config_overrides.hyperparameters`. Set `trainer.dataset.path_style: true` in +the experiment YAML so the spawner skips the index-split lookup. ```yaml -# fwdllm/configs/trainer_base.yaml (minimal skeleton) -backend: mqtt -brokers: - - host: localhost - port: 1883 -channels: - # ... same channel block as current trainer JSON configs +# fwdllm/configs/trainer_base.yaml (dataset section) hyperparameters: - # Dataset — override per experiment or per baseline - dataset: agnews # override in experiment YAML + dataset: agnews data_file_path: PLACEHOLDER # inject via config_overrides partition_file_path: PLACEHOLDER # inject via config_overrides partition_method: niid_label_clients=100_alpha=1 - # Model - model_type: distilbert - model_name: distilbert-base-uncased - max_seq_length: 64 - peft_method: adapter - # FL - fl_algorithm: FedFwd - epochs: 1 - comm_round: 3000 - learning_rate: 0.01 - server_lr: 0.1 - train_batch_size: 32 - eval_batch_size: 32 - forward_mode: "True" - use_adapter: "True" - freeze_layers: "True" - fp16: "True" - # Per-trainer fields — injected by spawner - client_idx: 0 # injected: (trainer_id - 1) % 100 - training_delay_s: 4.0 # injected from registry + client_idx: 0 # injected by spawner per trainer + training_delay_s: 4.0 # injected from registry training_delay_enabled: "False" - training_delay_factor: "10" - # Availability - wait_until_next_avl: "True" - client_notify: - enabled: "False" - trace: syn_0 # avl_events_* — injected by spawner for all five trace types ``` -**3. Per-trainer `client_idx` injection** +### Per-trainer `client_idx` injection -fwdllm uses `client_idx` (0–99) to select the trainer's data partition from the -H5 file. The spawner injects `taskid` and `training_delay_s` automatically from -the registry. For `client_idx`, add it to `experiment.trainer.config_overrides` -or implement a custom injection hook in a thin wrapper around `TrainerSpawner`. +fwdllm selects its H5 partition by `client_idx` (0–99), not a static index +list. The launcher computes `client_idx = (trainer_id - 1) % client_idx_modulo` +and injects it per trainer. Set `trainer.client_idx_modulo` in the experiment +YAML (`client_idx_modulo: 100` for a 100-client H5 file); no custom wrapper +needed. -Simplest approach: add `client_idx` as a dotted-key override per trainer. In the -experiment YAML, set a formula under `config_overrides.hyperparameters.client_idx` -that the spawner evaluates to `(trainer_id - 1) % num_clients`. If the spawner -doesn't support per-trainer formula evaluation, inject it via a small wrapper -script that calls the spawner with per-trainer overrides. +### Single aggregator entrypoint with custom `TopAggregator` -**4. Baselines in `_metadata/baselines.yaml`** +`FedSgdAggregator.py` extends `flame.mode.horizontal.syncfl.fwdllm_aggregator.TopAggregator`, +a FedFwd-specific class — not the generic swappable `asyncfl`/`syncfl` +hierarchy. fwdllm therefore uses **one** aggregator entrypoint +(`aggregator/main_fedfwd_agg.py`) for all baselines; sync vs. async is +dispatched at runtime by the `is_async` kwarg in `selector.kwargs`. -Add fwdllm baselines. Minimal entries: +`_validate_stack`'s regex matches `from flame.mode.horizontal..top_aggregator import` +— it doesn't match `fwdllm_aggregator` by pattern. The entrypoint adds a +marker import that does match (see §4 for the general pattern): -```yaml -fedfwd_async_oort: - description: FedFwd + async_oort selector + fedbuff optimizer (asyncfl stack) - example: - aggregator_main: aggregator/main_asyncfl_agg.py - aggregator: - selector: - sort: async_oort - kwargs: - evalGoalFactor: 1.0 - optimizer: - sort: fedbuff - kwargs: {} - hyperparameters: - trackTrainerAvail: - enabled: "False" - type: "NA" - trainer: - hyperparameters: - client_notify: - enabled: "True" - fl_algorithm: FedFwd - forward_mode: "True" - -fedfwd_oort_oracular: - description: FedFwd + oort selector + fedavg optimizer + oracular tracking (syncfl stack) - example: - aggregator_main: aggregator/main_oort_sync_agg.py - aggregator: - selector: - sort: oort - kwargs: {} - optimizer: - sort: fedavg - kwargs: {} - hyperparameters: - trackTrainerAvail: - enabled: "True" - type: oracular - trainer: - hyperparameters: - client_notify: - enabled: "False" - fl_algorithm: FedFwd +```python +from flame.mode.horizontal.syncfl.fwdllm_aggregator import TopAggregator # noqa: F401 ``` -**5. Availability traces** — reuse `synthetic_traces.yaml` and -`mobiperf_traces.yaml` as-is. fwdllm currently embeds trace arrays inline in -trainer JSONs; the launcher will inject them from `_metadata/` instead. No new -trace files needed for the standard syn_0/syn_20/syn_50/mobiperf variants. - -**6. Aggregator entrypoints** - -fwdllm currently has a single `aggregator/fl_main.py`. Split into per-stack -files matching async_cifar10's pattern, then register each in `baselines.yaml`: - -| Stack | File | Baseline | -|-------|------|---------| -| asyncfl | `aggregator/main_asyncfl_agg.py` | fedfwd_async_oort | -| syncfl (oort) | `aggregator/main_oort_sync_agg.py` | fedfwd_oort_oracular | - -Each file only changes the `TopAggregator` import; all FL logic stays in -`FedSGDAggregator.py`. - -**7. Wandb gating** +### Config intake -fwdllm aggregator likely calls `wandb.init()` unconditionally. Gate it behind -`--log_to_wandb` following `main_fedavg_agg.py`'s `initialize_wandb()` pattern. -The launcher sets `log_to_wandb: false` by default; override in the experiment -YAML if needed. - -**8. Telemetry** - -fwdllm does not yet emit structured JSONL telemetry. Add `trainer_round` events -at minimum to get loss/accuracy curves from the post-run analyzer. The env var -`FLAME_TELEMETRY_DIR` is set by the launcher; check it and open a JSONL file: +Both trainer and aggregator replace the legacy `--config ` path with: ```python -import json, os, pathlib -_tel_dir = os.environ.get("FLAME_TELEMETRY_DIR") -_tel_file = open(pathlib.Path(_tel_dir) / f"trainer_{trainer_id}.jsonl", "a") if _tel_dir else None - -def _emit(event, **fields): - if _tel_file: - _tel_file.write(json.dumps({"event": event, **fields}) + "\n") - _tel_file.flush() +from flame.launch.cli import load_config_from_argv +config = load_config_from_argv() ``` +Add `--time_mode` as a side-channel arg. Note: `--time_mode simulated` is +accepted but is a no-op for fwdllm (no simulated-clock support in the +FedFwd aggregator — real-time only). + +### Custom stopping criteria + +fwdllm's `rounds` is a poor stopping unit: one round is 150 `data_id` +completions (hardcoded `total_data_bins`), each with up to 15 variance-check +iterations. Use the `max_data_id_progress` and `max_runtime_s` hyperparameters +instead (both off by default). Smoke YAMLs set `max_data_id_progress: 10` / +`max_runtime_s: 1800`; pass criterion is reaching the data-id cap before the +wall-clock ceiling fires. + +### Availability traces and wandb + +Reuse `synthetic_traces.yaml` and `mobiperf_traces.yaml` as-is. Gate wandb +behind `--log_to_wandb` per §2. + +### NLP dependencies + +Install `transformers>=4.57,<4.58`, `adapters>=1.3,<1.4`, `h5py`, `pandas`, +`scikit-learn` from the `[examples]` extra (`pip install -e lib/python[examples,dev]`). +Two legacy import issues fixed in the codebase: `AdamW` now comes from +`torch.optim` (not `transformers`, removed in v4.x); `LoRAConfig`/`BnConfig` +come from the standalone `adapters` package (not the old `adapter-transformers` +fork). + +### Baseline taxonomy + +| Baseline | stack (`is_async`) | selector | optimizer | availability | +|---|---|---|---|---| +| `fwdllm` | sync | `random` (per-round) | `fedavg` | unaware | +| `fwdllm_plus` | sync | `random` (per-iteration) | `fedavg` | ORACULAR | +| `fluxtune` | async | `async_oort` | `fedbuff` | 3-tier `client_notify` | +| `fluxtune_dynkc` | async | `async_random` + `dynamic_kc` | `fedbuff` | off | + +`fluxtune`'s fedbuff optimizer uses an explicit `learning_rate` kwarg (not a +dataset-name table lookup — see `fedbuff.py`) so it doesn't need to be forked +from the felix/oracle baselines. + +### Telemetry + +`trainer_round` events are emitted at the end of each successful +`train_with_data_id()` call (`FedSgdTrainer.py`). See §5 for the JSONL +contract; the env var `FLAME_TELEMETRY_DIR` is set by the launcher. + +### Lessons from smoke-testing fwdllm + +- **CUDA init blocks before logging is configured.** In + `aggregator/main_fedfwd_agg.py`, call `logging.basicConfig()` (and log a + line) *before* `torch.cuda.is_available()`. That call can hang + indefinitely on a wedged GPU driver; logging first turns a silently empty + log file into one that visibly stalls right after "checking CUDA + availability...". +- **Guard variance checks against `n < 2`.** + `fwdgrad_utils.calculate_var`/`calculate_real_var` must skip (not crash on + `torch.stack([])`) when fewer than 2 gradients are available, matching the + existing `n<2` guard in `calculate_snr`/`calculate_cv`. A stale trainer + update can race into a freshly-cleared `grad_for_var_check_list` right at + a data_id transition. +- **`Hyperparameters.staleness_policy`** (`flame/config.py`) has three modes + — `exact` (must match round/data_id/iteration), `round_data_id` (must + match round/data_id, any iteration), `none` (no gate) — and supersedes the + plain `reject_stale_updates` boolean for FedFwd baselines. `exact` needs + `ITERATION_PER_DATA_ID` echoed back in the trainer's `GRADIENTS` message. + Wired per baseline: `fwdllm`=exact, `fwdllm_plus`=round_data_id, + `fluxtune`=none. +- **`run_sequential.sh`'s `--num-gpus` must scale with `--num-trainers`.** + Each smoke YAML's checked-in `execution.num_gpus` default is sized for its + own trainer count; overriding trainer count without also overriding GPU + count crams all trainers onto too few GPUs and OOMs. The script's + `--only`/`RUNS` keys and the run directory name it produces are the plain + baseline name (`fwdllm`, `fwdllm_plus`, `fluxtune`) plus the actual + `--num-trainers` value, not the source YAML's own checked-in `n10` suffix + — including `aggregator.config_overrides.job.id`, which every checked-in + YAML keeps equal to `exp["name"]`. +- **`syn_train_100_eval_0_unavail_0`/`syn_train_90_eval_10_unavail_0`/ + `syn_train_50_eval_30_unavail_20`** now have real per-trainer data in + `synthetic_traces.yaml` (ported from the 150-trainer JSON source in + `expts/run_tc_expts/json_scripts/`, trainers 151–300 wrap trainers 1–150). + Spawner auto-injection for these three keys isn't wired up yet — that's + future work, not part of this data port. +- **A debug log line indexing a message dict unconditionally, a few lines + above the code's own existence guard for the same keys, crashed every + idle trainer at end-of-run.** `Trainer._fetch_weights` + (`flame/mode/horizontal/syncfl/fwdllm_trainer.py`) logged + `msg[MessageType.DATA_ID]`/`msg[MessageType.ITERATION_PER_DATA_ID]` + directly, but the aggregator's end-of-training broadcast + (`inform_end_of_training` in `syncfl/top_aggregator.py`) sends only + `{MessageType.EOT: ...}` — no `DATA_ID`/`ITERATION_PER_DATA_ID` — so any + trainer still waiting in `_fetch_weights` when the aggregator wrapped up + hit an uncaught `KeyError` and crashed instead of reaching the `EOT` + handling a few lines further down that sets `self._work_done` and exits + its loop cleanly. Confirmed across all three of 2026-07-02's n=100 + overnight runs: every idle/unselected trainer (82–90 per run, i.e. + whichever of the ~90 joined trainers the round cache or concurrency + window never selected) crashed with this exact `KeyError` at the run's + stop timestamp. Harmless to run correctness (those trainers were about to + be swept by the launcher's `_sweep_stragglers` regardless — see §8), but + it meant every single run ended with dozens of uncaught-exception + tracebacks instead of clean shutdowns. **Fixed**: switched the log line + to `msg.get(...)`, matching the guarded-access pattern already used a few + lines below (the analogous `MessageType.WEIGHTS` log line already used + `.get(...)`). Regression test: + `tests/mode/test_fwdllm_trainer_eot_keyerror.py`. + +### `run_sequential.sh` controlled-comparison flags + +Beyond the base launcher, `expt_scripts/run_sequential.sh` gained flags for +running all baselines with a genuinely controlled comparison: + +- `--max-data-id N` — **not a per-round safety valve, a hard permanent + stop.** `total_data_bins=150` is hardcoded in `fwdllm_aggregator.py` + (shared by all baselines), and `data_id` counts 0..149 *within* a single + round, not across completed rounds. The script's own default (10) fires + within minutes regardless of `--max-runtime-s` — **always pass something + > 150** (e.g. 200) for any run meant to last more than a few minutes. +- `--agg-goal N` — sets `aggregator.agg_goal` directly, fanning into + `hyperparameters.aggGoal` + `selector.kwargs.aggGoal`/`aggr_num`, + independent of `--c`. Without it, legacy behavior (`agg_goal == c`) + applies. +- `--c-async N` — overrides `selector.kwargs.c` only for the async baseline + (`fluxtune`), letting sync baselines use `--c` (concurrency == agg_goal) + while fluxtune overcommits concurrency independently. +- `--min-initial-trainers N` — overrides `selector.kwargs.minInitialTrainers` + directly. Leaving it unset makes the `--c`-derived default equal + `--num-trainers`, i.e. the aggregator refuses to do *any* work until + every single trainer has joined — no tolerance for one that fails to + join, and no work starts until the slowest joiner does. At high trainer + counts, set this explicitly and a bit below `--num-trainers` (e.g. 5%). +- `--avail-trace NAME` — overrides the availability trace for all three + baselines' real signal fields at once (`trainer.availability.mode` is + cosmetic; the real per-baseline fields are + `trainer.config_overrides.hyperparameters.client_notify.trace` for + fluxtune and `aggregator.config_overrides.hyperparameters.trackTrainerAvail.trace` + for fwdllm_plus's ORACULAR tracking). Use `syn_0` (always-available) to + isolate selection/aggregation-logic questions from trace-driven + scarcity/churn; leaving it unset means each baseline keeps its own + checked-in trace (they differ by default — see the baseline taxonomy + table above), which is *not* a controlled comparison. +- `--partition-method NAME` — overrides `hyperparameters.partition_method` + on both trainer and aggregator (must match). The smoke-test default + (`uniform`, i.e. IID) is deliberately chosen to isolate launcher-mechanics + validation from data-skew effects — not representative for a convergence + check; use a `niid_label_clients=...` variant for that. +- `--num-gpus` does **not** need to scale with `--num-trainers` — each + checked-in YAML already defaults to all 8 available GPUs; only the + smoke-test's *default* `--num-trainers` (10) assumes a small pool, so + raising trainer count without also considering GPU contention at that + scale is a physical-resource judgment call, not a config-correctness one. + +### fwdllm's own reselection-cache design: round-cached vs. per-iteration + +`_select_ends_respecting_reselect_gate` (`fwdllm_aggregator.py`) branches on +`reselect_each_iteration` (a baseline-level setting): + +- `fwdllm` (`False`): accumulates picks into a per-round cache + (`_round_selected_ends`) until it hits `agg_goal`, then **reuses that + exact cached list for the rest of the round** (all remaining `data_id`s + and their variance-check-retry iterations) — only reset when the round + itself advances. Coarsest granularity; cheapest per-cycle selector cost. +- `fwdllm_plus` (`True`): calls the selector fresh every iteration — finest + granularity, but the real selector (and its telemetry) fires far more + often. +- `fluxtune` (async): no round/batch concept at all — concurrency is a + rolling window; the instant any slot frees (successful contribution, + explicit departure, or a selector-level reclaim timeout), the very next + `select()` call backfills it immediately. + +The round-cached design (`fwdllm`) trades elasticity for cost: a departed +trainer *is* pruned from the cache (see the generic §2 gotcha above). A +trainer that's merely stuck — still connected, never finished +initializing — used to not be, and could throttle an entire round's +progress at scale since there was no reselection to route around it +(confirmed on a real n=100 run: the aggregator's working set stayed capped +at 30 of 100 trainers for a full 90-minute run). **Fixed**: +`_prune_departed_from_round_cache` also evicts a cached member that's gone +`ROUND_CACHE_STUCK_TIMEOUT_S` (5 min) without a real accepted contribution, +tracked via `_round_cache_activity_ts` (stamped on cache entry, reset on +every accepted contribution) — same timeout-based reclaim pattern as +`SEND_TIMEOUT_WAIT_S`/`RECV_TIMEOUT_WAIT_S` elsewhere in this file's +gotchas. **GPU-validated** via a real 2h n=100 `fwdllm` run +(`run_20260702_050957_fwdllm_n100_syn_0_smoke`, `syn_0` availability): 0 +"hasn't received weights" messages (vs ~9,700 before the fix) and steady +progress to `data_id` 135/150 with accuracy climbing 30%→67%, using the +full `max_runtime_s` budget instead of stalling in the back half like the +pre-fix run did. Note this run's own working set never actually got stuck +(no evictions fired), so it confirms *no regression to the old stall +pathology*, not that the eviction code path itself fired correctly under +real contention — that remains to be seen on a run where a trainer +genuinely wedges. + +### `channel.recv_fifo()` timeout — concrete fwdllm instance of the §2 gotcha + +fwdllm's two aggregation-cycle methods +(`_aggregate_grads_async`/`sync_collect_and_accumulate_grads`, one per +stack) both used to call `channel.recv_fifo()` with no `timeout`, matching +the generic gotcha in §2 exactly — fixed by passing +`timeout=RECV_TIMEOUT_WAIT_S` (imported from `asyncfl/top_aggregator.py`) +at both call sites. Confirmed via a real run: a 10-min `fluxtune` smoke +test hung 20+ minutes past its `--max-runtime-s` budget under a churny +availability trace before the fix; the identical re-run self-terminated on +schedule after. + +### fwdllm's telemetry: manifest values and what's deliberately not populated + +fwdllm declares `telemetry_manifest.yaml` (see §5's general mechanism): +`model_param_count: 450340` — the *trainable* subset only (measured from a +live run's `print_trainable_params_stats()` log line), not the full +66.8M-param model, since FedFwd's forward-mode/JVP scheme only ever puts +the trainable subset on the wire; a `progress_hierarchy` of +`data_id(150)`/`iteration_per_data_id(15)` (iteration-level chosen +deliberately after checking real telemetry — data_id-only resolution +undercounted real granularity: 31 vs. 73 distinct buckets in one real +n=100 run); and an `event_categories` map with per-category reasoning. + +fwdllm's aggregator also emits `agg_eval`/`agg_round` (in +`_process_aggregation_goal_met`, the actual per-cycle-completion method — +not the gradient-accumulation methods, which never complete a cycle) and +`utility_belief` (in `_process_single_trainer_message`'s `STAT_UTILITY` +branch, staleness computed against `self._model_version` since `round` can +sit at 1 for an entire run). Its trainer reports `sim_round_duration_s` +(real GPU time + emulated delay). **Deliberately not populated**: +`training_budget_s`/`overran`/`remaining_time_s` — fwdllm's delay is a flat +additive sleep, not a budget-minus-actual sleep-to-fill model like +async_cifar10's, so there's no faithful "overrun" concept to report; +fabricating one would be misleading rather than merely incomplete. + +**Future telemetry improvements (optional, non-blocking):** + +- **No first-class metric for the round-cache-stuck class of issue** (the + bug fixed above in "fwdllm's own reselection-cache design"). Root-causing + the original occurrence took an hour of hand-grepping raw aggregator logs + (`Total ends: N`, `hasn't received weights`, staleness rejections). A + plot/metric for "live channel-end pool size vs. configured + `--num-trainers` over time" and "trainers stuck at `model_version=-1` + past N minutes" would turn that into a 30-second `analyze_run.py` check, + and would generalize to catching the same class of issue in future + examples. +- **fwdllm's own `selection`/`selection/why` telemetry stays structurally + thin.** `RandomSelector` carries no `believed_I`/`system_util`/`temporal` + factors (no "why" beyond uniform chance), and its real selector only + fires ~once per round under the cache-reuse design (`fwdllm_plus` is + richer, since it reselects every iteration). Worth a plot/metric that's + actually informative for this selection pattern instead of reusing + oort-family-shaped plots that don't fit it. + --- -## 7. Migration checklist for a new example +## 10. Migration checklist for a new example 1. Symlink `/metadata → ../_metadata` (or set `experiment.metadata.dir`). 2. Add `dataset_splits/_alpha_n.yaml`; reuse registry + traces. For path-style datasets (fwdllm), skip this step and inject paths via - `config_overrides` instead (§6). + `config_overrides` instead (§9). 3. Add `/configs/trainer_base.yaml` (static per-example trainer - template; per-trainer fields are injected by the launcher). + template; per-trainer fields are injected by the launcher) and + `/configs/aggregator_base.json` (example-specific aggregator + config template — do not use `_metadata/aggregator_base.json` for + example-specific fields; see §2). 4. Provide one aggregator entrypoint per stack you run (§2); delete the rest. + If your aggregator extends a custom `TopAggregator` subclass, add a marker + import to the entrypoint so `_validate_stack` detects it correctly (§4). 5. Make trainer + aggregator entrypoints use `load_config_from_argv()` and read all per-trainer values from `hyperparameters` (§2–§3). 6. Add the example's baselines to `baselines.yaml` with `example.aggregator_main`. 7. Add `expt_scripts/_n10_*_smoke.yaml` experiment YAMLs. 8. Validate without spawning: load the YAML, resolve the baseline, build the aggregator config, and run `_validate_stack`. Then run a 10-trainer smoke test. +8b. **If you add a new field anywhere in `ExperimentConfig`** (trainer, + aggregator, or execution), trace it all the way from the YAML to the + place that actually consumes it, and write a test that fails if a layer + in between drops it. A typed dataclass field with a plausible default is + not evidence the value reaches the real config — `agg_goal`, + `dataset_name`/`num_trainers`, and the now-removed + `MetadataPaths.dataset_splits_dir`/`traces_dir` were all declared, + parsed from YAML without error, and silently never used by anything + downstream (see §4's "real config vs. descriptive labels" and the + `dataset.name`/`num_trainers` note in §1). The smell: a function several + call-frames down has its own default for the same value the top-level + config also claims to set — if nothing forwards the real value through + that whole chain, the default always wins and the YAML field is a no-op. 9. (Optional) Add `trainer_round` / `avail_change` JSONL telemetry events to enable post-run analysis plots (§5). 10. (Optional) Port the `data_streaming` block into `trainer_base.yaml` + the @@ -538,4 +1072,4 @@ Keep (still current): | `async_cifar10` | Migrated (reference). 5 baselines: felix, fedbuff, fedavg, oort, refl. Includes telemetry, streaming, time_mode, memory profiler. | | `feddance_cifar10` | Has launcher YAMLs; FedDance baseline blockers tracked in `async_cifar10/FEDDANCE_TODO.md`. | | `async_google_speech` | **TODO** — migrate per this guide (needs google-speech dataset splits + per-stack aggregator entrypoints). | -| `fwdllm` | **TODO** — see §6 for fwdllm-specific steps. Main blockers: (1) config intake switch to `load_config_from_argv()`; (2) per-trainer `client_idx` injection; (3) split aggregator into per-stack entrypoints; (4) add baselines to `baselines.yaml`; (5) gate wandb; (6) add JSONL telemetry. Dataset splits are H5-path-based, not index-list-based — use `config_overrides` for data paths rather than `_metadata/dataset_splits/`. | +| `fwdllm` | Migrated and hardened post-migration (real deadlock, duplicate-contribution, `max_runtime_s`-starvation, round-cache-stuck, and end-of-training `KeyError` bugs found via longer/larger real runs and fixed — see §2/§8/§9's gotchas above, all sourced from this). Re-validated 2026-07-02 with three fresh 2h n=100 runs (one per baseline family: `fwdllm`, `fwdllm_plus`, `fluxtune`) — no stalls, no unhandled exceptions, telemetry manifests clean, accuracy climbing on all three. 4 baselines: `fwdllm` (syncfl/unaware), `fwdllm_plus` (syncfl/ORACULAR), `fluxtune` (asyncfl/async_oort+fedbuff), `fluxtune_dynkc`. H5 path-style dataset via `config_overrides`; `client_idx_modulo` injection; single aggregator entrypoint with marker import + `is_async`-kwarg-driven stack detection; full telemetry (`trainer_round`/`agg_eval`/`agg_round`/`utility_belief`/`selection`) + a per-example manifest for non-round-granular progress; `max_data_id_progress` auto-stop. See §9 for fwdllm-specific patterns; `fwdllm/MIGRATION_TO_LAUNCHER_FWDLLM.md` is now just a pointer here (no fwdllm-specific blockers remain) plus a link to `DELETION_CANDIDATES.md` for the post-merge legacy-code cleanup PR. | diff --git a/lib/python/examples/README.md b/lib/python/examples/README.md index a9e5feb23..844bc6aa6 100644 --- a/lib/python/examples/README.md +++ b/lib/python/examples/README.md @@ -2,6 +2,10 @@ This directory contains examples demonstrating various federated learning scenarios, algorithms, and topologies using the Flame framework. +> **New here?** For environment setup and copy-paste commands to run +> async_cifar10 / async_google_speech / fwdllm, start with +> [`lib/python/README.md`](../README.md). + ## Running experiments via the YAML launcher Most examples can be driven by `flame.launch`, which reads a single experiment diff --git a/lib/python/examples/_metadata/README.md b/lib/python/examples/_metadata/README.md new file mode 100644 index 000000000..979ce09be --- /dev/null +++ b/lib/python/examples/_metadata/README.md @@ -0,0 +1,20 @@ +# Metadata + +This folder contains trainer metadata and satellite latency data used in async federated learning experiments. + +## Contents + +- `trainer_registry.yaml` — per-trainer metadata (computation time, satellite index, RTT params, speed class) +- `baselines.yaml` — baseline experiment configurations +- `aggregator_base.json` — base aggregator configuration +- `availability_traces/` — trainer availability traces +- `dataset_splits/` — dataset index assignments per trainer +- `leo/` — LEO satellite latency traces + - `satellite_latencies.npy` — propagation latencies from a ground station in Norway to 150 LEO satellites over 10800 timesteps (units: ms, range: ~1.7–85.5ms). Generated using https://github.gatech.edu/vbhosale6/planet-latency +- `scripts/` — scripts for exploring or modifying metadata + - `explore_latencies.py` — visualize and analyze satellite_latencies.npy + - `update_registry.py` — update fields in trainer_registry.yaml + +## Regenerating satellite_latencies.npy + +Use the scripts at https://github.gatech.edu/vbhosale6/planet-latency to regenerate propagation latencies from a ground station location of your choice. diff --git a/lib/python/examples/_metadata/availability_traces/synthetic_traces.yaml b/lib/python/examples/_metadata/availability_traces/synthetic_traces.yaml index b2dfb508a..ebef63998 100644 --- a/lib/python/examples/_metadata/availability_traces/synthetic_traces.yaml +++ b/lib/python/examples/_metadata/availability_traces/synthetic_traces.yaml @@ -62211,3 +62211,87362 @@ traces: - AVL_TRAIN - - 86400 - UN_AVL + syn_train_100_eval_0_unavail_0: + description: 100% train / 0% eval / 0% unavail (ported from legacy json_scripts) + pattern: + - - 0 + - AVL_TRAIN + syn_train_90_eval_10_unavail_0: + description: 90% train / 10% eval / 0% unavail (ported from legacy json_scripts) + pattern: + - - 0 + - AVL_TRAIN + per_trainer: + n300: + trainer_001: + - - 0 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + trainer_002: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + trainer_003: + - - 0 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_004: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_005: + - - 0 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_006: + - - 0 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + trainer_007: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + trainer_008: + - - 0 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_009: + - - 0 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_010: + - - 0 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_011: + - - 0 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_012: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + trainer_013: + - - 0 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_014: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_015: + - - 0 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_016: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_017: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + trainer_018: + - - 0 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_019: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + trainer_020: + - - 0 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + trainer_021: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + trainer_022: + - - 0 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + trainer_023: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_024: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + trainer_025: + - - 0 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + trainer_026: + - - 0 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_027: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_028: + - - 0 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + trainer_029: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + trainer_030: + - - 0 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_031: + - - 0 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_032: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + trainer_033: + - - 0 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_034: + - - 0 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + trainer_035: + - - 0 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_036: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_037: + - - 0 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_038: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_039: + - - 0 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_040: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_041: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_042: + - - 0 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_043: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + trainer_044: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + trainer_045: + - - 0 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_046: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_047: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + trainer_048: + - - 0 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + trainer_049: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + trainer_050: + - - 0 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_051: + - - 0 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_052: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_053: + - - 0 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_054: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + trainer_055: + - - 0 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + trainer_056: + - - 0 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_057: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_058: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + trainer_059: + - - 0 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_060: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_061: + - - 0 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + trainer_062: + - - 0 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_063: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + trainer_064: + - - 0 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_065: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_066: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + trainer_067: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_068: + - - 0 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + trainer_069: + - - 0 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + trainer_070: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + trainer_071: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_072: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + trainer_073: + - - 0 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_074: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_075: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_076: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + trainer_077: + - - 0 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + trainer_078: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_079: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + trainer_080: + - - 0 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_081: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + trainer_082: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_083: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + trainer_084: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + trainer_085: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_086: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + trainer_087: + - - 0 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + trainer_088: + - - 0 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + trainer_089: + - - 0 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + trainer_090: + - - 0 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_091: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_092: + - - 0 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_093: + - - 0 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_094: + - - 0 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_095: + - - 0 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_096: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_097: + - - 0 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_098: + - - 0 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + trainer_099: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + trainer_100: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_101: + - - 0 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_102: + - - 0 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_103: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_104: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + trainer_105: + - - 0 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + trainer_106: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + trainer_107: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_108: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_109: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + trainer_110: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_111: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_112: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_113: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_114: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + trainer_115: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + trainer_116: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + trainer_117: + - - 0 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + trainer_118: + - - 0 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + trainer_119: + - - 0 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + trainer_120: + - - 0 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + trainer_121: + - - 0 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_122: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + trainer_123: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_124: + - - 0 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + trainer_125: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + trainer_126: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_127: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + trainer_128: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_129: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_130: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + trainer_131: + - - 0 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + trainer_132: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_133: + - - 0 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + trainer_134: + - - 0 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_135: + - - 0 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + trainer_136: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + trainer_137: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + trainer_138: + - - 0 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + trainer_139: + - - 0 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + trainer_140: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + trainer_141: + - - 0 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_142: + - - 0 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_143: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_144: + - - 0 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_145: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_146: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + trainer_147: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + trainer_148: + - - 0 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_149: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + trainer_150: + - - 0 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_151: + - - 0 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + trainer_152: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + trainer_153: + - - 0 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_154: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_155: + - - 0 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_156: + - - 0 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + trainer_157: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + trainer_158: + - - 0 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_159: + - - 0 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_160: + - - 0 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_161: + - - 0 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_162: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + trainer_163: + - - 0 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_164: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_165: + - - 0 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_166: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_167: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + trainer_168: + - - 0 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_169: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + trainer_170: + - - 0 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + trainer_171: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + trainer_172: + - - 0 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + trainer_173: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_174: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + trainer_175: + - - 0 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + trainer_176: + - - 0 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_177: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_178: + - - 0 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + trainer_179: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + trainer_180: + - - 0 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_181: + - - 0 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_182: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + trainer_183: + - - 0 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_184: + - - 0 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + trainer_185: + - - 0 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_186: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_187: + - - 0 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_188: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_189: + - - 0 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_190: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_191: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_192: + - - 0 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_193: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + trainer_194: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + trainer_195: + - - 0 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_196: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_197: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + trainer_198: + - - 0 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + trainer_199: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + trainer_200: + - - 0 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_201: + - - 0 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_202: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_203: + - - 0 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_204: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + trainer_205: + - - 0 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + trainer_206: + - - 0 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_207: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_208: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + trainer_209: + - - 0 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_210: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_211: + - - 0 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + trainer_212: + - - 0 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_213: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + trainer_214: + - - 0 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_215: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_216: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + trainer_217: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_218: + - - 0 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + trainer_219: + - - 0 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + trainer_220: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + trainer_221: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_222: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + trainer_223: + - - 0 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_224: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_225: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_226: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + trainer_227: + - - 0 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + trainer_228: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_229: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + trainer_230: + - - 0 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_231: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + trainer_232: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_233: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + trainer_234: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + trainer_235: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_236: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + trainer_237: + - - 0 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + trainer_238: + - - 0 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + trainer_239: + - - 0 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + trainer_240: + - - 0 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_241: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_242: + - - 0 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_243: + - - 0 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_244: + - - 0 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_245: + - - 0 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_246: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_247: + - - 0 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_248: + - - 0 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + trainer_249: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + trainer_250: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_251: + - - 0 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_252: + - - 0 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_253: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_254: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + trainer_255: + - - 0 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + trainer_256: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + trainer_257: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_258: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_259: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + trainer_260: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_261: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_262: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_263: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_264: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + trainer_265: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + trainer_266: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + trainer_267: + - - 0 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + trainer_268: + - - 0 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + trainer_269: + - - 0 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + trainer_270: + - - 0 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + trainer_271: + - - 0 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + trainer_272: + - - 0 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + trainer_273: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_274: + - - 0 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + trainer_275: + - - 0 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + trainer_276: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_277: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + trainer_278: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_279: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_280: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + trainer_281: + - - 0 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + trainer_282: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_283: + - - 0 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + trainer_284: + - - 0 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_285: + - - 0 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + trainer_286: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + trainer_287: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + trainer_288: + - - 0 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + trainer_289: + - - 0 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + trainer_290: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + trainer_291: + - - 0 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_292: + - - 0 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_293: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_294: + - - 0 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_295: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_296: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + trainer_297: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + trainer_298: + - - 0 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_299: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + trainer_300: + - - 0 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + syn_train_50_eval_30_unavail_20: + description: 50% train / 30% eval / 20% unavail (ported from legacy json_scripts) + pattern: + - - 0 + - AVL_TRAIN + per_trainer: + n300: + trainer_001: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 10800 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19800 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 30000 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67800 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 69600 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 86400 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 109800 + - AVL_EVAL + - - 111600 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172200 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 177600 + - UN_AVL + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_002: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 6000 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88800 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 101400 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 138600 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 150000 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_003: + - - 0 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27600 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - UN_AVL + - - 94800 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 98400 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 155400 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_004: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 11400 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55800 + - AVL_EVAL + - - 57600 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - UN_AVL + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 147000 + - UN_AVL + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_005: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22800 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82800 + - UN_AVL + - - 83400 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - UN_AVL + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - UN_AVL + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_006: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 84600 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 115200 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_007: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 9000 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33600 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 59400 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_EVAL + - - 89400 + - UN_AVL + - - 90600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96600 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102600 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 109200 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 119400 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 178200 + - UN_AVL + trainer_008: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 80400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 89400 + - UN_AVL + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - UN_AVL + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138600 + - UN_AVL + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 159600 + - UN_AVL + - - 160200 + - AVL_EVAL + - - 162000 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 163200 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169200 + - AVL_EVAL + - - 170400 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177000 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_009: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57000 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 67200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78600 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100800 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 113400 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 129600 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_010: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 15000 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91800 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 124200 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 159600 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 161400 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_011: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 35400 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172200 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_012: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 34200 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 110400 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - UN_AVL + - - 116400 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 160800 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 172200 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - UN_AVL + - - 178800 + - AVL_TRAIN + trainer_013: + - - 0 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 63000 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 159600 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - UN_AVL + - - 171600 + - AVL_TRAIN + trainer_014: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16800 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 35400 + - UN_AVL + - - 37200 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 57600 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 93000 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 106200 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 163200 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - UN_AVL + - - 177000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_015: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 34800 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - UN_AVL + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 121800 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136800 + - UN_AVL + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 153000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_016: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 60000 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 93000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 109800 + - AVL_EVAL + - - 110400 + - UN_AVL + - - 111000 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 144000 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 163200 + - AVL_EVAL + - - 163800 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_017: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 111000 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 120000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 153000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_018: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 6000 + - UN_AVL + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 13800 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28800 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61800 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 99600 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 146400 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 178800 + - AVL_TRAIN + trainer_019: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 22200 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 60600 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 74400 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94800 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 112200 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 129000 + - UN_AVL + - - 130200 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 136200 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 177000 + - AVL_TRAIN + trainer_020: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 9000 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 66600 + - UN_AVL + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 87600 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 101400 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 141600 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 144000 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 147600 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 178800 + - UN_AVL + - - 179400 + - AVL_TRAIN + trainer_021: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 11400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 31200 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 36000 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 60000 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108000 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_022: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22800 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30600 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51000 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57600 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66600 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 101400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 147000 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 162000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_023: + - - 0 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46800 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 61800 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 85200 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 94800 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 115200 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 177600 + - AVL_TRAIN + trainer_024: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 27600 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 49200 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57600 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 146400 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 154200 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_025: + - - 0 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 7200 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 33600 + - UN_AVL + - - 34200 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 57000 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - UN_AVL + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 112800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 132000 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 145800 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 157800 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 166800 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_026: + - - 0 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 14400 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_EVAL + - - 16800 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33600 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 61800 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 73800 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 89400 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 99600 + - UN_AVL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 156600 + - AVL_EVAL + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159600 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_027: + - - 0 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67800 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 81000 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96600 + - AVL_EVAL + - - 101400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118800 + - UN_AVL + - - 120600 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 150600 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 174000 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_028: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 9600 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 79200 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 118200 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129000 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 152400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_029: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 15000 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 45600 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117000 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 132000 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 141600 + - UN_AVL + - - 144600 + - AVL_EVAL + - - 145800 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 159000 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 160800 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_030: + - - 0 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 159600 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 174600 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 176400 + - UN_AVL + trainer_031: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 106200 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_032: + - - 0 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 29400 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33600 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 69000 + - UN_AVL + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 92400 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 110400 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 118200 + - AVL_EVAL + - - 118800 + - UN_AVL + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 138600 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157800 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 171000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_033: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 24000 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - UN_AVL + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 66600 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - UN_AVL + - - 106200 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - UN_AVL + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_034: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 18000 + - AVL_EVAL + - - 21600 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25200 + - AVL_EVAL + - - 25800 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 27600 + - UN_AVL + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 33600 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 85200 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 94800 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 110400 + - AVL_EVAL + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 132000 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 153600 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + trainer_035: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 20400 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 119400 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172200 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 177600 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_036: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 28800 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 177000 + - UN_AVL + - - 177600 + - AVL_TRAIN + trainer_037: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43800 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 79200 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 82800 + - UN_AVL + - - 83400 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 86400 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 99000 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102600 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_038: + - - 0 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 15000 + - UN_AVL + - - 17400 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 31800 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 34200 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 49800 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 84000 + - UN_AVL + - - 84600 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135000 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 138600 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 153000 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_039: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22800 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - UN_AVL + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 118800 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172800 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177600 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_040: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - UN_AVL + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31800 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 66600 + - UN_AVL + - - 67200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 161400 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_041: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 42600 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 67800 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 73800 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 90000 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 110400 + - AVL_EVAL + - - 111000 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 129600 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 161400 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 177600 + - UN_AVL + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_042: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30600 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 45000 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 91200 + - UN_AVL + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103800 + - UN_AVL + - - 104400 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 127200 + - AVL_EVAL + - - 128400 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 138600 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169200 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_043: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 16800 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_EVAL + - - 143400 + - UN_AVL + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 174600 + - UN_AVL + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_044: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 5400 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78600 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 107400 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 115200 + - AVL_EVAL + - - 116400 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 140400 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 176400 + - UN_AVL + - - 177000 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178200 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_045: + - - 0 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7800 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 28200 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 69600 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 159600 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 161400 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_046: + - - 0 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40800 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 69000 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 76200 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 110400 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117600 + - UN_AVL + - - 118800 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 166200 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 169200 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 178200 + - AVL_EVAL + - - 178800 + - UN_AVL + - - 179400 + - AVL_TRAIN + trainer_047: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 28800 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 36600 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126600 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 141600 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 157800 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 177600 + - UN_AVL + trainer_048: + - - 0 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 119400 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - UN_AVL + - - 134400 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_049: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 55800 + - AVL_EVAL + - - 57000 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 84600 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100800 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117000 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 174000 + - UN_AVL + - - 174600 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_050: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 27600 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 54600 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 76200 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 88200 + - UN_AVL + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 116400 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126000 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_051: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6000 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 9600 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 69600 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 70800 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 115200 + - UN_AVL + - - 115800 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138600 + - UN_AVL + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 153600 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 171000 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_052: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 51000 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82800 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 169200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177600 + - AVL_TRAIN + trainer_053: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - UN_AVL + - - 93600 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 110400 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117000 + - AVL_EVAL + - - 117600 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 171000 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 175800 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_054: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 57000 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 66600 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 70200 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 81000 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 94800 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102000 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - UN_AVL + - - 111600 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 177000 + - UN_AVL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_055: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - UN_AVL + - - 7200 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 42600 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 84600 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112800 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 130200 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_056: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 57000 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60600 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 93000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141600 + - UN_AVL + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 177000 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_057: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 48600 + - AVL_EVAL + - - 49200 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 59400 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 88800 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 99600 + - UN_AVL + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106200 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 137400 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144600 + - UN_AVL + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171600 + - AVL_EVAL + - - 172200 + - UN_AVL + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 178200 + - AVL_EVAL + trainer_058: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18000 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 31800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 43800 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51000 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_EVAL + - - 55800 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 92400 + - UN_AVL + - - 94200 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 110400 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 112800 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 119400 + - UN_AVL + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 129000 + - UN_AVL + - - 129600 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 162600 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 177000 + - AVL_EVAL + - - 177600 + - UN_AVL + trainer_059: + - - 0 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - UN_AVL + - - 140400 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 160800 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - UN_AVL + - - 179400 + - AVL_TRAIN + trainer_060: + - - 0 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 13800 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 27600 + - AVL_EVAL + - - 28200 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72000 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 88800 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 105600 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 141600 + - UN_AVL + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 153600 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 177000 + - UN_AVL + - - 177600 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_061: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 7200 + - UN_AVL + - - 7800 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 16200 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 29400 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 73200 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 127200 + - AVL_EVAL + - - 128400 + - UN_AVL + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 176400 + - UN_AVL + - - 177000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_062: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6000 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 9600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 22800 + - UN_AVL + - - 23400 + - AVL_EVAL + - - 24000 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 51000 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 89400 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 121800 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - UN_AVL + trainer_063: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12600 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 27600 + - UN_AVL + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36000 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 83400 + - AVL_EVAL + - - 84000 + - UN_AVL + - - 84600 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - UN_AVL + - - 93000 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115200 + - UN_AVL + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 169800 + - AVL_EVAL + - - 170400 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_064: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 69000 + - UN_AVL + - - 70800 + - AVL_EVAL + - - 71400 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 102000 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 163800 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - UN_AVL + - - 166800 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_065: + - - 0 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 7200 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102600 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_066: + - - 0 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 45600 + - AVL_EVAL + - - 46200 + - UN_AVL + - - 46800 + - AVL_EVAL + - - 51000 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 73200 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97800 + - AVL_EVAL + - - 98400 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102600 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117000 + - AVL_EVAL + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156000 + - UN_AVL + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160800 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - UN_AVL + trainer_067: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21600 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55200 + - UN_AVL + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 62400 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109800 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 146400 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 153000 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_068: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 76200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 100200 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 142800 + - UN_AVL + - - 143400 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 178800 + - AVL_EVAL + trainer_069: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 28200 + - UN_AVL + - - 29400 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_EVAL + - - 71400 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99600 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115200 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147000 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_070: + - - 0 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 1800 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 45000 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52800 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 63600 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 91200 + - UN_AVL + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 110400 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - UN_AVL + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 156000 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172200 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - UN_AVL + trainer_071: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 6600 + - UN_AVL + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - UN_AVL + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37800 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 79200 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_072: + - - 0 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13800 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 22800 + - UN_AVL + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33600 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 51000 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 112800 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 119400 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135000 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 167400 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_073: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 7200 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 45000 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 93000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126000 + - UN_AVL + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 147000 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 177600 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_074: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 153600 + - UN_AVL + - - 155400 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162600 + - UN_AVL + - - 164400 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 174600 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_075: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 11400 + - UN_AVL + - - 13800 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 22800 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 56400 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 60600 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 80400 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 167400 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169200 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_076: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9000 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_EVAL + - - 40800 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57600 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 79200 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87600 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 89400 + - UN_AVL + - - 90000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 99000 + - AVL_EVAL + - - 99600 + - UN_AVL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 110400 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + trainer_077: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 74400 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 84600 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 98400 + - UN_AVL + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124200 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 135600 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 166200 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 176400 + - UN_AVL + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_078: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - UN_AVL + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 28800 + - UN_AVL + - - 29400 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 64200 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 65400 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 72000 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 118800 + - UN_AVL + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - UN_AVL + - - 143400 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_079: + - - 0 + - UN_AVL + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99600 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_080: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 52800 + - UN_AVL + - - 54600 + - AVL_EVAL + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 70200 + - UN_AVL + - - 73800 + - AVL_EVAL + - - 75600 + - UN_AVL + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - UN_AVL + - - 84600 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91800 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - UN_AVL + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 177000 + - UN_AVL + - - 177600 + - AVL_TRAIN + trainer_081: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 11400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - UN_AVL + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 21600 + - UN_AVL + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 69000 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 88800 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142800 + - UN_AVL + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 167400 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_082: + - - 0 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 21000 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46800 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 55800 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81000 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 90000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 107400 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115200 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_083: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67800 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - UN_AVL + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 92400 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 96000 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 110400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_084: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 28800 + - UN_AVL + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 91200 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 124200 + - UN_AVL + - - 124800 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_085: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 56400 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 142200 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_086: + - - 0 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 34800 + - UN_AVL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - UN_AVL + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141600 + - UN_AVL + - - 142200 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166200 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 179400 + - AVL_TRAIN + trainer_087: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 59400 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 73200 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 89400 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 113400 + - AVL_EVAL + - - 114600 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 169800 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 172200 + - UN_AVL + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 177000 + - UN_AVL + trainer_088: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4800 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 31200 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 76200 + - UN_AVL + - - 76800 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 128400 + - UN_AVL + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 159600 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 166800 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_089: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33600 + - AVL_EVAL + - - 34800 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - UN_AVL + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60600 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 85200 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 121800 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 177000 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_090: + - - 0 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 9000 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72000 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82800 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 86400 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - UN_AVL + - - 124800 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_091: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 95400 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 111600 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 178800 + - AVL_EVAL + trainer_092: + - - 0 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 18000 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 24000 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 70800 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82800 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115800 + - AVL_EVAL + - - 117000 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 129000 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 144000 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_093: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 15000 + - UN_AVL + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 67800 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 73800 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102600 + - UN_AVL + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135600 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177000 + - AVL_TRAIN + trainer_094: + - - 0 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 26400 + - UN_AVL + - - 27600 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_EVAL + - - 42600 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 177600 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_095: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - UN_AVL + - - 36000 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 95400 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 119400 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 157800 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 172800 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_096: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 27600 + - UN_AVL + - - 28800 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 30000 + - AVL_EVAL + - - 31200 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - UN_AVL + - - 94800 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 138600 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 176400 + - UN_AVL + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_097: + - - 0 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57600 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 131400 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 153000 + - AVL_EVAL + - - 157200 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_098: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - UN_AVL + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 82800 + - UN_AVL + - - 83400 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 126000 + - UN_AVL + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 135000 + - UN_AVL + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147000 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177600 + - AVL_EVAL + - - 178200 + - UN_AVL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_099: + - - 0 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 28200 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 40200 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57600 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 94800 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_100: + - - 0 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54600 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 116400 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 136800 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 175800 + - AVL_EVAL + - - 177600 + - UN_AVL + trainer_101: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9600 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - UN_AVL + - - 70200 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 158400 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + trainer_102: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 2400 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 6600 + - UN_AVL + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 16200 + - UN_AVL + - - 18600 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 57600 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 76800 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81000 + - AVL_EVAL + - - 81600 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 94800 + - AVL_EVAL + - - 95400 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 113400 + - AVL_EVAL + - - 114600 + - UN_AVL + - - 115200 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147000 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - UN_AVL + - - 174600 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_103: + - - 0 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157200 + - UN_AVL + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - UN_AVL + - - 177000 + - AVL_TRAIN + trainer_104: + - - 0 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 9600 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54600 + - AVL_EVAL + - - 55800 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109800 + - UN_AVL + - - 110400 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 175800 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178800 + - AVL_TRAIN + trainer_105: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 14400 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 28800 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 153000 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172800 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - UN_AVL + trainer_106: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 17400 + - UN_AVL + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 73200 + - UN_AVL + - - 73800 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 95400 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103800 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 135000 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 153600 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 177000 + - UN_AVL + trainer_107: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 11400 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 12600 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33600 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 94800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - UN_AVL + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 123600 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 163200 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_108: + - - 0 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 37200 + - AVL_EVAL + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 49800 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 110400 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - UN_AVL + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 160200 + - AVL_EVAL + - - 160800 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 174000 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - UN_AVL + - - 179400 + - AVL_TRAIN + trainer_109: + - - 0 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 18000 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81600 + - UN_AVL + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102600 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_110: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 26400 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115200 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159000 + - UN_AVL + - - 159600 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 176400 + - AVL_TRAIN + trainer_111: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - UN_AVL + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33600 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 42600 + - UN_AVL + - - 45600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 98400 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 138600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 177600 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_112: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - UN_AVL + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 35400 + - UN_AVL + - - 36000 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37200 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - UN_AVL + - - 58800 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 138600 + - UN_AVL + - - 139800 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 144000 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 153000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_113: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51600 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 83400 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 156000 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 177000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_114: + - - 0 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 37800 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 93600 + - UN_AVL + - - 94200 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_115: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 73800 + - UN_AVL + - - 74400 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 93000 + - AVL_EVAL + - - 94800 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 135000 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_TRAIN + trainer_116: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 23400 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 72000 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 77400 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_EVAL + - - 89400 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 109800 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 120600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 153600 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_117: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 139800 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 176400 + - UN_AVL + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_118: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 4800 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 41400 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - UN_AVL + - - 58200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 91800 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 163200 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 172200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - UN_AVL + - - 177000 + - AVL_TRAIN + trainer_119: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 35400 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 57000 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - UN_AVL + - - 69600 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 73200 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 91200 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 156000 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 163800 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_120: + - - 0 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 11400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 24000 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 34800 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 127200 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136200 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_121: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 33600 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94800 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 124800 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151800 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_122: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6600 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 48600 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 75000 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 100200 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - UN_AVL + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 130200 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177600 + - AVL_TRAIN + trainer_123: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 14400 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 34200 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 93600 + - AVL_EVAL + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102600 + - UN_AVL + - - 105000 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 117000 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 153000 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 178200 + - UN_AVL + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_124: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16200 + - AVL_EVAL + - - 17400 + - UN_AVL + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30000 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 36000 + - UN_AVL + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 51600 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117000 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138600 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 176400 + - UN_AVL + - - 177000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - UN_AVL + trainer_125: + - - 0 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9000 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 36000 + - UN_AVL + - - 37800 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 111000 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141000 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 159000 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 166800 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_126: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 55200 + - UN_AVL + - - 56400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109800 + - AVL_EVAL + - - 111000 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142200 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 176400 + - AVL_TRAIN + trainer_127: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48000 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60000 + - UN_AVL + - - 60600 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 73800 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - UN_AVL + - - 104400 + - AVL_EVAL + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 178800 + - AVL_EVAL + trainer_128: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 5400 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 58800 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 87600 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 118800 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 129600 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 163200 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_129: + - - 0 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 67800 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 73200 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 93600 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 129000 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 140400 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160200 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + trainer_130: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 6000 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 13800 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 20400 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_EVAL + - - 25800 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - UN_AVL + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 78600 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 83400 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 85200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109800 + - UN_AVL + - - 110400 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - UN_AVL + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 156000 + - UN_AVL + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 166800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_131: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 4800 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 10800 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 58200 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 99000 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 172800 + - AVL_TRAIN + trainer_132: + - - 0 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7200 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 57600 + - UN_AVL + - - 60000 + - AVL_EVAL + - - 60600 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 69000 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 89400 + - UN_AVL + - - 90600 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_133: + - - 0 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 23400 + - AVL_EVAL + - - 24000 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 28800 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 41400 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 99000 + - UN_AVL + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 169200 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_134: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 84600 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 126600 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_135: + - - 0 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24600 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 69000 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 77400 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 78600 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 114600 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 119400 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - UN_AVL + - - 138600 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_136: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 59400 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 75600 + - UN_AVL + - - 76800 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117000 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 118800 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - UN_AVL + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 147000 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 154200 + - UN_AVL + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 172200 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_137: + - - 0 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 36600 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 60600 + - UN_AVL + - - 61800 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135600 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 163800 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_138: + - - 0 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12600 + - AVL_EVAL + - - 13200 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 33600 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 82200 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 102600 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 113400 + - AVL_EVAL + - - 115200 + - UN_AVL + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - UN_AVL + - - 132600 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_139: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48600 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 59400 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 88800 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 98400 + - UN_AVL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 147000 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166800 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + trainer_140: + - - 0 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30000 + - AVL_EVAL + - - 31200 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 65400 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 78600 + - AVL_TRAIN + - - 82800 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 99600 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 132000 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 139800 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + trainer_141: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18000 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63000 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136200 + - AVL_EVAL + - - 138000 + - UN_AVL + - - 139200 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159000 + - UN_AVL + - - 159600 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - UN_AVL + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_142: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 11400 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 93600 + - UN_AVL + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 98400 + - UN_AVL + - - 99000 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 110400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 141600 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 166800 + - UN_AVL + - - 167400 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_143: + - - 0 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 4200 + - AVL_EVAL + - - 4800 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 20400 + - AVL_EVAL + - - 21000 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 50400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 101400 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 163200 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 178200 + - UN_AVL + trainer_144: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30600 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 91200 + - AVL_EVAL + - - 91800 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 122400 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 157800 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 171600 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 175200 + - AVL_TRAIN + trainer_145: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 27600 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 88800 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 94800 + - UN_AVL + - - 96600 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 115800 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 135000 + - UN_AVL + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 143400 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 153000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 159000 + - AVL_EVAL + - - 160800 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 171000 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_146: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 48600 + - AVL_EVAL + - - 49200 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 88800 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 93600 + - UN_AVL + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124200 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 175800 + - AVL_TRAIN + trainer_147: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10800 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 77400 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 163200 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_148: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6000 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 83400 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 166200 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 171600 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_149: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42600 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 94800 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 116400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 133800 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_150: + - - 0 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 11400 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 70800 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 79200 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109800 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 139800 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 154200 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 159600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - UN_AVL + trainer_151: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 10800 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19800 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 30000 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67800 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 69600 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 86400 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 109800 + - AVL_EVAL + - - 111600 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172200 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 177600 + - UN_AVL + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_152: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 6000 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88800 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 101400 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 138600 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 150000 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_153: + - - 0 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27600 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - UN_AVL + - - 94800 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 98400 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 155400 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_154: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 11400 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55800 + - AVL_EVAL + - - 57600 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - UN_AVL + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 147000 + - UN_AVL + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_155: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22800 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82800 + - UN_AVL + - - 83400 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - UN_AVL + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - UN_AVL + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_156: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 84600 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 115200 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_157: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 9000 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33600 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 59400 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_EVAL + - - 89400 + - UN_AVL + - - 90600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96600 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102600 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 109200 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 119400 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 178200 + - UN_AVL + trainer_158: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 80400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 89400 + - UN_AVL + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - UN_AVL + - - 97800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138600 + - UN_AVL + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 159600 + - UN_AVL + - - 160200 + - AVL_EVAL + - - 162000 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 163200 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169200 + - AVL_EVAL + - - 170400 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177000 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_159: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57000 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 67200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78600 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100800 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 113400 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 129600 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_160: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 15000 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91800 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 124200 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 159600 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 161400 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_161: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 35400 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172200 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_162: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 34200 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 110400 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - UN_AVL + - - 116400 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 160800 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 172200 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - UN_AVL + - - 178800 + - AVL_TRAIN + trainer_163: + - - 0 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 63000 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 159600 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - UN_AVL + - - 171600 + - AVL_TRAIN + trainer_164: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16800 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 35400 + - UN_AVL + - - 37200 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 57600 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 93000 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 106200 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 163200 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - UN_AVL + - - 177000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_165: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 34800 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - UN_AVL + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 121800 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136800 + - UN_AVL + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 153000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_166: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 60000 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 93000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 109800 + - AVL_EVAL + - - 110400 + - UN_AVL + - - 111000 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 144000 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 163200 + - AVL_EVAL + - - 163800 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_167: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 111000 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 120000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 153000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_168: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 6000 + - UN_AVL + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 13800 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28800 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61800 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 99600 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 146400 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 178800 + - AVL_TRAIN + trainer_169: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 22200 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 60600 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 74400 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94800 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 112200 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 129000 + - UN_AVL + - - 130200 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 136200 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 177000 + - AVL_TRAIN + trainer_170: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 9000 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 66600 + - UN_AVL + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 87600 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 101400 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 141600 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 144000 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 147600 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 178800 + - UN_AVL + - - 179400 + - AVL_TRAIN + trainer_171: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 11400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 31200 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 36000 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 60000 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108000 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_172: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22800 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30600 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51000 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57600 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66600 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 101400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 147000 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 162000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_173: + - - 0 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46800 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 61800 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 85200 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 94800 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 115200 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 177600 + - AVL_TRAIN + trainer_174: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 27600 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 49200 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57600 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 146400 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 154200 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_175: + - - 0 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 7200 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 33600 + - UN_AVL + - - 34200 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 57000 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - UN_AVL + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 112800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 132000 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 145800 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 157800 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 166800 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_176: + - - 0 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 14400 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_EVAL + - - 16800 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33600 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 61800 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 73800 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 89400 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 99600 + - UN_AVL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 156600 + - AVL_EVAL + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159600 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_177: + - - 0 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67800 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 81000 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96600 + - AVL_EVAL + - - 101400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118800 + - UN_AVL + - - 120600 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 150600 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 174000 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_178: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 9600 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 79200 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 118200 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129000 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 152400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_179: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 15000 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 45600 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117000 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 132000 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 141600 + - UN_AVL + - - 144600 + - AVL_EVAL + - - 145800 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 159000 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 160800 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_180: + - - 0 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 159600 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 174600 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 176400 + - UN_AVL + trainer_181: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 106200 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_182: + - - 0 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 29400 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33600 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 69000 + - UN_AVL + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 92400 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 110400 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 118200 + - AVL_EVAL + - - 118800 + - UN_AVL + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 138600 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157800 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 171000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_183: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 24000 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - UN_AVL + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 66600 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - UN_AVL + - - 106200 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - UN_AVL + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_184: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 18000 + - AVL_EVAL + - - 21600 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25200 + - AVL_EVAL + - - 25800 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 27600 + - UN_AVL + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 33600 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 85200 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 94800 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 110400 + - AVL_EVAL + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 132000 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 153600 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + trainer_185: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 20400 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 119400 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172200 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 177600 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_186: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 28800 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 177000 + - UN_AVL + - - 177600 + - AVL_TRAIN + trainer_187: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43800 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 79200 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 82800 + - UN_AVL + - - 83400 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 86400 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 99000 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102600 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_188: + - - 0 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 15000 + - UN_AVL + - - 17400 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 31800 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 34200 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 49800 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 84000 + - UN_AVL + - - 84600 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135000 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 138600 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 153000 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_189: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22800 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - UN_AVL + - - 70200 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 118800 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172800 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177600 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_190: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - UN_AVL + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31800 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 66600 + - UN_AVL + - - 67200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 161400 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_191: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 42600 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 67800 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 73800 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 90000 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 110400 + - AVL_EVAL + - - 111000 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 129600 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 161400 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 177600 + - UN_AVL + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_192: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30600 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 45000 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 91200 + - UN_AVL + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103800 + - UN_AVL + - - 104400 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 127200 + - AVL_EVAL + - - 128400 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 138600 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169200 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_193: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 16800 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_EVAL + - - 143400 + - UN_AVL + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 174600 + - UN_AVL + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_194: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 5400 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78600 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 107400 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 115200 + - AVL_EVAL + - - 116400 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 140400 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 176400 + - UN_AVL + - - 177000 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178200 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_195: + - - 0 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7800 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 28200 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 69600 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 159600 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 161400 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_196: + - - 0 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40800 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 69000 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 76200 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 110400 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117600 + - UN_AVL + - - 118800 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 166200 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 169200 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 178200 + - AVL_EVAL + - - 178800 + - UN_AVL + - - 179400 + - AVL_TRAIN + trainer_197: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 28800 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 36600 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126600 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 141600 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 157800 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 177600 + - UN_AVL + trainer_198: + - - 0 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 119400 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - UN_AVL + - - 134400 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_199: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 55800 + - AVL_EVAL + - - 57000 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 84600 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100800 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117000 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 174000 + - UN_AVL + - - 174600 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_200: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 27600 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 54600 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 76200 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 88200 + - UN_AVL + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 116400 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126000 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_201: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6000 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 9600 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 69600 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 70800 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 115200 + - UN_AVL + - - 115800 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138600 + - UN_AVL + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 153600 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 171000 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_202: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 51000 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82800 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 169200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177600 + - AVL_TRAIN + trainer_203: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - UN_AVL + - - 93600 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 110400 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117000 + - AVL_EVAL + - - 117600 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 171000 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 175800 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + trainer_204: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 57000 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 66600 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 70200 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 81000 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 94800 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102000 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - UN_AVL + - - 111600 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138000 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 177000 + - UN_AVL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_205: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - UN_AVL + - - 7200 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 42600 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 84600 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112800 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 130200 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_206: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 57000 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60600 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 93000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141600 + - UN_AVL + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 177000 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_207: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 48600 + - AVL_EVAL + - - 49200 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 59400 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 88800 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 99600 + - UN_AVL + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106200 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 137400 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144600 + - UN_AVL + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 164400 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171600 + - AVL_EVAL + - - 172200 + - UN_AVL + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 178200 + - AVL_EVAL + trainer_208: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18000 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 31800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 43800 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51000 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_EVAL + - - 55800 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 92400 + - UN_AVL + - - 94200 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 110400 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 112800 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 119400 + - UN_AVL + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 129000 + - UN_AVL + - - 129600 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 162600 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 171600 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 177000 + - AVL_EVAL + - - 177600 + - UN_AVL + trainer_209: + - - 0 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - UN_AVL + - - 140400 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 160800 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - UN_AVL + - - 179400 + - AVL_TRAIN + trainer_210: + - - 0 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 13800 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 27600 + - AVL_EVAL + - - 28200 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72000 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 88800 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 105600 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 141600 + - UN_AVL + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 153600 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 177000 + - UN_AVL + - - 177600 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_211: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 7200 + - UN_AVL + - - 7800 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 16200 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 29400 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 73200 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 127200 + - AVL_EVAL + - - 128400 + - UN_AVL + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 176400 + - UN_AVL + - - 177000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_212: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6000 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 9600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 22800 + - UN_AVL + - - 23400 + - AVL_EVAL + - - 24000 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 51000 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 89400 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 121800 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - UN_AVL + trainer_213: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12600 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 27600 + - UN_AVL + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36000 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 83400 + - AVL_EVAL + - - 84000 + - UN_AVL + - - 84600 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - UN_AVL + - - 93000 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115200 + - UN_AVL + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 169800 + - AVL_EVAL + - - 170400 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_214: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 69000 + - UN_AVL + - - 70800 + - AVL_EVAL + - - 71400 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 102000 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 163800 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - UN_AVL + - - 166800 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_215: + - - 0 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 7200 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102600 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_216: + - - 0 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 45600 + - AVL_EVAL + - - 46200 + - UN_AVL + - - 46800 + - AVL_EVAL + - - 51000 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 73200 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97800 + - AVL_EVAL + - - 98400 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102600 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117000 + - AVL_EVAL + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156000 + - UN_AVL + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160800 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - UN_AVL + trainer_217: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21600 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55200 + - UN_AVL + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 62400 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109800 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 146400 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 153000 + - AVL_EVAL + - - 154200 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_218: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 76200 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 100200 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 142800 + - UN_AVL + - - 143400 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 178800 + - AVL_EVAL + trainer_219: + - - 0 + - AVL_TRAIN + - - 600 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 28200 + - UN_AVL + - - 29400 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_EVAL + - - 71400 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 99600 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115200 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147000 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_220: + - - 0 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 1800 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 45000 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52800 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 63600 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 91200 + - UN_AVL + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 110400 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - UN_AVL + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 156000 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172200 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - UN_AVL + trainer_221: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 6600 + - UN_AVL + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - UN_AVL + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37800 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 79200 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 165000 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_222: + - - 0 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13800 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 22800 + - UN_AVL + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33600 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 51000 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 112800 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 119400 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135000 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 167400 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_223: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 7200 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 45000 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 93000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 126000 + - UN_AVL + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 147000 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 177600 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_224: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 70800 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 153600 + - UN_AVL + - - 155400 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162600 + - UN_AVL + - - 164400 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 173400 + - AVL_EVAL + - - 174600 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_225: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 11400 + - UN_AVL + - - 13800 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 22800 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 56400 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 60600 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 80400 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 167400 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169200 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_226: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9000 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_EVAL + - - 40800 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57600 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 79200 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87600 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 89400 + - UN_AVL + - - 90000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 99000 + - AVL_EVAL + - - 99600 + - UN_AVL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 110400 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 155400 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + trainer_227: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 74400 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 84600 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 98400 + - UN_AVL + - - 99000 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 112200 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124200 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 135600 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 166200 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 176400 + - UN_AVL + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_228: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - UN_AVL + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 28800 + - UN_AVL + - - 29400 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 64200 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 65400 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 72000 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 118800 + - UN_AVL + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 138600 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - UN_AVL + - - 143400 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_229: + - - 0 + - UN_AVL + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99600 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_230: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 52800 + - UN_AVL + - - 54600 + - AVL_EVAL + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 70200 + - UN_AVL + - - 73800 + - AVL_EVAL + - - 75600 + - UN_AVL + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84000 + - UN_AVL + - - 84600 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91800 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - UN_AVL + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 177000 + - UN_AVL + - - 177600 + - AVL_TRAIN + trainer_231: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 4200 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 11400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - UN_AVL + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 21600 + - UN_AVL + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 69000 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 88800 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142800 + - UN_AVL + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 167400 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_232: + - - 0 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 21000 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46800 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 55800 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81000 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 90000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 107400 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115200 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_233: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67800 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - UN_AVL + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 92400 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 96000 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 110400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_234: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 28800 + - UN_AVL + - - 30600 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 91200 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 124200 + - UN_AVL + - - 124800 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_235: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 56400 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 142200 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - UN_AVL + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_236: + - - 0 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 34800 + - UN_AVL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - UN_AVL + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 120600 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141600 + - UN_AVL + - - 142200 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166200 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 179400 + - AVL_TRAIN + trainer_237: + - - 0 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 59400 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 73200 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 89400 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 113400 + - AVL_EVAL + - - 114600 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 169800 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 172200 + - UN_AVL + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 177000 + - UN_AVL + trainer_238: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 4800 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 31200 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 76200 + - UN_AVL + - - 76800 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 128400 + - UN_AVL + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 159600 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 166800 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_239: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33600 + - AVL_EVAL + - - 34800 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - UN_AVL + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60600 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 85200 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 112200 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 121800 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 177000 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_240: + - - 0 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 9000 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 63600 + - UN_AVL + - - 64200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72000 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 82800 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 86400 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - UN_AVL + - - 124800 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_241: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 95400 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - UN_AVL + - - 101400 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 111600 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 178800 + - AVL_EVAL + trainer_242: + - - 0 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 18000 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 24000 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 41400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 69000 + - AVL_TRAIN + - - 70800 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82800 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115800 + - AVL_EVAL + - - 117000 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 129000 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 144000 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_243: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 15000 + - UN_AVL + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 67800 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 73800 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102600 + - UN_AVL + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135600 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177000 + - AVL_TRAIN + trainer_244: + - - 0 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 26400 + - UN_AVL + - - 27600 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_EVAL + - - 42600 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 85800 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 177600 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_245: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - UN_AVL + - - 36000 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42000 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 95400 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 119400 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 131400 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 148800 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 157800 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 172800 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_246: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 26400 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 27600 + - UN_AVL + - - 28800 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 30000 + - AVL_EVAL + - - 31200 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - UN_AVL + - - 94800 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 138600 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 176400 + - UN_AVL + - - 177000 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_247: + - - 0 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 44400 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57600 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 107400 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 130800 + - AVL_EVAL + - - 131400 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 145200 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 153000 + - AVL_EVAL + - - 157200 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_248: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 40200 + - AVL_EVAL + - - 40800 + - UN_AVL + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 63000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 77400 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 82800 + - UN_AVL + - - 83400 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 126000 + - UN_AVL + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 135000 + - UN_AVL + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142800 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147000 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177600 + - AVL_EVAL + - - 178200 + - UN_AVL + - - 178800 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_249: + - - 0 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 15600 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 28200 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 40200 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57600 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 67800 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 94800 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_250: + - - 0 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54600 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 116400 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 136800 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 175800 + - AVL_EVAL + - - 177600 + - UN_AVL + trainer_251: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9600 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39000 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - UN_AVL + - - 70200 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 145200 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 158400 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + trainer_252: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 2400 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 6600 + - UN_AVL + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 16200 + - UN_AVL + - - 18600 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 57600 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 76800 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81000 + - AVL_EVAL + - - 81600 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 94800 + - AVL_EVAL + - - 95400 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 113400 + - AVL_EVAL + - - 114600 + - UN_AVL + - - 115200 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 137400 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147000 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - UN_AVL + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 172200 + - UN_AVL + - - 174600 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_253: + - - 0 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12000 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 30600 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66600 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 136200 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 140400 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157200 + - UN_AVL + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 160800 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - UN_AVL + - - 177000 + - AVL_TRAIN + trainer_254: + - - 0 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - UN_AVL + - - 9600 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54600 + - AVL_EVAL + - - 55800 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 59400 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85200 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109800 + - UN_AVL + - - 110400 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 123000 + - UN_AVL + - - 123600 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 128400 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 175200 + - UN_AVL + - - 175800 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178800 + - AVL_TRAIN + trainer_255: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 14400 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 28800 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 37800 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 153000 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172800 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - UN_AVL + trainer_256: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 17400 + - UN_AVL + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 35400 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 58800 + - AVL_EVAL + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 71400 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 73200 + - UN_AVL + - - 73800 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 95400 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103800 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 111600 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 135000 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138000 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 153600 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 177000 + - UN_AVL + trainer_257: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 11400 + - AVL_EVAL + - - 12000 + - UN_AVL + - - 12600 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24600 + - UN_AVL + - - 25200 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33600 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 37200 + - UN_AVL + - - 40200 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61200 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94200 + - UN_AVL + - - 94800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 103200 + - UN_AVL + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 123600 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126000 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 131400 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_TRAIN + - - 162600 + - UN_AVL + - - 163200 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_258: + - - 0 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 20400 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 37200 + - AVL_EVAL + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 49800 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 85800 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109200 + - UN_AVL + - - 110400 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118800 + - UN_AVL + - - 119400 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 125400 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141600 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 160200 + - AVL_EVAL + - - 160800 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 174000 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - UN_AVL + - - 179400 + - AVL_TRAIN + trainer_259: + - - 0 + - UN_AVL + - - 2400 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 9600 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 18000 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81600 + - UN_AVL + - - 82200 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 97800 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102600 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160200 + - AVL_EVAL + - - 160800 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_260: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 26400 + - UN_AVL + - - 27000 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 41400 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 101400 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115200 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132000 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - UN_AVL + - - 143400 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159000 + - UN_AVL + - - 159600 + - AVL_EVAL + - - 160200 + - UN_AVL + - - 162000 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 176400 + - AVL_TRAIN + trainer_261: + - - 0 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 5400 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - UN_AVL + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33600 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 42600 + - UN_AVL + - - 45600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 80400 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 98400 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120000 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123000 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 138600 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 147000 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 177600 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_262: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - UN_AVL + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 27000 + - UN_AVL + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 35400 + - UN_AVL + - - 36000 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37200 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - UN_AVL + - - 58800 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 70200 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 129600 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136200 + - AVL_TRAIN + - - 138600 + - UN_AVL + - - 139800 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 144000 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 153000 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 160200 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_263: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 1800 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42000 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 43800 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 46200 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51600 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 61200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79800 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 83400 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 117000 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 124800 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 156000 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169800 + - AVL_EVAL + - - 171000 + - AVL_TRAIN + - - 172800 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 177000 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_264: + - - 0 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 28800 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 37800 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 67800 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 93600 + - UN_AVL + - - 94200 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 102600 + - AVL_EVAL + - - 103200 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 133200 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 160800 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_265: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 5400 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 14400 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16800 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 50400 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 73800 + - UN_AVL + - - 74400 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 86400 + - UN_AVL + - - 87000 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 93000 + - AVL_EVAL + - - 94800 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 135000 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141000 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_TRAIN + trainer_266: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - UN_AVL + - - 7800 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 18600 + - UN_AVL + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 23400 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 31200 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45600 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 54600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 64800 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 70200 + - UN_AVL + - - 72000 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 77400 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_EVAL + - - 89400 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97200 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 109800 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 120600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 153600 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 159000 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 162000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 171000 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - AVL_TRAIN + trainer_267: + - - 0 + - AVL_TRAIN + - - 3000 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 37200 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 39600 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82800 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 101400 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 139800 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159600 + - AVL_EVAL + - - 160200 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 176400 + - UN_AVL + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_268: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 4800 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 14400 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 41400 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - UN_AVL + - - 58200 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 69000 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 91800 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - UN_AVL + - - 109800 + - AVL_TRAIN + - - 110400 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 117600 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159600 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 163200 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 172200 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 176400 + - UN_AVL + - - 177000 + - AVL_TRAIN + trainer_269: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 34200 + - AVL_EVAL + - - 35400 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 49800 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 57000 + - UN_AVL + - - 57600 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 61800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 66000 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 69000 + - UN_AVL + - - 69600 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 72600 + - AVL_EVAL + - - 73200 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 91200 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 103200 + - AVL_TRAIN + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 135000 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_TRAIN + - - 154800 + - AVL_EVAL + - - 156000 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 161400 + - AVL_EVAL + - - 163800 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 170400 + - AVL_TRAIN + - - 171600 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_270: + - - 0 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 7800 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 11400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - UN_AVL + - - 24000 + - AVL_EVAL + - - 27000 + - UN_AVL + - - 28800 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 34800 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43200 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 61800 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 81600 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 87000 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 126600 + - UN_AVL + - - 127200 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136200 + - AVL_EVAL + - - 139200 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 145800 + - AVL_TRAIN + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 169800 + - UN_AVL + - - 170400 + - AVL_EVAL + - - 172200 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_271: + - - 0 + - UN_AVL + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 4200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13200 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 33600 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 62400 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94800 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 124800 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 138000 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 148800 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151800 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165000 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_272: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 6600 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 29400 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 43200 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 48600 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 75000 + - UN_AVL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81000 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 82200 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 100200 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 112800 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - UN_AVL + - - 126600 + - AVL_EVAL + - - 127200 + - AVL_TRAIN + - - 129000 + - UN_AVL + - - 130200 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 163800 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 172200 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 177600 + - AVL_TRAIN + trainer_273: + - - 0 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 14400 + - AVL_EVAL + - - 19200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21000 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 33000 + - UN_AVL + - - 34200 + - AVL_TRAIN + - - 35400 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 49200 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 51600 + - UN_AVL + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 55200 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 62400 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - UN_AVL + - - 67800 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 75000 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 88200 + - UN_AVL + - - 88800 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 93000 + - UN_AVL + - - 93600 + - AVL_EVAL + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102600 + - UN_AVL + - - 105000 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 117000 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 133800 + - AVL_EVAL + - - 134400 + - AVL_TRAIN + - - 136800 + - UN_AVL + - - 137400 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 141600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 146400 + - UN_AVL + - - 147600 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 152400 + - UN_AVL + - - 153000 + - AVL_TRAIN + - - 154800 + - UN_AVL + - - 155400 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 178200 + - UN_AVL + - - 178800 + - AVL_EVAL + - - 179400 + - AVL_TRAIN + trainer_274: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9600 + - AVL_TRAIN + - - 10200 + - AVL_EVAL + - - 10800 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16200 + - AVL_EVAL + - - 17400 + - UN_AVL + - - 18000 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 26400 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30000 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 35400 + - AVL_EVAL + - - 36000 + - UN_AVL + - - 36600 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 51600 + - AVL_EVAL + - - 52200 + - UN_AVL + - - 52800 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 67200 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 79200 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 112200 + - AVL_TRAIN + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117000 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 123600 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127800 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133200 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138600 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 151800 + - UN_AVL + - - 152400 + - AVL_EVAL + - - 153000 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 158400 + - UN_AVL + - - 159000 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 176400 + - UN_AVL + - - 177000 + - AVL_TRAIN + - - 177600 + - AVL_EVAL + - - 178800 + - UN_AVL + trainer_275: + - - 0 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 9000 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 12600 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 21600 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 36000 + - UN_AVL + - - 37800 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 73800 + - UN_AVL + - - 74400 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 111000 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 129000 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 134400 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141000 + - AVL_EVAL + - - 145800 + - AVL_TRAIN + - - 148200 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 149400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 155400 + - UN_AVL + - - 156600 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 159000 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 162000 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 166800 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174000 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + trainer_276: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 47400 + - UN_AVL + - - 48000 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 55200 + - UN_AVL + - - 56400 + - AVL_EVAL + - - 60000 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 72000 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 76200 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109800 + - AVL_EVAL + - - 111000 + - UN_AVL + - - 111600 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129600 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 142200 + - UN_AVL + - - 144600 + - AVL_TRAIN + - - 147000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 176400 + - AVL_TRAIN + trainer_277: + - - 0 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 11400 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 16800 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 32400 + - AVL_EVAL + - - 33600 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36600 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48000 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 49800 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 60000 + - UN_AVL + - - 60600 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 73800 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85800 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 99600 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 103200 + - AVL_EVAL + - - 103800 + - UN_AVL + - - 104400 + - AVL_EVAL + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 106800 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 108600 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 113400 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 115800 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 120600 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 127200 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 133800 + - UN_AVL + - - 134400 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 137400 + - AVL_TRAIN + - - 138000 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 178200 + - UN_AVL + - - 178800 + - AVL_EVAL + trainer_278: + - - 0 + - UN_AVL + - - 600 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 5400 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 23400 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 26400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40800 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_TRAIN + - - 54000 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 58200 + - UN_AVL + - - 58800 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 63000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 78600 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 83400 + - AVL_EVAL + - - 84000 + - AVL_TRAIN + - - 85800 + - UN_AVL + - - 87600 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 103800 + - UN_AVL + - - 104400 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108600 + - UN_AVL + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 118800 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 123600 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 129600 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 136200 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 162000 + - AVL_EVAL + - - 163200 + - UN_AVL + - - 166200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 175200 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 178800 + - AVL_TRAIN + trainer_279: + - - 0 + - AVL_EVAL + - - 1200 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10200 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 19800 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 24000 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42000 + - AVL_TRAIN + - - 42600 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 51000 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 60000 + - UN_AVL + - - 60600 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 67800 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 73200 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 93600 + - UN_AVL + - - 95400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 102600 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 111600 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 120000 + - UN_AVL + - - 121200 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127800 + - UN_AVL + - - 129000 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 138000 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 140400 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 158400 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 160200 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 164400 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + trainer_280: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 6000 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 12000 + - UN_AVL + - - 13800 + - AVL_EVAL + - - 14400 + - UN_AVL + - - 15000 + - AVL_TRAIN + - - 15600 + - UN_AVL + - - 20400 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_EVAL + - - 25800 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 57600 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60000 + - UN_AVL + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 73200 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - UN_AVL + - - 78600 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 83400 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 85200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 97200 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109800 + - UN_AVL + - - 110400 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 123000 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139800 + - UN_AVL + - - 142200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 150000 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 156000 + - UN_AVL + - - 156600 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 162000 + - UN_AVL + - - 166800 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 169800 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 174000 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - UN_AVL + trainer_281: + - - 0 + - AVL_TRAIN + - - 4200 + - AVL_EVAL + - - 4800 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 10200 + - UN_AVL + - - 10800 + - AVL_EVAL + - - 11400 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 15600 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 25800 + - AVL_TRAIN + - - 28200 + - UN_AVL + - - 29400 + - AVL_EVAL + - - 30000 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 36000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 43800 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 46200 + - UN_AVL + - - 46800 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 48600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 55200 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 58200 + - UN_AVL + - - 58800 + - AVL_TRAIN + - - 59400 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69600 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 78000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 83400 + - UN_AVL + - - 84000 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 88200 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 98400 + - AVL_TRAIN + - - 99000 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127200 + - UN_AVL + - - 127800 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 130200 + - UN_AVL + - - 131400 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - AVL_TRAIN + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147000 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150600 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 153600 + - AVL_EVAL + - - 154200 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 156600 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 164400 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 170400 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 172800 + - AVL_TRAIN + trainer_282: + - - 0 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 7200 + - AVL_EVAL + - - 10200 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 20400 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - UN_AVL + - - 27600 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 40200 + - UN_AVL + - - 42600 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 51600 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57000 + - AVL_TRAIN + - - 57600 + - UN_AVL + - - 60000 + - AVL_EVAL + - - 60600 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 65400 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 69000 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 79200 + - UN_AVL + - - 81600 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 89400 + - UN_AVL + - - 90600 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 95400 + - UN_AVL + - - 96000 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 115800 + - AVL_TRAIN + - - 118800 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 126600 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136200 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 146400 + - UN_AVL + - - 148200 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 156600 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 163800 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 177600 + - AVL_TRAIN + trainer_283: + - - 0 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 3000 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 23400 + - AVL_EVAL + - - 24000 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 28800 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 41400 + - UN_AVL + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 50400 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 56400 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 61200 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 64800 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 78000 + - AVL_EVAL + - - 78600 + - UN_AVL + - - 79800 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 96600 + - AVL_TRAIN + - - 99000 + - UN_AVL + - - 102000 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 103200 + - UN_AVL + - - 103800 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106800 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 108000 + - UN_AVL + - - 108600 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - UN_AVL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 121200 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 142800 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 166800 + - AVL_EVAL + - - 168600 + - UN_AVL + - - 169200 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_284: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 6000 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 13800 + - AVL_EVAL + - - 16800 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 24600 + - UN_AVL + - - 26400 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39000 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 43200 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 47400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58800 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 84600 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 97800 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 106200 + - UN_AVL + - - 106800 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 109200 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 115200 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 121800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 123600 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 126600 + - AVL_EVAL + - - 128400 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - UN_AVL + - - 147000 + - AVL_TRAIN + - - 151200 + - UN_AVL + - - 151800 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154800 + - AVL_EVAL + - - 156000 + - AVL_TRAIN + - - 156600 + - AVL_EVAL + - - 157200 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - UN_AVL + - - 168000 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_285: + - - 0 + - AVL_EVAL + - - 1800 + - UN_AVL + - - 2400 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 12600 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15000 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19200 + - AVL_EVAL + - - 20400 + - UN_AVL + - - 21000 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 24600 + - AVL_EVAL + - - 25200 + - UN_AVL + - - 25800 + - AVL_TRAIN + - - 28200 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 33000 + - AVL_EVAL + - - 34200 + - UN_AVL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - UN_AVL + - - 39000 + - AVL_TRAIN + - - 40800 + - UN_AVL + - - 42600 + - AVL_TRAIN + - - 46800 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 52800 + - AVL_TRAIN + - - 53400 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 58200 + - AVL_EVAL + - - 58800 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 69000 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75000 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 77400 + - AVL_EVAL + - - 78000 + - UN_AVL + - - 78600 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 84000 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 88800 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 100800 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 114000 + - UN_AVL + - - 114600 + - AVL_EVAL + - - 115800 + - UN_AVL + - - 117000 + - AVL_TRAIN + - - 117600 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 119400 + - AVL_EVAL + - - 120000 + - UN_AVL + - - 120600 + - AVL_EVAL + - - 121800 + - AVL_TRAIN + - - 122400 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 132600 + - AVL_EVAL + - - 134400 + - UN_AVL + - - 135600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - UN_AVL + - - 138600 + - AVL_EVAL + - - 141000 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_EVAL + - - 157200 + - AVL_TRAIN + - - 162000 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 164400 + - AVL_TRAIN + - - 165000 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168600 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + trainer_286: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3000 + - AVL_EVAL + - - 4200 + - UN_AVL + - - 6000 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 9600 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 12600 + - UN_AVL + - - 13200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 18600 + - UN_AVL + - - 19200 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 51600 + - AVL_EVAL + - - 53400 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 59400 + - UN_AVL + - - 60000 + - AVL_TRAIN + - - 60600 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 62400 + - AVL_EVAL + - - 65400 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 67800 + - AVL_EVAL + - - 75600 + - UN_AVL + - - 76800 + - AVL_EVAL + - - 78600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 90000 + - AVL_EVAL + - - 90600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 91800 + - AVL_TRAIN + - - 92400 + - UN_AVL + - - 93600 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97200 + - AVL_TRAIN + - - 101400 + - AVL_EVAL + - - 102000 + - UN_AVL + - - 102600 + - AVL_EVAL + - - 103800 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105600 + - UN_AVL + - - 107400 + - AVL_TRAIN + - - 108000 + - UN_AVL + - - 108600 + - AVL_EVAL + - - 109800 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 117000 + - UN_AVL + - - 117600 + - AVL_EVAL + - - 118800 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124800 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 128400 + - UN_AVL + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135000 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 141600 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 143400 + - UN_AVL + - - 144000 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 147000 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 154200 + - UN_AVL + - - 155400 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 172200 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - AVL_TRAIN + - - 179400 + - AVL_EVAL + trainer_287: + - - 0 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6600 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 20400 + - AVL_TRAIN + - - 21000 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 30000 + - UN_AVL + - - 31200 + - AVL_EVAL + - - 32400 + - AVL_TRAIN + - - 34800 + - UN_AVL + - - 36600 + - AVL_EVAL + - - 38400 + - AVL_TRAIN + - - 39600 + - AVL_EVAL + - - 43800 + - AVL_TRAIN + - - 48000 + - UN_AVL + - - 49800 + - AVL_TRAIN + - - 52200 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 57600 + - AVL_EVAL + - - 60600 + - UN_AVL + - - 61800 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67200 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 72600 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 83400 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 86400 + - AVL_EVAL + - - 87000 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - UN_AVL + - - 94200 + - AVL_TRAIN + - - 97200 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 111000 + - AVL_TRAIN + - - 111600 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 114000 + - AVL_TRAIN + - - 116400 + - UN_AVL + - - 119400 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 130200 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 132000 + - AVL_TRAIN + - - 133800 + - AVL_EVAL + - - 135600 + - UN_AVL + - - 136800 + - AVL_TRAIN + - - 137400 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 140400 + - UN_AVL + - - 145800 + - AVL_EVAL + - - 146400 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 163800 + - AVL_TRAIN + - - 165600 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174000 + - AVL_TRAIN + - - 175800 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 179400 + - UN_AVL + trainer_288: + - - 0 + - AVL_TRAIN + - - 1200 + - UN_AVL + - - 4800 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 12600 + - AVL_EVAL + - - 13200 + - UN_AVL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 18600 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 25200 + - UN_AVL + - - 25800 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 27600 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 33600 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37800 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 52200 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 70800 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 72000 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 79800 + - UN_AVL + - - 82200 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 98400 + - UN_AVL + - - 99000 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 102000 + - AVL_TRAIN + - - 102600 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 113400 + - AVL_EVAL + - - 115200 + - UN_AVL + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 130800 + - AVL_EVAL + - - 131400 + - UN_AVL + - - 132600 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136200 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 153000 + - AVL_EVAL + - - 155400 + - AVL_TRAIN + - - 156000 + - UN_AVL + - - 158400 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 162600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 169200 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 175800 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_289: + - - 0 + - AVL_TRAIN + - - 1800 + - UN_AVL + - - 6600 + - AVL_TRAIN + - - 9000 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 15000 + - AVL_EVAL + - - 15600 + - UN_AVL + - - 16200 + - AVL_TRAIN + - - 16800 + - UN_AVL + - - 17400 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - UN_AVL + - - 22800 + - AVL_EVAL + - - 23400 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 32400 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 35400 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 45600 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 47400 + - AVL_EVAL + - - 48600 + - UN_AVL + - - 49200 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 54600 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 59400 + - UN_AVL + - - 61200 + - AVL_EVAL + - - 63000 + - UN_AVL + - - 63600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 65400 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72600 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 76800 + - AVL_EVAL + - - 77400 + - AVL_TRAIN + - - 78000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 82200 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 83400 + - UN_AVL + - - 84000 + - AVL_TRAIN + - - 84600 + - UN_AVL + - - 88800 + - AVL_TRAIN + - - 90000 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 98400 + - UN_AVL + - - 100200 + - AVL_TRAIN + - - 100800 + - AVL_EVAL + - - 101400 + - UN_AVL + - - 102600 + - AVL_TRAIN + - - 105000 + - AVL_EVAL + - - 107400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 114600 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_EVAL + - - 118800 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 124800 + - UN_AVL + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 127800 + - AVL_EVAL + - - 132000 + - UN_AVL + - - 132600 + - AVL_TRAIN + - - 137400 + - AVL_EVAL + - - 138000 + - UN_AVL + - - 139200 + - AVL_TRAIN + - - 139800 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 142200 + - UN_AVL + - - 142800 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 147000 + - AVL_EVAL + - - 148800 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 159000 + - AVL_EVAL + - - 159600 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166800 + - AVL_TRAIN + - - 168000 + - AVL_EVAL + - - 168600 + - AVL_TRAIN + - - 171600 + - UN_AVL + - - 172200 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175800 + - AVL_TRAIN + trainer_290: + - - 0 + - AVL_TRAIN + - - 13200 + - AVL_EVAL + - - 13800 + - AVL_TRAIN + - - 14400 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18600 + - AVL_EVAL + - - 19800 + - AVL_TRAIN + - - 27000 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30000 + - AVL_EVAL + - - 31200 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34800 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 40800 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 46200 + - AVL_TRAIN + - - 48000 + - AVL_EVAL + - - 48600 + - AVL_TRAIN + - - 49200 + - AVL_EVAL + - - 51600 + - AVL_TRAIN + - - 52800 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 60600 + - AVL_TRAIN + - - 64800 + - UN_AVL + - - 65400 + - AVL_EVAL + - - 66000 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67800 + - UN_AVL + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 71400 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 75600 + - UN_AVL + - - 78600 + - AVL_TRAIN + - - 82800 + - UN_AVL + - - 85800 + - AVL_TRAIN + - - 87600 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 90000 + - AVL_TRAIN + - - 90600 + - UN_AVL + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 93600 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 99600 + - UN_AVL + - - 100800 + - AVL_EVAL + - - 102600 + - AVL_TRAIN + - - 106200 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 111600 + - AVL_TRAIN + - - 113400 + - UN_AVL + - - 115800 + - AVL_EVAL + - - 116400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - UN_AVL + - - 121800 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129600 + - AVL_TRAIN + - - 132000 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 138600 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 139800 + - AVL_EVAL + - - 140400 + - UN_AVL + - - 141000 + - AVL_TRAIN + - - 142800 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 153000 + - AVL_TRAIN + - - 155400 + - UN_AVL + - - 156000 + - AVL_TRAIN + - - 157200 + - AVL_EVAL + - - 157800 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160800 + - UN_AVL + - - 163200 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 169800 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 173400 + - AVL_TRAIN + - - 174600 + - AVL_EVAL + - - 175200 + - UN_AVL + - - 176400 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + trainer_291: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 4800 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 11400 + - AVL_TRAIN + - - 16800 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 18000 + - UN_AVL + - - 19800 + - AVL_TRAIN + - - 21000 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24000 + - AVL_TRAIN + - - 30600 + - AVL_EVAL + - - 31200 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 33000 + - AVL_TRAIN + - - 33600 + - AVL_EVAL + - - 34800 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 38400 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 45000 + - UN_AVL + - - 45600 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 56400 + - AVL_TRAIN + - - 61800 + - UN_AVL + - - 63000 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 70800 + - AVL_EVAL + - - 71400 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 72600 + - AVL_TRAIN + - - 74400 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 79200 + - UN_AVL + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90000 + - UN_AVL + - - 91200 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100800 + - AVL_TRAIN + - - 103800 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 105600 + - UN_AVL + - - 106200 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109200 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114600 + - AVL_TRAIN + - - 117600 + - UN_AVL + - - 118200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 124200 + - AVL_EVAL + - - 124800 + - AVL_TRAIN + - - 126000 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 132600 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 135600 + - UN_AVL + - - 136200 + - AVL_EVAL + - - 138000 + - UN_AVL + - - 139200 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144000 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 148200 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 157800 + - AVL_EVAL + - - 159000 + - UN_AVL + - - 159600 + - AVL_EVAL + - - 162600 + - AVL_TRAIN + - - 163200 + - AVL_EVAL + - - 163800 + - UN_AVL + - - 164400 + - AVL_EVAL + - - 166200 + - AVL_TRAIN + - - 166800 + - UN_AVL + - - 168000 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172200 + - AVL_EVAL + - - 172800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - AVL_EVAL + - - 179400 + - UN_AVL + trainer_292: + - - 0 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 1800 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 6600 + - UN_AVL + - - 8400 + - AVL_TRAIN + - - 9600 + - AVL_EVAL + - - 10800 + - UN_AVL + - - 11400 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13200 + - UN_AVL + - - 14400 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 22800 + - AVL_TRAIN + - - 23400 + - UN_AVL + - - 27000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 34800 + - AVL_TRAIN + - - 36600 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 41400 + - UN_AVL + - - 43800 + - AVL_TRAIN + - - 44400 + - UN_AVL + - - 45000 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 47400 + - AVL_TRAIN + - - 50400 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 60600 + - UN_AVL + - - 63000 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 68400 + - AVL_EVAL + - - 69000 + - AVL_TRAIN + - - 70200 + - AVL_EVAL + - - 70800 + - AVL_TRAIN + - - 72000 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 76200 + - AVL_EVAL + - - 76800 + - AVL_TRAIN + - - 77400 + - UN_AVL + - - 82200 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 91200 + - AVL_TRAIN + - - 93600 + - UN_AVL + - - 94800 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 96600 + - AVL_EVAL + - - 98400 + - UN_AVL + - - 99000 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 106800 + - AVL_EVAL + - - 107400 + - UN_AVL + - - 108000 + - AVL_TRAIN + - - 109800 + - UN_AVL + - - 110400 + - AVL_TRAIN + - - 111000 + - AVL_EVAL + - - 113400 + - AVL_TRAIN + - - 118200 + - UN_AVL + - - 118800 + - AVL_EVAL + - - 119400 + - UN_AVL + - - 121200 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - UN_AVL + - - 126000 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 141600 + - UN_AVL + - - 142200 + - AVL_TRAIN + - - 146400 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 158400 + - AVL_EVAL + - - 159000 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_EVAL + - - 166800 + - UN_AVL + - - 167400 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 168600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 174600 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_293: + - - 0 + - AVL_TRAIN + - - 3000 + - UN_AVL + - - 4200 + - AVL_EVAL + - - 4800 + - UN_AVL + - - 5400 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10200 + - AVL_TRAIN + - - 12000 + - AVL_EVAL + - - 13200 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 18000 + - AVL_EVAL + - - 19200 + - UN_AVL + - - 20400 + - AVL_EVAL + - - 21000 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 22200 + - UN_AVL + - - 24000 + - AVL_TRAIN + - - 24600 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 28200 + - AVL_TRAIN + - - 34200 + - UN_AVL + - - 38400 + - AVL_EVAL + - - 39000 + - AVL_TRAIN + - - 40200 + - UN_AVL + - - 44400 + - AVL_EVAL + - - 45000 + - AVL_TRAIN + - - 46800 + - AVL_EVAL + - - 48000 + - UN_AVL + - - 49200 + - AVL_EVAL + - - 50400 + - UN_AVL + - - 51000 + - AVL_TRAIN + - - 53400 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 65400 + - UN_AVL + - - 66600 + - AVL_EVAL + - - 68400 + - AVL_TRAIN + - - 69600 + - UN_AVL + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 79800 + - AVL_EVAL + - - 80400 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 83400 + - AVL_TRAIN + - - 84600 + - AVL_EVAL + - - 85200 + - AVL_TRAIN + - - 87000 + - AVL_EVAL + - - 87600 + - UN_AVL + - - 88200 + - AVL_EVAL + - - 89400 + - AVL_TRAIN + - - 93000 + - AVL_EVAL + - - 94200 + - AVL_TRAIN + - - 95400 + - AVL_EVAL + - - 96000 + - UN_AVL + - - 96600 + - AVL_TRAIN + - - 100200 + - UN_AVL + - - 101400 + - AVL_EVAL + - - 104400 + - AVL_TRAIN + - - 108000 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 110400 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 116400 + - AVL_TRAIN + - - 117000 + - AVL_EVAL + - - 117600 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 123600 + - AVL_TRAIN + - - 124200 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126600 + - UN_AVL + - - 130200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 133200 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 139800 + - AVL_TRAIN + - - 141600 + - AVL_EVAL + - - 143400 + - AVL_TRAIN + - - 145200 + - UN_AVL + - - 146400 + - AVL_EVAL + - - 147600 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_TRAIN + - - 151200 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 163200 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 167400 + - AVL_TRAIN + - - 168000 + - UN_AVL + - - 168600 + - AVL_EVAL + - - 169200 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 175200 + - AVL_TRAIN + - - 178200 + - UN_AVL + trainer_294: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 7200 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 9000 + - UN_AVL + - - 10200 + - AVL_EVAL + - - 15000 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - UN_AVL + - - 21600 + - AVL_EVAL + - - 22200 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 27600 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 30600 + - UN_AVL + - - 31800 + - AVL_TRAIN + - - 33000 + - UN_AVL + - - 33600 + - AVL_TRAIN + - - 34200 + - AVL_EVAL + - - 36000 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 39600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 45600 + - UN_AVL + - - 46200 + - AVL_TRAIN + - - 52200 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 55800 + - UN_AVL + - - 57000 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75000 + - AVL_EVAL + - - 75600 + - AVL_TRAIN + - - 81000 + - AVL_EVAL + - - 81600 + - AVL_TRAIN + - - 89400 + - AVL_EVAL + - - 90600 + - UN_AVL + - - 91200 + - AVL_EVAL + - - 91800 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 96000 + - AVL_EVAL + - - 101400 + - AVL_TRAIN + - - 104400 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106200 + - AVL_TRAIN + - - 106800 + - UN_AVL + - - 107400 + - AVL_EVAL + - - 108000 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 109800 + - AVL_EVAL + - - 112200 + - UN_AVL + - - 112800 + - AVL_TRAIN + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 119400 + - AVL_EVAL + - - 122400 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 131400 + - AVL_EVAL + - - 133200 + - AVL_TRAIN + - - 133800 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 136800 + - AVL_TRAIN + - - 140400 + - AVL_EVAL + - - 141000 + - AVL_TRAIN + - - 144000 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 149400 + - UN_AVL + - - 150000 + - AVL_EVAL + - - 151800 + - AVL_TRAIN + - - 153000 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 155400 + - AVL_EVAL + - - 157800 + - UN_AVL + - - 160800 + - AVL_TRAIN + - - 162600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 164400 + - UN_AVL + - - 165000 + - AVL_EVAL + - - 165600 + - AVL_TRAIN + - - 166200 + - AVL_EVAL + - - 166800 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 171000 + - UN_AVL + - - 171600 + - AVL_EVAL + - - 173400 + - UN_AVL + - - 175200 + - AVL_TRAIN + trainer_295: + - - 0 + - AVL_TRAIN + - - 600 + - AVL_EVAL + - - 1200 + - AVL_TRAIN + - - 1800 + - AVL_EVAL + - - 2400 + - AVL_TRAIN + - - 3600 + - AVL_EVAL + - - 4800 + - UN_AVL + - - 6000 + - AVL_EVAL + - - 8400 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 21600 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 22800 + - AVL_TRAIN + - - 23400 + - AVL_EVAL + - - 25200 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 27600 + - UN_AVL + - - 28200 + - AVL_TRAIN + - - 29400 + - AVL_EVAL + - - 30600 + - AVL_TRAIN + - - 31800 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 37200 + - AVL_TRAIN + - - 41400 + - AVL_EVAL + - - 42600 + - AVL_TRAIN + - - 43800 + - AVL_EVAL + - - 44400 + - UN_AVL + - - 45000 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 47400 + - AVL_EVAL + - - 49800 + - AVL_TRAIN + - - 50400 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 51600 + - UN_AVL + - - 52200 + - AVL_TRAIN + - - 52800 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 62400 + - AVL_EVAL + - - 64200 + - AVL_TRAIN + - - 65400 + - AVL_EVAL + - - 66000 + - AVL_TRAIN + - - 66600 + - AVL_EVAL + - - 67800 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73200 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 80400 + - AVL_EVAL + - - 82200 + - AVL_TRAIN + - - 88800 + - UN_AVL + - - 90000 + - AVL_TRAIN + - - 90600 + - AVL_EVAL + - - 94800 + - UN_AVL + - - 96600 + - AVL_EVAL + - - 97800 + - UN_AVL + - - 98400 + - AVL_EVAL + - - 99000 + - AVL_TRAIN + - - 99600 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 102000 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 104400 + - UN_AVL + - - 105000 + - AVL_TRAIN + - - 108600 + - UN_AVL + - - 109200 + - AVL_EVAL + - - 113400 + - UN_AVL + - - 115800 + - AVL_EVAL + - - 117000 + - AVL_TRAIN + - - 118200 + - AVL_EVAL + - - 119400 + - AVL_TRAIN + - - 120600 + - AVL_EVAL + - - 121200 + - AVL_TRAIN + - - 121800 + - UN_AVL + - - 122400 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 125400 + - AVL_EVAL + - - 126000 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - AVL_TRAIN + - - 130800 + - UN_AVL + - - 132000 + - AVL_TRAIN + - - 135000 + - UN_AVL + - - 137400 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 139200 + - AVL_EVAL + - - 142200 + - AVL_TRAIN + - - 142800 + - UN_AVL + - - 143400 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 150000 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 153000 + - AVL_TRAIN + - - 153600 + - UN_AVL + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 159000 + - AVL_EVAL + - - 160800 + - UN_AVL + - - 162600 + - AVL_TRAIN + - - 167400 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 171000 + - AVL_TRAIN + - - 173400 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 178200 + - AVL_EVAL + trainer_296: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 2400 + - AVL_EVAL + - - 3600 + - UN_AVL + - - 5400 + - AVL_EVAL + - - 7800 + - AVL_TRAIN + - - 10800 + - UN_AVL + - - 11400 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 16200 + - AVL_EVAL + - - 17400 + - AVL_TRAIN + - - 22200 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25800 + - AVL_EVAL + - - 27000 + - AVL_TRAIN + - - 28800 + - AVL_EVAL + - - 29400 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 38400 + - AVL_EVAL + - - 40200 + - AVL_TRAIN + - - 42000 + - AVL_EVAL + - - 43200 + - AVL_TRAIN + - - 46200 + - AVL_EVAL + - - 46800 + - UN_AVL + - - 48600 + - AVL_EVAL + - - 49200 + - UN_AVL + - - 53400 + - AVL_EVAL + - - 54000 + - UN_AVL + - - 54600 + - AVL_TRAIN + - - 55200 + - AVL_EVAL + - - 55800 + - AVL_TRAIN + - - 57000 + - AVL_EVAL + - - 58200 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 63600 + - AVL_TRAIN + - - 65400 + - UN_AVL + - - 66600 + - AVL_TRAIN + - - 67200 + - UN_AVL + - - 69000 + - AVL_EVAL + - - 70200 + - AVL_TRAIN + - - 72600 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 74400 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 77400 + - AVL_TRAIN + - - 79200 + - AVL_EVAL + - - 79800 + - AVL_TRAIN + - - 82800 + - AVL_EVAL + - - 84600 + - AVL_TRAIN + - - 85800 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 88800 + - UN_AVL + - - 91800 + - AVL_TRAIN + - - 92400 + - AVL_EVAL + - - 93000 + - AVL_TRAIN + - - 93600 + - UN_AVL + - - 94800 + - AVL_EVAL + - - 96000 + - AVL_TRAIN + - - 96600 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 105000 + - UN_AVL + - - 105600 + - AVL_TRAIN + - - 107400 + - AVL_EVAL + - - 109200 + - AVL_TRAIN + - - 110400 + - AVL_EVAL + - - 112800 + - AVL_TRAIN + - - 113400 + - AVL_EVAL + - - 114000 + - AVL_TRAIN + - - 116400 + - AVL_EVAL + - - 118200 + - AVL_TRAIN + - - 120000 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 122400 + - AVL_TRAIN + - - 123000 + - AVL_EVAL + - - 124200 + - UN_AVL + - - 125400 + - AVL_TRAIN + - - 126600 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 128400 + - AVL_EVAL + - - 129000 + - AVL_TRAIN + - - 132600 + - UN_AVL + - - 133200 + - AVL_TRAIN + - - 135600 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 143400 + - AVL_EVAL + - - 144600 + - AVL_TRAIN + - - 145800 + - AVL_EVAL + - - 148200 + - AVL_TRAIN + - - 148800 + - AVL_EVAL + - - 149400 + - AVL_TRAIN + - - 150600 + - AVL_EVAL + - - 151200 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157200 + - AVL_TRAIN + - - 157800 + - UN_AVL + - - 159600 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 163200 + - AVL_TRAIN + - - 163800 + - AVL_EVAL + - - 165000 + - UN_AVL + - - 165600 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 171000 + - UN_AVL + - - 171600 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 175800 + - AVL_TRAIN + trainer_297: + - - 0 + - AVL_EVAL + - - 600 + - AVL_TRAIN + - - 1200 + - AVL_EVAL + - - 3000 + - UN_AVL + - - 3600 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 6000 + - AVL_TRAIN + - - 8400 + - AVL_EVAL + - - 9000 + - AVL_TRAIN + - - 9600 + - UN_AVL + - - 10800 + - AVL_EVAL + - - 12000 + - AVL_TRAIN + - - 15000 + - UN_AVL + - - 15600 + - AVL_TRAIN + - - 21600 + - AVL_EVAL + - - 24600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 30000 + - AVL_EVAL + - - 32400 + - UN_AVL + - - 33000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 37200 + - AVL_EVAL + - - 37800 + - AVL_TRAIN + - - 39600 + - UN_AVL + - - 40800 + - AVL_EVAL + - - 41400 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 48000 + - AVL_TRAIN + - - 55200 + - UN_AVL + - - 55800 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 60000 + - AVL_EVAL + - - 61200 + - AVL_TRAIN + - - 63000 + - UN_AVL + - - 63600 + - AVL_EVAL + - - 64200 + - UN_AVL + - - 64800 + - AVL_TRAIN + - - 69600 + - AVL_EVAL + - - 70800 + - UN_AVL + - - 71400 + - AVL_TRAIN + - - 75000 + - UN_AVL + - - 75600 + - AVL_TRAIN + - - 76200 + - UN_AVL + - - 77400 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 79800 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 81600 + - AVL_TRAIN + - - 84000 + - AVL_EVAL + - - 85200 + - UN_AVL + - - 86400 + - AVL_TRAIN + - - 87600 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 89400 + - AVL_TRAIN + - - 91200 + - AVL_EVAL + - - 92400 + - AVL_TRAIN + - - 94200 + - AVL_EVAL + - - 95400 + - AVL_TRAIN + - - 97800 + - UN_AVL + - - 98400 + - AVL_TRAIN + - - 99000 + - AVL_EVAL + - - 100200 + - AVL_TRAIN + - - 100800 + - UN_AVL + - - 102000 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 114600 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 121200 + - UN_AVL + - - 122400 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 130800 + - AVL_TRAIN + - - 134400 + - UN_AVL + - - 135000 + - AVL_TRAIN + - - 136200 + - AVL_EVAL + - - 138000 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 142200 + - AVL_EVAL + - - 142800 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 149400 + - AVL_EVAL + - - 150000 + - AVL_TRAIN + - - 152400 + - AVL_EVAL + - - 153600 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - AVL_TRAIN + - - 156000 + - AVL_EVAL + - - 156600 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 163200 + - UN_AVL + - - 165000 + - AVL_TRAIN + - - 169200 + - AVL_EVAL + - - 170400 + - AVL_TRAIN + - - 172800 + - UN_AVL + - - 174600 + - AVL_EVAL + - - 175200 + - AVL_TRAIN + - - 177000 + - AVL_EVAL + - - 177600 + - UN_AVL + - - 178200 + - AVL_TRAIN + trainer_298: + - - 0 + - UN_AVL + - - 1200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 5400 + - AVL_TRAIN + - - 6000 + - UN_AVL + - - 7200 + - AVL_TRAIN + - - 7800 + - AVL_EVAL + - - 8400 + - UN_AVL + - - 9000 + - AVL_TRAIN + - - 17400 + - AVL_EVAL + - - 18600 + - AVL_TRAIN + - - 20400 + - AVL_EVAL + - - 21000 + - AVL_TRAIN + - - 26400 + - AVL_EVAL + - - 28800 + - UN_AVL + - - 30000 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 34200 + - AVL_TRAIN + - - 35400 + - AVL_EVAL + - - 36000 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 37800 + - UN_AVL + - - 38400 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 42000 + - UN_AVL + - - 42600 + - AVL_EVAL + - - 44400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49800 + - UN_AVL + - - 54000 + - AVL_TRAIN + - - 56400 + - UN_AVL + - - 58200 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 64800 + - UN_AVL + - - 66000 + - AVL_EVAL + - - 66600 + - AVL_TRAIN + - - 73800 + - AVL_EVAL + - - 75000 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76800 + - UN_AVL + - - 78600 + - AVL_EVAL + - - 81000 + - UN_AVL + - - 83400 + - AVL_EVAL + - - 84600 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 88200 + - AVL_EVAL + - - 88800 + - UN_AVL + - - 90600 + - AVL_TRAIN + - - 91800 + - AVL_EVAL + - - 94800 + - AVL_TRAIN + - - 97200 + - AVL_EVAL + - - 99000 + - UN_AVL + - - 99600 + - AVL_TRAIN + - - 105600 + - AVL_EVAL + - - 106800 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 111000 + - UN_AVL + - - 112200 + - AVL_TRAIN + - - 115800 + - AVL_EVAL + - - 118200 + - UN_AVL + - - 120000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 124200 + - AVL_TRAIN + - - 128400 + - UN_AVL + - - 129000 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130200 + - UN_AVL + - - 130800 + - AVL_TRAIN + - - 131400 + - UN_AVL + - - 132000 + - AVL_EVAL + - - 133800 + - AVL_TRAIN + - - 136800 + - AVL_EVAL + - - 138600 + - AVL_TRAIN + - - 139200 + - UN_AVL + - - 139800 + - AVL_TRAIN + - - 144600 + - AVL_EVAL + - - 145200 + - AVL_TRAIN + - - 148200 + - UN_AVL + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 154200 + - AVL_EVAL + - - 154800 + - UN_AVL + - - 157800 + - AVL_EVAL + - - 158400 + - UN_AVL + - - 160200 + - AVL_TRAIN + - - 161400 + - AVL_EVAL + - - 166200 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 168000 + - AVL_TRAIN + - - 168600 + - UN_AVL + - - 169800 + - AVL_TRAIN + - - 170400 + - UN_AVL + - - 171600 + - AVL_EVAL + - - 173400 + - AVL_TRAIN + - - 174000 + - UN_AVL + - - 174600 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + trainer_299: + - - 0 + - AVL_EVAL + - - 600 + - UN_AVL + - - 1200 + - AVL_EVAL + - - 3000 + - AVL_TRAIN + - - 3600 + - UN_AVL + - - 4200 + - AVL_TRAIN + - - 4800 + - AVL_EVAL + - - 6600 + - AVL_TRAIN + - - 10800 + - AVL_EVAL + - - 12600 + - AVL_TRAIN + - - 13800 + - UN_AVL + - - 15600 + - AVL_EVAL + - - 16200 + - AVL_TRAIN + - - 17400 + - UN_AVL + - - 18000 + - AVL_TRAIN + - - 24000 + - UN_AVL + - - 24600 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 28800 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 31200 + - AVL_TRAIN + - - 31800 + - UN_AVL + - - 32400 + - AVL_EVAL + - - 33000 + - AVL_TRAIN + - - 36000 + - AVL_EVAL + - - 36600 + - AVL_TRAIN + - - 40800 + - AVL_EVAL + - - 42600 + - UN_AVL + - - 43200 + - AVL_TRAIN + - - 45000 + - AVL_EVAL + - - 45600 + - AVL_TRAIN + - - 48600 + - UN_AVL + - - 51000 + - AVL_EVAL + - - 52800 + - AVL_TRAIN + - - 56400 + - AVL_EVAL + - - 57000 + - AVL_TRAIN + - - 58800 + - UN_AVL + - - 59400 + - AVL_TRAIN + - - 61200 + - AVL_EVAL + - - 61800 + - AVL_TRAIN + - - 64200 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 66000 + - UN_AVL + - - 67200 + - AVL_TRAIN + - - 71400 + - AVL_EVAL + - - 73800 + - AVL_TRAIN + - - 78000 + - AVL_EVAL + - - 79200 + - AVL_TRAIN + - - 80400 + - UN_AVL + - - 81000 + - AVL_TRAIN + - - 82200 + - AVL_EVAL + - - 82800 + - UN_AVL + - - 85200 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 88200 + - AVL_TRAIN + - - 91800 + - UN_AVL + - - 92400 + - AVL_TRAIN + - - 94800 + - UN_AVL + - - 97800 + - AVL_TRAIN + - - 98400 + - AVL_EVAL + - - 99600 + - AVL_TRAIN + - - 100200 + - AVL_EVAL + - - 106200 + - UN_AVL + - - 109200 + - AVL_TRAIN + - - 114600 + - UN_AVL + - - 116400 + - AVL_EVAL + - - 120600 + - AVL_TRAIN + - - 121800 + - AVL_EVAL + - - 123000 + - AVL_TRAIN + - - 123600 + - AVL_EVAL + - - 127200 + - UN_AVL + - - 128400 + - AVL_TRAIN + - - 129600 + - AVL_EVAL + - - 130800 + - UN_AVL + - - 131400 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 133200 + - AVL_EVAL + - - 133800 + - UN_AVL + - - 135000 + - AVL_EVAL + - - 135600 + - AVL_TRAIN + - - 139800 + - AVL_EVAL + - - 140400 + - AVL_TRAIN + - - 144600 + - UN_AVL + - - 145200 + - AVL_TRAIN + - - 145800 + - UN_AVL + - - 146400 + - AVL_TRAIN + - - 147600 + - AVL_EVAL + - - 148800 + - UN_AVL + - - 149400 + - AVL_TRAIN + - - 150600 + - UN_AVL + - - 151200 + - AVL_TRAIN + - - 151800 + - AVL_EVAL + - - 152400 + - AVL_TRAIN + - - 156600 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 160200 + - AVL_EVAL + - - 161400 + - AVL_TRAIN + - - 163200 + - UN_AVL + - - 166800 + - AVL_EVAL + - - 168000 + - UN_AVL + - - 169800 + - AVL_EVAL + - - 171600 + - AVL_TRAIN + - - 175200 + - AVL_EVAL + - - 175800 + - UN_AVL + - - 176400 + - AVL_EVAL + - - 177000 + - UN_AVL + - - 177600 + - AVL_EVAL + - - 178200 + - AVL_TRAIN + - - 178800 + - UN_AVL + - - 179400 + - AVL_EVAL + trainer_300: + - - 0 + - AVL_TRAIN + - - 2400 + - UN_AVL + - - 3600 + - AVL_EVAL + - - 4200 + - AVL_TRAIN + - - 5400 + - AVL_EVAL + - - 7200 + - AVL_TRAIN + - - 8400 + - UN_AVL + - - 10800 + - AVL_TRAIN + - - 11400 + - UN_AVL + - - 12600 + - AVL_TRAIN + - - 16200 + - UN_AVL + - - 17400 + - AVL_EVAL + - - 18000 + - AVL_TRAIN + - - 19800 + - UN_AVL + - - 22200 + - AVL_TRAIN + - - 25200 + - AVL_EVAL + - - 26400 + - AVL_TRAIN + - - 29400 + - UN_AVL + - - 30600 + - AVL_TRAIN + - - 31200 + - AVL_EVAL + - - 31800 + - AVL_TRAIN + - - 36000 + - UN_AVL + - - 37200 + - AVL_TRAIN + - - 39000 + - AVL_EVAL + - - 39600 + - UN_AVL + - - 40200 + - AVL_TRAIN + - - 44400 + - AVL_EVAL + - - 46200 + - UN_AVL + - - 47400 + - AVL_TRAIN + - - 48600 + - AVL_EVAL + - - 49200 + - AVL_TRAIN + - - 51000 + - AVL_EVAL + - - 53400 + - UN_AVL + - - 54000 + - AVL_EVAL + - - 54600 + - UN_AVL + - - 55800 + - AVL_TRAIN + - - 57600 + - AVL_EVAL + - - 59400 + - UN_AVL + - - 63000 + - AVL_TRAIN + - - 63600 + - AVL_EVAL + - - 64800 + - AVL_TRAIN + - - 68400 + - UN_AVL + - - 69600 + - AVL_TRAIN + - - 70800 + - UN_AVL + - - 72000 + - AVL_TRAIN + - - 73200 + - AVL_EVAL + - - 74400 + - AVL_TRAIN + - - 75600 + - AVL_EVAL + - - 76200 + - AVL_TRAIN + - - 76800 + - UN_AVL + - - 78000 + - AVL_TRAIN + - - 78600 + - UN_AVL + - - 79200 + - AVL_EVAL + - - 81000 + - AVL_TRAIN + - - 81600 + - UN_AVL + - - 82800 + - AVL_TRAIN + - - 85200 + - AVL_EVAL + - - 86400 + - AVL_TRAIN + - - 87000 + - UN_AVL + - - 87600 + - AVL_TRAIN + - - 88800 + - AVL_EVAL + - - 93600 + - AVL_TRAIN + - - 96000 + - UN_AVL + - - 99600 + - AVL_EVAL + - - 100200 + - UN_AVL + - - 103200 + - AVL_EVAL + - - 105000 + - AVL_TRAIN + - - 108600 + - AVL_EVAL + - - 109800 + - UN_AVL + - - 111000 + - AVL_TRAIN + - - 112800 + - UN_AVL + - - 114000 + - AVL_EVAL + - - 115200 + - AVL_TRAIN + - - 115800 + - UN_AVL + - - 117600 + - AVL_TRAIN + - - 122400 + - UN_AVL + - - 124200 + - AVL_TRAIN + - - 124800 + - AVL_EVAL + - - 125400 + - AVL_TRAIN + - - 126000 + - UN_AVL + - - 126600 + - AVL_TRAIN + - - 127200 + - AVL_EVAL + - - 127800 + - AVL_TRAIN + - - 132000 + - AVL_EVAL + - - 132600 + - UN_AVL + - - 133800 + - AVL_TRAIN + - - 138600 + - AVL_EVAL + - - 139200 + - UN_AVL + - - 139800 + - AVL_EVAL + - - 141600 + - AVL_TRAIN + - - 145200 + - AVL_EVAL + - - 147600 + - UN_AVL + - - 148200 + - AVL_TRAIN + - - 150000 + - AVL_EVAL + - - 150600 + - AVL_TRAIN + - - 152400 + - UN_AVL + - - 153600 + - AVL_TRAIN + - - 154200 + - UN_AVL + - - 154800 + - AVL_TRAIN + - - 157200 + - UN_AVL + - - 157800 + - AVL_TRAIN + - - 159000 + - UN_AVL + - - 159600 + - AVL_EVAL + - - 163800 + - AVL_TRAIN + - - 165600 + - UN_AVL + - - 166200 + - AVL_EVAL + - - 169800 + - AVL_TRAIN + - - 171000 + - AVL_EVAL + - - 171600 + - UN_AVL + - - 172800 + - AVL_TRAIN + - - 173400 + - AVL_EVAL + - - 174600 + - AVL_TRAIN + - - 176400 + - AVL_EVAL + - - 178200 + - UN_AVL diff --git a/lib/python/examples/_metadata/baselines.yaml b/lib/python/examples/_metadata/baselines.yaml index 5195c71ca..8ee6e05df 100644 --- a/lib/python/examples/_metadata/baselines.yaml +++ b/lib/python/examples/_metadata/baselines.yaml @@ -15,6 +15,10 @@ baselines: + # === CNN/speech family (async_cifar10, google-speech, etc.) === + # Selectors/optimizers below are shared, generic library code -- example + # specificity lives only in each example's aggregator_main/trainer config, + # not in these classes. felix: description: >- Felix = async_oort selector (evalGoalFactor=1) + fedbuff optimizer @@ -208,6 +212,29 @@ baselines: hyperparameters: use_oort_loss_fn: "True" + oort_star: + description: >- + oort_star = oort sync + FedAvg + aware-at-selection (avail_select_filter=True), + no proactive in-flight eviction (reactive-90s). Differs from oort only in + avail_select_filter; the experiment config_overrides set avail_select_filter=True + (oort sets it False there). Uses same oracular tracking path. + example: + aggregator_main: aggregator/pytorch/main_oort_sync_agg.py + aggregator: + selector: + sort: oort + kwargs: {} + optimizer: + sort: fedavg + kwargs: {} + hyperparameters: + trackTrainerAvail: + enabled: "True" + type: ORACULAR + trainer: + hyperparameters: + use_oort_loss_fn: "True" + fedbuff: description: FedBuff = fedbuff selector (uniform async) + fedbuff optimizer. Async stack. example: @@ -253,3 +280,288 @@ baselines: client_notify: enabled: "False" trace: syn_0 + + # === LLM forward-mode family (fwdllm: FedFwd text-classification, agnews/DistilBERT) === + # FedFwd's aggregator (flame.mode.horizontal.syncfl.fwdllm_aggregator.TopAggregator) + # is a single, FedFwd-specific implementation (gradient-variance-gated commits, + # JVP/forward-mode, dynamic_kc controller) -- not the generic asyncfl/syncfl/oort + # hierarchy the baselines above swap between. All four baselines below + # therefore point at the same single aggregator entrypoint + # (aggregator/main_fedfwd_agg.py); there is no per-stack split here. They + # still share the same selector/optimizer library code as the CNN/speech + # family above (no forking) -- only this catalog's parameters differ. + # + # Taxonomy (see examples/MIGRATING_TO_LAUNCHER.md §9 "Baseline taxonomy"): + # fwdllm/fwdllm_plus are sync, fluxtune/fluxtune_dynkc are async. + + fwdllm: + description: >- + FedFwd's syncfl baseline (owner's "fwdllm" spec): random selector, + sync (is_async=false) + fedavg optimizer (plain federated averaging) + + unaware trainer availability (no trackTrainerAvail, no + client_notify) + random-candidate perturbation (perturbation_sampling + on, JVP scoring off -- both are trainer_base.yaml defaults, not + overridden here). Selection is per-round + (reselect_each_iteration=false): one selection persists across all + databins/iterations of a round, re-sampled only when the round + advances. This is the smoke-test baseline (cheapest, exercises the + sync path). + example: + aggregator_main: aggregator/main_fedfwd_agg.py + aggregator: + selector: + sort: random + kwargs: + is_async: false + k: 5 # override per experiment to scale with num_trainers + c: 15 # override per experiment to scale with num_trainers + optimizer: + sort: fedavg + kwargs: {} + hyperparameters: + trackTrainerAvail: + enabled: "False" + type: "NONE" + # rejectStaleUpdates (the older boolean gate) is superseded by + # stalenessPolicy below for FedFwd baselines -- see + # Hyperparameters.staleness_policy (flame/config.py). "exact" is the + # strictest mode, matching fwdllm's strict-sync design. TODO(verify): + # confirm this doesn't starve progress under the oracular/mobiperf + # availability traces at full (300+) trainer scale, where round-trip + # latency variance is much higher than the n=10 smoke default. + stalenessPolicy: exact + inc_model_version_per_data_id: true + max_iterations_per_data_id: 15 + var_threshold: 0.3 + reselect_each_iteration: false + trainer: + hyperparameters: + client_notify: + enabled: "False" + trace: syn_0 + + fwdllm_plus: + description: >- + FedFwd's syncfl+ baseline (owner's "fwdllm+" spec): same sync + random+fedavg stack as fwdllm, but with ORACULAR trainer-availability + tracking -- read from _metadata/trainer_registry.yaml + + _metadata/availability_traces/*.yaml (no more json_scripts/ + dependency) -- and per-iteration reselection + (reselect_each_iteration=true, i.e. today's default selector-call + behavior: a fresh selection on every iteration) instead of fwdllm's + per-round caching. + example: + aggregator_main: aggregator/main_fedfwd_agg.py + aggregator: + selector: + sort: random + kwargs: + is_async: false + k: 5 # override per experiment to scale with num_trainers + c: 15 # override per experiment to scale with num_trainers + optimizer: + sort: fedavg + kwargs: {} + hyperparameters: + trackTrainerAvail: + enabled: "True" + type: ORACULAR + trace: mobiperf_2st + # rejectStaleUpdates (the older boolean gate) is superseded by + # stalenessPolicy below -- see Hyperparameters.staleness_policy + # (flame/config.py). Looser than fwdllm's "exact" since + # reselect_each_iteration=true below already re-picks trainers every + # iteration, making per-iteration staleness not meaningful here. + # TODO(verify): confirm this is still the intended FedFwd+ semantics + # at full trainer scale; an unbounded version mismatch here is what + # let the 21:30 smoke-test crash (a model_version-45 update accepted + # into a model_version-53 cycle) happen in the first place. + stalenessPolicy: round_data_id + inc_model_version_per_data_id: true + max_iterations_per_data_id: 15 + var_threshold: 0.3 + reselect_each_iteration: true + trainer: + hyperparameters: + client_notify: + enabled: "False" + trace: syn_0 + + fluxtune: + description: >- + FedFwd's asyncfl baseline (owner's "fluxtune" spec, for LLM + fine-tuning -- as opposed to felix, which is for the CNN/speech + family): async_oort selector (selection axis intentionally + parameterized the same as felix's, per the owner's "should be + separated out from felix implementation" note -- no fork, just this + baseline's own kwargs) + fedbuff optimizer with an explicit + learning_rate instead of fedbuff's cifar-10/google-speech dataset_name + lookup table + greedy JVP-based + perturbation (select_perturbation_using_jvp=true) + 3-tier + client_notify availability (trainer self-reports + AVL_TRAIN/AVL_EVAL/UN_AVL via a *_3st_* trace; trackTrainerAvail + stays disabled -- client_notify is the only availability signal here, + not layered with ORACULAR/HEARTBEAT). Unlike felix (always fixed + K/C), fluxtune's K/C policy is itself config-driven: dynamic_kc + defaults to disabled (fixed K=k, C=c, same as felix's mode) but can + be flipped to adaptive K/C per experiment via + selector.kwargs.dynamic_kc.enabled + .policy -- DynamicKCController + is selector-agnostic (it pushes channel_props["dynamic_c"], which + async_oort.py already reads, falling back to static self.c when + absent), so no code fork is needed for either mode. + example: + aggregator_main: aggregator/main_fedfwd_agg.py + aggregator: + selector: + sort: async_oort + kwargs: + c: 15 # override per experiment to scale with num_trainers + aggGoal: 5 # override per experiment to scale with num_trainers + evalGoalFactor: 0 + selectType: default + roundNudgeType: last_train + minInitialTrainers: 15 # override per experiment to scale with num_trainers + k: 5 + is_async: true + task_eligible_states: + train: [AVL_TRAIN, AVL_EVAL] + eval: [AVL_EVAL, AVL_TRAIN] + # Disabled by default -- fluxtune runs fixed K/C (k/c above) just + # like felix. Flip enabled: true per experiment (via + # config_overrides) to switch to adaptive K/C; policy/policy_kwargs + # are pre-populated so enabling it doesn't require specifying the + # adaptive-tracking shape from scratch. K/C bounds default to the + # fixed k/c above when not separately overridden. + dynamic_kc: + enabled: false + policy: adaptive_k_var_tracking + policy_kwargs: + target_iter_per_data_id: 15 + k_step: 2 + window: 6 + k_min: 5 + k_max: 15 + c_min: 15 + c_max: 15 + update_every_n_aggs: 1 + history_window: 20 + optimizer: + sort: fedbuff + kwargs: + use_oort_lr: "True" + dataset_name: agnews + # Explicit rate -- wins over the dataset_name table above, which + # has no fwdllm/agnews entry. Starting point; retune against + # fluxtune's live smoke test. + learning_rate: 0.075 + agg_rate_conf: + type: new + scale: 0.4 + a_exp: 0.25 + b_exp: 0.1 + hyperparameters: + trackTrainerAvail: + enabled: "False" + type: "NA" + # rejectStaleUpdates (the older boolean gate) is superseded by + # stalenessPolicy below for FedFwd baselines -- see + # Hyperparameters.staleness_policy (flame/config.py). Async by + # design: fluxtune's fedbuff optimizer intentionally aggregates + # whatever's in flight, weighting by staleness (agg_rate_conf above) + # rather than rejecting it. Explicit "none" here so the gate's + # absence is a documented choice, not a default. + stalenessPolicy: none + inc_model_version_per_data_id: true + var_threshold: 0.3 + trainer: + hyperparameters: + select_perturbation_using_jvp: true + client_notify: + enabled: "True" + trace: mobiperf_3st_50 + + fluxtune_dynkc: + description: >- + Research variant: async_random + adaptive dynamic_kc controller + + fedbuff, preserving fedfwd_async_random_dynkc (the prior production + default, transcribed faithfully from the legacy + fwdllm/expts/run_tc_expts/json_scripts/aggregator.json) under the new + naming scheme rather than deleting it outright -- this adaptive + async+K research config maps to none of fwdllm/fwdllm_plus/fluxtune. + Selector/optimizer/hyperparameters kept identical to the ported + production default -- deliberately NOT updated to use fedbuff's new + explicit learning_rate kwarg or the agnews-correct dataset_name, + including its known + dataset_name: google-speech copy-paste artifact -- so it stays a + valid parity baseline. (Trainer-side forward_mode/var_control/ + perturbation_sampling/fl_algorithm overrides were dropped since they + only restated trainer_base.yaml's defaults; the resolved values are + unchanged.) + example: + aggregator_main: aggregator/main_fedfwd_agg.py + aggregator: + selector: + sort: async_random + kwargs: + c: 15 # concurrency level; override per experiment to scale with num_trainers + aggGoal: 5 # override per experiment to match num_trainers + evalGoalFactor: 0 + selectType: default + roundNudgeType: last_train + minInitialTrainers: 15 # override per experiment to scale with num_trainers + k: 5 + is_async: true + # Maps task names to eligible avl_state values. Classic FL: only + # AVL_TRAIN. FedFwd: both AVL_TRAIN and AVL_EVAL can train. + task_eligible_states: + train: [AVL_TRAIN, AVL_EVAL] + eval: [AVL_EVAL, AVL_TRAIN] + # K adapts to track variance against target_iter_per_data_id; C is + # held fixed (c_min == c_max == c). Override k_min/k_max/c_min/c_max + # per experiment to scale with num_trainers. + dynamic_kc: + enabled: true + policy: adaptive_k_var_tracking + policy_kwargs: + target_iter_per_data_id: 15 + k_step: 2 + window: 6 + k_min: 5 + k_max: 15 + c_min: 15 + c_max: 15 + update_every_n_aggs: 1 + history_window: 20 + optimizer: + sort: fedbuff + kwargs: + use_oort_lr: "True" + # NOTE: dataset_name is "google-speech" in the legacy aggregator.json + # this baseline was transcribed from, even though fwdllm runs agnews. + # Ported as-is per "transcribed faithfully, not redesigned" -- looks + # like a copy-paste artifact from another example's config, left + # unfixed here (deliberately, for parity -- see description above). + dataset_name: google-speech + agg_rate_conf: + type: old + scale: 1.0 + a_exp: 0.2 + b_exp: 0.25 + hyperparameters: + trackTrainerAvail: + enabled: "False" + type: "NONE" + rejectStaleUpdates: false + inc_model_version_per_data_id: true + # Soft-cap fallback. With adaptive_k_var_tracking, aggregations should + # converge near target without needing the cap, but it remains as a + # safety net. + max_iterations_per_data_id: 15 + # FedSGD variance check threshold. Raised from the distilbert default + # (0.1) for heterogeneous NIID partitions where gradient variance is + # naturally higher. + var_threshold: 0.3 + trainer: + hyperparameters: + client_notify: + enabled: "False" diff --git a/lib/python/examples/_metadata/leo/satellite_latencies.npy b/lib/python/examples/_metadata/leo/satellite_latencies.npy new file mode 100644 index 000000000..6219d4184 Binary files /dev/null and b/lib/python/examples/_metadata/leo/satellite_latencies.npy differ diff --git a/lib/python/examples/_metadata/scripts/explore_latencies.py b/lib/python/examples/_metadata/scripts/explore_latencies.py new file mode 100644 index 000000000..e1886b541 --- /dev/null +++ b/lib/python/examples/_metadata/scripts/explore_latencies.py @@ -0,0 +1,43 @@ +import os +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt + +# Define file path +FILE_PATH = 'lib/python/examples/_metadata/satellite_latencies.npy' + +if not os.path.exists(FILE_PATH): + raise FileNotFoundError(f"Could not find the file at {FILE_PATH}. Check your current working directory!") + +# Load data +data = np.load(FILE_PATH) +print("=" * 50) +print(f"Loaded Array Shape: {data.shape}") +print("=" * 50) + +# Print first 10 rows of first 10 columns +print("First 10 Rows and First 10 Columns:") +if data.ndim > 1: + # Slices rows 0-9 and columns 0-9 cleanly + print(data[:10, :10]) +else: + print("Note: Array is 1-dimensional. Printing first 10 elements instead:") + print(data[:10]) +print("=" * 50) + +# Create a figure with two subplots side-by-side or stacked +fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 10)) + +# ------------------------------------------------------------------ +# PLOT 1: Single Satellite Latency Over Time +# ------------------------------------------------------------------ +# track Satellite Index 4 (Column 4) over the first 1000 time steps +satellite_id = 4 +time_steps = 1000 + +ax1.plot(data[:time_steps, satellite_id], color='darkorange', linewidth=2, label=f'Satellite #{satellite_id}') +ax1.set_title(f'Orbital Latency Profile for a Single LEO Satellite (First {time_steps} Steps)', fontsize=14) +ax1.set_xlabel('Simulation Time Step', fontsize=12) +ax1.set_ylabel('Latency (Seconds)', fontsize=12) +ax1.grid(True, linestyle='--', alpha=0.5) +ax1.legend(fontsize=11) \ No newline at end of file diff --git a/lib/python/examples/_metadata/scripts/update_registry.py b/lib/python/examples/_metadata/scripts/update_registry.py new file mode 100644 index 000000000..62a997040 --- /dev/null +++ b/lib/python/examples/_metadata/scripts/update_registry.py @@ -0,0 +1,29 @@ +import yaml + +PATH = "lib/python/examples/_metadata/trainer_registry.yaml" +GPU_A40_DELAY_S = 0.2 + +def main() -> None: + with open(PATH) as f: + registry = yaml.safe_load(f) + + for trainer in registry["trainers"].values(): + # Rename training_delay_s -> computation_time_ms as a per-device dict + # (training_delay_s had mobile_device and gpu_a40 values in seconds) + existing = trainer["training_delay_s"] + trainer["computation_time_ms"] = { + "mobile_device": float(existing["mobile_device"]) * 1000, + "gpu_a40": float(existing["gpu_a40"]) * 1000, + } + # Remove the old field + del trainer["training_delay_s"] + # Remove the old flat computation_time_ms (was a single number, now replaced above) + # Note: the new computation_time_ms above overwrites it, so del not needed + + with open(PATH, "w") as f: + yaml.dump(registry, f, default_flow_style=False, sort_keys=False) + + print(f"Done. training_delay_s renamed to computation_time_ms (in ms) for {len(registry['trainers'])} trainers.") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/lib/python/examples/_metadata/trainer_registry.yaml b/lib/python/examples/_metadata/trainer_registry.yaml index 7956f22b1..a72615a5c 100644 --- a/lib/python/examples/_metadata/trainer_registry.yaml +++ b/lib/python/examples/_metadata/trainer_registry.yaml @@ -4,1800 +4,2700 @@ trainers: trainer_001: trainer_id: 1 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580370 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_001 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 0 trainer_002: trainer_id: 2 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580371 - training_delay_s: '16.0' speed_class: very_slow mobiperf_device_id: device_002 + computation_time_ms: + mobile_device: 16000.0 + gpu_a40: 200.0 + satellite_index: 1 trainer_003: trainer_id: 3 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580372 - training_delay_s: '13.0' speed_class: very_slow mobiperf_device_id: device_003 + computation_time_ms: + mobile_device: 13000.0 + gpu_a40: 200.0 + satellite_index: 2 trainer_004: trainer_id: 4 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580373 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_004 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 3 trainer_005: trainer_id: 5 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580374 - training_delay_s: '18.0' speed_class: very_slow mobiperf_device_id: device_005 + computation_time_ms: + mobile_device: 18000.0 + gpu_a40: 200.0 + satellite_index: 4 trainer_006: trainer_id: 6 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580375 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_006 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 5 trainer_007: trainer_id: 7 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580376 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_007 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 6 trainer_008: trainer_id: 8 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580377 - training_delay_s: '17.0' speed_class: very_slow mobiperf_device_id: device_008 + computation_time_ms: + mobile_device: 17000.0 + gpu_a40: 200.0 + satellite_index: 7 trainer_009: trainer_id: 9 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580378 - training_delay_s: '13.0' speed_class: very_slow mobiperf_device_id: device_009 + computation_time_ms: + mobile_device: 13000.0 + gpu_a40: 200.0 + satellite_index: 8 trainer_010: trainer_id: 10 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580379 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_010 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 9 trainer_011: trainer_id: 11 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580380 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_011 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 10 trainer_012: trainer_id: 12 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580381 - training_delay_s: '19.0' speed_class: very_slow mobiperf_device_id: device_012 + computation_time_ms: + mobile_device: 19000.0 + gpu_a40: 200.0 + satellite_index: 11 trainer_013: trainer_id: 13 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580382 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_013 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 12 trainer_014: trainer_id: 14 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580383 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_014 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 13 trainer_015: trainer_id: 15 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580384 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_015 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 14 trainer_016: trainer_id: 16 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580385 - training_delay_s: '13.0' speed_class: very_slow mobiperf_device_id: device_016 + computation_time_ms: + mobile_device: 13000.0 + gpu_a40: 200.0 + satellite_index: 15 trainer_017: trainer_id: 17 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580386 - training_delay_s: '14.0' speed_class: very_slow mobiperf_device_id: device_017 + computation_time_ms: + mobile_device: 14000.0 + gpu_a40: 200.0 + satellite_index: 16 trainer_018: trainer_id: 18 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580387 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_018 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 17 trainer_019: trainer_id: 19 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580388 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_019 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 18 trainer_020: trainer_id: 20 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580389 - training_delay_s: '47.0' speed_class: very_slow mobiperf_device_id: device_020 + computation_time_ms: + mobile_device: 47000.0 + gpu_a40: 200.0 + satellite_index: 19 trainer_021: trainer_id: 21 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580390 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_021 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 20 trainer_022: trainer_id: 22 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580391 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_022 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 21 trainer_023: trainer_id: 23 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580392 - training_delay_s: '21.0' speed_class: very_slow mobiperf_device_id: device_023 + computation_time_ms: + mobile_device: 21000.0 + gpu_a40: 200.0 + satellite_index: 22 trainer_024: trainer_id: 24 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580393 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_024 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 23 trainer_025: trainer_id: 25 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580394 - training_delay_s: '15.0' speed_class: very_slow mobiperf_device_id: device_025 + computation_time_ms: + mobile_device: 15000.0 + gpu_a40: 200.0 + satellite_index: 24 trainer_026: trainer_id: 26 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580395 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_026 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 25 trainer_027: trainer_id: 27 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580396 - training_delay_s: '13.0' speed_class: very_slow mobiperf_device_id: device_027 + computation_time_ms: + mobile_device: 13000.0 + gpu_a40: 200.0 + satellite_index: 26 trainer_028: trainer_id: 28 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580397 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_028 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 27 trainer_029: trainer_id: 29 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580398 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_029 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 28 trainer_030: trainer_id: 30 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580399 - training_delay_s: '15.0' speed_class: very_slow mobiperf_device_id: device_030 + computation_time_ms: + mobile_device: 15000.0 + gpu_a40: 200.0 + satellite_index: 29 trainer_031: trainer_id: 31 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580400 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_031 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 30 trainer_032: trainer_id: 32 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580401 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_032 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 31 trainer_033: trainer_id: 33 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580402 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_033 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 32 trainer_034: trainer_id: 34 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580403 - training_delay_s: '21.0' speed_class: very_slow mobiperf_device_id: device_034 + computation_time_ms: + mobile_device: 21000.0 + gpu_a40: 200.0 + satellite_index: 33 trainer_035: trainer_id: 35 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580404 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_035 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 34 trainer_036: trainer_id: 36 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580405 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_036 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 35 trainer_037: trainer_id: 37 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580406 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_037 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 36 trainer_038: trainer_id: 38 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580407 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_038 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 37 trainer_039: trainer_id: 39 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580408 - training_delay_s: '18.0' speed_class: very_slow mobiperf_device_id: device_039 + computation_time_ms: + mobile_device: 18000.0 + gpu_a40: 200.0 + satellite_index: 38 trainer_040: trainer_id: 40 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580409 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_040 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 39 trainer_041: trainer_id: 41 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580410 - training_delay_s: '21.0' speed_class: very_slow mobiperf_device_id: device_041 + computation_time_ms: + mobile_device: 21000.0 + gpu_a40: 200.0 + satellite_index: 40 trainer_042: trainer_id: 42 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580411 - training_delay_s: '13.0' speed_class: very_slow mobiperf_device_id: device_042 + computation_time_ms: + mobile_device: 13000.0 + gpu_a40: 200.0 + satellite_index: 41 trainer_043: trainer_id: 43 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580412 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_043 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 42 trainer_044: trainer_id: 44 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580413 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_044 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 43 trainer_045: trainer_id: 45 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580414 - training_delay_s: '15.0' speed_class: very_slow mobiperf_device_id: device_045 + computation_time_ms: + mobile_device: 15000.0 + gpu_a40: 200.0 + satellite_index: 44 trainer_046: trainer_id: 46 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580415 - training_delay_s: '24.0' speed_class: very_slow mobiperf_device_id: device_046 + computation_time_ms: + mobile_device: 24000.0 + gpu_a40: 200.0 + satellite_index: 45 trainer_047: trainer_id: 47 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580416 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_047 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 46 trainer_048: trainer_id: 48 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580417 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_048 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 47 trainer_049: trainer_id: 49 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580418 - training_delay_s: '14.0' speed_class: very_slow mobiperf_device_id: device_049 + computation_time_ms: + mobile_device: 14000.0 + gpu_a40: 200.0 + satellite_index: 48 trainer_050: trainer_id: 50 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580419 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_050 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 49 trainer_051: trainer_id: 51 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580420 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_051 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 50 trainer_052: trainer_id: 52 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580421 - training_delay_s: '16.0' speed_class: very_slow mobiperf_device_id: device_052 + computation_time_ms: + mobile_device: 16000.0 + gpu_a40: 200.0 + satellite_index: 51 trainer_053: trainer_id: 53 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580422 - training_delay_s: '14.0' speed_class: very_slow mobiperf_device_id: device_053 + computation_time_ms: + mobile_device: 14000.0 + gpu_a40: 200.0 + satellite_index: 52 trainer_054: trainer_id: 54 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580423 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_054 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 53 trainer_055: trainer_id: 55 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580424 - training_delay_s: '14.0' speed_class: very_slow mobiperf_device_id: device_055 + computation_time_ms: + mobile_device: 14000.0 + gpu_a40: 200.0 + satellite_index: 54 trainer_056: trainer_id: 56 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580425 - training_delay_s: '23.0' speed_class: very_slow mobiperf_device_id: device_056 + computation_time_ms: + mobile_device: 23000.0 + gpu_a40: 200.0 + satellite_index: 55 trainer_057: trainer_id: 57 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580426 - training_delay_s: '30.0' speed_class: very_slow mobiperf_device_id: device_057 + computation_time_ms: + mobile_device: 30000.0 + gpu_a40: 200.0 + satellite_index: 56 trainer_058: trainer_id: 58 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580427 - training_delay_s: '21.0' speed_class: very_slow mobiperf_device_id: device_058 + computation_time_ms: + mobile_device: 21000.0 + gpu_a40: 200.0 + satellite_index: 57 trainer_059: trainer_id: 59 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580428 - training_delay_s: '28.0' speed_class: very_slow mobiperf_device_id: device_059 + computation_time_ms: + mobile_device: 28000.0 + gpu_a40: 200.0 + satellite_index: 58 trainer_060: trainer_id: 60 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580429 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_060 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 59 trainer_061: trainer_id: 61 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580430 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_061 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 60 trainer_062: trainer_id: 62 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580431 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_062 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 61 trainer_063: trainer_id: 63 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580432 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_063 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 62 trainer_064: trainer_id: 64 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580433 - training_delay_s: '20.0' speed_class: very_slow mobiperf_device_id: device_064 + computation_time_ms: + mobile_device: 20000.0 + gpu_a40: 200.0 + satellite_index: 63 trainer_065: trainer_id: 65 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580434 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_065 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 64 trainer_066: trainer_id: 66 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580435 - training_delay_s: '22.0' speed_class: very_slow mobiperf_device_id: device_066 + computation_time_ms: + mobile_device: 22000.0 + gpu_a40: 200.0 + satellite_index: 65 trainer_067: trainer_id: 67 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580436 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_067 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 66 trainer_068: trainer_id: 68 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580437 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_068 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 67 trainer_069: trainer_id: 69 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580438 - training_delay_s: '15.0' speed_class: very_slow mobiperf_device_id: device_069 + computation_time_ms: + mobile_device: 15000.0 + gpu_a40: 200.0 + satellite_index: 68 trainer_070: trainer_id: 70 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580439 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_070 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 69 trainer_071: trainer_id: 71 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580440 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_071 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 70 trainer_072: trainer_id: 72 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580441 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_072 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 71 trainer_073: trainer_id: 73 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580442 - training_delay_s: '21.0' speed_class: very_slow mobiperf_device_id: device_073 + computation_time_ms: + mobile_device: 21000.0 + gpu_a40: 200.0 + satellite_index: 72 trainer_074: trainer_id: 74 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580443 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_074 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 73 trainer_075: trainer_id: 75 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580444 - training_delay_s: '28.0' speed_class: very_slow mobiperf_device_id: device_075 + computation_time_ms: + mobile_device: 28000.0 + gpu_a40: 200.0 + satellite_index: 74 trainer_076: trainer_id: 76 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580445 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_076 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 75 trainer_077: trainer_id: 77 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580446 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_077 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 76 trainer_078: trainer_id: 78 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580447 - training_delay_s: '22.0' speed_class: very_slow mobiperf_device_id: device_078 + computation_time_ms: + mobile_device: 22000.0 + gpu_a40: 200.0 + satellite_index: 77 trainer_079: trainer_id: 79 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580448 - training_delay_s: '16.0' speed_class: very_slow mobiperf_device_id: device_079 + computation_time_ms: + mobile_device: 16000.0 + gpu_a40: 200.0 + satellite_index: 78 trainer_080: trainer_id: 80 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580449 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_080 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 79 trainer_081: trainer_id: 81 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580450 - training_delay_s: '22.0' speed_class: very_slow mobiperf_device_id: device_081 + computation_time_ms: + mobile_device: 22000.0 + gpu_a40: 200.0 + satellite_index: 80 trainer_082: trainer_id: 82 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580451 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_082 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 81 trainer_083: trainer_id: 83 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580452 - training_delay_s: '18.0' speed_class: very_slow mobiperf_device_id: device_083 + computation_time_ms: + mobile_device: 18000.0 + gpu_a40: 200.0 + satellite_index: 82 trainer_084: trainer_id: 84 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580453 - training_delay_s: '14.0' speed_class: very_slow mobiperf_device_id: device_084 + computation_time_ms: + mobile_device: 14000.0 + gpu_a40: 200.0 + satellite_index: 83 trainer_085: trainer_id: 85 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580454 - training_delay_s: '27.0' speed_class: very_slow mobiperf_device_id: device_085 + computation_time_ms: + mobile_device: 27000.0 + gpu_a40: 200.0 + satellite_index: 84 trainer_086: trainer_id: 86 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580455 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_086 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 85 trainer_087: trainer_id: 87 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580456 - training_delay_s: '15.0' speed_class: very_slow mobiperf_device_id: device_087 + computation_time_ms: + mobile_device: 15000.0 + gpu_a40: 200.0 + satellite_index: 86 trainer_088: trainer_id: 88 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580457 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_088 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 87 trainer_089: trainer_id: 89 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580458 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_089 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 88 trainer_090: trainer_id: 90 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580459 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_090 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 89 trainer_091: trainer_id: 91 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580460 - training_delay_s: '38.0' speed_class: very_slow mobiperf_device_id: device_091 + computation_time_ms: + mobile_device: 38000.0 + gpu_a40: 200.0 + satellite_index: 90 trainer_092: trainer_id: 92 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580461 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_092 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 91 trainer_093: trainer_id: 93 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580462 - training_delay_s: '27.0' speed_class: very_slow mobiperf_device_id: device_093 + computation_time_ms: + mobile_device: 27000.0 + gpu_a40: 200.0 + satellite_index: 92 trainer_094: trainer_id: 94 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580463 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_094 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 93 trainer_095: trainer_id: 95 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580464 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_095 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 94 trainer_096: trainer_id: 96 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580465 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_096 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 95 trainer_097: trainer_id: 97 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580466 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_097 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 96 trainer_098: trainer_id: 98 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580467 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_098 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 97 trainer_099: trainer_id: 99 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580468 - training_delay_s: '17.0' speed_class: very_slow mobiperf_device_id: device_099 + computation_time_ms: + mobile_device: 17000.0 + gpu_a40: 200.0 + satellite_index: 98 trainer_100: trainer_id: 100 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580469 - training_delay_s: '36.0' speed_class: very_slow mobiperf_device_id: device_100 + computation_time_ms: + mobile_device: 36000.0 + gpu_a40: 200.0 + satellite_index: 99 trainer_101: trainer_id: 101 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580470 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_101 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 100 trainer_102: trainer_id: 102 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580471 - training_delay_s: '20.0' speed_class: very_slow mobiperf_device_id: device_102 + computation_time_ms: + mobile_device: 20000.0 + gpu_a40: 200.0 + satellite_index: 101 trainer_103: trainer_id: 103 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580472 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_103 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 102 trainer_104: trainer_id: 104 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580473 - training_delay_s: '17.0' speed_class: very_slow mobiperf_device_id: device_104 + computation_time_ms: + mobile_device: 17000.0 + gpu_a40: 200.0 + satellite_index: 103 trainer_105: trainer_id: 105 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580474 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_105 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 104 trainer_106: trainer_id: 106 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580475 - training_delay_s: '26.0' speed_class: very_slow mobiperf_device_id: device_106 + computation_time_ms: + mobile_device: 26000.0 + gpu_a40: 200.0 + satellite_index: 105 trainer_107: trainer_id: 107 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580476 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_107 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 106 trainer_108: trainer_id: 108 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580477 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_108 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 107 trainer_109: trainer_id: 109 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580478 - training_delay_s: '29.0' speed_class: very_slow mobiperf_device_id: device_109 + computation_time_ms: + mobile_device: 29000.0 + gpu_a40: 200.0 + satellite_index: 108 trainer_110: trainer_id: 110 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580479 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_110 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 109 trainer_111: trainer_id: 111 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580480 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_111 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 110 trainer_112: trainer_id: 112 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580481 - training_delay_s: '18.0' speed_class: very_slow mobiperf_device_id: device_112 + computation_time_ms: + mobile_device: 18000.0 + gpu_a40: 200.0 + satellite_index: 111 trainer_113: trainer_id: 113 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580482 - training_delay_s: '21.0' speed_class: very_slow mobiperf_device_id: device_113 + computation_time_ms: + mobile_device: 21000.0 + gpu_a40: 200.0 + satellite_index: 112 trainer_114: trainer_id: 114 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580483 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_114 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 113 trainer_115: trainer_id: 115 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580484 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_115 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 114 trainer_116: trainer_id: 116 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580485 - training_delay_s: '16.0' speed_class: very_slow mobiperf_device_id: device_116 + computation_time_ms: + mobile_device: 16000.0 + gpu_a40: 200.0 + satellite_index: 115 trainer_117: trainer_id: 117 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580486 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_117 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 116 trainer_118: trainer_id: 118 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580487 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_118 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 117 trainer_119: trainer_id: 119 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580488 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_119 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 118 trainer_120: trainer_id: 120 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580489 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_120 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 119 trainer_121: trainer_id: 121 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580490 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_121 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 120 trainer_122: trainer_id: 122 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580491 - training_delay_s: '17.0' speed_class: very_slow mobiperf_device_id: device_122 + computation_time_ms: + mobile_device: 17000.0 + gpu_a40: 200.0 + satellite_index: 121 trainer_123: trainer_id: 123 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580492 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_123 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 122 trainer_124: trainer_id: 124 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580493 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_124 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 123 trainer_125: trainer_id: 125 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580494 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_125 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 124 trainer_126: trainer_id: 126 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580495 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_126 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 125 trainer_127: trainer_id: 127 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580496 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_127 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 126 trainer_128: trainer_id: 128 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580497 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_128 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 127 trainer_129: trainer_id: 129 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580498 - training_delay_s: '22.0' speed_class: very_slow mobiperf_device_id: device_129 + computation_time_ms: + mobile_device: 22000.0 + gpu_a40: 200.0 + satellite_index: 128 trainer_130: trainer_id: 130 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580499 - training_delay_s: '18.0' speed_class: very_slow mobiperf_device_id: device_130 + computation_time_ms: + mobile_device: 18000.0 + gpu_a40: 200.0 + satellite_index: 129 trainer_131: trainer_id: 131 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580500 - training_delay_s: '13.0' speed_class: very_slow mobiperf_device_id: device_131 + computation_time_ms: + mobile_device: 13000.0 + gpu_a40: 200.0 + satellite_index: 130 trainer_132: trainer_id: 132 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580501 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_132 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 131 trainer_133: trainer_id: 133 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580502 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_133 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 132 trainer_134: trainer_id: 134 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580503 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_134 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 133 trainer_135: trainer_id: 135 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580504 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_135 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 134 trainer_136: trainer_id: 136 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580505 - training_delay_s: '15.0' speed_class: very_slow mobiperf_device_id: device_136 + computation_time_ms: + mobile_device: 15000.0 + gpu_a40: 200.0 + satellite_index: 135 trainer_137: trainer_id: 137 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580506 - training_delay_s: '22.0' speed_class: very_slow mobiperf_device_id: device_137 + computation_time_ms: + mobile_device: 22000.0 + gpu_a40: 200.0 + satellite_index: 136 trainer_138: trainer_id: 138 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580507 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_138 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 137 trainer_139: trainer_id: 139 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580508 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_139 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 138 trainer_140: trainer_id: 140 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580509 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_140 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 139 trainer_141: trainer_id: 141 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580510 - training_delay_s: '18.0' speed_class: very_slow mobiperf_device_id: device_141 + computation_time_ms: + mobile_device: 18000.0 + gpu_a40: 200.0 + satellite_index: 140 trainer_142: trainer_id: 142 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580511 - training_delay_s: '15.0' speed_class: very_slow mobiperf_device_id: device_142 + computation_time_ms: + mobile_device: 15000.0 + gpu_a40: 200.0 + satellite_index: 141 trainer_143: trainer_id: 143 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580512 - training_delay_s: '16.0' speed_class: very_slow mobiperf_device_id: device_143 + computation_time_ms: + mobile_device: 16000.0 + gpu_a40: 200.0 + satellite_index: 142 trainer_144: trainer_id: 144 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580513 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_144 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 143 trainer_145: trainer_id: 145 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580514 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_145 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 144 trainer_146: trainer_id: 146 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580515 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_146 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 145 trainer_147: trainer_id: 147 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580516 - training_delay_s: '29.0' speed_class: very_slow mobiperf_device_id: device_147 + computation_time_ms: + mobile_device: 29000.0 + gpu_a40: 200.0 + satellite_index: 146 trainer_148: trainer_id: 148 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580517 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_148 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 147 trainer_149: trainer_id: 149 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580518 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_149 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 148 trainer_150: trainer_id: 150 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580519 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_150 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 149 trainer_151: trainer_id: 151 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580520 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_151 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 0 trainer_152: trainer_id: 152 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580521 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_152 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 1 trainer_153: trainer_id: 153 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580522 - training_delay_s: '22.0' speed_class: very_slow mobiperf_device_id: device_153 + computation_time_ms: + mobile_device: 22000.0 + gpu_a40: 200.0 + satellite_index: 2 trainer_154: trainer_id: 154 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580523 - training_delay_s: '22.0' speed_class: very_slow mobiperf_device_id: device_154 + computation_time_ms: + mobile_device: 22000.0 + gpu_a40: 200.0 + satellite_index: 3 trainer_155: trainer_id: 155 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580524 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_155 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 4 trainer_156: trainer_id: 156 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580525 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_156 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 5 trainer_157: trainer_id: 157 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580526 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_157 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 6 trainer_158: trainer_id: 158 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580527 - training_delay_s: '32.0' speed_class: very_slow mobiperf_device_id: device_158 + computation_time_ms: + mobile_device: 32000.0 + gpu_a40: 200.0 + satellite_index: 7 trainer_159: trainer_id: 159 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580528 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_159 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 8 trainer_160: trainer_id: 160 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580529 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_160 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 9 trainer_161: trainer_id: 161 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580530 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_161 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 10 trainer_162: trainer_id: 162 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580531 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_162 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 11 trainer_163: trainer_id: 163 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580532 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_163 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 12 trainer_164: trainer_id: 164 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580533 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_164 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 13 trainer_165: trainer_id: 165 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580534 - training_delay_s: '16.0' speed_class: very_slow mobiperf_device_id: device_165 + computation_time_ms: + mobile_device: 16000.0 + gpu_a40: 200.0 + satellite_index: 14 trainer_166: trainer_id: 166 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580535 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_166 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 15 trainer_167: trainer_id: 167 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580536 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_167 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 16 trainer_168: trainer_id: 168 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580537 - training_delay_s: '25.0' speed_class: very_slow mobiperf_device_id: device_168 + computation_time_ms: + mobile_device: 25000.0 + gpu_a40: 200.0 + satellite_index: 17 trainer_169: trainer_id: 169 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580538 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_169 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 18 trainer_170: trainer_id: 170 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580539 - training_delay_s: '23.0' speed_class: very_slow mobiperf_device_id: device_170 + computation_time_ms: + mobile_device: 23000.0 + gpu_a40: 200.0 + satellite_index: 19 trainer_171: trainer_id: 171 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580540 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_171 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 20 trainer_172: trainer_id: 172 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580541 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_172 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 21 trainer_173: trainer_id: 173 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580542 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_173 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 22 trainer_174: trainer_id: 174 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580543 - training_delay_s: '21.0' speed_class: very_slow mobiperf_device_id: device_174 + computation_time_ms: + mobile_device: 21000.0 + gpu_a40: 200.0 + satellite_index: 23 trainer_175: trainer_id: 175 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580544 - training_delay_s: '18.0' speed_class: very_slow mobiperf_device_id: device_175 + computation_time_ms: + mobile_device: 18000.0 + gpu_a40: 200.0 + satellite_index: 24 trainer_176: trainer_id: 176 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580545 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_176 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 25 trainer_177: trainer_id: 177 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580546 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_177 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 26 trainer_178: trainer_id: 178 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580547 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_178 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 27 trainer_179: trainer_id: 179 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580548 - training_delay_s: '24.0' speed_class: very_slow mobiperf_device_id: device_179 + computation_time_ms: + mobile_device: 24000.0 + gpu_a40: 200.0 + satellite_index: 28 trainer_180: trainer_id: 180 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580549 - training_delay_s: '16.0' speed_class: very_slow mobiperf_device_id: device_180 + computation_time_ms: + mobile_device: 16000.0 + gpu_a40: 200.0 + satellite_index: 29 trainer_181: trainer_id: 181 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580550 - training_delay_s: '56.0' speed_class: very_slow mobiperf_device_id: device_181 + computation_time_ms: + mobile_device: 56000.0 + gpu_a40: 200.0 + satellite_index: 30 trainer_182: trainer_id: 182 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580551 - training_delay_s: '19.0' speed_class: very_slow mobiperf_device_id: device_182 + computation_time_ms: + mobile_device: 19000.0 + gpu_a40: 200.0 + satellite_index: 31 trainer_183: trainer_id: 183 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580552 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_183 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 32 trainer_184: trainer_id: 184 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580553 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_184 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 33 trainer_185: trainer_id: 185 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580554 - training_delay_s: '16.0' speed_class: very_slow mobiperf_device_id: device_185 + computation_time_ms: + mobile_device: 16000.0 + gpu_a40: 200.0 + satellite_index: 34 trainer_186: trainer_id: 186 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580555 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_186 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 35 trainer_187: trainer_id: 187 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580556 - training_delay_s: '31.0' speed_class: very_slow mobiperf_device_id: device_187 + computation_time_ms: + mobile_device: 31000.0 + gpu_a40: 200.0 + satellite_index: 36 trainer_188: trainer_id: 188 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580557 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_188 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 37 trainer_189: trainer_id: 189 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580558 - training_delay_s: '18.0' speed_class: very_slow mobiperf_device_id: device_189 + computation_time_ms: + mobile_device: 18000.0 + gpu_a40: 200.0 + satellite_index: 38 trainer_190: trainer_id: 190 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580559 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_190 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 39 trainer_191: trainer_id: 191 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580560 - training_delay_s: '13.0' speed_class: very_slow mobiperf_device_id: device_191 + computation_time_ms: + mobile_device: 13000.0 + gpu_a40: 200.0 + satellite_index: 40 trainer_192: trainer_id: 192 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580561 - training_delay_s: '17.0' speed_class: very_slow mobiperf_device_id: device_192 + computation_time_ms: + mobile_device: 17000.0 + gpu_a40: 200.0 + satellite_index: 41 trainer_193: trainer_id: 193 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580562 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_193 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 42 trainer_194: trainer_id: 194 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580563 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_194 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 43 trainer_195: trainer_id: 195 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580564 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_195 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 44 trainer_196: trainer_id: 196 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580565 - training_delay_s: '13.0' speed_class: very_slow mobiperf_device_id: device_196 + computation_time_ms: + mobile_device: 13000.0 + gpu_a40: 200.0 + satellite_index: 45 trainer_197: trainer_id: 197 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580566 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_197 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 46 trainer_198: trainer_id: 198 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580567 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_198 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 47 trainer_199: trainer_id: 199 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580568 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_199 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 48 trainer_200: trainer_id: 200 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580569 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_200 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 49 trainer_201: trainer_id: 201 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580570 - training_delay_s: '18.0' speed_class: very_slow mobiperf_device_id: device_201 + computation_time_ms: + mobile_device: 18000.0 + gpu_a40: 200.0 + satellite_index: 50 trainer_202: trainer_id: 202 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580571 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_202 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 51 trainer_203: trainer_id: 203 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580572 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_203 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 52 trainer_204: trainer_id: 204 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580573 - training_delay_s: '21.0' speed_class: very_slow mobiperf_device_id: device_204 + computation_time_ms: + mobile_device: 21000.0 + gpu_a40: 200.0 + satellite_index: 53 trainer_205: trainer_id: 205 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580574 - training_delay_s: '24.0' speed_class: very_slow mobiperf_device_id: device_205 + computation_time_ms: + mobile_device: 24000.0 + gpu_a40: 200.0 + satellite_index: 54 trainer_206: trainer_id: 206 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580575 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_206 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 55 trainer_207: trainer_id: 207 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580576 - training_delay_s: '14.0' speed_class: very_slow mobiperf_device_id: device_207 + computation_time_ms: + mobile_device: 14000.0 + gpu_a40: 200.0 + satellite_index: 56 trainer_208: trainer_id: 208 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580577 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_208 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 57 trainer_209: trainer_id: 209 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580578 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_209 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 58 trainer_210: trainer_id: 210 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580579 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_210 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 59 trainer_211: trainer_id: 211 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580580 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_211 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 60 trainer_212: trainer_id: 212 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580581 - training_delay_s: '14.0' speed_class: very_slow mobiperf_device_id: device_212 + computation_time_ms: + mobile_device: 14000.0 + gpu_a40: 200.0 + satellite_index: 61 trainer_213: trainer_id: 213 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580582 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_213 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 62 trainer_214: trainer_id: 214 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580583 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_214 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 63 trainer_215: trainer_id: 215 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580584 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_215 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 64 trainer_216: trainer_id: 216 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580585 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_216 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 65 trainer_217: trainer_id: 217 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580586 - training_delay_s: '28.0' speed_class: very_slow mobiperf_device_id: device_217 + computation_time_ms: + mobile_device: 28000.0 + gpu_a40: 200.0 + satellite_index: 66 trainer_218: trainer_id: 218 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580587 - training_delay_s: '31.0' speed_class: very_slow mobiperf_device_id: device_218 + computation_time_ms: + mobile_device: 31000.0 + gpu_a40: 200.0 + satellite_index: 67 trainer_219: trainer_id: 219 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580588 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_219 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 68 trainer_220: trainer_id: 220 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580589 - training_delay_s: '26.0' speed_class: very_slow mobiperf_device_id: device_220 + computation_time_ms: + mobile_device: 26000.0 + gpu_a40: 200.0 + satellite_index: 69 trainer_221: trainer_id: 221 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580590 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_221 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 70 trainer_222: trainer_id: 222 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580591 - training_delay_s: '13.0' speed_class: very_slow mobiperf_device_id: device_222 + computation_time_ms: + mobile_device: 13000.0 + gpu_a40: 200.0 + satellite_index: 71 trainer_223: trainer_id: 223 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580592 - training_delay_s: '14.0' speed_class: very_slow mobiperf_device_id: device_223 + computation_time_ms: + mobile_device: 14000.0 + gpu_a40: 200.0 + satellite_index: 72 trainer_224: trainer_id: 224 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580593 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_224 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 73 trainer_225: trainer_id: 225 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580594 - training_delay_s: '17.0' speed_class: very_slow mobiperf_device_id: device_225 + computation_time_ms: + mobile_device: 17000.0 + gpu_a40: 200.0 + satellite_index: 74 trainer_226: trainer_id: 226 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580595 - training_delay_s: '13.0' speed_class: very_slow mobiperf_device_id: device_226 + computation_time_ms: + mobile_device: 13000.0 + gpu_a40: 200.0 + satellite_index: 75 trainer_227: trainer_id: 227 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580596 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_227 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 76 trainer_228: trainer_id: 228 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580597 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_228 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 77 trainer_229: trainer_id: 229 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580598 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_229 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 78 trainer_230: trainer_id: 230 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580599 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_230 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 79 trainer_231: trainer_id: 231 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580600 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_231 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 80 trainer_232: trainer_id: 232 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580601 - training_delay_s: '27.0' speed_class: very_slow mobiperf_device_id: device_232 + computation_time_ms: + mobile_device: 27000.0 + gpu_a40: 200.0 + satellite_index: 81 trainer_233: trainer_id: 233 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580602 - training_delay_s: '19.0' speed_class: very_slow mobiperf_device_id: device_233 + computation_time_ms: + mobile_device: 19000.0 + gpu_a40: 200.0 + satellite_index: 82 trainer_234: trainer_id: 234 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580603 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_234 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 83 trainer_235: trainer_id: 235 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580604 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_235 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 84 trainer_236: trainer_id: 236 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580605 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_236 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 85 trainer_237: trainer_id: 237 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580606 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_237 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 86 trainer_238: trainer_id: 238 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580607 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_238 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 87 trainer_239: trainer_id: 239 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580608 - training_delay_s: '14.0' speed_class: very_slow mobiperf_device_id: device_239 + computation_time_ms: + mobile_device: 14000.0 + gpu_a40: 200.0 + satellite_index: 88 trainer_240: trainer_id: 240 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580609 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_240 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 89 trainer_241: trainer_id: 241 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580610 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_241 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 90 trainer_242: trainer_id: 242 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580611 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_242 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 91 trainer_243: trainer_id: 243 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580612 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_243 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 92 trainer_244: trainer_id: 244 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580613 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_244 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 93 trainer_245: trainer_id: 245 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580614 - training_delay_s: '20.0' speed_class: very_slow mobiperf_device_id: device_245 + computation_time_ms: + mobile_device: 20000.0 + gpu_a40: 200.0 + satellite_index: 94 trainer_246: trainer_id: 246 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580615 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_246 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 95 trainer_247: trainer_id: 247 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580616 - training_delay_s: '23.0' speed_class: very_slow mobiperf_device_id: device_247 + computation_time_ms: + mobile_device: 23000.0 + gpu_a40: 200.0 + satellite_index: 96 trainer_248: trainer_id: 248 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580617 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_248 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 97 trainer_249: trainer_id: 249 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580618 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_249 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 98 trainer_250: trainer_id: 250 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580619 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_250 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 99 trainer_251: trainer_id: 251 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580620 - training_delay_s: '31.0' speed_class: very_slow mobiperf_device_id: device_251 + computation_time_ms: + mobile_device: 31000.0 + gpu_a40: 200.0 + satellite_index: 100 trainer_252: trainer_id: 252 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580621 - training_delay_s: '6.0' speed_class: medium mobiperf_device_id: device_252 + computation_time_ms: + mobile_device: 6000.0 + gpu_a40: 200.0 + satellite_index: 101 trainer_253: trainer_id: 253 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580622 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_253 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 102 trainer_254: trainer_id: 254 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580623 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_254 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 103 trainer_255: trainer_id: 255 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580624 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_255 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 104 trainer_256: trainer_id: 256 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580625 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_256 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 105 trainer_257: trainer_id: 257 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580626 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_257 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 106 trainer_258: trainer_id: 258 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580627 - training_delay_s: '23.0' speed_class: very_slow mobiperf_device_id: device_258 + computation_time_ms: + mobile_device: 23000.0 + gpu_a40: 200.0 + satellite_index: 107 trainer_259: trainer_id: 259 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580628 - training_delay_s: '16.0' speed_class: very_slow mobiperf_device_id: device_259 + computation_time_ms: + mobile_device: 16000.0 + gpu_a40: 200.0 + satellite_index: 108 trainer_260: trainer_id: 260 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580629 - training_delay_s: '5.0' speed_class: medium mobiperf_device_id: device_260 + computation_time_ms: + mobile_device: 5000.0 + gpu_a40: 200.0 + satellite_index: 109 trainer_261: trainer_id: 261 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580630 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_261 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 110 trainer_262: trainer_id: 262 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580631 - training_delay_s: '28.0' speed_class: very_slow mobiperf_device_id: device_262 + computation_time_ms: + mobile_device: 28000.0 + gpu_a40: 200.0 + satellite_index: 111 trainer_263: trainer_id: 263 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580632 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_263 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 112 trainer_264: trainer_id: 264 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580633 - training_delay_s: '29.0' speed_class: very_slow mobiperf_device_id: device_264 + computation_time_ms: + mobile_device: 29000.0 + gpu_a40: 200.0 + satellite_index: 113 trainer_265: trainer_id: 265 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580634 - training_delay_s: '16.0' speed_class: very_slow mobiperf_device_id: device_265 + computation_time_ms: + mobile_device: 16000.0 + gpu_a40: 200.0 + satellite_index: 114 trainer_266: trainer_id: 266 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580635 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_266 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 115 trainer_267: trainer_id: 267 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580636 - training_delay_s: '19.0' speed_class: very_slow mobiperf_device_id: device_267 + computation_time_ms: + mobile_device: 19000.0 + gpu_a40: 200.0 + satellite_index: 116 trainer_268: trainer_id: 268 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580637 - training_delay_s: '23.0' speed_class: very_slow mobiperf_device_id: device_268 + computation_time_ms: + mobile_device: 23000.0 + gpu_a40: 200.0 + satellite_index: 117 trainer_269: trainer_id: 269 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580638 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_269 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 118 trainer_270: trainer_id: 270 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580639 - training_delay_s: '7.0' speed_class: medium mobiperf_device_id: device_270 + computation_time_ms: + mobile_device: 7000.0 + gpu_a40: 200.0 + satellite_index: 119 trainer_271: trainer_id: 271 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580640 - training_delay_s: '3.0' speed_class: fast mobiperf_device_id: device_271 + computation_time_ms: + mobile_device: 3000.0 + gpu_a40: 200.0 + satellite_index: 120 trainer_272: trainer_id: 272 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580641 - training_delay_s: '10.0' speed_class: slow mobiperf_device_id: device_272 + computation_time_ms: + mobile_device: 10000.0 + gpu_a40: 200.0 + satellite_index: 121 trainer_273: trainer_id: 273 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580642 - training_delay_s: '40.0' speed_class: very_slow mobiperf_device_id: device_273 + computation_time_ms: + mobile_device: 40000.0 + gpu_a40: 200.0 + satellite_index: 122 trainer_274: trainer_id: 274 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580643 - training_delay_s: '15.0' speed_class: very_slow mobiperf_device_id: device_274 + computation_time_ms: + mobile_device: 15000.0 + gpu_a40: 200.0 + satellite_index: 123 trainer_275: trainer_id: 275 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580644 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_275 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 124 trainer_276: trainer_id: 276 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580645 - training_delay_s: '17.0' speed_class: very_slow mobiperf_device_id: device_276 + computation_time_ms: + mobile_device: 17000.0 + gpu_a40: 200.0 + satellite_index: 125 trainer_277: trainer_id: 277 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580646 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_277 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 126 trainer_278: trainer_id: 278 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580647 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_278 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 127 trainer_279: trainer_id: 279 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580648 - training_delay_s: '2.0' speed_class: fast mobiperf_device_id: device_279 + computation_time_ms: + mobile_device: 2000.0 + gpu_a40: 200.0 + satellite_index: 128 trainer_280: trainer_id: 280 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580649 - training_delay_s: '14.0' speed_class: very_slow mobiperf_device_id: device_280 + computation_time_ms: + mobile_device: 14000.0 + gpu_a40: 200.0 + satellite_index: 129 trainer_281: trainer_id: 281 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580650 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_281 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 130 trainer_282: trainer_id: 282 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580651 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_282 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 131 trainer_283: trainer_id: 283 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580652 - training_delay_s: '21.0' speed_class: very_slow mobiperf_device_id: device_283 + computation_time_ms: + mobile_device: 21000.0 + gpu_a40: 200.0 + satellite_index: 132 trainer_284: trainer_id: 284 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580653 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_284 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 133 trainer_285: trainer_id: 285 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580654 - training_delay_s: '34.0' speed_class: very_slow mobiperf_device_id: device_285 + computation_time_ms: + mobile_device: 34000.0 + gpu_a40: 200.0 + satellite_index: 134 trainer_286: trainer_id: 286 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580655 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_286 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 135 trainer_287: trainer_id: 287 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580656 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_287 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 136 trainer_288: trainer_id: 288 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580657 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_288 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 137 trainer_289: trainer_id: 289 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580658 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_289 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 138 trainer_290: trainer_id: 290 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580659 - training_delay_s: '15.0' speed_class: very_slow mobiperf_device_id: device_290 + computation_time_ms: + mobile_device: 15000.0 + gpu_a40: 200.0 + satellite_index: 139 trainer_291: trainer_id: 291 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580660 - training_delay_s: '23.0' speed_class: very_slow mobiperf_device_id: device_291 + computation_time_ms: + mobile_device: 23000.0 + gpu_a40: 200.0 + satellite_index: 140 trainer_292: trainer_id: 292 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580661 - training_delay_s: '19.0' speed_class: very_slow mobiperf_device_id: device_292 + computation_time_ms: + mobile_device: 19000.0 + gpu_a40: 200.0 + satellite_index: 141 trainer_293: trainer_id: 293 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580662 - training_delay_s: '8.0' speed_class: medium mobiperf_device_id: device_293 + computation_time_ms: + mobile_device: 8000.0 + gpu_a40: 200.0 + satellite_index: 142 trainer_294: trainer_id: 294 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580663 - training_delay_s: '4.0' speed_class: fast mobiperf_device_id: device_294 + computation_time_ms: + mobile_device: 4000.0 + gpu_a40: 200.0 + satellite_index: 143 trainer_295: trainer_id: 295 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580664 - training_delay_s: '19.0' speed_class: very_slow mobiperf_device_id: device_295 + computation_time_ms: + mobile_device: 19000.0 + gpu_a40: 200.0 + satellite_index: 144 trainer_296: trainer_id: 296 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580665 - training_delay_s: '14.0' speed_class: very_slow mobiperf_device_id: device_296 + computation_time_ms: + mobile_device: 14000.0 + gpu_a40: 200.0 + satellite_index: 145 trainer_297: trainer_id: 297 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580666 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_297 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 146 trainer_298: trainer_id: 298 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580667 - training_delay_s: '12.0' speed_class: slow mobiperf_device_id: device_298 + computation_time_ms: + mobile_device: 12000.0 + gpu_a40: 200.0 + satellite_index: 147 trainer_299: trainer_id: 299 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580668 - training_delay_s: '9.0' speed_class: slow mobiperf_device_id: device_299 + computation_time_ms: + mobile_device: 9000.0 + gpu_a40: 200.0 + satellite_index: 148 trainer_300: trainer_id: 300 task_id: 505f9fc483cf4df68a2409257b5fad7d3c580669 - training_delay_s: '11.0' speed_class: slow mobiperf_device_id: device_300 + computation_time_ms: + mobile_device: 11000.0 + gpu_a40: 200.0 + satellite_index: 149 diff --git a/lib/python/examples/async_cifar10/PARITY.md b/lib/python/examples/async_cifar10/PARITY.md index 2cf0c8f60..bb07ce2a7 100644 --- a/lib/python/examples/async_cifar10/PARITY.md +++ b/lib/python/examples/async_cifar10/PARITY.md @@ -1,9 +1,16 @@ # Real / Sim Parity — Methodical Causal Ladder -Living doc for the async_cifar10 parity checker. Kept in sync with +Living doc for the parity checker. Kept in sync with `scripts/parity/checks.py` (checks), `scripts/parity/report.py` (stage grouping + verdict), and the pytest suite. **ONE `## Status` section, updated in place.** +**Scope: this is the shared parity methodology, not one example's.** The ladder (§1), roles/ +tiers/dependency-gating, workflow policy, run-length budget, and mechanism reference (§3) are +**example-agnostic**. The async_cifar10 rung catalog (§2) is the reference instance; a second +example appends its own rung catalog rather than forking the method. **fwdllm** (forward-gradient, +variance-gated dynamic-K FL) is catalogued in **§F** — its build plan lives in +`examples/fwdllm/simulate_fwdllm.md`, which references §F for rung definitions. + **Comparator — give two run dirs, get a report JSON:** ```bash cd lib/python/examples/async_cifar10 @@ -702,3 +709,103 @@ refl overriding. | S | refl exploitation | FIXED: was deterministic top-k; now fork's cut_off_util-weighted `np.random.choice` | | D7 | UCB temporal-uncertainty `time_stamp` | **FIXED (Jun 23, §S.temporal).** Reference Oort+REFL: `sc += sqrt(0.1·log(round)/time_stamp)`, `time_stamp=self.epoch` (agg round of last RECEIPT), init at registration → never None, always contributes, up-weights under-selected/slower-returning clients. flame bug: refl's term was DEAD (0/7513) — `refl_oort.select()` let it divide by a None `time_stamp`; oort used last-SELECTED (dispatch round) with a None→0 guard. **Fix:** `PROP_LAST_RETURNED_ROUND` stamped at every receipt (fresh+stale) in oort/top_aggregator = agg round; selector reads it, registration-init lazy to current round; both oort+refl. `enable_temporal` kwarg (default True; False = ablation only). The legacy last-SELECTED machinery (`_record_last_selected_round`, D5) is REMOVED from OortSelector (no baseline used it); D5's MODEL_VERSION value was for staleness, not this UCB term. felix AsyncOortSelector is a separate class — untouched. | | D8 | `pacer()` round_threshold adaptation | **FIXED (Jun 24, §S.pacer).** Reference (`oort.py:184-199`) makes TWO symmetric moves on the exploited-utility trend: FLAT `|Δ|≤0.1·last` → `round_threshold += pacer_delta`, SHARP `|Δ|≥5·last` → `round_threshold = max(pacer_delta, −pacer_delta)`, keyed on `training_round`. flame's base `OortSelector.pacer()` raised on ANY dip (`last > curr`) with NO decrease branch → monotonic ratchet to 100, noise-sensitive → sim/real `round_threshold` diverged & back-half-compounded (the oort §S.pacer root). **Fix:** faithful both-branch port keyed on the current round, `pacer_step>0` guard; `REFLOortSelector.pacer` override (already faithful) REMOVED so oort+refl share the base; `round_threshold` added to selection telemetry. Guard `TestPacerFidelity`. **Cross-checked vs the REFL fork too** (`third_party/REFL/thirdparty/oort/oort.py`:176-201, byte-identical pacer, only round_threshold=30 default differs). **felix `AsyncOortSelector` (separate class) had the SAME bug + fired the pacer on its eval hand off a stale round → ALSO fixed** (faithful two-branch, train-gated; `test_async_oort_pacer_faithful`); changes felix dynamics → re-validate its 46/46 next run. | + +--- + +## §F FwdLLM extension -- variance-gated dynamic-K (forward-gradient FL) + +The method above (§1-§5) is example-agnostic; this is fwdllm's rung catalog. Rungs not +redefined here are inherited from §2 unchanged. `[NEW]` = to implement. The fwdllm build plan +(staged implementation, files, exit criteria, design decisions) is +`examples/fwdllm/simulate_fwdllm.md`; this section is the rung reference it points at. + +### §F.1 How FwdLLM differs (drives every new rung) +- **Aggregates GRADIENTS (JVPs), not weights.** Trainers send forward-gradient estimates; the + aggregator accumulates them into `grad_pool` and applies a server-LR SGD step at commit. + Gradient **values** depend on real GPU compute (run for real in sim) -> mode-invariant given + identical input + perturbation seed. What differs across modes is **which** gradients arrive, + **in what order**, against **which model version** = clock + selection + ordering fidelity. + This is what makes the §2 ladder applicable to fwdllm at all. +- **Commit cadence is ENDOGENOUS (variance-gated dynamic-K).** At each `_agg_goal` (=K) boundary, + `aggregate()` computes `var`; `var <= var_threshold` -> **commit** (server step, eval, + `data_id += 1`, `model_version += 1`, clear `cached_v`); else **roll back**, push grads to + `cached_v`, `iteration_per_data_id += 1`, **retry the same data_id**; + `max_iterations_per_data_id` force-commits despite a failed variance gate. So + updates-per-`model_version` is a **random variable** of the gradient-variance trajectory -- the + `model_version` clock is not a fixed function of update count. A round is the outer loop over + data bins; `_round += 1` only when `data_id == total_data_bins` (=150). +- **Dynamic K and C.** `DynamicKCController.step(metrics)` may change K (`_agg_goal`) and C + (concurrency) from observed metrics (var-pass ratio, eligible-ends) after each agg-goal cycle. +- **Eval per variance-pass.** `eval_model()` runs on **every** committed data_id, not a fixed + schedule; its modeled delay must be stamped separately (a stale-eval `sct` past-dates the clock). +- **Progress axis is `data_id`** (committed variance passes), not raw update count -- all + throughput/terminal rungs re-key to `data_id`. + +> **Crux:** in async_cifar10 clock and commit-count are loosely coupled; in fwdllm the commit +> (model-version) cadence is a *feedback function of gradient variance over the accumulated pool*. +> The sim must reproduce not just **when** updates arrive (clock) but the **variance trajectory** +> gating each commit. Variance is mode-invariant **iff** the contributing set + order + +> model-version of gradients matches -- reducing fwdllm parity back to clock + selection + ordering +> parity, **plus** a new variance-cadence verification layer (§F.4). + +### §F.2 Baseline matrix (fwdllm) +Filled from the landed `examples/fwdllm/expt_scripts/*_n10_smoke.yaml`. Maps onto the +async_cifar10 availability taxonomy (`avail_select_filter` / `proactive_inflight_evict`, +Unavailability §Baseline matrix). + +| baseline | sync/async | selector | agg | tracking_mode / avail | reselection | K (agg_goal) | dynamic_kc | +|---|---|---|---|---|---|---|---| +| **fluxtune** | async | `async_oort` | fedbuff (+server LR, JVP) | `client_notify` (3-tier, mobiperf_3st_50) | -- | 3 | disabled (fixed K/C) | +| **fwdllm** | sync | `random` | fedavg | `default` (unaware) | per-round | 10 (=c; all selected required) | -- | +| **fwdllm_plus** | sync | `random` | fedavg | `oracular` (`_metadata`, mobiperf_2st) | per-iteration (`reselect_each_iteration=True`) | 2 | -- | + +Decides scope: Stage 3 oort rungs (Sx/Sd/S2) run only for **fluxtune** (`async_oort`); the two +`random`-selector baselines skip them. Stage 5 sync-barrier rungs run for **fwdllm**/**fwdllm_plus** +(sync); fluxtune streams per-message. `client_notify` (fluxtune) is async_cifar10's deferred Stage-H +tracking model -- see simulate_fwdllm.md decision D1. + +### §F.3 Modified rungs (async_cifar10 meaning -> fwdllm redefinition) +| ID | async_cifar10 | FwdLLM redefinition | +|---|---|---| +| **K3a** | K-th fastest async commit advance | advance of `model_version` **per committed data_id** (clock delta between successive **variance passes**) | +| **K3b** | overhead residual ~= 0 | same, measured on the **variance-pass** boundary | +| **K2** | model versions / vsec | **committed data_ids / vsec** (throughput of *successful* variance passes) | +| **U3** | version gap at commit | gap of each contributing gradient vs `model_version` at the cycle it lands -- spread across **multiple iterations per data_id** | +| **K8 / U2** | @ matched model_version | @ matched **data_id** (the meaningful progress axis) | + +### §F.4 New rungs -- the variance-cadence layer (the fwdllm prize) +Append-only, deps let the engine localize. Never fix an EMERGENT rung directly (§1): walk down to +the lowest variance-cadence rung whose inputs are matched. + +**Stage 6' -- Variance-gated aggregation cadence** (dep Stage 5 ordering + Stage 1 clock) + +| ID | Check | Role/Tier | Isolates | Dep | +|---|---|---|---|---| +| **V1** `[NEW]` | iterations-per-data_id dist (realized dynamic K) | MECHANISM/DIST | # accumulation cycles to pass variance => contributing set/order diverged | U5,U4 | +| **V2** `[NEW]` | per-cycle `var` trajectory (at each agg-goal) | MECHANISM/DIST | variance *signal* diverges with matched inputs => grad-pool composition/order differs | V1 | +| **V3** `[NEW]` | `cached_v` pool size over time | MECHANISM/DIAG | rollback/cache bookkeeping diverges | V1 | +| **V4** `[NEW]` | force-commit freq (`max_iterations_per_data_id` bypass rate) | MECHANISM/DIST | cap hit at a different rate => chronic variance divergence | V1 | +| **V5** `[NEW]` | variance-pass ratio per window | EMERGENT/DIST | rollup feeding DynamicKC | V1,V2 | + +**Stage 3' -- Dynamic K/C trajectory** (dep Stage 3 selection + V5) + +| ID | Check | Role/Tier | Isolates | Dep | +|---|---|---|---|---| +| **DK1** `[NEW]` | K (`_agg_goal`) trajectory | MECHANISM/DIST | DynamicKC sees different metrics => K diverges (feeds back into cadence) | V5 | +| **DK2** `[NEW]` | C (`dynamic_c`) trajectory | MECHANISM/DIST | concurrency target diverges | V5,S3/4 | +| **DK3** `[NEW]` | eligible-ends-count metric fed to policy | CONTROL/DIST | the policy *input* differs (fix input, not policy) | A2 | + +**Stage 7' -- Forward-gradient quality** + +| ID | Check | Role/Tier | Isolates | Dep | +|---|---|---|---|---| +| **G1** `[NEW]` | per-update grad/JVP norm or SNR dist | EMERGENT/DIST | grad *quality* diverges (should be ~mode-invariant; FAIL = perturbation seed/order leaked) | S2,T_gpu | +| **G2** `[NEW]` | grad_pool size at commit (realized contributions) | EMERGENT/DIST | rollup of V1 x K | V1,DK1 | + +> **Decomposition:** `K2`(throughput)x but `K3a`(per-pass advance)ok -> clock fine, commit count +> diverged -> walk to V1/V5. `V1`x + `V2`ok-given-matched-input -> the *inputs* to variance differ +> -> walk to U5/S2. `V2`x with V1 inputs matched -> a true grad-pool accumulation-order bug. +> **DynamicKC coupling:** validate DK3 (policy *input*) before DK1/DK2 -- a diverging input means +> fix the metric, not the policy (CONTROL before MECHANISM). `var_threshold` / +> `max_iterations_per_data_id` are **baseline-defining config knobs, not parity levers** -- a +> cadence gap is always an upstream set/order/clock divergence. diff --git a/lib/python/examples/async_cifar10/UNAVAILABILITY_DESIGN.md b/lib/python/examples/async_cifar10/UNAVAILABILITY_DESIGN.md index c89361578..10177ea23 100644 --- a/lib/python/examples/async_cifar10/UNAVAILABILITY_DESIGN.md +++ b/lib/python/examples/async_cifar10/UNAVAILABILITY_DESIGN.md @@ -1,318 +1,283 @@ -# Sim Unavailability — Design & Staged Plan +# Sim Unavailability -- Design & Remaining Work -**Status:** design settled (all open questions resolved Jun 25); implementation NOT started. -Pickup-ready reference for adding trainer **unavailability** to the high-fidelity async_cifar10 -sim — and the template for the same feature in fwdllm ([simulate_fwdllm.md](../fwdllm/simulate_fwdllm.md) §7). +Design + status for modeling client **unavailability** in the FLAME FL simulator. The mechanism is +built and landed across all six async_cifar10 baselines; **felix is confirmed at full parity**. This +doc now carries mostly **open items + next-steps**; landed history is collapsed to pointers (full detail +in git). The fwdllm port has its own plan in +[../fwdllm/simulate_fwdllm.md](../fwdllm/simulate_fwdllm.md) (parity rungs in +[PARITY.md §F](PARITY.md)). -**Prerequisites (read first):** [PARITY.md](PARITY.md) §1–§2 (the causal ladder, role/tier tags, -dependency gating) and its §3 mechanism reference (`_vclock`, §3.drain, §3.resid, §4.5/§4.9, §S.dur). -This feature extends that ladder; every new rung and mechanism below assumes that vocabulary. +--- -**Goal:** let trainers drop in/out of `AVL_TRAIN` / `AVL_EVAL` / `UN_AVL` per their traces inside -the sim, emitting correct client-side notifications on the **virtual clock**, without (a) breaking -the parity already won at 100% availability, (b) a per-tick MQTT broadcast storm, or (c) -frozen-clock deadlocks. +## Status (Jul 2) -- felix CONFIRMED, fedbuff blocked, cross-baseline validation pending + +- **felix: FULL PARITY, 62/62 enforced checks** (live n=300 syn_50, `--runtime-s 3150`). Clock/timebase, + availability composition, selection, dispatch/training phases, staleness, and outcomes all PASS; real + self-stops cleanly (`"stopping run"`, no external kill, no `SIM_WALL_CEILING`). This is the reference + baseline the project set out to validate -- essentially PR-ready on its own. +- **fedbuff: NOT yet trustworthy.** Its run from the same campaign was **confounded** by a concurrent + felix-real run: fedbuff-real's per-round pacing collapsed ~3 min after felix-real launched (5-10s/round + -> 40-80s+/round) while felix-real stayed steady. The two ran on **separate nodes** with flat RAM / 0% + GPU on fedbuff's node, so it is **not** local CPU/GPU/RAM contention -- leading suspects are a shared + MQTT broker under ~600 concurrent real trainer connections, a shared network path, or shared + storage/telemetry-write contention. Not yet root-caused. + +### Next steps (this workstream) +1. **fedbuff shared-resource investigation** -- root-cause what collapsed fedbuff-real's pacing when + felix-real started despite separate nodes (broker / network / storage). Do this before a blind re-run. +2. **fedbuff isolated re-run** (+ sim) once understood, or at minimum confirmed no other n=300 real run is + active anywhere in the shared environment during its window; re-check parity. +3. **PR scoping** -- felix is PR-ready (62/62, clean self-stop). Decide whether to scope the PR to felix + now and follow up on fedbuff, or hold for both per the standing "land baselines together" agreement. + +### Next steps (parallel branch -- can proceed independently, merge fixes back as they land) +Exhaustive cross-baseline validation is **not** a blocker for landing the substrate. On a parallel branch, +run the full parity campaign for **oort / oort_star / refl / feddance** across **syn_0 / syn_20 / syn_50 / +mobiperf**, sim+real, at n=300; resolve the still-open §7 rows; fixes merge back into `dg-fork-main` as +they come. See "Open items" for the ordered gates (legacy `trackTrainerAvail` cleanup, mobiperf live +exercise) and PARITY.md's run-length budget. --- -## 0. What already exists (design *with* the grain) +## Preamble -- what this is + +**Goal.** Model client *unavailability* (devices dropping offline mid-training) so a fast **simulated** +run (virtual clock, no real sleeps) reproduces what a **real** run (wall-clock, MQTT, true delays) does -- +**sim/real parity** -- for every baseline, **config-gated and default-OFF** (byte-identical to today when off). + +**What was built (v1).** A shared availability substrate (`flame/availability/trace.py` + +`ClientAvailability`) mixed into the syncfl base and inherited by asyncfl/oort, so all baselines share one +trace-read effect path: +- **Send-time gate, deliver-late-stale.** A trainer that goes UN_AVL mid-flight *keeps computing*; its + upload is gated at send-time (real) / buffered to `delivery_ts = max(sct, next_avail)` (sim) and + committed later as a stale update. Nothing is cancelled or dropped. +- **Two ledgers, never conflated.** Slot ledger (90s vclock *abandon* frees the in-flight slot) + delivery + ledger (`pending_withheld[end]=delivery_ts`, commits through the existing staleness gate). +- **Proactive in-flight eviction** -- **felix only** (the one fully-aware baseline): frees a slot the trace + shows UN_AVL at the next selection boundary, no 90s wait. +- **Starvation / vclock-advance under scarcity.** When the eligible pool is too small to start a round, sim + advances the vclock to the next availability transition instead of spinning (self-terminating, B2.0.2). +- **Absolute (vs. ground-truth-trace) fidelity checks** on top of the relative (real-vs-sim) ones: A6 + (trainer state), A7 (aggregator belief, per selection/commit checkpoint), A8 (send-gate wait), K11 + (commit promptness). Relative checks answer "do the two modes agree?"; these answer "is either one + *correct*?" -- shared `scripts/parity/ground_truth.py`, one canonical trainer<->aggregator time origin. +- **Parity ladder** (`scripts/parity/`) -- availability rungs A1/A3/A4/A4dur/A5/A6/A7/A8/K11, + withheld_delivery, abandon_timeout, starvation_advance, eligible_pool_reduction. + +**Two orthogonal axes per baseline (keep separate).** +1. **Knowledge at selection** (`avail_select_filter`): does the selector read the trace to avoid + *selecting* currently-UN_AVL trainers? aware = yes, unaware = select blind. +2. **In-flight slot-free timing** (`proactive_inflight_evict`): when a *dispatched* trainer goes UN_AVL + mid-round, free its slot at the next boundary (proactive, felix only) or wait the 90s vclock abandon + (reactive-90s, everyone else). Aware-at-selection != in-flight eviction. + +The knowledge *model* is **trace-read** for all v1 baselines; message-transport (`client_notify`) and +predictive models are **Stage H** (future). + +--- + +## Working agreement (standing -- read every session) + +1. **Common first, one baseline first.** Land shared/library changes once, drive a single reference + baseline; don't fan out until it behaves. +2. **Short runs to debug, long runs to confirm.** Gate on unit tests + syn_0 byte-identity + shortest + syn_20 smoke. Long runs confirm; never find first bugs. +3. **Local deterministic tests before runs.** Prefer a synthetic-trace pytest that exhibits the bug over a + long run that hunts for it. +4. **Keep this doc crisp.** Completed stages: mechanism + where it lives + exit (2-3 lines). Full detail + only for active/next; dead-ends in §6. +5. **No stale content.** The moment a section is superseded -- a bug fixed, a task landed, a prediction + resolved, a next-step taken -- collapse it to a 2-3 line note (or delete) **in the same edit**. +6. **Whole-doc crisp pass on every edit.** Re-read top to bottom and push down anything the new result also + supersedes. The top of the doc carries only **open issues** + **next steps**; run commands, wall-time + estimates, and per-run hypothesis tables for finished work belong in raw logs. + +--- -The tree already has **three** availability paths; the 100%-avail runs left them dormant -(`trainer_event_dict`/`trainer_unavail_durations` default `None`). Reconcile these, don't add a fourth. +## Baseline matrix (CANONICAL) + +| baseline | sync/async | agg base / entry | knowledge @ selection (`avail_select_filter`) | in-flight slot-free (`proactive_inflight_evict`) | config-gate (as run) | +|---|---|---|---|---|---| +| **felix** | **async** | `asyncfl` (<- syncfl) / `main_asyncfl_agg.py` | aware | **proactive** (felix only) | `simUnavailability` | +| **fedbuff** | **async** | `asyncfl` / `main_asyncfl_agg.py` | unaware | reactive-90s | `simUnavailability` | +| **oort** | **sync** | `oort/top_aggregator` / `main_oort_sync_agg.py` | unaware | reactive-90s | `simUnavailability`+ | +| **oort_star** | **sync** | `oort/top_aggregator` / `main_oort_sync_agg.py` | aware | reactive-90s | `simUnavailability`+ | +| **refl** | **sync** | `syncfl` FedAvg / `main_fedavg_agg.py` | aware | reactive-90s | `simUnavailability`+ | +| **feddance** | **sync** | `syncfl` FedAvg / `main_fedavg_agg.py` | aware | reactive-90s | `simUnavailability` | + ++ oort/oort_star/refl's `baselines.yaml` catalog entry still carries the legacy `trackTrainerAvail: +{enabled: True, type: ORACULAR}` block (pre-dates this project). In every `debug_run.sh --trace`-launched +run the substitution sets `simUnavailability=True` for them too, so they run the same modern path. The +legacy block only matters if the parity YAML is loaded *without* that substitution -- untested territory, +and the reason it isn't cleaned up yet (removing it risks silently disabling availability in that path). +See Open item 1. + +**Notes.** (1) `ClientAvailability` lives in `flame/availability/client_availability.py`, mixed into +`syncfl/top_aggregator.py` (`class TopAggregator(ClientAvailability, Role)`); asyncfl/oort extend it -- all +six share the substrate. (2) trace-read is v1; the knowledge model becomes message-transport / predictive +in Stage H, but the select-filter / in-flight-evict *behavior* is unchanged. (3) **felix is the only +baseline that de-selects an in-flight trainer** when it goes UN_AVL; the aware-at-selection-only baselines +still hit the 90s abandon for mid-round drop-offs. + +### Flag reference +- `avail_select_filter: bool` -- selector excludes currently-UN_AVL trainers from the **selection** pool + (`get_curr_task_ineligible_trainers`). ON: felix/oort_star/refl/feddance. OFF: oort/fedbuff. +- `proactive_inflight_evict: bool` -- gates `_sim_evict_unavail_inflight` (in-flight boundary eviction). + ON: **felix only**. OFF: everyone else (reactive-90s). +- `tracking_mode` -- knowledge-model axis: `trace_read` (v1, live) | `client_notify` (Stage H) | + `predictive` (future). Replaces the `oracular` value at concept/log level (YAML field *value* compat kept). -| # | Path | Where | Time-base | Drives | -|---|---|---|---|---| -| **A. Agg pull (event trace)** | `get_curr_unavail_trainers()` binary-searches each trainer's `trainer_event_dict` (SortedDict `ts→state`) | syncfl/oort/asyncfl top_agg | `_vclock.now` (sim) / `time.time()−agg_start` (real) | `channel.set_curr_unavailable_trainers` at selection | -| **B. Agg pull (duration windows)** | `oracular_trainer_avail_check(end)` tests `trainer_unavail_durations[end]` `(start,dur)` | `asyncfl/top_aggregator.py:1264` | same | per-pick veto | -| **C. Trainer push (notifications)** | `check_and_update_state_avl` pops trace events → `channel.update_trainer_state` → backend → `Channel.update_state` (evicts `UN_AVL` / `AVL_TRAIN→AVL_EVAL` from `selected_ends`) | `trainer/pytorch/main.py` + `channel.py:1056` | `_sim_now()` = last dispatch `_sim_send_ts` (sim) / wall (real) | MQTT message | +--- -**Two anchoring facts:** -1. **A/B already key on `_vclock.now` in sim** (comment at `asyncfl/top_aggregator.py:1264`: - *"wall-clock would barely advance vs the sim timeline, so every unavailability window would be - missed"*). Aggregator-pull on the virtual clock = the no-comms, deterministic, never-freezes path. -2. **C has a frozen-clock defect in sim:** `_sim_now()` returns `_sim_send_ts`, which only updates - when the trainer is *dispatched*. An unselected trainer never advances → never pops events → never - notifies; a trainer that goes `UN_AVL` can't be selected → can't advance → **stuck `UN_AVL` - forever**. So C cannot be the source of truth for *selection* in sim until this is fixed. +## v1 core decisions (resolved -- durable reference) + +- **Knowledge model:** trace-read for all; one shared trace + `state_at(trainer, vclock)` + one effect path. +- **Mid-flight UN_AVL = compute-completes, gate the send, deliver-late (stale).** Real: gate at send-time. + Sim: buffer at `delivery_ts = max(sct, next_avail_ts)`. +- **Two ledgers, never conflated:** slot ledger (frees `selected_ends`) + delivery ledger + (`pending_withheld`, commits stale through the staleness gate). Order commits by `(delivery_ts, end_id)`, + never `sct`. +- **Busy != unavailable != withheld** -- three distinct non-pool states. Never route busy->UN_AVL. +- **All availability time on the vclock in sim.** Never wall, never a frozen per-trainer clock. +- **Config-gated, default OFF** => byte-identical. `simUnavailability` is the gate for all 6 baselines as + run (see Baseline matrix + note). +- **availability state** (`AVL_TRAIN/AVL_EVAL/UN_AVL`) x **busy?** x **has in-flight update?** are + orthogonal. `syn_0/20/50` are 2-state (no AVL_EVAL); `_trace_has_avl_eval` guard collapses D.2 for them. --- -## 1. Core decisions (all resolved) - -### The source of truth is PER-BASELINE — the asymmetry IS the design -- **Availability-UNAWARE (oort, refl):** real trainers go unavailable and **do not notify**; the - oracular aggregator **reads the traces**. So **A/B are the FAITHFUL model here, not a shortcut** — - real oort has no notification channel. The oracle gates **new selection only** (Q-new-1): it never - proactively evicts an in-flight trainer (it has no way to know), it just waits for the withheld - update to arrive on return. -- **Availability-AWARE (felix, fluxtune):** the aggregator does **not** read traces; it is informed - by **trainer→agg notification events** that **must take effect immediately** at the aggregator and - factor into selection AND `selected_ends`. So **C is the faithful model here**, with the - frozen-clock defect fixed. -- **One trace + one `state_at(trainer, vclock)` resolver + one effect path** shared by both, so - "what the agg believes" and "what the trainer is" cannot disagree. The only per-baseline difference - is *how the agg learns* a transition (oracle read vs event) and *whether* it acts on it (`awareness` - flag). **agg awareness** (does it factor availability in?) is orthogonal to **how it learns**. - -### Stop-gap for the aware path (Q4) -Model the aware event as **instant oracular reflection at the agg** (agg reads the shared trace on -the vclock at the transition instant, zero lag — behaviorally equal to instant push for selection). -**End goal = the true `avl_*` trainer→agg message.** Architecture must keep the -state-resolution + effect logic identical so the future swap changes only *transport*, not *effect* -(extensibility is a hard requirement). Per-tick broadcast (agg pings everyone each step) is -**rejected** (comms-heavy, induces sub-optimal decisions). - -### Mid-flight unavailability = COMPLETE-then-WITHHOLD-then-DELIVER (not a lost update) -When a trainer goes `UN_AVL` mid-compute it **finishes local compute, withholds the result, and -delivers it (now stale) on return to an available state.** Delayed delivery, not cancellation: -- Sim holds the completed update at `sct` but gates *delivery* on the next `AVL_*` window: - **`delivery_ts = max(sct, next_avail_ts)`**; it commits as a **stale** contribution (feeds - Stage-5/6 staleness, not a lost-update path). -- **AWARE agg:** on the `UN_AVL` event, **frees the slot** (replacement selectable) AND **tracks the - pending withheld delivery separately** (two ledgers — see Challenge 4). -- **UNAWARE agg:** no replacement; just waits for the delayed delivery. -- Late withheld update on return (Q-new-2): **async aware (felix) = accept-stale** through the - baseline's existing staleness path; **sync (feddance) = reject if staleness exceeds the baseline's - (lower) tolerance** — reuse the existing threshold, do NOT invent a new scalar. -- **Distinct from "busy"** (PARITY.md dead-end: do NOT route busy→`UN_AVL`). Busy = `AVL_*` but - occupied (hold slot, returns on time). Withheld = result exists, delivery deferred. Separate states. - -### Timing, comms, determinism -- **Transitions are continuous / event-scheduled at the exact transition vclock**, reflected at the - aware agg **immediately (lag = 0 first cut)** — not sampled-at-selection (a mid-round transition - must take effect mid-round). The clock-advance/commit path must consult the **next transition time** - so it can't skip a mid-window change: clamp the advance to `min(next_sct, next_transition_ts)`. -- If lag is ever modeled it lives on the **vclock** (per the §S.dur lesson: selector-fed quantities - must be intrinsic, never wall-contaminated). -- Oracular-pull is deterministic given trace+clock. The event path stays deterministic too (first cut - = instant oracular reflection); the true-message path must order events by vclock with a defined - tie-break to preserve `SEED=1234` real+sim parity (Challenge 6). -- **Everything config-gated, default OFF** ⇒ byte-identical to today's 46/46 scoreboard. Per-baseline - `availability_aware: bool` + `availability_trace: ` + master `sim_unavailability` gate. - -### Trace representation -- Collapse to **one event-trace representation** (`AVL_TRAIN/AVL_EVAL/UN_AVL`, strictly more - expressive than duration-windows; derive windows if a path still needs them). **Prefer 3-state - traces**; 2-state ({avail, unavail}) is allowed but **limited-utility for aware baselines** - (felix/fluxtune act on the `AVL_TRAIN↔AVL_EVAL` task-type split a 2-state trace collapses; oort is - indifferent). Surface trace granularity in telemetry. -- Single-source the trace + resolver like `client_duration.py` was single-sourced in §S.dur; both the - trainer side (transitions/telemetry) and agg side (oracular driver) read the identical object. - Traces (`mobiperf_2st/3st`, `syn_0`=100%, `syn_20`, `syn_50`) cover all n=300, loaded identically - both sides (Q-new-3). +## Parity rungs (availability tier -- what exists) + +- **A1** `avail_composition` (per-state counts, binned). **A3** `trace_time_base_consistency` -- CONTROL + hard gate (dep K3). **A4** `per_trainer_duty_cycle`. **A4dur** duration-weighted TVD + (`mean_err<=0.05`, `frac_within_tol(0.10)>=0.95`). **A5** `state_timeline_agreement` -- per-(trainer,t) + exact match. All five are **relative** (real vs sim). +- **A6** `trainer_trace_fidelity`, **A7** `agg_belief_fidelity` (tagged `selection`/`commit`), **A8** + `send_gate_wait_fidelity` (real-mode only) -- **absolute** (vs. ground-truth trace), independently per + mode. A7 is mechanism-agnostic (trace_read now, client_notify/predictive later). +- **K11** `commit_promptness` (INV) -- per-event: actual commit vs. earliest-legally-committable time, + generic over gate reason; primary promptness gate. `withheld_delivery` / `abandon_timeout` stay as + secondary distributional diagnostics. +- **eligible_pool_reduction** (`Aa`, HELD), **observation_lag** (live in v1 trace_read via A7), + **starvation_advance** (vclock jumps under scarcity). Calibrate HELD rungs at mobiperf. +- **Ramp:** syn_0 -> syn_20 -> syn_50 -> mobiperf_*. --- -## 2. First-principles factors (the why behind each decision) - -- **F1 Clock authority.** One monotonic vclock owns "now"; every availability decision is indexed by - it, never wall, never a per-trainer frozen clock. The trace is **sim-seconds since run start**; sim - (vclock) and real (wall-elapsed) must index the SAME windows — this is parity rung **A3** (the REFL - HIGH-1 hazard), a CONTROL for the whole feature. -- **F2 Source of truth** — per-baseline (§1). Both models share one trace + one resolver + one effect. -- **F3 Event semantics (what a transition CAUSES).** `→UN_AVL` aware: excluded from selection AND - freed from `selected_ends`/`all_selected` (`channel.update_state`), in-flight update withheld not - discarded. `→UN_AVL` unaware: agg waits (no proactive free). `AVL_TRAIN→AVL_EVAL`: train-pool - removal, eval-eligible only. `→AVL_TRAIN`: re-enters pool + triggers withheld delivery. The driver - must produce these effects deterministically at the transition instant, not merely filter the next - selection. -- **F4 Withhold-then-deliver** (§1). Return-stage fates: on-time / straggler-hold / withheld-then- - delivered. NO permanent cancellation. `_sim_hold_busy_slots` and oort `pending_after`/carry-over - must keep a withheld end accounted until its delayed delivery commits. -- **F5 Comms** — unaware: zero (oracular pull); aware: bounded by # real transitions (instant - reflection first cut), per-tick broadcast rejected. -- **F6 Timing** — continuous/event-scheduled, lag 0 first cut (§1). -- **F7 Regression surface (won mechanisms).** §3.resid `_sim_hold_busy_slots` (aware frees slot + - tracks pending; unaware holds until delivery); §4.5 `pending_after` / §4.9 carry-over (withheld end - must NOT re-enter pool during the down window, but its delivery must still commit, stale); §S.pacer - /§S.dur/A2c selector inputs (fewer candidates move the `pref` percentile — expect A2/S2/A2c shift; - score only genuinely-eligible trainers); per-baseline return stages each gain a "trainer vanished" - branch. All config-gated ⇒ default-off keeps byte-identity. -- **F8 Determinism** — oracular-pull seed-stable; event path ordered by vclock (Challenge 6). -- **F9 Trace** (§1). -- **F10 Starvation.** `oort/top_aggregator` already has a `max_retries` wait-retry for too-few- - available; under real unavailability it fires. In sim the wait must **advance the vclock** (jump to - next availability event / next in-flight `delivery_ts`), not spin on wall (Stage F). +## Challenges / land-mines (durable -- consult before the fwdllm port) + +Most are resolved; the still-open ones (3, 15) matter for cross-baseline validation and the port. + +1. Ordering on `delivery_ts`, not `sct` -- resolved (U6/U3 validated). +2. A3 time-base drift -- resolved; hard CONTROL gate; 90s abandon re-clocked to vclock. +3. **A2 two-tolerance trap (OPEN, watch).** Bimodal sim vs smoother real -> KS shape artifact; means match; + improving with run length (0.437->0.338). Expect <=0.2 at n=300/3h -- confirm at T5. +4-14. Resolved: busy/unavail/withheld three ledgers (4); real send-gate fidelity (5); determinism via + `(delivery_ts,end_id)` (6); compound straggler x UN_AVL (7); AVL_EVAL inert for oort + `_trace_has_avl_eval` + guard (8); staleness-on-sync cohort movement (9); scarcity advance skips no events (10); syn_0 + byte-identity discipline (11); library mixin spans examples, never example-local (12); empty per-task + pool corrupting `selected_ends` -- fixed by keying cleanup off `connected_ends` in all 3 selectors, + **still needs live mobiperf_3st exercise** (13); scarcity threshold via F.2 unified pattern (14). +15. **Per-baseline in-flight accounting + scenario sizing (OPEN, per-baseline).** In-flight is NOT constant: + oort (sync, over-selects) `in_flight ~= overcommitment*agg_goal - completed`; felix/fedbuff (async) + concurrency-bound, can exceed agg_goal; refl/feddance (sync FedAvg) clear `selected_ends` each round, + feddance returns *partial* selections so `eligible ~= (1-unavail)*n`. Manage in-flight per baseline; do + NOT assume "sync has no in-flight term." syn_50 caps ~43% unavail, so feddance's straddle window is + narrow (n~19) -- size `n ~= threshold / (1-unavail_frac)`. +16-18. Resolved: real syncfl recv-barrier bounded `timeout=min(90s,budget)` (B2.0.1, 16); sim starvation + self-termination `>`->`>=` budget check (B2.0.2, 17); real-mode trace-clock join-ramp re-anchor + (B2.0.3, 18) -- correct, but was masking item 20. +19. Resolved (Batch 4): oort/felix `K6 sim_send_ts` -- sim `Trainer._sim_now()` froze at last dispatch; + fixed via due-ts stamping + EOT final wake-up. K6/A6 PASS on the felix n=300 run. +20. Resolved (Batch 3 T3.1a): `debug_run.sh` never wired the trainer's own `client_notify.trace`, so real + trainers ran their send-gate against always-available `syn_0` regardless of `--trace` (sim was + aggregator-driven, so unaffected). Fixed + regression-tested + (`tests/launch/test_debug_run_trace_substitution.py`). This was the true cause behind the feddance A3/K3b + symptoms earlier blamed on clock-origin. --- -## 3. Concepts to keep crisp (naming discipline, PARITY.md) +## Dead-ends (settled -- do not retry) -- **availability state** (`AVL_TRAIN/AVL_EVAL/UN_AVL`) × **busy/occupied?** × **has in-flight update?** - — three orthogonal axes, never conflate (the busy→UN_AVL dead-end). -- **transition instant** (vclock the state changes) vs **observation instant** (vclock the agg acts); - lag = observation − transition (0 if continuous). -- Return fates: on-time / straggler-hold / withheld-then-delivered (stale). No cancellation. -- **agg awareness** ⊥ **how it learns** (oracle read vs event message). -- `_sim_now()` must stop meaning "last dispatch ts" — availability reads the **global vclock** (or is - fully agg-driven so the trainer never needs `_sim_now` for it). +- **busy -> UN_AVL routing** -- three distinct states. +- **Frozen per-trainer clock** (`_sim_now()` = last-dispatch ts) -- stuck UN_AVL forever; read `_vclock.now`. +- **Wall-clock in sim** for selection gate / 90s abandon -- wall barely advances vs vclock. +- **Per-tick MQTT broadcast** -- comms storm; v1 = trace-read pull (zero comms). +- **Ordering withheld commits by `sct`** -- past-dating; order by `(delivery_ts, end_id)`. +- **Forking withhold/abandon per stack** -- single shared `ClientAvailability`. +- **A4 bare transition fraction** -- brittle in trace-read mode; replaced by A4dur + Aa. +- **D.2 excluding AVL_TRAIN from eval on 2-state traces** -- empty eval pool wiped `selected_ends`; fixed by + `_trace_has_avl_eval` guard. +- **Subtracting starvation vclock-jumps from the budget** -- breaks parity (real polls scarcity on wall + budget; sim vclock jump consumes virtual budget symmetrically). Size `--runtime-s` accordingly. --- -## 4. New parity rungs (Stage 2 = Availability; extend the ladder) - -Each new mechanism leaves the finest-grained check that localizes it (PARITY.md Growth rule). -- **A1 avail_composition** (exists, trivial at 100%): now match per-state counts over the run, binned. -- **A3 trace_time_base_consistency** `[NEW]` (CONTROL/DIST, dep K3): same trace → same windows both - modes. **Hard gate — do not read A1/A2/A4 until A3 passes** (the REFL HIGH-1 / Challenge 2 lesson). -- **A4 per_trainer_duty_cycle** `[NEW]` (MECHANISM/DIST, dep A3): on/off fraction per trainer matches. -- **transition_effect** `[NEW]`: counts of UN_AVL slot-frees (aware), withheld-then-delivered updates, - AVL_TRAIN→AVL_EVAL demotions; sim vs real. -- **withheld_delivery** `[NEW]`: dist of `delivery_ts − sct` (down-window delay) + resulting staleness - (cross-checks F4 against Stage-5/6 U3). -- **observation_lag** `[NEW]`: transition→effect lag (tests F6; **must be ≈0** first cut for aware). -- **eligible_pool_reduction** `[NEW]`: A2 (`num_eligible`) tracks real's reduction, not just at 100%. -- **Regression guard:** re-run the syn_0 90-min all-baseline parity with availability OFF → current - scoreboard byte-for-byte (config-gating proof). -- **Ramp:** `syn_0` (regression) → **`syn_20` (first validation target)** → `syn_50` → `mobiperf_*`. - Shortest run per effect (run-length budget table); reserve long runs for C1/C2. First mechanism pass - = 45-min "one rung" budget, 5-min smoke first. +## Known parity failures (non-blocking -- resolve at T5 with long-run data) + +Resolved this project (full detail in git / §7 history): A4dur (all baselines, real selection missing +`vclock_now` -> fixed, `mean_err=0.0`); feddance A3 (item 20); K6/A6/A7-commit/asyncfl-TIMEOUT (Batch 4, +confirmed on felix n=300). Still open, for the parallel-branch campaign: + +| Check | Baseline | Status | +|---|---|---| +| A2 `eligibility` KS | oort | 0.437->0.338 (1.5h->3h); FAILs @ syn_20 n=300 short. Bimodal-vs-smooth shape; means match. Investigate with A4dur. | +| A2 `eligibility` KS | feddance | FAILs @ syn_20 n=300 smoke; earlier "clears at n=300" (n=25) not confirmed -- re-open. | +| K3b `overhead_residual` | oort | rel~=0.116; run-length sensitive; P3 gates at n=300. | +| P3 `trainer_speed` | oort | ratio=1.153 (tol 1.15); marginal tail at n=300; gates K3b. | +| `throughput` | oort | FAILs @ syn_20+syn_50 n=300 smoke; baseline-specific, lower priority. | +| `avail_composition`/`commit_visibility`/`total_commits` | fedbuff | FAILs @ syn_20 n=300 smoke -- but see fedbuff confound (Status); re-check after isolated re-run. | +| C2 `loss` | feddance | avg_diff~=0.16 (few eval pts); early-training noise at alpha=0.1; K8/C1/utility PASS. | +| U5 `inter-arrival` rho | feddance | 0.659->0.381 (syn_20->50); watch at mobiperf. | --- -## 5. Staged implementation + testing plan - -One mechanism per stage, each gated by its own tests + a syn_0 byte-identity regression + (where it -changes dynamics) a short syn_20 run. All config-gated, default OFF. Build the **unaware** (oort, -pure pull) path before the **aware** (felix, event+eviction+withhold) path — strictly simpler, shares -the substrate. Context-free names (`_ts`/`_time_s`, `_round`). - -### Stage A — Substrate: one trace, one resolver, one clock (NO behavior change) -- **A.1** New `flame/availability/trace.py` (mirrors `client_duration.py`): `load_trace(trainer_id) → - SortedDict[ts→state]` and `state_at(trace, t) → TrainerAvailState` (the binary-search currently - inlined in `get_curr_unavail_trainers` / `oracular_trainer_avail_check` / trainer - `check_and_update_state_avl`). Replace all three call sites; collapse `trainer_unavail_durations` - onto the event-trace. -- **A.2** Config surface: per-baseline `availability_aware`, `availability_trace`, master - `sim_unavailability` (default False). `syn_0` ⇒ no UN_AVL events ⇒ inert even when on. -- **A.3** Fix `_sim_now()` frozen clock (F1/F8): trainer availability reads the **global vclock**, not - `_sim_send_ts`. Route: make availability fully agg-driven; agg stamps the current vclock onto every - message the trainer receives, trainer uses that as "now" for its notification telemetry. -- **A.4** Telemetry (on the vclock): `avail_change` (move off wall), `agg_observed_state` (per-trainer - belief at each selection), trace granularity per run. -- **Tests:** resolver determinism + parity with the old inlined searches; frozen-clock deadlock cannot - recur; `sim_unavailability=False` ⇒ byte-identical. **Exit:** syn_0 90-min all-baseline parity holds - the scoreboard byte-for-byte. - -### Stage B — A3 time-base CONTROL (gate for everything above it) -- **B.1** A3 `trace_time_base_consistency` (CONTROL/DIST, dep K3): resolved on/off windows align - between modes within tolerance. **B.2** A4 `per_trainer_duty_cycle` (dep A3). -- **Tests + a 5-min syn_20 smoke** to populate A3/A4 (checker-side, validates instantly vs stored - dirs). **Exit:** A3 PASS on a syn_20 smoke for oort. - -### Stage C — UNAWARE oracular-pull driver (oort, refl) -- **C.1** Activate `get_curr_unavail_trainers()` for oort/refl via the Stage-A resolver on - `_vclock.now` → `channel.set_curr_unavailable_trainers`. **Gates new selection only** (Q-new-1). -- **C.2** Withheld-then-deliver for the pull path: an in-flight trainer entering `UN_AVL` is **not** - evicted; its modeled update is held and delivered at `delivery_ts = max(sct, next_avail_ts)`, - committing **stale**. Held end must NOT re-enter the pool during the down window (extend §4.5 - `pending_after`: exclude on `vclock < delivery_ts`, not just `< sct`). -- **C.3** Ordering: drain/commit order must key on **`delivery_ts`** for held ends (a withheld delivery - has `delivery_ts > sct`), or past-dating reappears (Challenge 1). -- **Tests:** unaware never frees the in-flight slot; withheld delivers at `max(sct,next_avail)`, - commits stale; held end excluded until delivery; determinism. -- **Validation:** syn_20, 45-min, oort+refl. Read A1, A2 (eligible-pool reduction), A4, withheld-delay - dist + staleness (U3). **Exit:** A1/A2/A3/A4 PASS, no new past-dating (U6), K2/K3b hold vs a syn_20 - real reference. - -### Stage D — AWARE immediate-event driver (felix; fluxtune if in scope) -- **D.1** Instant reflection: at every selection AND at each transition vclock the agg recomputes - per-trainer state from the resolver (stop-gap for the push message); effect path identical to a real - `avl_*` message (future swap = transport only). -- **D.2** Continuous/event-scheduled timing (F6): advancing the vclock toward the next commit, clamp to - `min(next_sct, next_transition_ts)` so a mid-window `UN_AVL` takes effect before the in-flight `sct`. -- **D.3** UN_AVL eviction + reselect: free the slot from `selected_ends`/`all_selected` (reuse - `channel.update_state` logic), make a replacement selectable, AND register the withheld delivery - separately (`pending_withheld[end]=delivery_ts`). Reconcile with §3.resid `_sim_hold_busy_slots` — - slot freed *and* pending delivery tracked, no leak, no double-count (Challenge 4). -- **D.4** `AVL_TRAIN↔AVL_EVAL`: task-type eligibility change via the resolver; only meaningful where - the baseline dispatches eval (sync oort dispatches 0 — felix-relevant; flag inert baselines, - Challenge 8). -- **D.5** Late withheld update = accept-stale (async) through felix's existing staleness path (no new - accept path; Q-new-2 async branch). -- **Tests:** UN_AVL frees slot + tracks pending (no leak); replacement selectable; event-scheduled - clamp fires a mid-window transition before the straggler's sct; AVL_EVAL gates task type; late update - commits stale. -- **Validation:** syn_20, 45-min, felix. A1/A2/A3/A4, transition-effect counts vs real, observation_lag - ≈0, withheld-delivery, U3, U6. **Exit:** mechanism rungs PASS at syn_20; then a full-length run to - re-confirm felix C1/C2 under unavailability. - -### Stage E — SYNC baselines + staleness-gated rejection (feddance) -- **E.1** Apply C/D to the sync path (feddance is availability-aware via its predictor; barrier - re-selects the cohort each round). -- **E.2** Staleness rejection: a late withheld update exceeding feddance's tolerance is **dropped** - (baseline's existing rule, no new threshold). Changes round composition → expect K8/U2 movement; - validate it's faithful (Challenge 9). -- **E.3** §6.u6 barrier-anchor: unavailability changes which K form the barrier; the barrier-anchored - U6 lag must be computed over the *actually contributing* cohort. -- **Tests + syn_20 45-min feddance.** **Exit:** A-rungs + U3/U6 + K8 PASS. - -### Stage F — Starvation / clock-advance under scarcity (F10) -- **F.1** In the `max_retries` wait-retry, when no one is selectable, **advance the vclock to the next - availability event (or next in-flight `delivery_ts`)** rather than wall-sleeping. Clamp to the - nearest of {next transition, next `delivery_ts`, next `sct`}; guard against an all-unavailable window - spinning forever (Challenge 10). -- **Validation:** syn_50, 45-min (heavier unavailability triggers scarcity), all baselines. **Exit:** - no stalls; K1 monotone; round cadence faithful at syn_50. - -### Stage G — Ladder integration + ramp + sign-off -- **G.1** Land all new rungs in `scripts/parity/{checks.py,report.py}` with deps (A1 now enforced, A3, - A4, transition_effect, withheld_delivery, observation_lag, eligible_pool_reduction). Append-only. -- **G.2** Ramp: syn_0 → syn_20 → syn_50 → mobiperf_*. **G.3** Per-baseline sign-off, now *with* - availability. - -### Stage H (FUTURE) — true `avl_*` message transport -Swap the aware-path instant-oracular reflection for real trainer→agg `avl_*` messages, processed -immediately, **without changing the effect logic** (D.1 was built for this). Preserve determinism by -ordering events on the vclock with a defined tie-break (Challenge 6). +## Open items -- pick up in order + +1. **Legacy `trackTrainerAvail` cleanup (oort/oort_star/refl) -- flagged, NOT done.** Their `baselines.yaml` + entries still carry `trackTrainerAvail: {enabled: True, type: ORACULAR}`. In every `debug_run.sh + --trace` run this resolves to the same `simUnavailability=True` path (a substitution quirk, not a static + value). Do **not** just zero `enabled`/`type` -- that risks silently disabling availability for any + invocation not going through the substitution script. Safe path: (a) add `simUnavailability: true` + statically wherever their trace is set; (b) only then zero the legacy block; (c) verify via an actual + generation + short real run (no pytest coverage of `debug_run.sh`'s generator). +2. **Minimal mobiperf live exercise before "mature enough to port."** The entire mobiperf (3-state, + AVL_EVAL) path is untested live so far (only syn_0/20/50, which are 2-state and collapse AVL_EVAL away). + Challenge 13's fix explicitly still needs live exercise at mobiperf_3st. ~30-45 min for one async + (felix) + one sync (refl or oort_star) baseline exercises AVL_EVAL + the empty-pool cleanup live and runs + Batch 3's checks against a 3-state trace. +3. **PR workflow.** felix is confirmed (62/62). Gated for a felix+fedbuff PR on the fedbuff isolated re-run + + concurrent-run investigation (Status). The fwdllm learnings are now carried into + [../fwdllm/simulate_fwdllm.md](../fwdllm/simulate_fwdllm.md) and [PARITY.md §F](PARITY.md); the design + decisions kept (this doc's v1 decisions / land-mines) and rejected (Dead-ends) are the durable record. + +### Minimal bar before porting fwdllm (not a full T5 gate) +Don't gate the port on the full 3h x 6-baseline x 4-trace campaign (that's for paper-quality numbers). Bar: +(1) Batch 3 (T3.0-T3.5) at least through felix -- **done** (A4dur confirmed; item 20 fixed; absolute +fidelity checks live). (2) mobiperf_2st for one async + one sync baseline (~30-45 min) to exercise AVL_EVAL ++ Challenge 13's cleanup live for the first time. (3) The full syn_50/mobiperf 6-baseline sweep is +separable -- parallel branch, not a pre-port blocker. --- -## 6. Challenges / land-mines - -1. **Ordering must key on `delivery_ts`, not `sct`, for withheld updates** (high risk of - re-introducing past-dating). §3.drain's min-`sct` gate and §4.9 carry-over assume `commit order == - sct order`; a withheld delivery commits at `max(sct,next_avail) > sct`. Re-validate U6/U3 after C/D. -2. **A3 time-base drift is the silent killer.** If sim vclock and real wall-elapsed advance at - different rates, the same trace makes a trainer unavailable at different real moments → every higher - rung diverges and mislocalizes. Hard CONTROL gate; do not read A1/A2/A4 until A3 passes. -3. **Two-tolerance trap on the eligible pool (A2 vs S3/4).** With availability ON, - `eligible = candidates − in_flight − unavailable`; a small gap can fail A2's tight KS while S3/4 - in_flight passes. Decompose the channel first; don't chase A2 as a separate bug. -4. **Busy vs unavailable vs withheld = three distinct non-pool states** (slot-leak / N≈300 ramp). The - §3.resid dead-end (busy→UN_AVL) ramped in-flight to ~300. Aware UN_AVL **frees** the slot but still - **tracks** the pending delivery — slot accounting and delivery accounting are separate ledgers; - conflating them leaks slots or double-commits. -5. **Stop-gap fidelity to real felix may not be lag-free.** Real felix uses MQTT notifications with - real delivery+processing lag; the stop-gap models lag 0. If real's lag is non-trivial, - `observation_lag` parity (sim 0 vs real >0) diverges and selection contexts won't match. Measure - real's notification lag early; if material, model it on the vclock or accelerate Stage H (the §S.dur - lesson: don't let a wall lag contaminate a vclock-indexed decision). -6. **Determinism / event tie-break at a shared vclock instant.** Transition, commit, and selection - events can coincide. Define a total order (e.g. transitions < commits < selections, then by - trainer_id) so `SEED=1234` real+sim parity + exact rungs stay enforceable. -7. **Compound states with existing carry-over.** An oort §4.9 carried-over straggler that ALSO goes - UN_AVL, or a §3.resid held slot whose trainer flips AVL_TRAIN→AVL_EVAL, are real cases. Enumerate - the (avail_state × occupied × in-flight) cross-product and assert each cell in tests. -8. **AVL_EVAL may be inert for some baselines** (sync oort dispatches 0 eval). A 3-state trace's eval - windows then do nothing; report which baselines exercise the eval split (ties to the 2-state - limited-utility flag, F9). -9. **Staleness-rejection on sync changes round composition (feddance).** Dropping over-stale late - updates shifts K8/U2/round-count — expect movement, validate it's faithful, reuse the existing - threshold (no new scalar). -10. **Scarcity clock-advance must not stall or fast-forward past events** (F10/Stage F). Clamp the jump - to the nearest of {next transition, next `delivery_ts`, next `sct`} and terminate on an - all-unavailable window. Guard K1 monotone + the K5 failsafe ceiling. -11. **Regression discipline.** Every stage re-runs the syn_0 90-min all-baseline parity and must hold - the scoreboard byte-for-byte before its syn_20 validation counts. A stage perturbing another - baseline serializes (one baseline per run round). +## Stage H (future -- out of scope) + +Two independent knowledge-model upgrades, both replacing `trace_read` on the `tracking_mode` axis; the +effect logic (select-filter / in-flight-evict) is unchanged -- only how the agg learns state changes: +- **H.1 Message-transport** (`client_notify` ON for aware baselines): trainers push avl-state changes over + MQTT instead of the agg reading the trace + a continuous/event-scheduled vclock clamp. Re-measure + `observation_lag` (must be ~0) once live. (fwdllm's fluxtune baseline already configures `client_notify` + -- see simulate_fwdllm.md D1.) +- **H.2 Predictive**: a learned/heuristic availability model (no trace read or message push). Not designed yet. --- -## 7. Open follow-ups (note here as work lands) +## History (collapsed -- full detail in git) -- **Q-new-2 sync confirmation:** verify feddance's existing staleness threshold is the right rejection - gate on a real syn_20 run before E.2 (don't assume the async tolerance transfers). -- **Real notification lag (Challenge 5):** measure on a real felix run early; decides whether lag 0 is - admissible or Stage H must move up. -- *(Append new open questions/info needs here as the substrate lands — keep this the single ledger.)* +- **A-G, C.6, D, E, F.2, B2.0.x, T0-T5, Batch 2/3/4** all landed. Substrate + A3 time-base CONTROL, + send-gate/deliver-late, two-ledger, proactive evict (felix), syncfl path, starvation self-termination, + the absolute ground-truth fidelity checks (Batch 3 T3.0-T3.5: A6/A7/A8/K11 + `ground_truth.py` + shared + canonical time origin), and Batch 4's four gating fixes (asyncfl real self-stop, sim trainer-clock freeze + / K6 / A6, A7-commit checker `max_gap_s`) are all in code + tests, confirmed on the felix n=300 run. + Per-task mechanism/file/exit detail lives in commit history; the durable decisions are in "v1 core + decisions", "Challenges", and "Dead-ends" above. diff --git a/lib/python/examples/async_cifar10/aggregator/pytorch/main_asyncfl_agg.py b/lib/python/examples/async_cifar10/aggregator/pytorch/main_asyncfl_agg.py index bfa3d6312..f8a7739d2 100644 --- a/lib/python/examples/async_cifar10/aggregator/pytorch/main_asyncfl_agg.py +++ b/lib/python/examples/async_cifar10/aggregator/pytorch/main_asyncfl_agg.py @@ -119,25 +119,9 @@ def __init__( self.learning_rate = self.config.hyperparameters.learning_rate self.batch_size = self.config.hyperparameters.batch_size or 16 - self.track_trainer_avail = ( - self.config.hyperparameters.track_trainer_avail or None - ) self.reject_stale_updates = ( self.config.hyperparameters.reject_stale_updates or False ) - self.trainer_event_dict = None - if ( - self.track_trainer_avail["enabled"] - and self.track_trainer_avail["type"] == "ORACULAR" - ): - self.trainer_event_dict = self.read_trainer_unavailability( - self.track_trainer_avail["trace"] - ) - else: - print( - f"Did not read oracular trainer jsons. Enabled value: {self.track_trainer_avail['enabled']}, type: {self.track_trainer_avail['type']}, trace: {self.track_trainer_avail.get('trace', '')}" - ) - print("self.trainer_event_dict: ", self.trainer_event_dict) self.loss_list = [] @@ -155,18 +139,6 @@ def initialize(self): _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), "..", "..", "data")) - def read_trainer_unavailability(self, trace=None) -> None: - """ - Read availability trace pattern from central trace file. - - Currently returns None to disable oracular pre-loading. - The selector can still access traces via availability_trace_file config. - - This allows the aggregator to work with dynamic trainer spawning - without hardcoding the number of expected trainers. - """ - return None - def load_data(self) -> None: """Load a test dataset.""" transform_test = transforms.Compose( diff --git a/lib/python/examples/async_cifar10/aggregator/pytorch/main_oort_sync_agg.py b/lib/python/examples/async_cifar10/aggregator/pytorch/main_oort_sync_agg.py index 46ddbd794..f733093b1 100644 --- a/lib/python/examples/async_cifar10/aggregator/pytorch/main_oort_sync_agg.py +++ b/lib/python/examples/async_cifar10/aggregator/pytorch/main_oort_sync_agg.py @@ -22,14 +22,12 @@ import logging import time -from pathlib import Path import torch import torch.nn as nn import torch.nn.functional as F import torchvision import torchvision.transforms as transforms -import yaml # wandb setup import wandb @@ -41,15 +39,6 @@ import sys as _sys, os as _os _sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__))) from oracle_utility import OracleInjectMixin # noqa: E402 -from sortedcontainers import SortedDict - - -_METADATA_DIR = (Path(__file__).resolve().parents[3] / "_metadata") -_TRACE_KEY_TO_MOBIPERF_SUB = { - "mobiperf_2st": "states_2st", - "mobiperf_3st_50": "states_3st_50", - "mobiperf_3st_75": "states_3st_75", -} def initialize_wandb(run_name=None): @@ -130,26 +119,6 @@ def __init__( self.learning_rate = self.config.hyperparameters.learning_rate self.batch_size = self.config.hyperparameters.batch_size or 16 - self.track_trainer_avail = ( - self.config.hyperparameters.track_trainer_avail or None - ) - self.trainer_event_dict = None - if ( - self.track_trainer_avail["enabled"] - and self.track_trainer_avail["type"] == "ORACULAR" - ): - self.trainer_event_dict = self.read_trainer_unavailability( - self.track_trainer_avail["trace"] - ) - else: - print( - "Did not read oracular trainer jsons. " - f"enabled={self.track_trainer_avail.get('enabled')}, " - f"type={self.track_trainer_avail.get('type')}, " - f"trace={self.track_trainer_avail.get('trace', '')}" - ) - print("self.trainer_event_dict: ", self.trainer_event_dict) - self.loss_list = [] # Use wandb logging if enabled @@ -166,63 +135,6 @@ def initialize(self): _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), "..", "..", "data")) - # Initialize aggregator start time for oracular availability tracking - self.agg_start_time_ts = time.time() - logger.info(f"Aggregator initialized at timestamp: {self.agg_start_time_ts}") - - def read_trainer_unavailability(self, trace=None) -> dict: - """Build trainer_id -> SortedDict(timestamp -> state) for `trace`. - - Reads from the shared examples/_metadata/ bundle (registry + traces), - not from legacy per-trainer JSON files. - """ - logger.info(f"Reading trainer unavailability for trace: {trace}") - - registry_path = _METADATA_DIR / "trainer_registry.yaml" - with open(registry_path) as f: - registry = yaml.safe_load(f)["trainers"] - - if trace in _TRACE_KEY_TO_MOBIPERF_SUB: - sub = _TRACE_KEY_TO_MOBIPERF_SUB[trace] - with open(_METADATA_DIR / "availability_traces/mobiperf_traces.yaml") as f: - traces = yaml.safe_load(f)["traces"] - - def lookup(tk: str, trainer_id: int) -> list: - return traces[f"device_{trainer_id:03d}"][sub] - - elif trace and trace.startswith("syn_"): - with open(_METADATA_DIR / "availability_traces/synthetic_traces.yaml") as f: - syn = yaml.safe_load(f)["traces"] - if trace not in syn: - logger.warning(f"trace {trace!r} not found in synthetic_traces.yaml") - return None - entry = syn[trace] - per_trainer = entry.get("per_trainer", {}).get("n300", {}) - pattern = entry.get("pattern", []) - - def lookup(tk: str, trainer_id: int) -> list: - return per_trainer.get(tk) or pattern - - else: - logger.warning(f"unsupported trace name: {trace!r}") - return None - - trainer_events_dict = {} - for tk, meta in registry.items(): - trainer_id = meta["trainer_id"] - task_id = meta["task_id"] - events = lookup(tk, trainer_id) - state_dict = SortedDict() - for timestamp, state in events: - state_dict[timestamp] = state - trainer_events_dict[task_id] = state_dict - - logger.info( - f"Loaded availability traces for {len(trainer_events_dict)} trainers " - f"(trace={trace})" - ) - return trainer_events_dict - def load_data(self) -> None: """Load a test dataset.""" transform_test = transforms.Compose( @@ -295,41 +207,6 @@ def _job(): import threading threading.Thread(target=_job, daemon=True).start() - def get_curr_unavail_trainers(self) -> list: - """Return trainer IDs currently in UN_AVL state based on oracular traces.""" - curr_unavail_trainer_list = [] - - if self.trainer_event_dict is None: - return curr_unavail_trainer_list - - agg_time_since_start_s = time.time() - self.agg_start_time_ts - - for trainer_id, event_dict in list(self.trainer_event_dict.items()): - if not event_dict: - continue - - idx = event_dict.bisect_right(agg_time_since_start_s) - 1 - if idx >= 0: - most_recent_event = event_dict.peekitem(idx) - most_recent_event_ts = most_recent_event[0] - most_recent_event_state = most_recent_event[1] - - if most_recent_event_state == "UN_AVL": - curr_unavail_trainer_list.append(trainer_id) - elif most_recent_event_state == "AVL_TRAIN": - pass - else: - logger.warning( - f"Trainer {trainer_id} has unknown state: {most_recent_event_state}" - ) - - logger.info( - f"[ORACULAR] Current unavailable trainers: {len(curr_unavail_trainer_list)} " - f"out of {len(self.trainer_event_dict)} total @ time={agg_time_since_start_s:.1f}s" - ) - - return curr_unavail_trainer_list - def check_and_sleep(self) -> None: """Induce transient unavailability""" pass diff --git a/lib/python/examples/async_cifar10/configs/trainer_base.yaml b/lib/python/examples/async_cifar10/configs/trainer_base.yaml index 302d5892b..efcc3ef86 100644 --- a/lib/python/examples/async_cifar10/configs/trainer_base.yaml +++ b/lib/python/examples/async_cifar10/configs/trainer_base.yaml @@ -48,6 +48,9 @@ hyperparameters: epochs: 1 use_oort_loss_fn: "True" training_delay_enabled: "True" + satellite_latencies_path: "lib/python/examples/_metadata/leo/satellite_latencies.npy" + bandwidth_mbps: 100.0 + data_size_megabits: 1.0 # training_delay_s: injected at runtime from trainer registry # avl_events_*: injected at runtime from availability traces client_notify: diff --git a/lib/python/examples/async_cifar10/docs/EXPERIMENT_felix_streaming.md b/lib/python/examples/async_cifar10/docs/EXPERIMENT_felix_streaming.md index 887e2d15d..00312a1ca 100644 --- a/lib/python/examples/async_cifar10/docs/EXPERIMENT_felix_streaming.md +++ b/lib/python/examples/async_cifar10/docs/EXPERIMENT_felix_streaming.md @@ -114,7 +114,7 @@ each round). Two readings: | Streaming | **uniform (phase 1)** | one `full_after_s=10800`. Staggered (per-client onset≤5400 s, ±50% span) = phase 2 | | Time mode | **simulated** | virtual-clock time-to-accuracy, deterministic, fast | | Target accuracy | **60%** | | -| Stop rule | **20 consecutive evals ≥ 60%** | resets on any dip; `rounds`/`max_runtime_s` safety cap | +| Stop rule | **20 consecutive evals ≥ 60%** | resets on any dip; `rounds`/`max_experiment_runtime_s` safety cap | | Eval cadence | every **10** rounds | 20 evals ≈ 200 sustained rounds | **Arms (8).** `{felix, oort, refl, feddance} × {B, B_oracle}`. Each `B_oracle` uses @@ -193,7 +193,7 @@ oracle runs are suffixed `_node`). artifact of a single global unlock clock: staggering (clients' data arriving in different windows) should *amplify* the top-K churn and the baselines' disparity. - **"20 consecutive evals ≥ 60%"** yields a stable time-to-accuracy (not a lucky - spike); the `rounds`/`max_runtime_s` cap guarantees non-converging arms still + spike); the `rounds`/`max_experiment_runtime_s` cap guarantees non-converging arms still terminate. - **Simulated mode** gives a clean virtual-clock time axis, determinism, and speed. diff --git a/lib/python/examples/async_cifar10/docs/IMPLEMENTATION_felix_streaming.md b/lib/python/examples/async_cifar10/docs/IMPLEMENTATION_felix_streaming.md index 79521e459..26b4fde25 100644 --- a/lib/python/examples/async_cifar10/docs/IMPLEMENTATION_felix_streaming.md +++ b/lib/python/examples/async_cifar10/docs/IMPLEMENTATION_felix_streaming.md @@ -85,7 +85,7 @@ Follow‑ups at the bottom. **Config** (`config.py`, `Hyperparameters`): added `target_accuracy` (`targetAccuracy`, float, default `None` = disabled) and `stable_evals_above_target` (`stableEvalsAboveTarget`, int, default 20). The -existing `rounds` and `max_runtime_s` remain the safety cap (the latter is already +existing `rounds` and `max_experiment_runtime_s` remain the safety cap (the latter is already honored against the **virtual** clock in sim mode at `increment_round`). **Aggregator** (`syncfl/top_aggregator.py`, shared by sync + async stacks): @@ -105,7 +105,7 @@ rounds rather than tens of thousands. **Acceptance**: smoke run with `targetAccuracy=0.2, stableEvalsAboveTarget=2` terminates shortly after two consecutive evals ≥ 0.2; a high target falls through -to the `rounds`/`max_runtime_s` cap. +to the `rounds`/`max_experiment_runtime_s` cap. ## B. Staggered per-client streaming @@ -194,7 +194,7 @@ blocks on the aggregator config. Each arm: `num_trainers=50`, `data_streaming` (uniform `full_after_s=10800`; staggered adds the `stagger` block), `util_counterfactual` on, `checkpoint` on (offline oracle needs it), `aggGoal/aggr_num=10`, `targetAccuracy=0.60`, `stableEvalsAboveTarget=20`, -`evalEveryNRounds=10`, `rounds=20000`/`max_runtime_s=12600` cap. felix `c=10`; +`evalEveryNRounds=10`, `rounds=20000`/`max_experiment_runtime_s=12600` cap. felix `c=10`; `B_oracle` keeps B's own selector kwargs. Structure mirrors the working `felix_oort_refl_feddance_alpha0.1.yaml`. diff --git a/lib/python/examples/async_cifar10/docs/PLAN_felix_streaming_experiment.md b/lib/python/examples/async_cifar10/docs/PLAN_felix_streaming_experiment.md index adb688e24..a74711fcf 100644 --- a/lib/python/examples/async_cifar10/docs/PLAN_felix_streaming_experiment.md +++ b/lib/python/examples/async_cifar10/docs/PLAN_felix_streaming_experiment.md @@ -123,7 +123,7 @@ figures (see Verification below), `dg_flame` conda env. - **Config** — `lib/python/flame/config.py`: add hyperparameters `target_accuracy` (alias `targetAccuracy`, float, default `None` = disabled), `stable_evals_above_target` (alias, int, default 20). Reuse the existing `rounds` and - `max_runtime_s` as the safety cap (already honored in sim via the virtual clock). + `max_experiment_runtime_s` as the safety cap (already honored in sim via the virtual clock). - **Aggregator** — the eval result funnels through `_eval_emit(round, loss, acc)` in `lib/python/flame/mode/horizontal/syncfl/top_aggregator.py` (shared by sync + async stacks). Add a `_check_target_stop(acc)` called from `_eval_emit`: @@ -193,7 +193,7 @@ figures (see Verification below), `dg_flame` conda env. `data_streaming.enabled: 'True'` (+ `stagger` block for the staggered variant), `util_counterfactual.enabled: 'True'`, `checkpoint.enabled: 'True'` + `every_n_rounds` (required for offline oracle), `aggGoal/aggr_num: 10`, `targetAccuracy: 0.60`, - `stableEvalsAboveTarget: 20`, `evalEveryNRounds: 10`, `rounds`/`max_runtime_s` cap. felix + `stableEvalsAboveTarget: 20`, `evalEveryNRounds: 10`, `rounds`/`max_experiment_runtime_s` cap. felix `selector.kwargs.c: 10`; oracle arm `c: 50`. ### E. Analysis + claim figures diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_real.yaml index e646fd11c..443ab1326 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_real.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_real.yaml @@ -40,7 +40,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 selector: kwargs: k: 8 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_sim.yaml index 52ff2a455..a5f49cc5b 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_sim.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/fedavg_n48_parity_seeded_sim.yaml @@ -40,7 +40,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 selector: kwargs: k: 8 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_real.yaml index 87087cf80..d48e87017 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_real.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_real.yaml @@ -43,7 +43,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 selector: kwargs: c: 8 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_sim.yaml index d53d5d9de..89078f442 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_sim.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/fedbuff_n48_parity_seeded_sim.yaml @@ -43,7 +43,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 selector: kwargs: c: 8 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_real.yaml index e863ff5d2..2e57f4cc2 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_real.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_real.yaml @@ -40,7 +40,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 selector: kwargs: aggr_num: 5 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_sim.yaml index adef5f2a8..684ac8d0a 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_sim.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/feddance_n48_parity_seeded_sim.yaml @@ -40,7 +40,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 selector: kwargs: aggr_num: 5 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n10_alpha100_syn20_smoke.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n10_alpha100_syn20_smoke.yaml index cfd26dac2..7dc0676e4 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n10_alpha100_syn20_smoke.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n10_alpha100_syn20_smoke.yaml @@ -18,7 +18,7 @@ experiments: name: cifar10 dirichlet_alpha: 100.0 availability: - mode: syn_20 + mode: syn_0 enable_training_delays: true hyperparameters: batchSize: 32 @@ -26,7 +26,7 @@ experiments: config_overrides: hyperparameters: client_notify: - trace: syn_20 + trace: syn_0 aggregator: config_template: ../_metadata/aggregator_base.json @@ -41,11 +41,12 @@ experiments: batchSize: 32 learningRate: 0.001 rounds: 200 - aggGoal: 5 selector: kwargs: c: 8 - aggGoal: 5 + # aggGoal is set once via the top-level `agg_goal: 5` above -- + # the runner fans it into hyperparameters.aggGoal and this kwarg + # together, so don't duplicate it here. execution: num_gpus: 2 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n300_alpha0.1_syn0_STREAMING.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n300_alpha0.1_syn0_STREAMING.yaml index cc92117ea..128675a49 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n300_alpha0.1_syn0_STREAMING.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n300_alpha0.1_syn0_STREAMING.yaml @@ -39,7 +39,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 checkpoint: diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_real.yaml index 4737f99ef..8be0df0f5 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_real.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_real.yaml @@ -46,7 +46,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 selector: kwargs: c: 8 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_sim.yaml index 201b35207..7cc3ae224 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_sim.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_parity_seeded_sim.yaml @@ -46,7 +46,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 selector: kwargs: c: 8 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_real.yaml index f3ae65215..159521c83 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_real.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_real.yaml @@ -45,7 +45,7 @@ experiments: rounds: 40 aggGoal: 8 seed: 1234 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 selector: kwargs: c: 12 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_sim.yaml index 653681627..9f07c7a72 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_sim.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_n48_stress_sim.yaml @@ -45,7 +45,7 @@ experiments: rounds: 40 aggGoal: 8 seed: 1234 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 selector: kwargs: c: 12 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1.yaml index 5b266aedc..6fd5f8076 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1.yaml @@ -67,7 +67,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) + max_experiment_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) aggGoal: 10 evalEveryNRounds: 10 checkpoint: {enabled: "True", every_n_rounds: 10} @@ -111,7 +111,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) + max_experiment_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) aggGoal: 10 evalEveryNRounds: 10 checkpoint: {enabled: "True", every_n_rounds: 10} @@ -152,7 +152,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) + max_experiment_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) aggGoal: 10 checkpoint: {enabled: "True", every_n_rounds: 10} trackTrainerAvail: {trace: syn_0} @@ -192,7 +192,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) + max_experiment_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) aggGoal: 10 checkpoint: {enabled: "True", every_n_rounds: 10} trackTrainerAvail: {trace: syn_0} @@ -233,7 +233,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) + max_experiment_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) aggGoal: 10 checkpoint: {enabled: "True", every_n_rounds: 10} trackTrainerAvail: {trace: syn_0} @@ -273,7 +273,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) + max_experiment_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) aggGoal: 10 checkpoint: {enabled: "True", every_n_rounds: 10} trackTrainerAvail: {trace: syn_0} @@ -314,7 +314,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) + max_experiment_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) aggGoal: 10 evalEveryNRounds: 10 checkpoint: {enabled: "True", every_n_rounds: 10} @@ -354,7 +354,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) + max_experiment_runtime_s: 12600 # 3.5h wall-clock cap (data fully unlocks at 3h) aggGoal: 10 evalEveryNRounds: 10 checkpoint: {enabled: "True", every_n_rounds: 10} diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node1.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node1.yaml index 6b2b629ff..3d265b444 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node1.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node1.yaml @@ -38,7 +38,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 checkpoint: @@ -101,7 +101,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 checkpoint: enabled: 'True' diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node2.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node2.yaml index 1125a87c0..af125748a 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node2.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_CONTROL_node2.yaml @@ -42,7 +42,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 checkpoint: enabled: 'True' @@ -105,7 +105,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 checkpoint: diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node1.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node1.yaml index 663adb0b2..db6f09f66 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node1.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node1.yaml @@ -38,7 +38,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 min_trainers_to_start: 290 min_trainers_join_timeout_s: 600 aggGoal: 10 @@ -103,7 +103,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 min_trainers_to_start: 290 min_trainers_join_timeout_s: 600 aggGoal: 10 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node2.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node2.yaml index 953dbd3ec..bc0825b98 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node2.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_SIMULATED_node2.yaml @@ -42,7 +42,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 min_trainers_to_start: 290 min_trainers_join_timeout_s: 600 aggGoal: 10 @@ -110,7 +110,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 min_trainers_to_start: 290 min_trainers_join_timeout_s: 600 aggGoal: 10 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node1.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node1.yaml index 29e11e960..dd8944410 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node1.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node1.yaml @@ -38,7 +38,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 checkpoint: @@ -101,7 +101,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 checkpoint: enabled: 'True' diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node2.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node2.yaml index e1f914b75..0108a0e54 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node2.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_STREAMING_node2.yaml @@ -42,7 +42,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 checkpoint: enabled: 'True' @@ -105,7 +105,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 checkpoint: diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_parity.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_parity.yaml index e588ed18d..c21c64518 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_parity.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_parity.yaml @@ -41,7 +41,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 min_trainers_to_start: 290 min_trainers_join_timeout_s: 600 aggGoal: 10 @@ -91,6 +91,18 @@ experiments: checkpoint: enabled: 'True' every_n_rounds: 50 + # Stage C/D gate plumbing (§7): sim_unavailability activates the oracular + # delivery-ledger substrate for felix via the asyncfl commit loop. With + # syn_0 (100% avail) the mechanism fires but sees no UN_AVL → byte-identical + # behavior. client_notify.trace is overridden by debug_run.sh --trace; + # enabled stays False (Stage H). + # Two-axis flag split (T1): felix is the only baseline with both flags ON. + sim_unavailability: 'True' + avail_select_filter: 'True' + proactive_inflight_evict: 'True' + client_notify: + enabled: 'False' + trace: syn_0 selector: kwargs: c: 30 @@ -156,7 +168,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 50 checkpoint: @@ -164,6 +176,12 @@ experiments: every_n_rounds: 50 min_trainers_to_start: 290 min_trainers_join_timeout_s: 600 + sim_unavailability: 'True' + avail_select_filter: 'True' + proactive_inflight_evict: 'True' + client_notify: + enabled: 'False' + trace: syn_0 selector: kwargs: c: 30 @@ -233,7 +251,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 min_trainers_to_start: 290 min_trainers_join_timeout_s: 600 aggGoal: 10 @@ -242,6 +260,10 @@ experiments: # arrival, so sim in_flight (~3 carry) matches real. Sim-only; validated # by this run (Sr residence rung). See PARITY.md Jun-17c. simInflightCarryover: true + # oort is unaware at selection (avail_select_filter=False); the trace is + # used for starvation-advance vclock tracking only, not selection filtering. + avail_select_filter: 'False' + proactive_inflight_evict: 'False' checkpoint: enabled: 'True' every_n_rounds: 50 @@ -303,8 +325,12 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 + # oort is unaware at selection (avail_select_filter=False); the trace is + # used for starvation-advance vclock tracking only, not selection filtering. + avail_select_filter: 'False' + proactive_inflight_evict: 'False' checkpoint: enabled: 'True' every_n_rounds: 50 @@ -368,7 +394,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 min_trainers_to_start: 290 min_trainers_join_timeout_s: 600 aggGoal: 10 @@ -385,6 +411,9 @@ experiments: # in _advance_sim_clock (max(vclock,sct)+overhead, drift-instrumented), NOT a # clock ramp. Refine the value from the next run's K3b residual if over/under. simCommitOverheadSeconds: 0.011 + # refl is aware at selection but not proactive-evict (reactive-90s). + avail_select_filter: 'True' + proactive_inflight_evict: 'False' checkpoint: enabled: 'True' every_n_rounds: 50 @@ -453,8 +482,11 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 + # refl is aware at selection but not proactive-evict (reactive-90s). + avail_select_filter: 'True' + proactive_inflight_evict: 'False' checkpoint: enabled: 'True' every_n_rounds: 50 @@ -524,11 +556,14 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 min_trainers_to_start: 290 min_trainers_join_timeout_s: 600 aggGoal: 10 evalEveryNRounds: 50 + # feddance is aware at selection but not proactive-evict (reactive-90s). + avail_select_filter: 'True' + proactive_inflight_evict: 'False' checkpoint: enabled: 'True' every_n_rounds: 50 @@ -588,9 +623,12 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 50 + # feddance is aware at selection but not proactive-evict (reactive-90s). + avail_select_filter: 'True' + proactive_inflight_evict: 'False' checkpoint: enabled: 'True' every_n_rounds: 50 @@ -610,3 +648,297 @@ experiments: ram_critical_percent: 90.0 gpu_warning_percent: 80.0 gpu_critical_percent: 90.0 + +# ── oort_star ───────────────────────────────────────────────────────────────── +# oort-sync base + avail_select_filter=True (T3 scaffold). +# Aware at selection (filters UN_AVL), reactive-90s in-flight (no proactive evict). +- name: oort_star_n300_alpha0.1_syn0_stream_sim + description: oort_star (oort sync + aware selection, no proactive evict) sim. + baseline: oort_star + trainer: + num_trainers: 300 + start_id: 1 + dataset: + name: cifar10 + dirichlet_alpha: 0.1 + availability: + mode: syn_0 + enable_training_delays: true + time_mode: simulated + hyperparameters: + batchSize: 10 + learningRate: 0.01 + lrDecayEnabled: true + lrDecayFactor: 0.98 + lrDecayEpoch: 10 + minLearningRate: 0.0001 + config_overrides: + hyperparameters: + data_streaming: + enabled: "True" + full_data_available_after_s: 10800 + util_counterfactual: + enabled: "True" + every_n_rounds: 50 + sample_size: 256 + aggregator: + config_template: ../_metadata/aggregator_base.json + selector: oort + tracking_mode: oracular + agg_goal: 10 + log_to_wandb: false + config_overrides: + job: + id: oort_star_n300_alpha0.1_syn0_stream_sim + hyperparameters: + batchSize: 10 + learningRate: 0.01 + rounds: 20000 + max_experiment_runtime_s: 12600 + min_trainers_to_start: 290 + min_trainers_join_timeout_s: 600 + aggGoal: 10 + simInflightCarryover: true + avail_select_filter: "True" + proactive_inflight_evict: "False" + checkpoint: + enabled: "True" + every_n_rounds: 50 + trackTrainerAvail: + trace: syn_0 + selector: + kwargs: + aggr_num: 10 + execution: + num_gpus: 8 + sleep_between_spawns: 1.0 + aggregator_warmup_time: 60 + monitoring: + enabled: true + check_interval_seconds: 30 + ram_warning_percent: 80.0 + ram_critical_percent: 90.0 + gpu_warning_percent: 80.0 + gpu_critical_percent: 90.0 +- name: oort_star_n300_alpha0.1_syn0_stream_real + description: oort_star (oort sync + aware selection, no proactive evict) real. + baseline: oort_star + trainer: + num_trainers: 300 + start_id: 1 + dataset: + name: cifar10 + dirichlet_alpha: 0.1 + availability: + mode: syn_0 + enable_training_delays: true + time_mode: real + hyperparameters: + batchSize: 10 + learningRate: 0.01 + lrDecayEnabled: true + lrDecayFactor: 0.98 + lrDecayEpoch: 10 + minLearningRate: 0.0001 + config_overrides: + hyperparameters: + data_streaming: + enabled: "True" + full_data_available_after_s: 10800 + util_counterfactual: + enabled: "True" + every_n_rounds: 50 + sample_size: 256 + aggregator: + config_template: ../_metadata/aggregator_base.json + selector: oort + tracking_mode: oracular + agg_goal: 10 + log_to_wandb: false + config_overrides: + job: + id: oort_star_n300_alpha0.1_syn0_stream_real + hyperparameters: + batchSize: 10 + learningRate: 0.01 + rounds: 20000 + max_experiment_runtime_s: 12600 + aggGoal: 10 + avail_select_filter: "True" + proactive_inflight_evict: "False" + checkpoint: + enabled: "True" + every_n_rounds: 50 + trackTrainerAvail: + trace: syn_0 + min_trainers_to_start: 290 + min_trainers_join_timeout_s: 600 + selector: + kwargs: + aggr_num: 10 + execution: + num_gpus: 8 + sleep_between_spawns: 1.0 + aggregator_warmup_time: 60 + monitoring: + enabled: true + check_interval_seconds: 30 + ram_warning_percent: 80.0 + ram_critical_percent: 90.0 + gpu_warning_percent: 80.0 + gpu_critical_percent: 90.0 +# ── fedbuff ─────────────────────────────────────────────────────────────────── +# asyncfl base + FedBuffSelector + both flags OFF (unaware, T3 scaffold). +- name: fedbuff_n300_alpha0.1_syn0_stream_sim + description: fedbuff (asyncfl + fedbuff selector, both flags OFF) sim. + baseline: fedbuff + trainer: + num_trainers: 300 + start_id: 1 + dataset: + name: cifar10 + dirichlet_alpha: 0.1 + availability: + mode: syn_0 + enable_training_delays: true + time_mode: simulated + hyperparameters: + # LR schedule matches felix and all other async cifar10 runs. + batchSize: 10 + learningRate: 0.01 + lrDecayEnabled: true + lrDecayFactor: 0.98 + lrDecayEpoch: 10 + minLearningRate: 0.0001 + config_overrides: + hyperparameters: + data_streaming: + enabled: "True" + full_data_available_after_s: 10800 + util_counterfactual: + enabled: "True" + every_n_rounds: 50 + sample_size: 256 + aggregator: + config_template: ../_metadata/aggregator_base.json + selector: fedbuff + tracking_mode: default + agg_goal: 10 + log_to_wandb: false + config_overrides: + job: + id: fedbuff_n300_alpha0.1_syn0_stream_sim + hyperparameters: + batchSize: 10 + learningRate: 0.01 + rounds: 20000 + max_experiment_runtime_s: 12600 + min_trainers_to_start: 290 + min_trainers_join_timeout_s: 600 + aggGoal: 10 + evalEveryNRounds: 50 + simSctOrderedDrain: true + simClockJumpClamp: true + simInflightResidence: true + avail_select_filter: "False" + proactive_inflight_evict: "False" + sim_unavailability: "True" + availability_trace: syn_0 + client_notify: + enabled: "False" + trace: syn_0 + checkpoint: + enabled: "True" + every_n_rounds: 50 + selector: + kwargs: + c: 30 + aggGoal: 10 + round_threshold: 70 + exploration_decay: 0.999 + execution: + num_gpus: 8 + sleep_between_spawns: 1.0 + aggregator_warmup_time: 60 + monitoring: + enabled: true + check_interval_seconds: 30 + ram_warning_percent: 80.0 + ram_critical_percent: 90.0 + gpu_warning_percent: 80.0 + gpu_critical_percent: 90.0 +- name: fedbuff_n300_alpha0.1_syn0_stream_real + description: fedbuff (asyncfl + fedbuff selector, both flags OFF) real. + baseline: fedbuff + trainer: + num_trainers: 300 + start_id: 1 + dataset: + name: cifar10 + dirichlet_alpha: 0.1 + availability: + mode: syn_0 + enable_training_delays: true + time_mode: real + hyperparameters: + # LR schedule matches felix and all other async cifar10 runs. + batchSize: 10 + learningRate: 0.01 + lrDecayEnabled: true + lrDecayFactor: 0.98 + lrDecayEpoch: 10 + minLearningRate: 0.0001 + config_overrides: + hyperparameters: + data_streaming: + enabled: "True" + full_data_available_after_s: 10800 + util_counterfactual: + enabled: "True" + every_n_rounds: 50 + sample_size: 256 + aggregator: + config_template: ../_metadata/aggregator_base.json + selector: fedbuff + tracking_mode: default + agg_goal: 10 + log_to_wandb: false + config_overrides: + job: + id: fedbuff_n300_alpha0.1_syn0_stream_real + hyperparameters: + batchSize: 10 + learningRate: 0.01 + rounds: 20000 + max_experiment_runtime_s: 12600 + aggGoal: 10 + evalEveryNRounds: 50 + avail_select_filter: "False" + proactive_inflight_evict: "False" + sim_unavailability: "True" + availability_trace: syn_0 + client_notify: + enabled: "False" + trace: syn_0 + checkpoint: + enabled: "True" + every_n_rounds: 50 + min_trainers_to_start: 290 + min_trainers_join_timeout_s: 600 + selector: + kwargs: + c: 30 + aggGoal: 10 + round_threshold: 70 + exploration_decay: 0.999 + execution: + num_gpus: 8 + sleep_between_spawns: 1.0 + aggregator_warmup_time: 60 + monitoring: + enabled: true + check_interval_seconds: 30 + ram_warning_percent: 80.0 + ram_critical_percent: 90.0 + gpu_warning_percent: 80.0 + gpu_critical_percent: 90.0 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node1.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node1.yaml index 33b55173f..df2fdcbd7 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node1.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node1.yaml @@ -42,7 +42,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 @@ -106,7 +106,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node2.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node2.yaml index c8321ff9e..df3542118 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node2.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node2.yaml @@ -42,7 +42,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 @@ -105,7 +105,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node3.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node3.yaml index 601a483b5..81c108d0b 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node3.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node3.yaml @@ -42,7 +42,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 @@ -105,7 +105,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node4.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node4.yaml index 1210e376f..1a9e9ba92 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node4.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_node4.yaml @@ -42,7 +42,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 @@ -105,7 +105,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_sim.yaml index ede512daa..f4c23b9b3 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_sim.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/n50_alpha0.1_syn0_stream_unif_sim.yaml @@ -42,7 +42,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 @@ -106,7 +106,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 @@ -167,7 +167,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 @@ -220,7 +220,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 @@ -281,7 +281,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 @@ -334,7 +334,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 @@ -395,7 +395,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 @@ -448,7 +448,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 20000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 evalEveryNRounds: 10 targetAccuracy: 0.6 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n10_alpha100_syn0_smoke.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n10_alpha100_syn0_smoke.yaml index 31b78a669..254cf9ab4 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n10_alpha100_syn0_smoke.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n10_alpha100_syn0_smoke.yaml @@ -36,12 +36,12 @@ experiments: batchSize: 32 learningRate: 0.001 rounds: 200 - aggGoal: 5 trackTrainerAvail: trace: syn_0 - selector: - kwargs: - aggr_num: 5 + # aggr_num (oort's name for the selection/aggregation count) is set + # once via the top-level `agg_goal: 5` above -- the runner fans it + # into hyperparameters.aggGoal and selector.kwargs.aggr_num + # together, so don't duplicate it here. execution: num_gpus: 2 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n300_alpha0.1_syn0_STREAMING.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n300_alpha0.1_syn0_STREAMING.yaml index e352df9d1..1bdc33f3e 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n300_alpha0.1_syn0_STREAMING.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n300_alpha0.1_syn0_STREAMING.yaml @@ -43,7 +43,7 @@ experiments: batchSize: 10 learningRate: 0.01 rounds: 1000 - max_runtime_s: 12600 + max_experiment_runtime_s: 12600 aggGoal: 10 checkpoint: enabled: 'True' diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_real.yaml index d1d066d86..1ac3fa384 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_real.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_real.yaml @@ -40,7 +40,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 trackTrainerAvail: trace: syn_0 selector: diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_sim.yaml index f42ec358b..4b1881fa5 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_sim.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/oort_n48_parity_seeded_sim.yaml @@ -40,7 +40,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 trackTrainerAvail: trace: syn_0 selector: diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n10_alpha100_syn0_smoke.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n10_alpha100_syn0_smoke.yaml index 8e5fdea08..18600cb3a 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n10_alpha100_syn0_smoke.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n10_alpha100_syn0_smoke.yaml @@ -36,12 +36,12 @@ experiments: batchSize: 32 learningRate: 0.001 rounds: 200 - aggGoal: 5 trackTrainerAvail: trace: syn_0 - selector: - kwargs: - aggr_num: 5 + # aggr_num (refl_oort's name for the selection/aggregation count) is + # set once via the top-level `agg_goal: 5` above -- the runner fans + # it into hyperparameters.aggGoal and selector.kwargs.aggr_num + # together, so don't duplicate it here. execution: num_gpus: 2 diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_real.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_real.yaml index 20390d30e..497552c7c 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_real.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_real.yaml @@ -40,7 +40,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 trackTrainerAvail: trace: syn_0 selector: diff --git a/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_sim.yaml b/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_sim.yaml index e26166e12..304e0e201 100644 --- a/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_sim.yaml +++ b/lib/python/examples/async_cifar10/expt_scripts_2026/refl_n48_parity_seeded_sim.yaml @@ -40,7 +40,7 @@ experiments: aggGoal: 5 seed: 1234 min_trainers_to_start: 48 - max_runtime_s: 1200 + max_experiment_runtime_s: 1200 trackTrainerAvail: trace: syn_0 selector: diff --git a/lib/python/examples/async_cifar10/real-sim_parity_checker_plan.md b/lib/python/examples/async_cifar10/real-sim_parity_checker_plan.md index 951528856..2290af0fa 100644 --- a/lib/python/examples/async_cifar10/real-sim_parity_checker_plan.md +++ b/lib/python/examples/async_cifar10/real-sim_parity_checker_plan.md @@ -7,7 +7,7 @@ - real = `experiments/run_20260606_182638_dbg_felix_n300_alpha0.1_syn0_stream_real` Both: Felix (`async_oort` + `fedbuff`), n=300, α=0.1, syn_0, agg_goal=10, -`max_runtime_s = sim_wall_ceiling_s = 10800s (3h)`, `min_trainers_to_start=290`. +`max_experiment_runtime_s = sim_wall_ceiling_s = 10800s (3h)`, `min_trainers_to_start=290`. --- @@ -107,7 +107,7 @@ Four findings: `rounds` cap, not the wall/vclock budget. **Fixed**: `rounds: 1000 → 20000` in `expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_OVERNIGHT_node{1,2}.yaml` (canonical source, covers overnight + debug) plus an explicit `h["rounds"]=20000` - guard in `scripts/debug_run.sh` (non-smoke branch, alongside the `max_runtime_s` + guard in `scripts/debug_run.sh` (non-smoke branch, alongside the `max_experiment_runtime_s` override). New checker check **K9** below makes truncation-by-cap an explicit WARN so it can never silently distort a comparison again. @@ -277,7 +277,7 @@ gating; surface Jaccard as signal. | K6 | INV | sim mode: `task_recv.sim_send_ts` non-null & increasing after round 1; real mode: null | trainer task_recv | no violations | | K7 | INV | sim_rate (`vclock/wall`) in sane range [0.01, 100] | agg_round (sim) | in range | | K8 | DIST | **terminal-state parity**: at matched virtual budget V, both reached comparable FL-round count, total commits, total unique trainers used | agg_round | rounds within 10%, trainers within 5% | -| K9 | INV | **stopped-by-budget, not by cap**: neither run hit the `rounds` cap before `max_runtime_s` — else the comparison is truncated and downstream metrics are biased | agg_round + config | WARN if `max_round == rounds_cap` and wall/vclock < budget | +| K9 | INV | **stopped-by-budget, not by cap**: neither run hit the `rounds` cap before `max_experiment_runtime_s` — else the comparison is truncated and downstream metrics are biased | agg_round + config | WARN if `max_round == rounds_cap` and wall/vclock < budget | | K10 | INV | **vclock telemetry present**: a sim run's agg_round events must carry `vclock_now` (sync path currently omits it). FAIL-LOUD rather than silently SKIP K1–K3/K7 | agg_round (sim) | FAIL if sim run has zero `vclock_now` stamps | > **K2/K3/K4 are the checks that would have caught the 410-vs-673 regression on diff --git a/lib/python/examples/async_cifar10/scripts/debug_run.sh b/lib/python/examples/async_cifar10/scripts/debug_run.sh index 492e134dd..fe24b6326 100755 --- a/lib/python/examples/async_cifar10/scripts/debug_run.sh +++ b/lib/python/examples/async_cifar10/scripts/debug_run.sh @@ -17,7 +17,7 @@ # baseline is a no-op (not an error). # # Runtime: -# --runtime-s sets max_runtime_s for BOTH real and sim variants. +# --runtime-s sets max_experiment_runtime_s for BOTH real and sim variants. # Real mode: wall-clock seconds (passes directly). # Sim mode: virtual-clock seconds (vclock fix ensures sim stops at this # many virtual seconds, which completes in far less wall-clock @@ -49,20 +49,22 @@ echo "conda: base=$CB env=$ENVNAME python=$(which python)" EX="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" cd "$EX" || exit 1 SCR=expt_scripts_2026 -LOGDIR=/tmp/debug_run_logs; mkdir -p "$LOGDIR" +LOGDIR="${FLAME_LOGDIR:-/tmp/debug_run_logs}"; mkdir -p "$LOGDIR" export FLAME_BATCH_CONTINUE_ON_ERROR=1 # defaults RUNTIME_S=10800 BASELINES="felix refl" -SIM_WALL_CEILING_S="" # empty = max_runtime_s (1×, tight guard; sim should be faster than real) +SIM_WALL_CEILING_S="" # empty = max_experiment_runtime_s (1×, tight guard; sim should be faster than real) MODE="both" # sim | real | both — which time_mode variant(s) of each baseline to run +NUM_TRAINERS="" # empty = use whatever's in the parity config (300); non-smoke override only +ALPHA="" # empty = use the parity config's dirichlet_alpha (0.1); e.g. 100 for homogeneous usage() { - echo "usage: $0 [--baselines 'felix refl'] [--runtime-s 3600] [--mode sim|real|both] [--sim-wall-ceiling-s 2700]" - echo " $0 smoke [--baselines ...] [--mode sim|real|both]" + echo "usage: $0 [--baselines 'felix refl'] [--runtime-s 3600] [--mode sim|real|both] [--sim-wall-ceiling-s 2700] [--trace syn_20]" + echo " $0 smoke [--baselines ...] [--mode sim|real|both] [--trace syn_20]" echo "" - echo " --baselines which baselines to run (any of felix oort refl feddance);" + echo " --baselines which baselines to run (any of felix oort oort_star refl feddance fedbuff);" echo " filtered from the parity config, node-agnostic." echo " --mode which time_mode variant(s) to run for each baseline:" echo " 'sim' (only the simulated run), 'real' (only the real run)," @@ -71,17 +73,31 @@ usage() { echo " --sim-wall-ceiling-s wall-clock ceiling for sim mode (default: = runtime_s)." echo " A well-behaved sim finishes in <= real-mode wall time." echo " Fires [SIM_WALL_CEILING] warning + stops when exceeded." + echo " --trace availability trace name(s) to substitute, space-separated for" + echo " multiple (e.g. 'syn_20 syn_50' queues both, one experiment set each)." + echo " Default: use whatever is in the parity config (syn_0)." + echo " --num-trainers non-smoke only: shrink the cohort below the parity config's 300," + echo " scaling min_trainers_to_start down with it (gap of 8, same ratio as" + echo " smoke). Use this instead of 'smoke' when you need a real --runtime-s" + echo " budget (e.g. a vclock floor for an availability trace) that smoke's" + echo " hardcoded rounds=4/runtime=240 would cut short." + echo " --alpha Dirichlet alpha override (default: parity config's 0.1). Supported" + echo " values have an n300 split: 0.1 / 1.0 / 10.0 / 100.0 (100=homogeneous)." + echo " When set, the split lookup uses the n300 partition for that alpha." exit 2 } # parse args +TRACE="" # empty = use whatever is in the parity config (syn_0) if [ "${1:-}" = "smoke" ]; then SMOKE=1; shift - BASELINES="felix oort refl feddance" # smoke default: validate all + BASELINES="felix oort oort_star refl feddance fedbuff" # smoke default: validate all while [[ $# -gt 0 ]]; do case "$1" in --baselines) BASELINES="$2"; shift 2 ;; --mode) MODE="$2"; shift 2 ;; + --trace) TRACE="$2"; shift 2 ;; + --alpha) ALPHA="$2"; shift 2 ;; *) shift ;; esac done @@ -94,6 +110,9 @@ else --mode) MODE="$2"; shift 2 ;; --sim-wall-ceiling-s) SIM_WALL_CEILING_S="$2"; shift 2 ;; --wall-runtime-s) SIM_WALL_CEILING_S="$2"; shift 2 ;; # backward compat alias + --trace) TRACE="$2"; shift 2 ;; + --num-trainers) NUM_TRAINERS="$2"; shift 2 ;; + --alpha) ALPHA="$2"; shift 2 ;; # --node is DEPRECATED (node1/node2 split removed): baselines are filtered # from a single node-agnostic parity config, so the node is irrelevant. # Accept+ignore so existing wrappers don't hard-error. @@ -106,15 +125,21 @@ case "$MODE" in sim|real|both) ;; *) echo "ERROR: --mode must be sim|real|both ( # Generate a single filtered+patched YAML from the parity source config. # $1 = baselines (space-separated), $2 = runtime_s, $3 = output path, -# [$4 = smoke: 1|0], [$5 = sim_wall_ceiling_s: int or ""], [$6 = mode: sim|real|both] +# [$4 = smoke: 1|0], [$5 = sim_wall_ceiling_s: int or ""], [$6 = mode: sim|real|both], +# [$7 = trace: trace name or ""], [$8 = num_trainers override: int or "", non-smoke only], +# [$9 = alpha override: float or ""] make_debug_yaml() { - python - "$SCR" "$1" "$2" "$3" "${4:-0}" "${5:-}" "${6:-both}" <<'PY' + python - "$SCR" "$1" "$2" "$3" "${4:-0}" "${5:-}" "${6:-both}" "${7:-}" "${8:-}" "${9:-}" <<'PY' import yaml, sys, copy, os scr, baselines_str, runtime_s, outpath, smoke, ceil_arg = ( sys.argv[1], sys.argv[2], int(sys.argv[3]), sys.argv[4], sys.argv[5] == "1", sys.argv[6] if len(sys.argv) > 6 else "" ) mode = (sys.argv[7] if len(sys.argv) > 7 else "both").lower() +# Space-separated list of trace names (e.g. "syn_20 syn_50"); "" -> [""] (no substitution). +trace_overrides = sys.argv[8].strip().split() if len(sys.argv) > 8 and sys.argv[8].strip() else [""] +num_trainers_override = int(sys.argv[9]) if len(sys.argv) > 9 and sys.argv[9].strip() else None +alpha_override = float(sys.argv[10]) if len(sys.argv) > 10 and sys.argv[10].strip() else None requested = set(baselines_str.lower().split()) # Deterministic selection seed (same for real+sim). Default 1234; SEED=none disables. _seed_env = os.environ.get("SEED", "1234").strip() @@ -141,44 +166,127 @@ def exp_mode(e): # feddance) × {sim, real}; filter it to the requested baselines/mode. src = f"{scr}/felix_oort_refl_feddance_alpha0.1_parity.yaml" try: - cfg = yaml.safe_load(open(src)) + # encoding="utf-8" explicit: the config has non-ASCII chars (e.g. "->" arrows + # in comments/descriptions); without this, open() falls back to the node's + # locale-preferred encoding, which mis-decodes them on non-UTF-8 locales + # (e.g. C/POSIX) and yaml.safe_load then rejects the resulting control chars. + cfg = yaml.safe_load(open(src, encoding="utf-8")) except FileNotFoundError: print(f"ERROR: parity config not found: {src}", flush=True) sys.exit(1) kept = [] -for e in cfg.get("experiments", []): - bl = e.get("baseline", "").lower() +for e_src in cfg.get("experiments", []): + bl = e_src.get("baseline", "").lower() if bl not in requested: continue - if mode != "both" and exp_mode(e) != mode: + if mode != "both" and exp_mode(e_src) != mode: continue - e = copy.deepcopy(e) - h = e["aggregator"]["config_overrides"]["hyperparameters"] - h["max_runtime_s"] = runtime_s - # Deterministic seed: the SAME value for every experiment so the real and sim - # variants of each baseline make identical selection draws (dedicated per- - # selector RNG, PARITY "Determinism / seeding"). Without this, real vs sim are - # two independent stochastic paths and participation/utility can never match. - # Override per-invocation with SEED=; SEED=none disables (legacy unseeded). - if seed_val is not None: - h["seed"] = seed_val - # sim_wall_ceiling_s: tight wall guard — sim must finish in <= this many - # wall-seconds (default = max_runtime_s = 1×; a healthy sim is faster). - h["sim_wall_ceiling_s"] = int(ceil_arg) if ceil_arg else runtime_s - if smoke: - e["trainer"]["num_trainers"] = 48 - h["rounds"] = 4 - h["min_trainers_to_start"] = 40 - h["min_trainers_join_timeout_s"] = 120 - e["name"] = "dbg_smoke_" + e["name"] - else: - # High round cap so the wall/vclock budget (max_runtime_s) is the - # binding stop condition, not an early round-count termination. - h["rounds"] = 20000 - e["name"] = f"dbg_{e['name']}" - e["aggregator"]["config_overrides"]["job"]["id"] = e["name"] - kept.append(e) + # One experiment per requested trace (trace_overrides has 1 entry, "", when + # --trace wasn't given, so this loop is a no-op pass-through by default). + for trace_override in trace_overrides: + e = copy.deepcopy(e_src) + h = e["aggregator"]["config_overrides"]["hyperparameters"] + h["max_experiment_runtime_s"] = runtime_s + # Deterministic seed: the SAME value for every experiment so the real and sim + # variants of each baseline make identical selection draws (dedicated per- + # selector RNG, PARITY "Determinism / seeding"). Without this, real vs sim are + # two independent stochastic paths and participation/utility can never match. + # Override per-invocation with SEED=; SEED=none disables (legacy unseeded). + if seed_val is not None: + h["seed"] = seed_val + # sim_wall_ceiling_s: tight wall guard -- sim must finish in <= this many + # wall-seconds (default = max_experiment_runtime_s = 1x; a healthy sim is faster). + h["sim_wall_ceiling_s"] = int(ceil_arg) if ceil_arg else runtime_s + if smoke: + e["trainer"]["num_trainers"] = 48 + h["rounds"] = 4 + h["min_trainers_to_start"] = 40 + h["min_trainers_join_timeout_s"] = 120 + e["name"] = "dbg_smoke_" + e["name"] + else: + # High round cap so the wall/vclock budget (max_experiment_runtime_s) is the + # binding stop condition, not an early round-count termination. + h["rounds"] = 20000 + if num_trainers_override: + # Shrink the cohort but keep runtime_s as the real budget (unlike + # smoke, which hardcodes rounds=4/runtime=240 -- too short for a + # trace-driven vclock floor like syn_20's first UN_AVL at t=600s). + # Same join-barrier slack ratio as smoke (gap of 8 below the count). + # Preserve the config's native partition size as split_num_trainers + # so the shrunk cohort reads the existing n split (e.g. n300) + # instead of demanding a dedicated n split file that may + # not exist (there is no cifar10_alpha0.1_n10 split, only n48/50/300). + # spawn_all spawns num_trainers trainers but keys the split lookup on + # split_num_trainers -- the two are independent by design. + orig_n = e["trainer"].get("num_trainers", 300) + e["trainer"]["num_trainers"] = num_trainers_override + e["trainer"]["split_num_trainers"] = orig_n + h["min_trainers_to_start"] = max(1, num_trainers_override - 8) + e["name"] = f"dbg_{e['name']}" + # --alpha override: repoint dirichlet_alpha and the split lookup. Only n300 + # splits exist for every alpha (0.1/1.0/10.0/100.0=homogeneous); n48/n50 + # exist for alpha0.1 only. So read the n300 partition for the chosen alpha + # (the cohort stays num_trainers, spawned as the first num_trainers of the + # 300-way split via the split_num_trainers decoupling). Name gets an + # alpha<..> tag so run dirs are distinguishable across alphas. + if alpha_override is not None: + e["trainer"].setdefault("dataset", {})["dirichlet_alpha"] = alpha_override + e["trainer"]["split_num_trainers"] = 300 + e["name"] = f"{e['name']}_alpha{str(alpha_override).replace('.', 'p')}" + # --trace override: substitute availability trace in trainer + aggregator config. + if trace_override: + # trainer.availability.mode is NOT read by anything (main.py/config.py never + # touch config.availability) -- vestigial from an earlier design, kept + # write-only here so as not to silently drop a field some other consumer may + # still expect. The trainer's ACTUAL trace selection comes from + # hyperparameters.client_notify.trace (see main.py's state_avl_event_ts + # assignment), which lives under trainer.config_overrides.hyperparameters, + # not trainer.hyperparameters (that block is base-model HP only: batchSize/ + # learningRate/etc, merged from configs/trainer_base.yaml's own client_notify + # default of trace=syn_0). Before this fix, ONLY the aggregator's own trace + # read (via `h` below) was ever overridden -- every debug_run.sh-launched + # trainer, real and sim, ran with client_notify.trace stuck at the + # trainer_base.yaml default (syn_0, always-available) regardless of the + # requested --trace, silently no-op'ing the trainer-side avl_state machinery + # (and hence the real-mode send-gate and all avail_change telemetry) for + # every trace-driven run this project has ever launched. Root-caused Jul 1 + # via UNAVAILABILITY_DESIGN.md Batch 3 T3.1. + avail = e["trainer"].setdefault("availability", {}) + old_trace = avail.get("mode", "syn_0") + avail["mode"] = trace_override + t_co_hp = e["trainer"].setdefault("config_overrides", {}).setdefault("hyperparameters", {}) + t_co_hp.setdefault("client_notify", {})["trace"] = trace_override + if "trackTrainerAvail" in h: + h["trackTrainerAvail"]["trace"] = trace_override + # For baselines NOT on the ORACULAR legacy path (felix, feddance, + # oracle, fedbuff): activate the new sim_unavailability gate so + # _init_availability picks up the trace (Sec 7 felix master-gate). + # ORACULAR baselines (oort, refl) already activate via the legacy path. + if h["trackTrainerAvail"].get("type", "").upper() != "ORACULAR": + h["simUnavailability"] = True + # proactive_inflight_evict is set directly in each experiment's + # config_overrides HP (T1 two-axis split); no auto-detection needed + # here. The client_notify.enabled check below is always False + # (Stage H is future), so proactiveInflightEvict is never set by + # this branch -- the explicit YAML value is authoritative. + t_hp = e.get("trainer", {}).get("hyperparameters", {}) + if str(t_hp.get("client_notify", {}).get("enabled", "False")).lower() == "true": + h["proactiveInflightEvict"] = True + elif "client_notify" in h and isinstance(h["client_notify"], dict): + h["client_notify"]["trace"] = trace_override + h["simUnavailability"] = True + elif e["aggregator"].get("tracking_mode", "oracular").lower() != "oracular": + # Non-oracular baseline with no HP-level tracking block (e.g. feddance + # in v1, which has no client_notify in HP and no trackTrainerAvail). + # Inject trace via availability_trace so _init_availability finds it. + h["availability_trace"] = trace_override + h["simUnavailability"] = True + # Rewrite syn_ or syn in the name so run dirs are identifiable. + import re + e["name"] = re.sub(r"syn_?[0-9]+", trace_override, e["name"]) + e["aggregator"]["config_overrides"]["job"]["id"] = e["name"] + kept.append(e) if not kept: print(f"WARNING: no experiments matched baselines={baselines_str} mode={mode}", @@ -186,19 +294,61 @@ if not kept: sys.exit(0) cfg["experiments"] = kept -yaml.safe_dump(cfg, open(outpath, "w"), sort_keys=False) +yaml.safe_dump(cfg, open(outpath, "w", encoding="utf-8"), sort_keys=False) print(f"Generated {outpath} with {len(kept)} experiment(s): " f"{[e['name'] for e in kept]}", flush=True) PY } +# Count experiments in a generated YAML (used to estimate budget and track progress). +_count_exps() { + python3 - "$1" <<'PY' +import yaml, sys +d = yaml.safe_load(open(sys.argv[1], encoding="utf-8")) +print(len(d.get('experiments', []))) +PY +} + run_node() { - local label="$1" cfg="$2" - echo "[$(date '+%F %T')] START $label -> $cfg" | tee -a "$LOGDIR/debug_run.log" + local label="$1" cfg="$2" budget_s="${3:-0}" n_exps="${4:-1}" + local start_ts; start_ts=$(date +%s) + # Baseline run-dir count — new dirs that appear are newly-started experiments. + local initial_runs; initial_runs=$(find experiments -maxdepth 1 -name "run_*" -type d 2>/dev/null | wc -l) + + echo "[$(date '+%F %T')] START $label ($n_exps exp(s), ~${budget_s}s budget)" | tee -a "$LOGDIR/debug_run.log" + + # Background progress ticker: fires every 30s, prints elapsed/remaining/percent + # and how many experiments have started (each start creates a new run_* dir). + ( + while true; do + sleep 30 + local now; now=$(date +%s) + local elapsed=$(( now - start_ts )) + local pct=0 remaining=0 + if [ "$budget_s" -gt 0 ]; then + pct=$(( elapsed * 100 / budget_s )) + remaining=$(( budget_s - elapsed )) + [ "$pct" -gt 100 ] && pct=100 + [ "$remaining" -lt 0 ] && remaining=0 + fi + local curr; curr=$(find experiments -maxdepth 1 -name "run_*" -type d 2>/dev/null | wc -l) + local started=$(( curr - initial_runs )) + [ "$started" -lt 0 ] && started=0 + printf " [%s] %s | %ds elapsed / ~%ds (%d%%) | exp started: %d/%d\n" \ + "$(date '+%T')" "$label" "$elapsed" "$budget_s" "$pct" "$started" "$n_exps" + done + ) & + local ticker_pid=$! + python -m flame.launch.run_experiment "$cfg" --example-dir "$EX" \ < /dev/null >> "$LOGDIR/${label}.out" 2>&1 local rc=$? - echo "[$(date '+%F %T')] DONE $label exit=$rc" | tee -a "$LOGDIR/debug_run.log" + + kill "$ticker_pid" 2>/dev/null + wait "$ticker_pid" 2>/dev/null + + local elapsed=$(( $(date +%s) - start_ts )) + echo "[$(date '+%F %T')] DONE $label exit=$rc (took ${elapsed}s / ~${budget_s}s budget)" | tee -a "$LOGDIR/debug_run.log" } # ---- smoke mode ---- @@ -208,8 +358,11 @@ if [ "$SMOKE" = "1" ]; then # Clear any stale config from a previous invocation so a no-match run is # skipped (not silently re-running a leftover config). rm -f "$cfg" - make_debug_yaml "$BASELINES" 240 "$cfg" 1 "$SIM_WALL_CEILING_S" "$MODE" - [ -f "$cfg" ] && run_node "dbg_smoke" "$cfg" + make_debug_yaml "$BASELINES" 240 "$cfg" 1 "$SIM_WALL_CEILING_S" "$MODE" "$TRACE" "" "$ALPHA" + if [ -f "$cfg" ]; then + _n=$(_count_exps "$cfg") + run_node "dbg_smoke" "$cfg" $(( _n * 240 )) "$_n" + fi echo "=== SMOKE RESULTS ===" for dd in experiments/run_*dbg_smoke_*; do [ -d "$dd" ] || continue @@ -221,18 +374,21 @@ if [ "$SMOKE" = "1" ]; then fi # ---- normal run mode ---- -echo "=== DEBUG RUN: baselines='$BASELINES' mode=$MODE runtime_s=$RUNTIME_S sim_wall_ceiling_s=${SIM_WALL_CEILING_S:-auto(=runtime_s)} ===" +echo "=== DEBUG RUN: baselines='$BASELINES' mode=$MODE runtime_s=$RUNTIME_S sim_wall_ceiling_s=${SIM_WALL_CEILING_S:-auto(=runtime_s)} num_trainers=${NUM_TRAINERS:-300(default)} alpha=${ALPHA:-0.1(default)} ===" cfg="$LOGDIR/debug_run.yaml" # Clear any stale config so a no-match run is skipped (not silently re-running # a previous baseline's leftover config). rm -f "$cfg" -make_debug_yaml "$BASELINES" "$RUNTIME_S" "$cfg" 0 "$SIM_WALL_CEILING_S" "$MODE" +make_debug_yaml "$BASELINES" "$RUNTIME_S" "$cfg" 0 "$SIM_WALL_CEILING_S" "$MODE" "$TRACE" "$NUM_TRAINERS" "$ALPHA" if [ ! -f "$cfg" ]; then echo "No experiments matched for baselines='$BASELINES'. Nothing to run." exit 0 fi -run_node "debug_run" "$cfg" +_n_exps=$(_count_exps "$cfg") +_budget=$(( _n_exps * RUNTIME_S )) +echo " queued: $_n_exps exp(s), estimated budget ~${_budget}s (sim finishes faster than real)" +run_node "debug_run" "$cfg" "$_budget" "$_n_exps" echo "Logs: $LOGDIR/debug_run.out" echo "Run dirs: experiments/run_*dbg_*" diff --git a/lib/python/examples/async_cifar10/scripts/gen_n50_experiment.py b/lib/python/examples/async_cifar10/scripts/gen_n50_experiment.py index 602a4a161..1e3a16b0c 100755 --- a/lib/python/examples/async_cifar10/scripts/gen_n50_experiment.py +++ b/lib/python/examples/async_cifar10/scripts/gen_n50_experiment.py @@ -83,7 +83,7 @@ def make_arm(baseline, staggered, oracle=False, suffix=""): name = f"{baseline}{ocl}_n50_alpha0.1_syn0_stream_{cond}_sim{suffix}" agg_hp = { "batchSize": 10, "learningRate": 0.01, - "rounds": ROUNDS_CAP, "max_runtime_s": MAX_RUNTIME_S, + "rounds": ROUNDS_CAP, "max_experiment_runtime_s": MAX_RUNTIME_S, "aggGoal": 10, "evalEveryNRounds": EVAL_EVERY, "targetAccuracy": TARGET_ACC, "stableEvalsAboveTarget": STABLE_EVALS, "min_trainers_to_start": N - 2, "min_trainers_join_timeout_s": 600, diff --git a/lib/python/examples/async_cifar10/scripts/parity/avail_state_series.py b/lib/python/examples/async_cifar10/scripts/parity/avail_state_series.py new file mode 100644 index 000000000..00344ce07 --- /dev/null +++ b/lib/python/examples/async_cifar10/scripts/parity/avail_state_series.py @@ -0,0 +1,183 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Shared per-trainer availability-state series builder (Stage C.6.2). + +Single resolver, imported by both checks.py (Aa / A4dur / observation_lag rungs) +and analyze_run.py (the four plots re-pointed in C.6.4), so the forward-fill +semantics never diverge between the checker and the plotter (Challenge 12 +discipline — one function, not a duplicated copy in each consumer). + +Reads `per_trainer[end_id]["avl_state"]` on each `selection` event (C.6.1). +Time-base: both modes prefer `vclock_now`, stamped on the event via +`ClientAvailability._avail_now()` (sim: `_vclock.now`; real: wall-elapsed since +`agg_start_time_ts`) — the same shared origin the rest of the availability +substrate uses. Telemetry recorded before real-mode `vclock_now` stamping was +added falls back to `ts - t0` (t0 = the run's first selection event ts), which +is a *biased* estimate: real's first selection event fires only once enough +trainers have joined over MQTT (~300s for n=300), so it under-counts elapsed +time relative to the trace's true origin and skews any duration-weighted +comparison (A4dur) for trainers whose state changes mid-run. Kept only for +backward-compat with old runs — new telemetry should always carry vclock_now. +""" + +from __future__ import annotations + +from typing import Optional + + +def _event_time(e: dict, mode: str, t0: float) -> Optional[float]: + vclock = e.get("vclock_now") + if vclock is not None: + return vclock + if mode == "sim": + return None + ts = e.get("ts") + return None if ts is None else ts - t0 + + +def build_trainer_state_series( + selection_events: list, mode: str +) -> dict[str, list]: + """{end_id: [(t, avl_state), ...]} forward-fill series, sorted by t. + + mode: "sim" or "real", both preferring t = vclock_now, falling back to + ts - t0 only for real-mode telemetry recorded before vclock_now was + stamped on real selection events. One sample per + end_id per selection event it appears as a candidate in (whether or not + selected) — `avail_composition`/`per_trainer` already cover every + candidate in the pool, not just the chosen subset. Consecutive samples at + the same t collapse to the last write (same-instant events, e.g. carried + pacer state). + """ + real_ts = [e.get("ts") for e in selection_events if e.get("ts") is not None] + t0 = min(real_ts) if (mode == "real" and real_ts) else 0.0 + + series: dict[str, list] = {} + for e in sorted( + selection_events, key=lambda x: (x.get("round", 0), x.get("ts", 0.0)) + ): + t = _event_time(e, mode, t0) + if t is None: + continue + for end_id, cand in (e.get("per_trainer") or {}).items(): + state = cand.get("avl_state") + if state is None or state == "UNKNOWN": + continue + pts = series.setdefault(end_id, []) + if pts and pts[-1][0] == t: + pts[-1] = (t, state) + else: + pts.append((t, state)) + return series + + +def build_observed_timeline_from_avail_change(avail_change_events: list) -> list: + """Sorted [(sim_now, new_state), ...] from one trainer's own avail_change telemetry. + + ``sim_now`` (Batch 3 T3.2) is the trainer's own trace-time-basis clock at + the moment it applied the transition — sim: virtual-clock seconds; real: + wall-elapsed since the shared AGG_START_TS origin (T3.0). Distinct from + the record's ``ts`` (always wall time.time(), meaningless against a trace + indexed in trace-seconds). Events recorded before ``sim_now`` existed are + dropped; an entirely-empty result means "no fidelity signal for this + trainer" (old telemetry), not "trainer never transitioned" — the A6 + caller must treat empty-with-no-events differently only if it also has no + sim_now-tagged events at all across the whole run (checked once, not per + trainer). + """ + pts: list = [] + for e in sorted( + avail_change_events, key=lambda x: (x.get("round", 0), x.get("ts", 0.0)) + ): + t = e.get("sim_now") + state = e.get("new_state") + if t is None or state is None: + continue + if pts and pts[-1][0] == t: + pts[-1] = (t, state) + else: + pts.append((t, state)) + return pts + + +def build_observed_timeline_from_agg_belief(events: list) -> list: + """Sorted [(observed_at, state), ...] from one trainer's own + agg_belief_change telemetry (Batch 3 T3.3), already filtered by the + caller to a single end_id and checkpoint ("selection" | "commit"). + + ``observed_at`` is the trace-time-basis clock the belief was read at + (vclock seconds / wall-elapsed since the shared origin) -- same role as + avail_change's ``sim_now`` in build_observed_timeline_from_avail_change, + just a different telemetry stream (aggregator belief vs. trainer's own + self-report). + """ + pts: list = [] + for e in sorted( + events, key=lambda x: (x.get("round", 0), x.get("observed_at", 0.0)) + ): + t = e.get("observed_at") + state = e.get("state") + if t is None or state is None: + continue + if pts and pts[-1][0] == t: + pts[-1] = (t, state) + else: + pts.append((t, state)) + return pts + + +def selection_run_span(selection_events: list, mode: str) -> float: + """Max observed time across all selection events. + + Unlike run_span() (which needs a built per-trainer avl_state series), + this only needs the events' own ts/vclock_now -- usable by checks that + just need the run's overall time horizon and nothing about per-trainer + avail state (e.g. A6, which reads its own per-trainer state from + avail_change telemetry instead). Same t = vclock_now / (ts - t0) + time-base convention as build_trainer_state_series. + """ + real_ts = [e.get("ts") for e in selection_events if e.get("ts") is not None] + t0 = min(real_ts) if (mode == "real" and real_ts) else 0.0 + times = [ + t for t in (_event_time(e, mode, t0) for e in selection_events) + if t is not None + ] + return max(times) if times else 0.0 + + +def run_span(series: dict) -> float: + """Max observed t across all trainers — the run's own time horizon.""" + return max((pts[-1][0] for pts in series.values() if pts), default=0.0) + + +def state_fractions(series: dict, t_end: Optional[float] = None) -> dict: + """Per-trainer {state: fraction_of_span} from a forward-filled series. + + Dwell-time integration: each sample's state holds until the next sample + (or `t_end` for the trailing segment, default = the trainer's own last + sample — i.e. no tail credited beyond its last observation). Trainers + with < 2 samples are omitted (no observed dwell to integrate). Per-trainer + vectors sum to 1. + """ + out: dict = {} + for end_id, pts in series.items(): + if len(pts) < 2: + continue + durations: dict = {} + for (t_a, s_a), (t_b, _) in zip(pts, pts[1:]): + durations[s_a] = durations.get(s_a, 0.0) + max(0.0, t_b - t_a) + last_t, last_s = pts[-1] + end_t = t_end if t_end is not None else last_t + if end_t > last_t: + durations[last_s] = durations.get(last_s, 0.0) + (end_t - last_t) + total = sum(durations.values()) + if total <= 0: + continue + out[end_id] = {s: d / total for s, d in durations.items()} + return out + + +def total_variation_distance(a: dict, b: dict) -> float: + """0.5 * Σ_s |a_s - b_s| over the union of states; 0 if identical.""" + keys = set(a) | set(b) + return 0.5 * sum(abs(a.get(k, 0.0) - b.get(k, 0.0)) for k in keys) diff --git a/lib/python/examples/async_cifar10/scripts/parity/checks.py b/lib/python/examples/async_cifar10/scripts/parity/checks.py index effc43fc7..984939709 100644 --- a/lib/python/examples/async_cifar10/scripts/parity/checks.py +++ b/lib/python/examples/async_cifar10/scripts/parity/checks.py @@ -26,6 +26,22 @@ import re import statistics from pathlib import Path + +from .avail_state_series import ( + build_observed_timeline_from_agg_belief, + build_observed_timeline_from_avail_change, + build_trainer_state_series, + run_span, + selection_run_span, + state_fractions, + total_variation_distance, +) +from .ground_truth import ( + by_short_id, + expected_send_gate_wait, + state_fractions_over_range, + transitions_in_range, +) from typing import Optional @@ -190,6 +206,9 @@ def load_agg_jsonl(path: str) -> dict: eval_commits: list = [] agg_evals: list = [] residence: list = [] + withheld_deliveries: list = [] + abandon_timeouts: list = [] + agg_belief_changes: list = [] with open(path) as f: for line in f: line = line.strip() @@ -199,6 +218,12 @@ def load_agg_jsonl(path: str) -> dict: ev = e.get("event") if ev == "selection" and e.get("task") == "train": selection_train.append(e) + elif ev == "withheld_delivery": + withheld_deliveries.append(e) + elif ev == "abandon_timeout": + abandon_timeouts.append(e) + elif ev == "agg_belief_change": + agg_belief_changes.append(e) elif ev == "agg_round": # Eval commits emit event=agg_round (tagged task=eval) so U6/U6e can # read their commit timeliness, but they carry no agg_goal_count and @@ -218,12 +243,22 @@ def load_agg_jsonl(path: str) -> dict: eval_commits.sort(key=lambda x: (x["round"], x["ts"])) agg_evals.sort(key=lambda x: x["round"]) residence.sort(key=lambda x: (x["round"], x["ts"])) + withheld_deliveries.sort(key=lambda x: (x.get("round", 0), x.get("ts", 0))) + abandon_timeouts.sort(key=lambda x: (x.get("round", 0), x.get("ts", 0))) + agg_belief_changes.sort(key=lambda x: (x.get("round", 0), x.get("observed_at", 0.0))) return { "selection_train": selection_train, "agg_rounds": agg_rounds, "eval_commits": eval_commits, "agg_evals": agg_evals, "residence": residence, + # Stage C availability events (sim-only): the send-gate late stale + # deliveries and the 90s vclock abandons. + "withheld_deliveries": withheld_deliveries, + "abandon_timeouts": abandon_timeouts, + # Batch 3 T3.3: aggregator belief-tracking (commit checkpoint only — + # the selection checkpoint is already in selection_train.per_trainer.avl_state). + "agg_belief_changes": agg_belief_changes, } @@ -241,6 +276,7 @@ def load_trainer_jsonl_dir(telemetry_dir: Optional[str]) -> dict: for f in sorted(d.glob("trainer_*.jsonl")): short_id = f.stem[-4:] task_recv_evs, trainer_round_evs, task_send_evs = [], [], [] + avail_change_evs: list = [] with open(f) as fp: for line in fp: line = line.strip() @@ -257,10 +293,15 @@ def load_trainer_jsonl_dir(telemetry_dir: Optional[str]) -> dict: trainer_round_evs.append(e) elif ev == "task_send": task_send_evs.append(e) + elif ev == "avail_change": + # Trainer availability transitions (A4 duty-cycle). Previously + # dropped here, so duty_cycle_parity was permanently SKIP. + avail_change_evs.append(e) result[short_id] = { "task_recv": task_recv_evs, "trainer_round": trainer_round_evs, "task_send": task_send_evs, + "avail_change": avail_change_evs, } return result @@ -1020,7 +1061,11 @@ def vals(agg_rounds): } -NEAR_ZERO_LAG_S = 0.05 # U6: both-modes mean lag <= this ⇒ immediate commit, KS uninformative +NEAR_ZERO_LAG_S = 0.10 # U6: both-modes mean lag <= this ⇒ immediate commit, KS uninformative +# 0.10s (raised from 0.05): sim with active availability windows sees ~70ms mean lag +# from carry-over burst commits right after an unavailability window ends — vclock +# advances through the stale queue before the next fresh update, inflating the per-round +# mean slightly above the old 50ms guard without indicating a real past-dating bug. def commit_visibility_parity(real: dict, sim: dict, warn_ks: float = 0.2, @@ -1034,20 +1079,37 @@ def commit_visibility_parity(real: dict, sim: dict, warn_ks: float = 0.2, the barrier wait, matching in both. Either way fidelity = sim dist == real dist, so we KS the two and also flag the mean gap. Upstream of staleness: a sim that commits updates late (past-dating) inflates staleness downstream. + + A withheld-then-delivered update (D.1/C.2) commits at + ``delivery_ts = max(sct, next_avail_ts)`` by construction (the down-window + delay), so its ``update_visibility_lag_s`` for that one commit equals the + delay already measured by the dedicated ``withheld_delivery`` rung + (`delivery_ts - sct`). Folding it into this distribution double-counts the + same signal and inflates the mean with an outlier this metric isn't + measuring (commit timeliness) — excluded by (round, end) cross-reference + against ``withheld_deliveries`` so the two rungs stay separable, per the + intended "withheld past-dating bucket" split (Stage C invariant notes). """ - def vals(agg_rounds): + def vals(agg_rounds, withheld_keys): out = [] for e in agg_rounds: v = e.get("update_visibility_lag_s") if v is None: continue + ends = e.get("contributing_trainers") or [] + if any((e.get("round"), end) in withheld_keys for end in ends): + continue if isinstance(v, (int, float)): out.append(float(v)) else: out.extend(float(x) for x in v if x is not None) return out - rv, sv = vals(real["agg_rounds"]), vals(sim["agg_rounds"]) + def withheld_keys(loaded): + return {(e.get("round"), e.get("end_id")) for e in loaded.get("withheld_deliveries", [])} + + rv = vals(real["agg_rounds"], withheld_keys(real)) + sv = vals(sim["agg_rounds"], withheld_keys(sim)) if not rv or not sv: return {"ok": True, "tier": "DIST", "skipped": True, "reason": "update_visibility_lag_s absent in one mode " @@ -2330,9 +2392,15 @@ def _traj(sel): def duty_cycle_parity(real_trainers: dict, sim_trainers: dict) -> dict: """A4 [DIST]: per-trainer availability duty-cycle parity. - Requires avail_change telemetry (on/off transitions per trainer), which - the current loader does not surface — SKIP placeholder per the append-only - growth rule; activates automatically once that telemetry exists. + Requires avail_change telemetry (per-trainer state transitions), now surfaced + by load_trainer_jsonl_dir. SKIP when absent (e.g. v1 oracular runs with + client_notify OFF, where the aggregator reads the trace directly and the + trainer emits no transitions — the trace-grounded A4b validator is the right + check there; see UNAVAILABILITY_DESIGN.md Stage B). + + NOTE (limitation, intentional): this counts the fraction of TRANSITIONS whose + new_state is AVL_*, not time-in-state. A duration-weighted duty cycle is the + A4b trace-vs-dispatch validator (to add with run data). """ def _has_avail_change(tr): return any(d.get("avail_change") for d in tr.values()) @@ -2340,14 +2408,15 @@ def _has_avail_change(tr): if not _has_avail_change(real_trainers) and not _has_avail_change(sim_trainers): return {"ok": True, "tier": "DIST", "status": "SKIP", "note": "avail_change telemetry not available; A4 inactive"} - # Telemetry present: compare per-trainer on-fraction. + # Telemetry present: compare per-trainer on-fraction. avail_change events carry + # {old_state, new_state} (build_avail_change), so "available" = new_state is AVL_*. def _on_frac(tr): out = {} for tid, d in tr.items(): evs = d.get("avail_change", []) if not evs: continue - on = sum(1 for e in evs if e.get("available")) + on = sum(1 for e in evs if str(e.get("new_state", "")).startswith("AVL")) out[tid] = on / len(evs) return out @@ -2359,6 +2428,870 @@ def _on_frac(tr): "max_dutycycle_diff": round(max_diff, 3), "n_trainers": len(keys)} +def duration_duty_cycle_parity(real: dict, sim: dict, + mean_tol: float = 0.05, + within_tau: float = 0.10, + frac_pass_tol: float = 0.95) -> dict: + """A4dur [DIST]: duration-weighted duty-cycle parity, real vs sim (C.6.3). + + Replaces A4's transition-FRACTION counting (a bare max over `avail_change` + — brittle, and blind in pure-oracular mode; see Dead-ends §9) with time- + IN-STATE: per-trainer {state: fraction_of_run} from `trainer_state_series` + (C.6.2, reading the C.6.1 per-trainer `avl_state` on selection events), + dwell-integrated over each mode's own run span. Per-trainer error = total- + variation distance between the real/sim fraction vectors. + + Population rollup is a DISTRIBUTION (mean/p50/p90/p99 + + frac_trainers_within_tol), not a single number — a systematic small drift + (mean) and a real diverging subset (tail) are different failure modes; + neither alone is robust (mirrors U6's "distribution + robust summary" + precedent already in this checker). + + Pass rule: mean_err <= mean_tol AND frac_within_tol >= frac_pass_tol — two + independent conditions for the two failure modes above. Kept alongside the + existing transition-count `duty_cycle_parity` (A4), which catches a + different failure mode (transitions stopping entirely) cheaply. SKIP if + either mode has no per-trainer avl_state samples (gate off, or telemetry + predates C.6.1). + """ + r_series = build_trainer_state_series(real["selection_train"], mode="real") + s_series = build_trainer_state_series(sim["selection_train"], mode="sim") + if not r_series or not s_series: + return {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "no per-trainer avl_state in selection telemetry " + "(gate off, or predates C.6.1)"} + + r_frac = state_fractions(r_series, t_end=run_span(r_series)) + s_frac = state_fractions(s_series, t_end=run_span(s_series)) + common = sorted(set(r_frac) & set(s_frac)) + if not common: + return {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "no trainers with >=2 avl_state samples in both modes"} + + errs = {tid: total_variation_distance(r_frac[tid], s_frac[tid]) for tid in common} + err_vals = list(errs.values()) + mean_err = sum(err_vals) / len(err_vals) + frac_within_tol = sum(1 for e in err_vals if e <= within_tau) / len(err_vals) + worst = sorted(errs.items(), key=lambda kv: -kv[1])[:5] + return { + "ok": mean_err <= mean_tol and frac_within_tol >= frac_pass_tol, + "tier": "DIST", + "n_trainers": len(common), + "mean_err": round(mean_err, 4), + "p50_err": round(percentile(err_vals, 50), 4), + "p90_err": round(percentile(err_vals, 90), 4), + "p99_err": round(percentile(err_vals, 99), 4), + "frac_within_tol": round(frac_within_tol, 3), + "within_tau": within_tau, + "mean_tol": mean_tol, + "frac_pass_tol": frac_pass_tol, + "worst_trainers": [{"end": short(tid), "err": round(e, 4)} for tid, e in worst], + } + + +def withheld_delivery_parity(real: dict, sim: dict) -> dict: + """withheld_delivery [NEW, sim characterization]: send-gated updates deliver + late and STALE, never before completion. + + The C.2 send-gate holds an update whose trainer is UN_AVL at completion (sct) + and re-commits it at delivery_ts = max(sct, next_avail) — stale, never + discarded. This rung asserts the STRUCTURAL invariants of that path (the + cross-mode staleness magnitude is owned by the `staleness` rung / U3): + * delivery_ts >= sct — never deliver before completion (no past-dating), + * delay_s = delivery_ts - sct >= 0, + * staleness >= 0. + Real mode emits no withheld_delivery (its trainer send-gate is a different + mechanism), so this is sim-only; SKIP when the gate is off (no events). + """ + evs = sim.get("withheld_deliveries", []) or [] + if not evs: + return {"ok": True, "tier": "DIAG", "status": "SKIP", + "note": "no withheld_delivery events (gate off or no withholds)"} + delays, stales, accepted, bad = [], [], 0, [] + for e in evs: + sct, dts = e.get("sct"), e.get("delivery_ts") + dly, st = e.get("delay_s"), e.get("staleness") + if dly is None and sct is not None and dts is not None: + dly = float(dts) - float(sct) + if sct is not None and dts is not None and float(dts) + 1e-6 < float(sct): + bad.append({"end": e.get("end_id"), "sct": sct, "delivery_ts": dts}) + if dly is not None: + delays.append(float(dly)) + if float(dly) < -1e-6: + bad.append({"end": e.get("end_id"), "delay_s": dly}) + if st is not None: + stales.append(int(st)) + if int(st) < 0: + bad.append({"end": e.get("end_id"), "staleness": st}) + if e.get("accepted"): + accepted += 1 + dmean, _ = mean_std(delays) if delays else (float("nan"), 0.0) + smean, _ = mean_std(stales) if stales else (float("nan"), 0.0) + return { + "ok": len(bad) == 0, + "tier": "DIAG", + "n_withheld": len(evs), + "mean_delay_s": round(dmean, 1) if delays else None, + "p95_delay_s": round(percentile(delays, 95), 1) if delays else None, + "mean_staleness": round(smean, 2) if stales else None, + "accept_frac": round(accepted / len(evs), 3), + "violations": bad[:10], + } + + +def commit_promptness_parity(sim: dict, early_tol_s: float = 1.0, + late_slack_tol_s: float = 30.0) -> dict: + """K11 [INV]: per-event hard invariant -- actual commit time vs. + earliest-legally-committable time (Batch 3 T3.5, "Pillar 3" aggregator + half — general/mechanism-agnostic, not availability-specific in principle, + though today's only telemetry source for it is the availability send-gate). + + Scope: the withheld-then-delivered population only (`withheld_deliveries`), + not every commit. A NORMAL (non-gated) commit's earliest-legally-committable + time is trivially its own `sct` — checking `actual_commit_ts >= sct` there + would just be re-measuring ordinary round-batching queue depth (multiple + commits sharing one monotonic vclock inside a round always show positive + "slack" against their own sct, by construction of `_advance_sim_clock`'s + max()), not a real promptness bug. The withheld population is where + `earliest_legally_committable_time` is a MEANINGFUL constraint distinct + from `sct` — and, per `compute_delivery_ts` (client_availability.py, T3.5 + finding, see UNAVAILABILITY_DESIGN.md), `delivery_ts` there already IS + `earliest_legally_committable_time` (the max of whichever gates are + active, generalized as far as v1 has more than one gate type to take a + max over) — no separate bookkeeping field was needed, just an + `actual_commit_ts` stamp to compare it against. + + `commit_slack_s = actual_commit_ts - delivery_ts`. Two distinct failure + modes, reported separately: + * EARLY (`slack < -early_tol_s`): committed before it was legally + available — a correctness bug (past-dating), same class as + `withheld_delivery`'s `delivery_ts >= sct` check but stricter (against + the ACTUAL commit instant, not just the registered delivery_ts). + * LATE (`slack > late_slack_tol_s`): held longer than the gate strictly + required — a promptness/scheduling bug (e.g. coarse reinjection + polling — `_sim_reinject_ready_withheld` only runs once per + commit-loop invocation). + Both gate `ok`; `late_slack_tol_s`'s default is a starting point pending + real-run calibration (Phase 6), same caveat as A6/A7/A8's DIST tolerances. + + Sim-only: real emits no `withheld_delivery` at all (its trainer send-gate + is a different, trainer-side mechanism — see `withheld_delivery_parity`). + SKIP when no withheld_delivery event carries `actual_commit_ts` (gate off, + no withholds, or telemetry predates T3.5). + """ + evs = sim.get("withheld_deliveries", []) or [] + slacks: list = [] + early_violations: list = [] + late_violations: list = [] + for e in evs: + act, dts = e.get("actual_commit_ts"), e.get("delivery_ts") + if act is None or dts is None: + continue + slack = float(act) - float(dts) + slacks.append(slack) + if slack < -early_tol_s: + early_violations.append({"end": e.get("end_id"), "slack_s": round(slack, 2)}) + elif slack > late_slack_tol_s: + late_violations.append({"end": e.get("end_id"), "slack_s": round(slack, 2)}) + + if not slacks: + return {"ok": True, "tier": "INV", "status": "SKIP", + "note": "no withheld_delivery events with actual_commit_ts " + "(gate off, no withholds, or predates T3.5)"} + + mean_slack, _ = mean_std(slacks) + return { + "ok": not early_violations and not late_violations, + "tier": "INV", + "n_events": len(slacks), + "mean_slack_s": round(mean_slack, 2), + "max_slack_s": round(max(slacks), 2), + "min_slack_s": round(min(slacks), 2), + "n_early_violations": len(early_violations), + "n_late_violations": len(late_violations), + "early_tol_s": early_tol_s, + "late_slack_tol_s": late_slack_tol_s, + "early_violations": early_violations[:10], + "late_violations": late_violations[:10], + } + + +def abandon_timeout_parity(real: dict, sim: dict, + threshold_s: float = 90.0, + wall_leak_ceiling_s: float = 1e7) -> dict: + """abandon_timeout [NEW, CONTROL]: the 90s abandon fires on the VCLOCK. + + Each C.3 abandon (``reason="abandon_90s_vclock"``) frees a stalled + in-flight slot at age >= SEND_TIMEOUT_WAIT_S. Control purpose + (Challenge 2): the deadline must be measured on the vclock, not the wall — + a wall-clock leak surfaces as an age in epoch-scale seconds (~1.7e9) + instead of sim-seconds. Fails loudly if any C.3 age is wall-scale or below + the threshold. + + D.1 boundary evictions (``reason="aware_boundary_eviction"``) are a + *different* mechanism — they free the slot proactively at the next + selection boundary specifically to avoid the 90s wait, so a low age is + their correct, expected behavior, not a violation. They're tracked + separately and never measured against ``threshold_s``; only a wall-clock + leak (age epoch-scale) would be a bug for them too. + + Sim-only (real uses the wall selector abandon); SKIP when no abandons + fired. + """ + evs = sim.get("abandon_timeouts", []) or [] + if not evs: + return {"ok": True, "tier": "INV", "status": "SKIP", + "note": "no abandon_timeout events (gate off or none stalled)"} + + def _age(e): + age = e.get("age_s") + if age is None: + sst, now = e.get("sim_send_ts"), e.get("vclock_now") + if sst is not None and now is not None: + age = float(now) - float(sst) + return None if age is None else float(age) + + c3_ages, d1_ages, wall_leak, below = [], [], [], [] + for e in evs: + age = _age(e) + if age is None: + continue + if age >= wall_leak_ceiling_s: + wall_leak.append(e.get("end_id")) + continue + if e.get("reason") == "aware_boundary_eviction": + d1_ages.append(age) + else: + c3_ages.append(age) + if age + 1e-6 < threshold_s: + below.append({"end": e.get("end_id"), "age_s": round(age, 1)}) + c3_mean, _ = mean_std(c3_ages) if c3_ages else (float("nan"), 0.0) + out = { + "ok": not wall_leak and not below, + "tier": "INV", + "n_abandon": len(c3_ages), + "mean_age_s": round(c3_mean, 1) if c3_ages else None, + "max_age_s": round(max(c3_ages), 1) if c3_ages else None, + "threshold_s": threshold_s, + "wall_leak_ends": wall_leak[:10], + "below_threshold": below[:10], + } + if d1_ages: + d1_mean, _ = mean_std(d1_ages) + out["n_aware_boundary_eviction"] = len(d1_ages) + out["aware_boundary_eviction_mean_age_s"] = round(d1_mean, 1) + out["aware_boundary_eviction_max_age_s"] = round(max(d1_ages), 1) + if wall_leak: + out["note"] = "WALL-CLOCK LEAK: abandon age is epoch-scale; vclock not used" + return out + + +def starvation_advance_parity(real: dict, sim: dict, + jump_factor: float = 5.0) -> dict: + """starvation_advance [NEW, DIAG, Stage F]: vclock-advance events under scarcity. + + Stage F replaces wall-sleeping with vclock-advances when no trainers are + selectable. This rung detects such advances from the sim's agg_round timeline: + a vclock jump between consecutive rounds that exceeds ``jump_factor × mean_advance`` + suggests a starvation advance fired (the round completed without a commit). + + SKIP when the gate is off (no avail events) or when fewer than 3 rounds are + present (too few points to establish a baseline). PASS when no anomalous jumps + are detected (or syn_0 / 100%-availability runs where F never fires). + """ + rounds = sim.get("agg_rounds", []) + if not rounds: + return {"ok": True, "tier": "DIAG", "status": "SKIP", + "note": "no agg_round events"} + # Check if availability gate was active: any withheld_deliveries or + # abandon_timeouts events indicate the sim-unavailability path ran. + gate_active = bool( + sim.get("withheld_deliveries") or sim.get("abandon_timeouts") + or any(e.get("avail_composition") for e in sim.get("selection_train", [])) + ) + if not gate_active: + return {"ok": True, "tier": "DIAG", "status": "SKIP", + "note": "availability gate off (syn_0 / 100%-avail)"} + vclocks = sorted( + [float(r["vclock_now"]) for r in rounds if r.get("vclock_now") is not None] + ) + if len(vclocks) < 3: + return {"ok": True, "tier": "DIAG", "status": "SKIP", + "note": f"only {len(vclocks)} vclock points; need ≥3"} + gaps = [vclocks[i + 1] - vclocks[i] for i in range(len(vclocks) - 1)] + mean_gap = sum(gaps) / len(gaps) + threshold = jump_factor * mean_gap + jumps = [(i, g) for i, g in enumerate(gaps) if g > threshold] + return { + "ok": True, # informational only — starvation advances are expected + "tier": "DIAG", + "n_rounds": len(vclocks), + "mean_advance_s": round(mean_gap, 2), + "jump_threshold_s": round(threshold, 2), + "n_starvation_jumps": len(jumps), + "max_jump_s": round(max(g for _, g in jumps), 1) if jumps else 0.0, + "note": (f"{len(jumps)} starvation advance(s) detected " + f"(jump > {threshold:.1f}s = {jump_factor}× mean)") if jumps + else "no starvation advances detected", + } + + +def eligible_pool_reduction_parity(real: dict, sim: dict, + tol_rel: float = 0.25) -> dict: + """eligible_pool_reduction [NEW, DIAG]: availability shrinks the eligible pool + by the same amount in both modes. + + Complements A2 (absolute num_eligible) by isolating the REDUCTION + (num_candidates - num_eligible) — what availability + in-flight remove from + the pool. Under unavailability this is > 0 and should track across modes; at + 100% availability it is ~the in-flight count and A2 already covers it. + """ + def _red(sel): + out = [] + for e in sel: + nc, ne = e.get("num_candidates"), e.get("num_eligible") + if nc is not None and ne is not None: + out.append(max(0, int(nc) - int(ne))) + return out + + rr, sr = _red(real["selection_train"]), _red(sim["selection_train"]) + if not rr or not sr: + return {"ok": True, "tier": "DIAG", "status": "SKIP", + "note": "no num_candidates/num_eligible to compute reduction"} + rm, sm = sum(rr) / len(rr), sum(sr) / len(sr) + ref = max(rm, sm, 1.0) + rel = abs(rm - sm) / ref + return {"ok": rel <= tol_rel, "tier": "DIAG", + "real_mean_reduction": round(rm, 1), "sim_mean_reduction": round(sm, 1), + "rel_diff": round(rel, 3), "tol_rel": tol_rel} + + +def state_timeline_agreement(real: dict, sim: dict, + n_bins: int = 20, + tol: float = 0.95) -> dict: + """A5 [DIST]: per-(trainer, t) avl_state agreement between real and sim. + + Real and sim both read availability from the SAME trace, so at any + normalised time t ∈ [0, 1], a trainer's avl_state should be identical in + both runs. Forward-fills the per-trainer series (from C.6.1 avl_state on + selection events) at n_bins equally-spaced normalised time points, compares + the result per (trainer, bin), and reports match_frac. + + Time is normalised within each mode (t / run_span) so wall-time vs vclock + differences are removed before comparison. SKIP if either mode has no + per-trainer avl_state, or if the two modes share no common trainers. + PASS when match_frac >= tol (default 0.95). + """ + r_series = build_trainer_state_series(real["selection_train"], mode="real") + s_series = build_trainer_state_series(sim["selection_train"], mode="sim") + if not r_series or not s_series: + return {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "no per-trainer avl_state in selection telemetry " + "(gate off, or predates C.6.1)"} + + r_span = run_span(r_series) + s_span = run_span(s_series) + if r_span <= 0 or s_span <= 0: + return {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "degenerate run span (zero duration)"} + + common = sorted(set(r_series) & set(s_series)) + if not common: + return {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "no common trainers between real and sim series"} + + def _state_at_frac(pts, frac, span): + """Forward-fill: trainer state at absolute time frac*span.""" + target = frac * span + state = None + for t, s in pts: + if t <= target: + state = s + else: + break + return state + + bin_fracs = [(b + 0.5) / n_bins for b in range(n_bins)] + matched = 0 + total = 0 + mismatched: list = [] + + for tid in common: + r_pts, s_pts = r_series[tid], s_series[tid] + if not r_pts or not s_pts: + continue + for frac in bin_fracs: + rs = _state_at_frac(r_pts, frac, r_span) + ss = _state_at_frac(s_pts, frac, s_span) + if rs is None or ss is None: + continue + total += 1 + if rs == ss: + matched += 1 + elif len(mismatched) < 5: + mismatched.append({ + "trainer": short(tid), + "frac": round(frac, 2), + "real": rs, "sim": ss, + }) + + if total == 0: + return {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "no (trainer, bin) pairs with data in both modes"} + + match_frac = matched / total + return { + "ok": match_frac >= tol, + "tier": "DIST", + "match_frac": round(match_frac, 4), + "matched": matched, + "total": total, + "tol": tol, + "n_bins": n_bins, + "n_trainers": len(common), + "mismatched_examples": mismatched, + } + + +def _match_transitions(gt_transitions: list, obs_transitions: list, + lag_tol_s: float) -> tuple: + """Greedy in-order pairing of ground-truth vs observed transition events. + + Both lists are chronological per-trainer transition sequences, so an + accurate observer's transitions should appear in the same order as ground + truth's (states alternate the same way in both). Walks ground truth in + order; each gt event consumes the *next* unconsumed observed event if it + has the same new_state and lands within lag_tol_s, else it's counted + missed. Any observed events never consumed are spurious. Returns + (lags, n_missed, n_spurious). + """ + lags: list = [] + missed = 0 + j = 0 + for gt_t, gt_s in gt_transitions: + if j < len(obs_transitions): + obs_t, obs_s = obs_transitions[j] + if obs_s == gt_s and abs(obs_t - gt_t) <= lag_tol_s: + lags.append(abs(obs_t - gt_t)) + j += 1 + continue + missed += 1 + spurious = len(obs_transitions) - j + return lags, missed, spurious + + +def _pad_tail(obs: list, span: float) -> list: + """Ensure a (t, state) series reaches `span` with >= 2 points. + + state_fractions() drops single-point series outright (no dwell segment to + integrate) -- append a synthetic tail point at the run's own span so a + trainer with exactly one observed point (its only transition landed at + t=0, or it never changed again after one early change) still contributes + a full-span dwell estimate instead of being silently excluded. + """ + if not obs: + return obs + if obs[-1][0] < span: + return obs + [(span, obs[-1][1])] + return obs + + +def _covered_intervals(obs: list, t_start: float, t_end: float, + max_gap_s: float) -> list: + """[(a, b, state), ...] -- the union of windows each observation + vouches for: itself forward to the next observation, or `max_gap_s` past + itself, whichever is sooner (capped at `t_end`). A gap longer than + `max_gap_s` on both sides of a given instant has NO covering + observation and is excluded from the returned intervals entirely. + + This is the interior-gap generalization of the tail truncation below: a + sparse, event-triggered observation stream (A7 commit-checkpoint) can't + be blamed for silence beyond its own validity window, whether that + silence is at the end of the run or between two observations. The + caller uses these same intervals to restrict BOTH the duration-weighted + TVD score and the missed/spurious-transition diagnostic, so a + transition with no nearby observation on either side is consistently + excluded from both (not scored as an error, not flagged as missed) -- + it is simply not fair to score what nothing was there to observe. + """ + pts = [p for p in obs if t_start <= p[0] <= t_end] + intervals: list = [] + for i, (t_a, s_a) in enumerate(pts): + nxt = pts[i + 1][0] if i + 1 < len(pts) else t_end + seg_end = min(nxt, t_a + max_gap_s, t_end) + if seg_end > t_a: + intervals.append((t_a, seg_end, s_a)) + return intervals + + +def _covered_fractions(intervals: list, gt) -> tuple: + """Duration-weighted {state: fraction} for obs and gt, integrated only + over `intervals` (see `_covered_intervals`).""" + obs_durations: dict = {} + gt_durations: dict = {} + for t_a, seg_end, s_a in intervals: + obs_durations[s_a] = obs_durations.get(s_a, 0.0) + (seg_end - t_a) + for s, frac in state_fractions_over_range(gt, t_a, seg_end).items(): + gt_durations[s] = gt_durations.get(s, 0.0) + frac * (seg_end - t_a) + obs_total = sum(obs_durations.values()) + gt_total = sum(gt_durations.values()) + if obs_total <= 0 or gt_total <= 0: + return None, {} + obs_frac = {s: d / obs_total for s, d in obs_durations.items()} + gt_frac = {s: d / gt_total for s, d in gt_durations.items()} + return obs_frac, gt_frac + + +def _fidelity_score(raw_obs: list, gt, span: float, lag_tol_s: float = 30.0, + seed_state: Optional[str] = None, + extrapolate_tail: bool = True, + max_gap_s: Optional[float] = None) -> Optional[tuple]: + """Shared A6/A7 core: one trainer's duration-weighted TVD vs ground truth, + plus event-level diagnostics (missed/spurious transitions, lags) from a + greedy in-order match against the raw trace's own transition points. + + `seed_state`: prepend (0.0, seed_state) when raw_obs doesn't already + start at/before t=0 -- the known initial-belief anchor (A6: a trainer + inits AVL_TRAIN, see main.py; A7 commit-checkpoint belief has no such + anchor -- a trainer with zero commits has no belief to seed, pass None). + Without a seed, the window before the first observation is EXCLUDED from + both sides of the comparison (t_start = first observed t) rather than + penalizing a belief that couldn't exist yet — a commit-checkpoint belief + only starts at the first commit, always > 0, so scoring against [0, span) + would otherwise blame a fixed, unavoidable "missing prefix" as if it were + genuine drift. + + `extrapolate_tail`: when True (A6, A7-selection -- continuously/densely + refreshed observation streams), `_pad_tail` carries the last observation + forward to `span`, matching the historical behavior. When False (A7 + commit-checkpoint -- Batch 4 finding, UNAVAILABILITY_DESIGN.md), the + window is instead truncated to `[t_start, last observed t]`: "commit" is + an inherently event-triggered sample, not a continuous one, and a + trainer that legitimately stops committing (typically because it went + UN_AVL -- exactly the state this check cares about) has no way to record + a belief for the un-observed tail. Extrapolating "still believed X" + across that silence blamed the *absence of a later commit* as if it were + a stale belief, systematically worst for the trainers this check most + wants to catch. Symmetric with the existing start-side truncation above. + + `max_gap_s`: when set (A7 commit-checkpoint -- Batch 4 live-run finding, + UNAVAILABILITY_DESIGN.md), extends the same "don't extrapolate a sparse + observation" reasoning to INTERIOR gaps, not just the tail: each + observation only vouches for its own state up to `max_gap_s` past + itself, not all the way to the next commit (subsuming and superseding + `extrapolate_tail`'s truncation -- the last observation's own + `max_gap_s` window already bounds the tail the same way). Without this, + a trainer that commits correctly at t=100 (AVL_TRAIN) and again + correctly at t=590 (AVL_TRAIN) but flips through UN_AVL and back in + between (e.g. [200,400)) was scored as if it believed AVL_TRAIN for the + whole [100,590) gap -- penalizing the *absence of a mid-gap commit*, the + same class of error the tail fix already exempts. The missed/spurious + transition diagnostic is filtered the same way: a ground-truth + transition with no covering observation window on either side is + excluded from both the score AND the diagnostic, not scored as 0 error + while simultaneously flagged "missed" (self-contradictory). `None` + (default) preserves the historical hold-until-next-observation behavior + for A6 and A7-selection, both dense enough that this rarely matters and + byte-identical scoring is wanted. + + Returns None if there's nothing to score (empty input, or ground-truth / + observed fraction computation comes up empty). + """ + if not raw_obs: + return None + obs = raw_obs + t_start = 0.0 + if seed_state is not None and raw_obs[0][0] > 0.0: + obs = [(0.0, seed_state)] + raw_obs + elif seed_state is None and raw_obs[0][0] > 0.0: + t_start = raw_obs[0][0] + if max_gap_s is None: + t_end = span if extrapolate_tail else min(span, obs[-1][0]) + obs = _pad_tail(obs, t_end) + obs_frac = state_fractions({"_": obs}, t_end=t_end).get("_") + gt_frac = state_fractions_over_range(gt, t_start, t_end) + gt_transitions = transitions_in_range(gt, t_start, t_end) + else: + t_end = span + intervals = _covered_intervals(obs, t_start, t_end, max_gap_s) + obs_frac, gt_frac = _covered_fractions(intervals, gt) + gt_transitions = [ + (ts, s) for ts, s in transitions_in_range(gt, t_start, t_end) + if any(a <= ts <= b for a, b, _ in intervals) + ] + if obs_frac is None or not gt_frac: + return None + tvd = total_variation_distance(obs_frac, gt_frac) + lags, missed, spurious = _match_transitions(gt_transitions, raw_obs, lag_tol_s) + return tvd, lags, missed, spurious + + +def _fidelity_result(errs: dict, n_missed: int, n_spurious: int, max_lag: float, + mode: str, mean_tol: float, within_tau: float, + frac_pass_tol: float, skip_note: str) -> dict: + """Shared A6/A7 result shape: DIST-tier population rollup (mean/p50/p90/ + p99 + frac_within_tol) over a {short_id: tvd_error} map, same pass rule + and worst-trainers reporting for both rungs.""" + if not errs: + return {"ok": True, "tier": "DIST", "status": "SKIP", "note": skip_note} + err_vals = list(errs.values()) + mean_err = sum(err_vals) / len(err_vals) + frac_within_tol = sum(1 for e in err_vals if e <= within_tau) / len(err_vals) + worst = sorted(errs.items(), key=lambda kv: -kv[1])[:5] + return { + "ok": mean_err <= mean_tol and frac_within_tol >= frac_pass_tol, + "tier": "DIST", + "mode": mode, + "n_trainers": len(errs), + "mean_err": round(mean_err, 4), + "p50_err": round(percentile(err_vals, 50), 4), + "p90_err": round(percentile(err_vals, 90), 4), + "p99_err": round(percentile(err_vals, 99), 4), + "frac_within_tol": round(frac_within_tol, 3), + "within_tau": within_tau, + "mean_tol": mean_tol, + "frac_pass_tol": frac_pass_tol, + "n_missed_transitions": n_missed, + "n_spurious_transitions": n_spurious, + "max_lag_s": round(max_lag, 1), + "worst_trainers": [{"end": tid, "err": round(e, 4)} for tid, e in worst], + } + + +def trainer_trace_fidelity_parity(trainer_dict: dict, selection_events: list, + mode: str, ground_truth: Optional[dict], + mean_tol: float = 0.05, + within_tau: float = 0.10, + frac_pass_tol: float = 0.95, + lag_tol_s: float = 30.0) -> dict: + """A6 [DIST]: per-trainer observed-vs-ground-truth-trace fidelity, ONE + mode at a time (Batch 3 T3.2 — "Pillar 1"). + + Unlike A4dur/A5 (real vs sim compared *to each other*), this compares a + single mode's own trainer-side telemetry (avail_change, i.e. what the + trainer itself believes/logs about its availability) against the raw + trace file directly — the absolute check that would have caught + Challenges §5 item 20 (real trainers running their send-gate against a + trivial always-available trace) on its own, without needing a companion + sim run to diff against. + + SKIP if no ground-truth trace was resolved for this run (predates T3.2 / + aggregator_config.json missing), the run span is degenerate, or no + trainer carries sim_now-tagged avail_change telemetry (predates T3.2). + """ + if not ground_truth: + return {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "no ground-truth trace resolved for this run"} + + span = selection_run_span(selection_events, mode) + if span <= 0: + return {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "degenerate run span"} + + gt_by_short = by_short_id(ground_truth) + errs: dict = {} + n_missed = n_spurious = 0 + max_lag = 0.0 + for short_id, d in trainer_dict.items(): + gt = gt_by_short.get(short_id) + if gt is None: + continue + raw_obs = build_observed_timeline_from_avail_change(d.get("avail_change", [])) + scored = _fidelity_score(raw_obs, gt, span, lag_tol_s, seed_state="AVL_TRAIN") + if scored is None: + continue + tvd, lags, missed, spurious = scored + errs[short_id] = tvd + n_missed += missed + n_spurious += spurious + if lags: + max_lag = max(max_lag, max(lags)) + + return _fidelity_result( + errs, n_missed, n_spurious, max_lag, mode, mean_tol, within_tau, frac_pass_tol, + skip_note="no trainers with both ground-truth and sim_now-tagged " + "avail_change telemetry (gate off, or predates T3.2)") + + +def agg_belief_fidelity_parity(agg: dict, mode: str, ground_truth: Optional[dict], + mean_tol: float = 0.05, within_tau: float = 0.10, + frac_pass_tol: float = 0.95, + lag_tol_s: float = 30.0) -> dict: + """A7 [DIST]: aggregator BELIEF vs ground-truth trace, ONE mode, BOTH + checkpoints (Batch 3 T3.3 — "Pillar 2"). Returns + {"selection": {...}, "commit": {...}}; the caller flattens each into its + own top-level result key so the causal ladder can localize a + selection-only vs commit-only divergence separately. + + **selection checkpoint** reuses the EXISTING per-candidate avl_state + stamped every selection cycle (`PROP_AVL_STATE` via + `_avail_stamp_end_states`, already read into `selection_train`'s + `per_trainer.avl_state` by `flame/selector/__init__.py`'s + `emit_selection`) — already the aggregator's belief, no new telemetry + (found while building T3.3: emitting a *fresh* `agg_belief_change` here + too would have doubled telemetry volume — up to 300 events/round — for + data that's already fully persisted; same class of "verify the doc's + assumption against actual code" correction as T3.2's `avail_change`/ + `sim_now` finding). + + **commit checkpoint** reads the NEW `agg_belief_change` telemetry + (`checkpoint="commit"`), emitted by `_record_commit_belief` from every + stack's real receive loop and from `_sim_withhold_if_unavail` in sim — + meaningful for ALL baselines, including unaware ones (oort/fedbuff) that + don't filter at selection but still get a commit-time belief reading. + """ + if not ground_truth: + skip = {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "no ground-truth trace resolved for this run"} + return {"selection": skip, "commit": skip} + + sel_events = agg.get("selection_train", []) + span = selection_run_span(sel_events, mode) + if span <= 0: + skip = {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "degenerate run span"} + return {"selection": skip, "commit": skip} + + gt_by_short = by_short_id(ground_truth) + + # --- selection checkpoint: reuse the existing per-candidate avl_state series --- + sel_series = build_trainer_state_series(sel_events, mode=mode) + sel_errs: dict = {} + sel_missed = sel_spurious = 0 + sel_max_lag = 0.0 + for end_id, raw_obs in sel_series.items(): + short_id = str(end_id)[-4:] + gt = gt_by_short.get(short_id) + if gt is None: + continue + scored = _fidelity_score(raw_obs, gt, span, lag_tol_s, seed_state="AVL_TRAIN") + if scored is None: + continue + tvd, lags, missed, spurious = scored + sel_errs[short_id] = tvd + sel_missed += missed + sel_spurious += spurious + if lags: + sel_max_lag = max(sel_max_lag, max(lags)) + sel_result = _fidelity_result( + sel_errs, sel_missed, sel_spurious, sel_max_lag, mode, mean_tol, within_tau, + frac_pass_tol, + skip_note="no trainers with ground-truth-matched avl_state in " + "selection telemetry") + + # --- commit checkpoint: NEW agg_belief_change telemetry --- + commit_by_end: dict = collections.defaultdict(list) + for e in agg.get("agg_belief_changes", []): + if e.get("checkpoint") == "commit": + commit_by_end[e.get("end_id")].append(e) + commit_errs: dict = {} + commit_missed = commit_spurious = 0 + commit_max_lag = 0.0 + for end_id, evs in commit_by_end.items(): + short_id = str(end_id)[-4:] + gt = gt_by_short.get(short_id) + if gt is None: + continue + raw_obs = build_observed_timeline_from_agg_belief(evs) + # extrapolate_tail=False + max_gap_s=lag_tol_s: "commit" is + # event-triggered, not continuous (Batch 4 finding, + # UNAVAILABILITY_DESIGN.md) -- don't score the silence after a + # trainer's last commit (tail) OR between two commits (interior gap) + # as if it were stale belief; each commit only vouches for its own + # state within lag_tol_s of itself. + scored = _fidelity_score(raw_obs, gt, span, lag_tol_s, seed_state=None, + extrapolate_tail=False, max_gap_s=lag_tol_s) + if scored is None: + continue + tvd, lags, missed, spurious = scored + commit_errs[short_id] = tvd + commit_missed += missed + commit_spurious += spurious + if lags: + commit_max_lag = max(commit_max_lag, max(lags)) + commit_result = _fidelity_result( + commit_errs, commit_missed, commit_spurious, commit_max_lag, mode, mean_tol, + within_tau, frac_pass_tol, + skip_note="no trainers with ground-truth-matched commit-checkpoint " + "agg_belief_change telemetry (gate off, or predates T3.3)") + + return {"selection": sel_result, "commit": commit_result} + + +def send_gate_wait_fidelity_parity(trainer_dict: dict, ground_truth: Optional[dict], + mean_tol_s: float = 10.0, + within_tau_s: float = 30.0, + frac_pass_tol: float = 0.95) -> dict: + """A8 [DIST, real mode only]: observed [SEND_GATE] wait vs. ground-truth- + expected wait (Batch 3 T3.4 — "Pillar 3", trainer half). + + For every real-mode task_send event carrying both send_gate_wait_s (the + actual wall-time spent blocked in _send_weights's UN_AVL wait loop) and + send_gate_sct (the trainer's own trace-time-basis clock, sampled right + before the gate check — same clock T3.2's avail_change.sim_now uses), + computes the ground-truth-expected wait directly from the raw trace + (expected_send_gate_wait, ground_truth.py) and compares it against the + observed wait. This validates the WAIT DURATION matches what the trace + says it should be — not just that some wait happened (a weaker property + already visible in the real send-gate's own [SEND_GATE] log line). + + Real mode only: sim's send-time gate is agg-side (Stage C); trainer-side + send_gate_wait_s/send_gate_sct are always None in sim telemetry by + construction, so a sim run naturally contributes nothing here. + + SKIP if no ground truth resolved, or no event carries both fields + (gate off, gate never engaged in this run, or telemetry predates T3.4). + Events whose trace never recovers after sct (expected wait undefined, + "would wait forever") are excluded from scoring, not treated as error. + """ + if not ground_truth: + return {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "no ground-truth trace resolved for this run"} + + gt_by_short = by_short_id(ground_truth) + errs: list = [] + n_events = 0 + n_uncomparable = 0 + for short_id, d in trainer_dict.items(): + gt = gt_by_short.get(short_id) + if gt is None: + continue + for e in d.get("task_send", []): + obs = e.get("send_gate_wait_s") + sct = e.get("send_gate_sct") + if obs is None or sct is None: + continue + n_events += 1 + expected = expected_send_gate_wait(gt, float(sct)) + if expected is None: + n_uncomparable += 1 + continue + errs.append(abs(float(obs) - expected)) + + if not errs: + return {"ok": True, "tier": "DIST", "status": "SKIP", + "note": "no real-mode task_send events with both " + "send_gate_wait_s and send_gate_sct (gate off, gate " + "never engaged, or predates T3.4)"} + + mean_err = sum(errs) / len(errs) + frac_within_tol = sum(1 for e in errs if e <= within_tau_s) / len(errs) + return { + "ok": mean_err <= mean_tol_s and frac_within_tol >= frac_pass_tol, + "tier": "DIST", + "n_events": n_events, + "n_scored": len(errs), + "n_uncomparable": n_uncomparable, + "mean_err_s": round(mean_err, 2), + "p50_err_s": round(percentile(errs, 50), 2), + "p90_err_s": round(percentile(errs, 90), 2), + "p99_err_s": round(percentile(errs, 99), 2), + "frac_within_tol": round(frac_within_tol, 3), + "within_tau_s": within_tau_s, + "mean_tol_s": mean_tol_s, + "frac_pass_tol": frac_pass_tol, + } + # ═══════════════════════════════════════════════════════════════════ # §3.4x Training input control & per-phase split (T2 / T_*) — Stage 4 # ═══════════════════════════════════════════════════════════════════ @@ -2432,9 +3365,24 @@ def _collect(tr, field): ks = ks_stat(rv, sv) rm, _ = mean_std(rv) sm, _ = mean_std(sv) - res = {"ok": ks <= ks_tol, "tier": "DIST", "phase": f, + # Point-mass guard: when both modes are sub-5ms the distribution is a + # near-zero spike; KS→1 is a statistical artifact of comparing two + # point masses at slightly different zero-proxies (0.001s real vs 0.0s + # sim). Pass on mean_diff instead — a real past-dating divergence clears + # 5ms by orders of magnitude. + _near_zero_phase_s = 0.005 + if abs(rm) <= _near_zero_phase_s and abs(sm) <= _near_zero_phase_s: + ok = True + note = (f"near-zero point mass (both means <={_near_zero_phase_s*1000:.0f}ms): " + "KS uninformative — passed on mean") + else: + ok = ks <= ks_tol + note = None + res = {"ok": ok, "tier": "DIST", "phase": f, "ks_stat": round(ks, 3), "ks_tol": ks_tol, "real_mean_s": round(rm, 3), "sim_mean_s": round(sm, 3)} + if note: + res["note"] = note # mqtt_fetch is pure network-I/O wall time: the sim serves weights from # an in-memory cache and folds the trainer cycle into budget+leg, so this # phase is deliberately NOT part of the virtual clock. Comparing it @@ -2485,7 +3433,9 @@ def run_all_parity(real_agg: dict, sim_agg: dict, agg_goal: int = 0, max_rounds: Optional[int] = None, rounds_cap: Optional[int] = None, - budget_s: Optional[float] = None) -> dict: + budget_s: Optional[float] = None, + real_ground_truth: Optional[dict] = None, + sim_ground_truth: Optional[dict] = None) -> dict: """Run the full parity + invariant battery; returns {name: result_dict}. Ordered HIGH → MID → LOW so coarse failures surface first: @@ -2523,6 +3473,24 @@ def run_all_parity(real_agg: dict, sim_agg: dict, results["eligible_speed"] = eligible_speed_composition_parity(real_agg, sim_agg) results["avail_timebase"] = avail_timebase_parity(real_agg, sim_agg) results["duty_cycle"] = duty_cycle_parity(real_trainers, sim_trainers) + results["duty_cycle_duration"] = duration_duty_cycle_parity(real_agg, sim_agg) + results["eligible_pool_reduction"] = eligible_pool_reduction_parity( + real_agg, sim_agg) + results["abandon_timeout"] = abandon_timeout_parity(real_agg, sim_agg) + results["starvation_advance"] = starvation_advance_parity(real_agg, sim_agg) + results["state_timeline_agreement"] = state_timeline_agreement(real_agg, sim_agg) + results["trainer_trace_fidelity_real"] = trainer_trace_fidelity_parity( + real_trainers, real_agg["selection_train"], "real", real_ground_truth) + results["trainer_trace_fidelity_sim"] = trainer_trace_fidelity_parity( + sim_trainers, sim_agg["selection_train"], "sim", sim_ground_truth) + _a7_real = agg_belief_fidelity_parity(real_agg, "real", real_ground_truth) + _a7_sim = agg_belief_fidelity_parity(sim_agg, "sim", sim_ground_truth) + results["agg_belief_fidelity_real_selection"] = _a7_real["selection"] + results["agg_belief_fidelity_real_commit"] = _a7_real["commit"] + results["agg_belief_fidelity_sim_selection"] = _a7_sim["selection"] + results["agg_belief_fidelity_sim_commit"] = _a7_sim["commit"] + results["send_gate_wait_fidelity_real"] = send_gate_wait_fidelity_parity( + real_trainers, real_ground_truth) # ── Stage 3 Selection ── results["selection_detail"] = selection_detail_parity(real_agg, sim_agg) @@ -2552,6 +3520,8 @@ def run_all_parity(real_agg: dict, sim_agg: dict, results["commit_visibility"] = commit_visibility_parity(real_agg, sim_agg) results["eval_commit_timeliness"] = eval_commit_timeliness(sim_agg) results["staleness"] = staleness_parity(real_agg, sim_agg) + results["withheld_delivery"] = withheld_delivery_parity(real_agg, sim_agg) + results["commit_promptness"] = commit_promptness_parity(sim_agg) results["aggregation_sequence"] = aggregation_sequence_parity( real_agg, sim_agg, max_rounds) @@ -2603,6 +3573,18 @@ def run_all_parity(real_agg: dict, sim_agg: dict, "eligible_speed": {"stage": 2, "role": "MECHANISM", "deps": ("eligibility",)}, "avail_timebase": {"stage": 2, "role": "CONTROL", "deps": ("per_round_advance",)}, "duty_cycle": {"stage": 2, "role": "MECHANISM", "deps": ("avail_timebase",)}, + "duty_cycle_duration": {"stage": 2, "role": "MECHANISM", "deps": ("avail_timebase",)}, + "eligible_pool_reduction": {"stage": 2, "role": "DIAG", "deps": ("eligibility",)}, + "abandon_timeout": {"stage": 2, "role": "CONTROL", "deps": ("avail_timebase",)}, + # A6/A7 (Batch 3 T3.2/T3.3) are absolute (vs. ground truth), not real-vs-sim + # — no dependency on avail_timebase (A3), unlike the relative Stage 2 checks above. + "trainer_trace_fidelity_real": {"stage": 2, "role": "MECHANISM", "deps": ()}, + "trainer_trace_fidelity_sim": {"stage": 2, "role": "MECHANISM", "deps": ()}, + "agg_belief_fidelity_real_selection": {"stage": 2, "role": "MECHANISM", "deps": ()}, + "agg_belief_fidelity_real_commit": {"stage": 2, "role": "MECHANISM", "deps": ()}, + "agg_belief_fidelity_sim_selection": {"stage": 2, "role": "MECHANISM", "deps": ()}, + "agg_belief_fidelity_sim_commit": {"stage": 2, "role": "MECHANISM", "deps": ()}, + "send_gate_wait_fidelity_real": {"stage": 2, "role": "MECHANISM", "deps": ()}, # ── Stage 3 Selection ── "selection_detail": {"stage": 3, "role": "MECHANISM", "deps": ("eligibility",)}, "residence": {"stage": 3, "role": "MECHANISM", "deps": ("eligibility",)}, @@ -2632,6 +3614,8 @@ def run_all_parity(real_agg: dict, sim_agg: dict, "commit_visibility": {"stage": 6, "role": "MECHANISM", "deps": ("per_round_advance",)}, "eval_commit_timeliness": {"stage": 6, "role": "MECHANISM", "deps": ("commit_visibility",)}, "staleness": {"stage": 6, "role": "MECHANISM", "deps": ("per_round_advance", "inter_arrival_order", "commit_visibility")}, + "withheld_delivery": {"stage": 6, "role": "DIAG", "deps": ("staleness", "abandon_timeout")}, + "commit_promptness": {"stage": 6, "role": "CONTROL", "deps": ("withheld_delivery",)}, "aggregation_sequence": {"stage": 6, "role": "EMERGENT", "deps": ("participation", "inter_arrival_order")}, "first_divergence_summary": {"stage": 6, "role": "DIAG", "deps": ()}, # ── Stage 7 Statistical utility ── @@ -2644,6 +3628,8 @@ def run_all_parity(real_agg: dict, sim_agg: dict, # ── Stage 9 Budget / stop sanity (orthogonal) ── "budget_not_cap": {"stage": 9, "role": "DIAG", "deps": ()}, "failsafe": {"stage": 9, "role": "MECHANISM", "deps": ()}, + # ── Stage F Starvation clock-advance ── + "starvation_advance": {"stage": 2, "role": "DIAG", "deps": ("abandon_timeout",)}, } # Checks whose FAIL is downgraded to WARN regardless of tier (expected-noisy). diff --git a/lib/python/examples/async_cifar10/scripts/parity/cli.py b/lib/python/examples/async_cifar10/scripts/parity/cli.py index a069b957c..7a4b2bbc6 100644 --- a/lib/python/examples/async_cifar10/scripts/parity/cli.py +++ b/lib/python/examples/async_cifar10/scripts/parity/cli.py @@ -57,6 +57,7 @@ def _run_pair(real_dir: str, sim_dir: str, from parity.checks import ( load_run_dir, run_all_parity, first_divergence, ) + from parity.ground_truth import load_ground_truth, resolve_trace_name from parity.report import print_report, write_json, write_plot real_label = real_label or os.path.basename(real_dir.rstrip("/")) @@ -67,6 +68,9 @@ def _run_pair(real_dir: str, sim_dir: str, print(f"[parity] Loading sim: {sim_label}") sim_agg, sim_trainers = load_run_dir(sim_dir) + real_ground_truth = load_ground_truth(resolve_trace_name(real_dir)) + sim_ground_truth = load_ground_truth(resolve_trace_name(sim_dir)) + print(f"[parity] real: {len(real_agg['agg_rounds'])} agg_round events, " f"{len(real_agg['selection_train'])} selection events, " f"{len(real_agg['agg_evals'])} eval events, " @@ -81,6 +85,8 @@ def _run_pair(real_dir: str, sim_dir: str, agg_goal=agg_goal, rounds_cap=rounds_cap, budget_s=budget_s, + real_ground_truth=real_ground_truth, + sim_ground_truth=sim_ground_truth, ) # Add first_divergence as a diagnostic summary entry (always ok — index=0 is expected for async) @@ -120,7 +126,7 @@ def main() -> None: parser.add_argument("--rounds-cap", type=int, default=None, help="rounds cap from config (enables K9 truncation check)") parser.add_argument("--budget-s", type=float, default=None, - help="max_runtime_s / sim_wall_ceiling_s (enables K5/K9)") + help="max_experiment_runtime_s / sim_wall_ceiling_s (enables K5/K9)") parser.add_argument("--strict", action="store_true", help="Treat WARN as FAIL") parser.add_argument("--lenient", action="store_true", diff --git a/lib/python/examples/async_cifar10/scripts/parity/ground_truth.py b/lib/python/examples/async_cifar10/scripts/parity/ground_truth.py new file mode 100644 index 000000000..d52cc94bd --- /dev/null +++ b/lib/python/examples/async_cifar10/scripts/parity/ground_truth.py @@ -0,0 +1,155 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Ground-truth trace lookups — shared infra for the Batch 3 absolute-fidelity +rungs (A6 trainer_trace_fidelity, A7 agg_belief_fidelity, A8 send_gate_wait_fidelity). + +Deliberately thin (see UNAVAILABILITY_DESIGN.md Batch 3 ▶ Implementation +phases → Phase 2): reuses flame.availability.trace's load_trace/state_at/ +read_trainer_unavailability almost as-is — no need to reimplement trace +loading, it already exists in exactly the shape needed. New code here is: + (a) a trace-*name* resolver — given a run dir, which of 3 possible config + keys holds the trace name actually used (varies by baseline, mirrors + debug_run.sh's own 3-way substitution branch), and + (b) a duration-weighted, time-range query wrapper around state_at, since the + checkers need "fraction of [t_start, t_end] spent in each state", not a + single point lookup. +""" + +from __future__ import annotations + +import json +import math +from pathlib import Path +from typing import Optional + +from sortedcontainers import SortedDict + +from flame.availability.trace import ( + next_avail_after, + read_trainer_unavailability, + state_at, +) +from flame.config import TrainerAvailState + +_AVL_STATES = frozenset({TrainerAvailState.AVL_TRAIN, TrainerAvailState.AVL_EVAL}) + + +def resolve_trace_name(run_dir: str) -> Optional[str]: + """Read aggregator_config.json in run_dir and return the configured trace name. + + Priority mirrors debug_run.sh's own ``--trace`` substitution branch (see + UNAVAILABILITY_DESIGN.md Baseline matrix ⁺ note): oort/oort_star/refl write + trackTrainerAvail.trace; felix/oort_star (HP-level client_notify path) + write client_notify.trace; feddance/fedbuff write availability_trace. Try + in that order so a run with more than one key set (e.g. a stale YAML + default alongside the live debug_run.sh override) resolves to the one + debug_run.sh itself would have picked, not an arbitrary one. + + Returns None if the config file is missing/unreadable or no key is set + (gate off / syn_0-style always-available). + """ + path = Path(run_dir) / "aggregator_config.json" + try: + with open(path, encoding="utf-8") as f: + cfg = json.load(f) + except (FileNotFoundError, json.JSONDecodeError): + return None + hp = cfg.get("hyperparameters", cfg) + + track = hp.get("trackTrainerAvail") or {} + trace = track.get("trace") + if trace: + return trace + + client_notify = hp.get("client_notify") or {} + trace = client_notify.get("trace") + if trace: + return trace + + return hp.get("availability_trace") or None + + +def load_ground_truth( + trace_name: Optional[str], base_dir: Optional[str] = None +) -> Optional[dict]: + """{task_id: SortedDict[ts -> state_str]} for every registered trainer. + + Thin re-export of flame.availability.trace.read_trainer_unavailability — + the canonical per-trainer trace loader, already used aggregator-side. + Returns None when trace_name is falsy or the registry/trace can't be read. + """ + return read_trainer_unavailability(trace_name, base_dir=base_dir) + + +def by_short_id(ground_truth: Optional[dict]) -> dict: + """Re-key {task_id: trace} to {task_id[-4:]: trace}. + + Matches the short-id convention scripts/parity/checks.py uses for trainer + telemetry (load_trainer_jsonl_dir keys on f.stem[-4:]; short() truncates + the same way elsewhere in this module) — lets A6/A7 join ground truth + directly against per-trainer telemetry dicts without a separate registry + lookup at call time. + """ + return {task_id[-4:]: trace for task_id, trace in (ground_truth or {}).items()} + + +def state_fractions_over_range( + trace: SortedDict, t_start: float, t_end: float +) -> dict: + """Duration-weighted {state: fraction_of[t_start, t_end]}, read directly + off the raw ground-truth trace. + + Exact dwell-time integration over the trace's own transition points + within the range (not sampled/binned) — the ground-truth counterpart to + avail_state_series.state_fractions(), which does the same integration + over an *observed* (telemetry-derived) series instead. + """ + if t_end <= t_start: + return {} + boundaries = [t_start] + boundaries.extend(trace.irange(t_start, t_end, inclusive=(False, False))) + boundaries.append(t_end) + durations: dict = {} + for a, b in zip(boundaries, boundaries[1:]): + if b <= a: + continue + s = state_at(trace, a).value + durations[s] = durations.get(s, 0.0) + (b - a) + total = sum(durations.values()) + if total <= 0: + return {} + return {s: d / total for s, d in durations.items()} + + +def transitions_in_range(trace: SortedDict, t_start: float, t_end: float) -> list: + """[(ts, state_str), ...] ground-truth transitions within (t_start, t_end].""" + return [ + (ts, trace[ts]) for ts in trace.irange(t_start, t_end, inclusive=(False, True)) + ] + + +def expected_send_gate_wait(trace: SortedDict, sct: float) -> Optional[float]: + """Ground-truth-expected [SEND_GATE] wait (Batch 3 T3.4, A8): the trainer + became ready to send at ``sct`` (its own trace-time-basis clock) -- how + long should it have had to wait, per the raw trace, before the gate + releases it? + + 0 if the trace already shows the trainer AVL_* at ``sct`` (no reason to + wait), else the gap to the next AVL_* transition. Same state-check-first + logic as ``ClientAvailability.compute_delivery_ts`` (client_availability.py, + the sim-side send-gate) -- next_avail_after(trace, sct) alone is NOT + enough, since it always returns the *next* transition even when the + trainer is already available right now -- expressed as a wait DURATION + (this - sct) rather than an absolute delivery time. + + Returns None if the trace never recovers after ``sct`` + (``next_avail_after`` == inf) -- an unanswerable "would wait forever" + case; the caller excludes it from scoring instead of treating it as a + numeric error. + """ + if state_at(trace, sct) in _AVL_STATES: + return 0.0 + nxt = next_avail_after(trace, sct) + if math.isinf(nxt): + return None + return max(0.0, nxt - sct) diff --git a/lib/python/examples/async_cifar10/scripts/parity/report.py b/lib/python/examples/async_cifar10/scripts/parity/report.py index 78cea17b4..5cdd1b824 100644 --- a/lib/python/examples/async_cifar10/scripts/parity/report.py +++ b/lib/python/examples/async_cifar10/scripts/parity/report.py @@ -50,6 +50,18 @@ ("A2b eligible-pool speed composition", "eligible_speed"), ("A3 trace time-base consistency", "avail_timebase"), ("A4 per-trainer duty-cycle", "duty_cycle"), + ("A4dur duration duty-cycle parity", "duty_cycle_duration"), + ("Aa eligible-pool reduction (diag)", "eligible_pool_reduction"), + ("C.3 abandon_timeout (vclock CTRL)", "abandon_timeout"), + ("Fst starvation_advance (diag)", "starvation_advance"), + ("A5 state_timeline_agreement", "state_timeline_agreement"), + ("A6r trainer_trace_fidelity (real, abs)", "trainer_trace_fidelity_real"), + ("A6s trainer_trace_fidelity (sim, abs)", "trainer_trace_fidelity_sim"), + ("A7r.sel agg_belief_fidelity (real, selection, abs)", "agg_belief_fidelity_real_selection"), + ("A7r.com agg_belief_fidelity (real, commit, abs)", "agg_belief_fidelity_real_commit"), + ("A7s.sel agg_belief_fidelity (sim, selection, abs)", "agg_belief_fidelity_sim_selection"), + ("A7s.com agg_belief_fidelity (sim, commit, abs)", "agg_belief_fidelity_sim_commit"), + ("A8r send_gate_wait_fidelity (real, abs)", "send_gate_wait_fidelity_real"), ]), ("3", "Selection", [ ("S3/4 num_chosen / in_flight / eff_c", "selection_detail"), @@ -82,6 +94,8 @@ ("6", "Aggregation", [ ("U6 commit visibility lag", "commit_visibility"), ("U3 staleness distribution", "staleness"), + ("C.2 withheld_delivery (diag)", "withheld_delivery"), + ("K11 commit_promptness (sim, INV)", "commit_promptness"), ("P1 aggregation sequence", "aggregation_sequence"), ("U1 first divergence", "first_divergence_summary"), ]), @@ -413,6 +427,92 @@ def _fmt_metric(name: str, res: dict) -> list: f" max_dutycycle_diff={res.get('max_dutycycle_diff')} " f"n_trainers={res.get('n_trainers')}" ) + elif name == "duty_cycle_duration": + if res.get("mean_err") is not None: + lines.append( + f" mean_err={res.get('mean_err')} (<={res.get('mean_tol')}) " + f"frac_within_tol={res.get('frac_within_tol')} (>={res.get('frac_pass_tol')} " + f"@ tau={res.get('within_tau')}) n_trainers={res.get('n_trainers')}" + ) + elif name == "eligible_pool_reduction": + if res.get("real_mean_reduction") is not None: + lines.append( + f" real_mean_reduction={res.get('real_mean_reduction')} " + f"sim_mean_reduction={res.get('sim_mean_reduction')} " + f"rel_diff={res.get('rel_diff')} (<={res.get('tol_rel')})" + ) + elif name == "state_timeline_agreement": + if res.get("match_frac") is not None: + lines.append( + f" match_frac={res.get('match_frac')} (>={res.get('tol')}) " + f"matched={res.get('matched')}/{res.get('total')} bins " + f"n_trainers={res.get('n_trainers')} n_bins={res.get('n_bins')}" + ) + if res.get("mismatched_examples"): + lines.append(f" mismatch_examples={res.get('mismatched_examples')}") + elif name in ("trainer_trace_fidelity_real", "trainer_trace_fidelity_sim", + "agg_belief_fidelity_real_selection", "agg_belief_fidelity_real_commit", + "agg_belief_fidelity_sim_selection", "agg_belief_fidelity_sim_commit"): + if res.get("mean_err") is not None: + lines.append( + f" mean_err={res.get('mean_err')} (<={res.get('mean_tol')}) " + f"frac_within_tol={res.get('frac_within_tol')} (>={res.get('frac_pass_tol')} " + f"@ tau={res.get('within_tau')}) n_trainers={res.get('n_trainers')}" + ) + lines.append( + f" n_missed_transitions={res.get('n_missed_transitions')} " + f"n_spurious_transitions={res.get('n_spurious_transitions')} " + f"max_lag_s={res.get('max_lag_s')}" + ) + if res.get("worst_trainers"): + lines.append(f" worst_trainers={res.get('worst_trainers')}") + elif name == "send_gate_wait_fidelity_real": + if res.get("mean_err_s") is not None: + lines.append( + f" mean_err_s={res.get('mean_err_s')} (<={res.get('mean_tol_s')}) " + f"frac_within_tol={res.get('frac_within_tol')} (>={res.get('frac_pass_tol')} " + f"@ tau={res.get('within_tau_s')}s) n_scored={res.get('n_scored')}/" + f"{res.get('n_events')} n_uncomparable={res.get('n_uncomparable')}" + ) + elif name == "abandon_timeout": + if res.get("n_abandon") is not None: + parts = [f" n_abandon={res.get('n_abandon')}"] + if res.get("mean_age_s") is not None: + parts.append(f"mean_age_s={res.get('mean_age_s')}") + if res.get("n_aware_boundary_eviction") is not None: + parts.append( + f"aware_evictions={res.get('n_aware_boundary_eviction')} " + f"(mean_age={res.get('aware_boundary_eviction_mean_age_s')}s)" + ) + lines.append(" ".join(parts)) + elif name == "withheld_delivery": + if res.get("n_withheld") is not None: + lines.append( + f" n_withheld={res.get('n_withheld')} " + f"mean_delay_s={res.get('mean_delay_s')} " + f"mean_staleness={res.get('mean_staleness')} " + f"accept_frac={res.get('accept_frac')}" + ) + if res.get("violations"): + lines.append(f" violations={res.get('violations')}") + elif name == "commit_promptness": + if res.get("n_events") is not None: + lines.append( + f" n_events={res.get('n_events')} " + f"mean_slack_s={res.get('mean_slack_s')} " + f"max_slack_s={res.get('max_slack_s')} " + f"min_slack_s={res.get('min_slack_s')}" + ) + lines.append( + f" n_early_violations={res.get('n_early_violations')} " + f"(<={res.get('early_tol_s')}s) " + f"n_late_violations={res.get('n_late_violations')} " + f"(<={res.get('late_slack_tol_s')}s)" + ) + if res.get("early_violations"): + lines.append(f" early_violations={res.get('early_violations')}") + if res.get("late_violations"): + lines.append(f" late_violations={res.get('late_violations')}") elif name == "training_budget": if res.get("ks_stat") is not None: defer = " [mix-deferred to A2c]" if res.get("mix_deferred") else "" diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_agg_belief_fidelity.py b/lib/python/examples/async_cifar10/scripts/parity/test_agg_belief_fidelity.py new file mode 100644 index 000000000..67f9d5e1c --- /dev/null +++ b/lib/python/examples/async_cifar10/scripts/parity/test_agg_belief_fidelity.py @@ -0,0 +1,209 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Batch 3 T3.3 — A7 agg_belief_fidelity_parity. + +Same synthetic-drift unit-test pattern as T3.2's test_ground_truth.py, applied +to the aggregator's BELIEF (not the trainer's own avail_change self-report). +Two independent checkpoints (selection / commit) are tested separately since +that's the whole point of tagging them apart -- an unaware baseline (oort/ +fedbuff) only ever gets a meaningful commit-checkpoint score. +""" + +from __future__ import annotations + +import os +import sys + +from sortedcontainers import SortedDict + +_SCRIPTS = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if _SCRIPTS not in sys.path: + sys.path.insert(0, _SCRIPTS) + +from parity.checks import agg_belief_fidelity_parity # noqa: E402 + + +def _sel(round_num, vclock_now, per_trainer): + return {"event": "selection", "task": "train", "round": round_num, + "ts": vclock_now, "vclock_now": vclock_now, "per_trainer": per_trainer} + + +def _belief(round_num, end_id, state, observed_at, checkpoint="commit"): + return {"event": "agg_belief_change", "round": round_num, "end_id": end_id, + "state": state, "observed_at": observed_at, "checkpoint": checkpoint} + + +def test_a7_skips_without_ground_truth(): + agg = {"selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})], + "agg_belief_changes": []} + res = agg_belief_fidelity_parity(agg, "sim", None) + assert res["selection"]["ok"] and res["selection"].get("status") == "SKIP" + assert res["commit"]["ok"] and res["commit"].get("status") == "SKIP" + + +def test_a7_skips_on_degenerate_span(): + agg = {"selection_train": [], "agg_belief_changes": []} + gt = {"t1_0001": SortedDict()} + res = agg_belief_fidelity_parity(agg, "sim", gt) + assert res["selection"].get("status") == "SKIP" + assert res["commit"].get("status") == "SKIP" + + +def test_a7_selection_checkpoint_passes_when_matched(): + # Ground truth: AVL_TRAIN [0,600), UN_AVL [600,900). Aggregator's own + # selection-time belief (per_trainer.avl_state) tracks it exactly. + gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})} + agg = { + "selection_train": [ + _sel(1, 0.0, {"0001": {"avl_state": "AVL_TRAIN"}}), + _sel(2, 600.0, {"0001": {"avl_state": "UN_AVL"}}), + _sel(3, 900.0, {"0001": {"avl_state": "UN_AVL"}}), + ], + "agg_belief_changes": [], + } + res = agg_belief_fidelity_parity(agg, "sim", gt) + assert res["selection"]["ok"], res["selection"] + assert res["selection"]["mean_err"] == 0.0 + # No commit-checkpoint telemetry at all in this run -> SKIP, not a false pass. + assert res["commit"].get("status") == "SKIP" + + +def test_a7_selection_checkpoint_fails_when_diverged(): + gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})} + agg = { + "selection_train": [ + _sel(1, 0.0, {"0001": {"avl_state": "AVL_TRAIN"}}), + _sel(2, 900.0, {"0001": {"avl_state": "AVL_TRAIN"}}), # never saw UN_AVL + ], + "agg_belief_changes": [], + } + res = agg_belief_fidelity_parity(agg, "sim", gt) + assert not res["selection"]["ok"], res["selection"] + assert res["selection"]["mean_err"] > 0.0 + + +def test_a7_commit_checkpoint_passes_when_matched(): + # Aggregator's own commit-time belief (agg_belief_change, from + # _record_commit_belief) reads the same state ground truth has at that + # instant -- meaningful even for an unaware baseline with no selection + # filter at all (selection_train carries no per_trainer avl_state here). + gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})} + agg = { + "selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})], + "agg_belief_changes": [ + _belief(1, "0001", "AVL_TRAIN", 100.0, checkpoint="commit"), + _belief(2, "0001", "UN_AVL", 600.0, checkpoint="commit"), + ], + } + res = agg_belief_fidelity_parity(agg, "sim", gt) + assert res["commit"]["ok"], res["commit"] + assert res["commit"]["mean_err"] == 0.0 + # No per_trainer.avl_state anywhere -> selection checkpoint has no signal. + assert res["selection"].get("status") == "SKIP" + + +def test_a7_commit_checkpoint_fails_on_belief_wrong_at_its_own_instant(): + # Ground truth transitions at 600s; the aggregator's LAST commit lands at + # 900 but still claims AVL_TRAIN -- i.e. a belief-recording bug where the + # recorded state doesn't even match ground truth AT its own claimed + # instant (unlike the interior-gap case below, where both endpoints are + # individually correct and only the un-observed middle differs). This + # must still fail post-interior-gap-fix: `max_gap_s` only excuses + # UN-observed periods, not a wrong reading at an observed one. + gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})} + agg = { + "selection_train": [_sel(1, 0.0, {}), _sel(2, 1000.0, {})], + "agg_belief_changes": [ + _belief(1, "0001", "AVL_TRAIN", 100.0, checkpoint="commit"), + _belief(2, "0001", "AVL_TRAIN", 900.0, checkpoint="commit"), # still wrong + ], + } + res = agg_belief_fidelity_parity(agg, "sim", gt, lag_tol_s=30.0) + assert not res["commit"]["ok"], res["commit"] + assert res["commit"]["mean_err"] > 0.05 + + +def test_a7_commit_checkpoint_ignores_selection_events(): + # A selection-checkpoint agg_belief_change (if one were ever emitted) + # must not leak into the commit-checkpoint score. + gt = {"t1_0001": SortedDict()} + agg = { + "selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})], + "agg_belief_changes": [ + _belief(1, "0001", "UN_AVL", 100.0, checkpoint="selection"), + ], + } + res = agg_belief_fidelity_parity(agg, "sim", gt) + assert res["commit"].get("status") == "SKIP" + + +def test_a7_commit_checkpoint_does_not_extrapolate_past_last_commit(): + # Batch 4 finding (UNAVAILABILITY_DESIGN.md): the trainer's last commit + # lands at 550 while still AVL_TRAIN (correctly so -- ground truth is + # AVL_TRAIN up to 600), then it goes UN_AVL at 600 and never commits + # again for the rest of the 900s span. Extrapolating "still AVL_TRAIN" + # across [550, 900) would blame ~300/900 of the span on a belief that + # was simply never re-sampled, not wrong -- the window must truncate to + # [t_start, last observed t] instead. + gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})} + agg = { + "selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})], + "agg_belief_changes": [ + _belief(1, "0001", "AVL_TRAIN", 100.0, checkpoint="commit"), + _belief(2, "0001", "AVL_TRAIN", 550.0, checkpoint="commit"), + ], + } + res = agg_belief_fidelity_parity(agg, "sim", gt) + assert res["commit"]["ok"], res["commit"] + assert res["commit"]["mean_err"] == 0.0 + # The untruncated window would have counted the 600s ground-truth + # transition as "missed" too (it falls after the last observation) -- + # truncation excludes it from the diagnostic count as well. + assert res["commit"]["n_missed_transitions"] == 0 + + + +def test_a7_commit_checkpoint_does_not_extrapolate_across_interior_gap(): + # Batch 4 live-run finding (UNAVAILABILITY_DESIGN.md, felix n=300 syn_50): + # both commits are individually CORRECT -- t=100 reads AVL_TRAIN (true, + # ground truth is AVL_TRAIN on [0,200)), t=590 reads AVL_TRAIN (true, + # ground truth is AVL_TRAIN on [400,600)) -- but the trace dips to UN_AVL + # on [200,400) in between, with no commit to observe it. Holding the + # first commit's belief all the way to the second (old behavior) would + # blame ~200/490s of that gap on "wrong belief", when neither commit was + # ever wrong at its own instant -- same class of over-penalization the + # tail fix (extrapolate_tail=False) already exempts, just mid-run instead + # of at the end. + gt = {"t1_0001": SortedDict({200.0: "UN_AVL", 400.0: "AVL_TRAIN"})} + agg = { + "selection_train": [_sel(1, 0.0, {}), _sel(2, 600.0, {})], + "agg_belief_changes": [ + _belief(1, "0001", "AVL_TRAIN", 100.0, checkpoint="commit"), + _belief(2, "0001", "AVL_TRAIN", 590.0, checkpoint="commit"), + ], + } + res = agg_belief_fidelity_parity(agg, "sim", gt, lag_tol_s=30.0) + assert res["commit"]["ok"], res["commit"] + assert res["commit"]["mean_err"] == 0.0 + + +def test_a7_real_and_sim_scored_independently(): + gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})} + real_agg = { + "selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})], + "agg_belief_changes": [ + _belief(1, "0001", "AVL_TRAIN", 100.0), + _belief(2, "0001", "AVL_TRAIN", 700.0), # real never saw UN_AVL + ], + } + sim_agg = { + "selection_train": [_sel(1, 0.0, {}), _sel(2, 900.0, {})], + "agg_belief_changes": [ + _belief(1, "0001", "AVL_TRAIN", 100.0), + _belief(2, "0001", "UN_AVL", 600.0), + ], + } + real_res = agg_belief_fidelity_parity(real_agg, "real", gt) + sim_res = agg_belief_fidelity_parity(sim_agg, "sim", gt) + assert not real_res["commit"]["ok"] + assert sim_res["commit"]["ok"] diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_avail_state_series.py b/lib/python/examples/async_cifar10/scripts/parity/test_avail_state_series.py new file mode 100644 index 000000000..0f5917347 --- /dev/null +++ b/lib/python/examples/async_cifar10/scripts/parity/test_avail_state_series.py @@ -0,0 +1,119 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Unit tests for the C.6.2 shared trainer_state_series resolver.""" + +from __future__ import annotations + +import os +import sys + +_SCRIPTS = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if _SCRIPTS not in sys.path: + sys.path.insert(0, _SCRIPTS) + +from parity.avail_state_series import ( # noqa: E402 + build_trainer_state_series, + run_span, + state_fractions, + total_variation_distance, +) + + +def _sel(round_num, ts, vclock_now, per_trainer): + return { + "event": "selection", "task": "train", "round": round_num, "ts": ts, + "vclock_now": vclock_now, "per_trainer": per_trainer, + } + + +def test_build_series_sim_uses_vclock(): + events = [ + _sel(1, 100.0, 0.0, {"t1": {"avl_state": "AVL_TRAIN"}}), + _sel(2, 110.0, 600.0, {"t1": {"avl_state": "UN_AVL"}}), + _sel(3, 120.0, 900.0, {"t1": {"avl_state": "AVL_TRAIN"}}), + ] + series = build_trainer_state_series(events, mode="sim") + assert series["t1"] == [ + (0.0, "AVL_TRAIN"), (600.0, "UN_AVL"), (900.0, "AVL_TRAIN"), + ] + + +def test_build_series_real_uses_ts_minus_t0(): + events = [ + _sel(1, 1000.0, None, {"t1": {"avl_state": "AVL_TRAIN"}}), + _sel(2, 1300.0, None, {"t1": {"avl_state": "UN_AVL"}}), + ] + series = build_trainer_state_series(events, mode="real") + assert series["t1"] == [(0.0, "AVL_TRAIN"), (300.0, "UN_AVL")] + + +def test_build_series_real_prefers_vclock_now_over_ts_minus_t0(): + # Real-mode first selection event fires well after the true run start + # (e.g. ~300s of MQTT join-ramp for n=300) — ts - t0 would understate + # elapsed time relative to the trace's agg_start-anchored origin. Once + # vclock_now is stamped on real events too (ClientAvailability._avail_now()), + # it must win over the ts - t0 fallback. + events = [ + _sel(1, 1000.0, 600.0, {"t1": {"avl_state": "AVL_TRAIN"}}), + _sel(2, 1300.0, 900.0, {"t1": {"avl_state": "UN_AVL"}}), + ] + series = build_trainer_state_series(events, mode="real") + assert series["t1"] == [(600.0, "AVL_TRAIN"), (900.0, "UN_AVL")] + + +def test_build_series_skips_unknown_state(): + events = [_sel(1, 0.0, 0.0, {"t1": {"avl_state": "UNKNOWN"}})] + series = build_trainer_state_series(events, mode="sim") + assert series == {} + + +def test_build_series_same_t_last_write_wins(): + events = [ + _sel(1, 0.0, 100.0, {"t1": {"avl_state": "AVL_TRAIN"}}), + _sel(2, 0.0, 100.0, {"t1": {"avl_state": "UN_AVL"}}), + ] + series = build_trainer_state_series(events, mode="sim") + assert series["t1"] == [(100.0, "UN_AVL")] + + +def test_run_span(): + series = {"t1": [(0.0, "AVL_TRAIN"), (900.0, "UN_AVL")], + "t2": [(0.0, "AVL_TRAIN"), (500.0, "UN_AVL")]} + assert run_span(series) == 900.0 + + +def test_state_fractions_dwell_time(): + # AVL_TRAIN for 600s, then UN_AVL for the remaining 300s of a 900s span. + series = {"t1": [(0.0, "AVL_TRAIN"), (600.0, "UN_AVL"), (900.0, "UN_AVL")]} + fracs = state_fractions(series) + assert fracs["t1"]["AVL_TRAIN"] == 600.0 / 900.0 + assert fracs["t1"]["UN_AVL"] == 300.0 / 900.0 + + +def test_state_fractions_credits_trailing_segment_to_t_end(): + series = {"t1": [(0.0, "AVL_TRAIN"), (600.0, "UN_AVL")]} + fracs = state_fractions(series, t_end=900.0) + assert fracs["t1"]["AVL_TRAIN"] == 600.0 / 900.0 + assert fracs["t1"]["UN_AVL"] == 300.0 / 900.0 + + +def test_state_fractions_omits_single_sample_trainers(): + series = {"t1": [(0.0, "AVL_TRAIN")]} + assert state_fractions(series) == {} + + +def test_total_variation_distance_identical_is_zero(): + a = {"AVL_TRAIN": 0.7, "UN_AVL": 0.3} + assert total_variation_distance(a, dict(a)) == 0.0 + + +def test_total_variation_distance_disjoint_is_one(): + a = {"AVL_TRAIN": 1.0} + b = {"UN_AVL": 1.0} + assert total_variation_distance(a, b) == 1.0 + + +def test_total_variation_distance_partial(): + a = {"AVL_TRAIN": 0.6, "UN_AVL": 0.4} + b = {"AVL_TRAIN": 0.5, "UN_AVL": 0.5} + assert abs(total_variation_distance(a, b) - 0.1) < 1e-9 diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_availability_rungs.py b/lib/python/examples/async_cifar10/scripts/parity/test_availability_rungs.py new file mode 100644 index 000000000..0a84ef2db --- /dev/null +++ b/lib/python/examples/async_cifar10/scripts/parity/test_availability_rungs.py @@ -0,0 +1,334 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Stage C parity rungs: withheld_delivery / abandon_timeout / eligible_pool_reduction. + +These cover the run-independent (structural) logic of the new availability rungs +and the loader fields that feed them. Tolerance calibration vs a real syn_20 +reference is deferred to an actual run (these only assert what is true regardless +of run data: ordering invariants, the vclock wall-leak guard, and SKIP/empty +handling). +""" + +from __future__ import annotations + +import json +import os +import sys + +_SCRIPTS = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if _SCRIPTS not in sys.path: + sys.path.insert(0, _SCRIPTS) + +from parity.checks import ( # noqa: E402 + abandon_timeout_parity, + commit_promptness_parity, + duration_duty_cycle_parity, + eligible_pool_reduction_parity, + load_agg_jsonl, + load_trainer_jsonl_dir, + starvation_advance_parity, + withheld_delivery_parity, +) + + +def _sel(round_num, nc, ne): + return {"event": "selection", "task": "train", "round": round_num, + "ts": float(round_num), "num_candidates": nc, "num_eligible": ne} + + +# --------------------------------------------------------------------------- +# withheld_delivery +# --------------------------------------------------------------------------- + +def test_withheld_delivery_skips_when_empty(): + res = withheld_delivery_parity({}, {"withheld_deliveries": []}) + assert res["ok"] and res.get("status") == "SKIP" + + +def test_withheld_delivery_passes_well_formed(): + evs = [ + {"end_id": "t1", "sct": 150.0, "delivery_ts": 200.0, "delay_s": 50.0, + "staleness": 3, "accepted": True}, + {"end_id": "t2", "sct": 260.0, "delivery_ts": 260.0, "delay_s": 0.0, + "staleness": 0, "accepted": True}, + ] + res = withheld_delivery_parity({}, {"withheld_deliveries": evs}) + assert res["ok"], res + assert res["n_withheld"] == 2 + assert res["accept_frac"] == 1.0 + assert res["mean_delay_s"] == 25.0 + + +def test_withheld_delivery_fails_on_pre_completion_delivery(): + # delivery_ts < sct would be past-dating — must fail loudly. + evs = [{"end_id": "t1", "sct": 200.0, "delivery_ts": 150.0, "staleness": 1}] + res = withheld_delivery_parity({}, {"withheld_deliveries": evs}) + assert not res["ok"] and res["violations"] + + +def test_withheld_delivery_fails_on_negative_staleness(): + evs = [{"end_id": "t1", "sct": 100.0, "delivery_ts": 120.0, "staleness": -2}] + res = withheld_delivery_parity({}, {"withheld_deliveries": evs}) + assert not res["ok"] + + +# --------------------------------------------------------------------------- +# commit_promptness (K11, Batch 3 T3.5) +# --------------------------------------------------------------------------- + +def test_commit_promptness_skips_when_empty(): + res = commit_promptness_parity({"withheld_deliveries": []}) + assert res["ok"] and res.get("status") == "SKIP" + + +def test_commit_promptness_skips_when_no_actual_commit_ts(): + # Telemetry predating T3.5: delivery_ts present, actual_commit_ts absent. + evs = [{"end_id": "t1", "sct": 100.0, "delivery_ts": 150.0}] + res = commit_promptness_parity({"withheld_deliveries": evs}) + assert res.get("status") == "SKIP" + + +def test_commit_promptness_passes_near_zero_slack(): + evs = [ + {"end_id": "t1", "delivery_ts": 200.0, "actual_commit_ts": 200.0}, + {"end_id": "t2", "delivery_ts": 300.0, "actual_commit_ts": 300.4}, + ] + res = commit_promptness_parity({"withheld_deliveries": evs}) + assert res["ok"], res + assert res["n_events"] == 2 + assert res["n_early_violations"] == 0 + assert res["n_late_violations"] == 0 + + +def test_commit_promptness_fails_on_early_violation(): + # Committed BEFORE its legal delivery_ts -- a hard correctness bug. + evs = [{"end_id": "t1", "delivery_ts": 200.0, "actual_commit_ts": 150.0}] + res = commit_promptness_parity({"withheld_deliveries": evs}) + assert not res["ok"], res + assert res["n_early_violations"] == 1 + assert res["early_violations"] == [{"end": "t1", "slack_s": -50.0}] + assert res["n_late_violations"] == 0 + + +def test_commit_promptness_fails_on_late_violation(): + # Held far longer than delivery_ts required -- a promptness/scheduling bug. + evs = [{"end_id": "t1", "delivery_ts": 200.0, "actual_commit_ts": 260.0}] + res = commit_promptness_parity({"withheld_deliveries": evs}, late_slack_tol_s=30.0) + assert not res["ok"], res + assert res["n_late_violations"] == 1 + assert res["late_violations"] == [{"end": "t1", "slack_s": 60.0}] + assert res["n_early_violations"] == 0 + + +def test_commit_promptness_early_and_late_scored_independently(): + evs = [ + {"end_id": "t1", "delivery_ts": 200.0, "actual_commit_ts": 150.0}, # early + {"end_id": "t2", "delivery_ts": 200.0, "actual_commit_ts": 260.0}, # late + {"end_id": "t3", "delivery_ts": 200.0, "actual_commit_ts": 200.5}, # fine + ] + res = commit_promptness_parity({"withheld_deliveries": evs}, late_slack_tol_s=30.0) + assert not res["ok"] + assert res["n_events"] == 3 + assert res["n_early_violations"] == 1 + assert res["n_late_violations"] == 1 + + +def test_commit_promptness_ignores_events_missing_delivery_ts(): + evs = [{"end_id": "t1", "actual_commit_ts": 200.0}] + res = commit_promptness_parity({"withheld_deliveries": evs}) + assert res.get("status") == "SKIP" + + +# --------------------------------------------------------------------------- +# abandon_timeout (vclock wall-leak control) +# --------------------------------------------------------------------------- + +def test_abandon_skips_when_empty(): + res = abandon_timeout_parity({}, {"abandon_timeouts": []}) + assert res["ok"] and res.get("status") == "SKIP" + + +def test_abandon_passes_vclock_scale_ages(): + evs = [{"end_id": "t1", "sim_send_ts": 100.0, "vclock_now": 195.0, "age_s": 95.0}, + {"end_id": "t2", "sim_send_ts": 50.0, "vclock_now": 200.0, "age_s": 150.0}] + res = abandon_timeout_parity({}, {"abandon_timeouts": evs}) + assert res["ok"], res + assert res["n_abandon"] == 2 and res["mean_age_s"] >= 90 + + +def test_abandon_fails_on_wall_clock_leak(): + # epoch-scale age => the deadline was measured on the wall, not the vclock. + evs = [{"end_id": "t1", "sim_send_ts": 0.0, "vclock_now": 1.75e9, "age_s": 1.75e9}] + res = abandon_timeout_parity({}, {"abandon_timeouts": evs}) + assert not res["ok"] and res["wall_leak_ends"] == ["t1"] + assert "WALL-CLOCK LEAK" in res.get("note", "") + + +def test_abandon_fails_below_threshold(): + evs = [{"end_id": "t1", "sim_send_ts": 100.0, "vclock_now": 150.0, "age_s": 50.0}] + res = abandon_timeout_parity({}, {"abandon_timeouts": evs}) + assert not res["ok"] and res["below_threshold"] + + +def test_abandon_age_derived_when_missing(): + evs = [{"end_id": "t1", "sim_send_ts": 100.0, "vclock_now": 195.0}] # no age_s + res = abandon_timeout_parity({}, {"abandon_timeouts": evs}) + assert res["ok"] and res["max_age_s"] == 95.0 + + +# --------------------------------------------------------------------------- +# eligible_pool_reduction +# --------------------------------------------------------------------------- + +def test_eligible_pool_reduction_skips_without_fields(): + real = {"selection_train": [{"event": "selection", "round": 1, "ts": 1.0}]} + sim = {"selection_train": [{"event": "selection", "round": 1, "ts": 1.0}]} + res = eligible_pool_reduction_parity(real, sim) + assert res["ok"] and res.get("status") == "SKIP" + + +def test_eligible_pool_reduction_passes_when_matched(): + real = {"selection_train": [_sel(1, 300, 240), _sel(2, 300, 250)]} # red 60,50 + sim = {"selection_train": [_sel(1, 300, 245), _sel(2, 300, 248)]} # red 55,52 + res = eligible_pool_reduction_parity(real, sim) + assert res["ok"], res + + +def test_eligible_pool_reduction_fails_when_divergent(): + real = {"selection_train": [_sel(1, 300, 290), _sel(2, 300, 292)]} # red ~9 + sim = {"selection_train": [_sel(1, 300, 200), _sel(2, 300, 210)]} # red ~95 + res = eligible_pool_reduction_parity(real, sim) + assert not res["ok"] + + +# --------------------------------------------------------------------------- +# duty_cycle_duration (A4dur, C.6.3) +# --------------------------------------------------------------------------- + +def _sel_avl(round_num, ts, vclock_now, per_trainer): + return {"event": "selection", "task": "train", "round": round_num, "ts": ts, + "vclock_now": vclock_now, "per_trainer": per_trainer} + + +def test_duty_cycle_duration_skips_without_avl_state(): + real = {"selection_train": [{"event": "selection", "round": 1, "ts": 1.0, + "per_trainer": {"t1": {}}}]} + sim = {"selection_train": [{"event": "selection", "round": 1, "ts": 1.0, + "vclock_now": 0.0, "per_trainer": {"t1": {}}}]} + res = duration_duty_cycle_parity(real, sim) + assert res["ok"] and res.get("status") == "SKIP" + + +def test_duty_cycle_duration_passes_when_matched(): + # t1: AVL_TRAIN for [0,600), UN_AVL for [600,900) in both modes. + real = {"selection_train": [ + _sel_avl(1, 1000.0, None, {"t1": {"avl_state": "AVL_TRAIN"}}), + _sel_avl(2, 1600.0, None, {"t1": {"avl_state": "UN_AVL"}}), + _sel_avl(3, 1900.0, None, {"t1": {"avl_state": "UN_AVL"}}), + ]} + sim = {"selection_train": [ + _sel_avl(1, 0.0, 0.0, {"t1": {"avl_state": "AVL_TRAIN"}}), + _sel_avl(2, 0.0, 600.0, {"t1": {"avl_state": "UN_AVL"}}), + _sel_avl(3, 0.0, 900.0, {"t1": {"avl_state": "UN_AVL"}}), + ]} + res = duration_duty_cycle_parity(real, sim) + assert res["ok"], res + assert res["n_trainers"] == 1 + assert res["mean_err"] == 0.0 + + +def test_duty_cycle_duration_fails_when_divergent(): + # real: AVL_TRAIN the whole span. sim: UN_AVL the whole span -> TVD = 1.0. + real = {"selection_train": [ + _sel_avl(1, 1000.0, None, {"t1": {"avl_state": "AVL_TRAIN"}}), + _sel_avl(2, 1900.0, None, {"t1": {"avl_state": "AVL_TRAIN"}}), + ]} + sim = {"selection_train": [ + _sel_avl(1, 0.0, 0.0, {"t1": {"avl_state": "UN_AVL"}}), + _sel_avl(2, 0.0, 900.0, {"t1": {"avl_state": "UN_AVL"}}), + ]} + res = duration_duty_cycle_parity(real, sim) + assert not res["ok"] + assert res["mean_err"] == 1.0 + + +# --------------------------------------------------------------------------- +# loaders surface the new events +# --------------------------------------------------------------------------- + +def test_load_agg_jsonl_surfaces_new_events(tmp_path): + p = tmp_path / "aggregator_x.jsonl" + lines = [ + {"event": "selection", "task": "train", "round": 1, "ts": 1.0, + "num_candidates": 300, "num_eligible": 250}, + {"event": "withheld_delivery", "round": 2, "ts": 2.0, "end_id": "t1", + "sct": 10.0, "delivery_ts": 20.0, "delay_s": 10.0, "staleness": 1}, + {"event": "abandon_timeout", "round": 3, "ts": 3.0, "end_id": "t2", + "sim_send_ts": 5.0, "vclock_now": 100.0, "age_s": 95.0}, + ] + p.write_text("\n".join(json.dumps(x) for x in lines) + "\n") + agg = load_agg_jsonl(str(p)) + assert len(agg["withheld_deliveries"]) == 1 + assert len(agg["abandon_timeouts"]) == 1 + assert agg["withheld_deliveries"][0]["end_id"] == "t1" + + +# --------------------------------------------------------------------------- +# starvation_advance +# --------------------------------------------------------------------------- + +def _agg_round(vclock_now): + return {"event": "agg_round", "vclock_now": vclock_now} + + +def _sim_with_avail(rounds, withheld=True): + """Build a sim dict with gate-active marker and given agg_round list.""" + return { + "agg_rounds": rounds, + "withheld_deliveries": [{"end_id": "t0"}] if withheld else [], + "abandon_timeouts": [], + "selection_train": [], + } + + +def test_starvation_advance_skips_without_avail(): + # no withheld/abandon/avail_composition → gate off → SKIP + sim = {"agg_rounds": [_agg_round(10.0), _agg_round(20.0), _agg_round(30.0)], + "withheld_deliveries": [], "abandon_timeouts": [], "selection_train": []} + res = starvation_advance_parity({}, sim) + assert res["ok"] and res.get("status") == "SKIP" + + +def test_starvation_advance_skips_with_no_agg_rounds(): + sim = _sim_with_avail([]) + res = starvation_advance_parity({}, sim) + assert res["ok"] and res.get("status") == "SKIP" + + +def test_starvation_advance_no_jumps(): + sim = _sim_with_avail([_agg_round(float(i * 100)) for i in range(10)]) + res = starvation_advance_parity({}, sim) + assert res["ok"] and res["n_starvation_jumps"] == 0 + + +def test_starvation_advance_detects_jump(): + # 8 normal 100s gaps then one 3000s gap (30× mean) + vclocks = [float(i * 100) for i in range(8)] + [800.0 + 3000.0] + sim = _sim_with_avail([_agg_round(v) for v in vclocks]) + res = starvation_advance_parity({}, sim, jump_factor=5.0) + assert res["ok"] and res["n_starvation_jumps"] >= 1 + assert res["max_jump_s"] > 1000.0 + + +def test_load_trainer_jsonl_dir_surfaces_avail_change(tmp_path): + p = tmp_path / "trainer_0001.jsonl" + lines = [ + {"event": "task_recv", "round": 1}, + {"event": "avail_change", "round": 1, "old_state": "AVL_TRAIN", + "new_state": "UN_AVL"}, + ] + p.write_text("\n".join(json.dumps(x) for x in lines) + "\n") + tr = load_trainer_jsonl_dir(str(tmp_path)) + assert "0001" in tr + assert len(tr["0001"]["avail_change"]) == 1 + assert tr["0001"]["avail_change"][0]["new_state"] == "UN_AVL" diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_ground_truth.py b/lib/python/examples/async_cifar10/scripts/parity/test_ground_truth.py new file mode 100644 index 000000000..4c51adb9f --- /dev/null +++ b/lib/python/examples/async_cifar10/scripts/parity/test_ground_truth.py @@ -0,0 +1,245 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Batch 3 T3.2 — ground_truth.py + A6 trainer_trace_fidelity_parity. + +Unlike the relative (real-vs-sim) rungs in test_availability_rungs.py, A6 +compares one mode's own trainer telemetry against a synthetic ground-truth +trace directly — these tests inject a *known* drift between "observed" and +"ground truth" and assert the fidelity calc measures and flags it correctly, +per the working agreement (synthetic-drift unit test before touching real data). +""" + +from __future__ import annotations + +import json +import math +import os +import sys + +from sortedcontainers import SortedDict + +_SCRIPTS = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if _SCRIPTS not in sys.path: + sys.path.insert(0, _SCRIPTS) + +from parity.checks import trainer_trace_fidelity_parity # noqa: E402 +from parity.ground_truth import ( # noqa: E402 + by_short_id, + expected_send_gate_wait, + load_ground_truth, + resolve_trace_name, + state_fractions_over_range, + transitions_in_range, +) + + +def _sel(round_num, vclock_now): + return {"event": "selection", "task": "train", "round": round_num, + "ts": vclock_now, "vclock_now": vclock_now} + + +def _avail_change(round_num, old_state, new_state, sim_now): + return {"event": "avail_change", "round": round_num, "old_state": old_state, + "new_state": new_state, "sim_now": sim_now} + + +# --------------------------------------------------------------------------- +# resolve_trace_name +# --------------------------------------------------------------------------- + +def _write_config(tmp_path, hp: dict): + p = tmp_path / "aggregator_config.json" + p.write_text(json.dumps({"hyperparameters": hp})) + return tmp_path + + +def test_resolve_trace_name_missing_file(tmp_path): + assert resolve_trace_name(str(tmp_path)) is None + + +def test_resolve_trace_name_no_keys_set(tmp_path): + _write_config(tmp_path, {"trackTrainerAvail": {"enabled": "False", "type": "NA"}}) + assert resolve_trace_name(str(tmp_path)) is None + + +def test_resolve_trace_name_track_trainer_avail_priority(tmp_path): + # All three keys set -> trackTrainerAvail wins (debug_run.sh's own priority). + _write_config(tmp_path, { + "trackTrainerAvail": {"enabled": "True", "type": "ORACULAR", "trace": "syn_20"}, + "client_notify": {"enabled": "False", "trace": "syn_50"}, + "availability_trace": "syn_0", + }) + assert resolve_trace_name(str(tmp_path)) == "syn_20" + + +def test_resolve_trace_name_client_notify_fallback(tmp_path): + _write_config(tmp_path, { + "trackTrainerAvail": {"enabled": "False", "type": "NA"}, + "client_notify": {"enabled": "False", "trace": "syn_20"}, + }) + assert resolve_trace_name(str(tmp_path)) == "syn_20" + + +def test_resolve_trace_name_availability_trace_fallback(tmp_path): + _write_config(tmp_path, {"availability_trace": "syn_50"}) + assert resolve_trace_name(str(tmp_path)) == "syn_50" + + +def test_load_ground_truth_none_when_no_trace(): + assert load_ground_truth(None) is None + + +# --------------------------------------------------------------------------- +# state_fractions_over_range / transitions_in_range +# --------------------------------------------------------------------------- + +def test_state_fractions_over_range_always_available(): + trace = SortedDict() # syn_0-style empty trace -> always AVL_TRAIN + frac = state_fractions_over_range(trace, 0.0, 100.0) + assert frac == {"AVL_TRAIN": 1.0} + + +def test_state_fractions_over_range_single_transition(): + trace = SortedDict({600.0: "UN_AVL"}) + frac = state_fractions_over_range(trace, 0.0, 900.0) + assert math.isclose(frac["AVL_TRAIN"], 600.0 / 900.0) + assert math.isclose(frac["UN_AVL"], 300.0 / 900.0) + + +def test_state_fractions_over_range_degenerate(): + trace = SortedDict({600.0: "UN_AVL"}) + assert state_fractions_over_range(trace, 100.0, 100.0) == {} + + +def test_transitions_in_range(): + trace = SortedDict({100.0: "UN_AVL", 200.0: "AVL_TRAIN", 500.0: "UN_AVL"}) + assert transitions_in_range(trace, 0.0, 300.0) == [ + (100.0, "UN_AVL"), (200.0, "AVL_TRAIN"), + ] + # left-exclusive: a transition exactly at t_start is not "within" the range. + assert transitions_in_range(trace, 100.0, 300.0) == [(200.0, "AVL_TRAIN")] + + +def test_by_short_id(): + gt = {"505f9fc483cf4df68a2409257b5fad7d3c580370": SortedDict()} + out = by_short_id(gt) + assert list(out) == ["0370"] + + +# --------------------------------------------------------------------------- +# expected_send_gate_wait (Batch 3 T3.4, A8) +# --------------------------------------------------------------------------- + +def test_expected_send_gate_wait_already_available(): + trace = SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"}) + # sct before the drop -> already AVL_TRAIN there (default), no wait. + assert expected_send_gate_wait(trace, 500.0) == 0.0 + + +def test_expected_send_gate_wait_mid_gap(): + trace = SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"}) + # sct lands inside the UN_AVL window -> wait until the recovery transition. + assert math.isclose(expected_send_gate_wait(trace, 700.0), 200.0) + + +def test_expected_send_gate_wait_exact_transition_boundary(): + trace = SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"}) + # sct exactly at the recovery point -> already available, zero wait. + assert expected_send_gate_wait(trace, 900.0) == 0.0 + + +def test_expected_send_gate_wait_never_recovers(): + trace = SortedDict({600.0: "UN_AVL"}) + assert expected_send_gate_wait(trace, 700.0) is None + + +# --------------------------------------------------------------------------- +# trainer_trace_fidelity_parity (A6) +# --------------------------------------------------------------------------- + +def test_a6_skips_without_ground_truth(): + trainers = {"0001": {"avail_change": [_avail_change(1, "AVL_TRAIN", "UN_AVL", 100.0)]}} + sel = [_sel(1, 900.0)] + res = trainer_trace_fidelity_parity(trainers, sel, "sim", None) + assert res["ok"] and res.get("status") == "SKIP" + + +def test_a6_skips_on_degenerate_span(): + trainers = {"0001": {"avail_change": []}} + gt = {"t1_0001": SortedDict()} + res = trainer_trace_fidelity_parity(trainers, [], "sim", gt) + assert res["ok"] and res.get("status") == "SKIP" + + +def test_a6_skips_when_no_matching_trainers(): + # ground truth keyed by a short id that never shows up in trainer telemetry. + trainers = {"0001": {"avail_change": []}} + gt = {"t1_9999": SortedDict()} + sel = [_sel(1, 900.0)] + res = trainer_trace_fidelity_parity(trainers, sel, "sim", gt) + assert res["ok"] and res.get("status") == "SKIP" + + +def test_a6_passes_when_observed_matches_ground_truth(): + # Ground truth: AVL_TRAIN [0,600), UN_AVL [600,900). Trainer observes and + # logs the exact same transition at the exact same trace-time. + gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})} + trainers = {"0001": {"avail_change": [ + _avail_change(1, "AVL_TRAIN", "UN_AVL", 600.0), + ]}} + sel = [_sel(1, 0.0), _sel(2, 900.0)] + res = trainer_trace_fidelity_parity(trainers, sel, "sim", gt) + assert res["ok"], res + assert res["n_trainers"] == 1 + assert res["mean_err"] == 0.0 + assert res["n_missed_transitions"] == 0 + assert res["n_spurious_transitions"] == 0 + assert res["max_lag_s"] == 0.0 + + +def test_a6_fails_when_trainer_never_tracked_the_trace(): + # This is exactly Challenges §5 item 20: the trainer's own trace was + # wired to a trivial always-available one, so it never logs any + # transition, while ground truth says it should have gone UN_AVL at 600s + # for the back half of a 900s run -- a full state-fraction mismatch. + gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})} + trainers = {"0001": {"avail_change": []}} + sel = [_sel(1, 0.0), _sel(2, 900.0)] + res = trainer_trace_fidelity_parity(trainers, sel, "sim", gt) + # No sim_now-tagged avail_change events anywhere in the run -> SKIP, not a + # false "perfect fidelity" pass -- distinguishing "never transitioned" from + # "no fidelity signal at all" is the whole point of this rung. + assert res["ok"] and res.get("status") == "SKIP" + + +def test_a6_fails_on_injected_lag_drift(): + # Ground truth transitions at 600s; the trainer's own clock is skewed and + # only logs the transition (and its corresponding entry into the observed + # timeline) 300s late -- same class of bug as B2.0.3, but on the trainer + # side. Duration-weighted TVD should catch the resulting fraction skew. + gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})} + trainers = {"0001": {"avail_change": [ + _avail_change(1, "AVL_TRAIN", "UN_AVL", 900.0), # 300s late + ]}} + sel = [_sel(1, 0.0), _sel(2, 900.0)] + res = trainer_trace_fidelity_parity(trainers, sel, "sim", gt, lag_tol_s=30.0) + assert not res["ok"], res + assert res["mean_err"] > 0.05 + assert res["n_missed_transitions"] == 1 # 300s lag exceeds lag_tol_s + assert res["n_spurious_transitions"] == 1 + + +def test_a6_syn0_regression_perfect_fidelity(): + # syn_0-style always-available trace: empty ground-truth SortedDict, and a + # trainer that (correctly) never transitions -- but DOES carry at least + # one sim_now-tagged avail_change event (e.g. a same-state re-stamp), + # otherwise there's no fidelity signal to distinguish from "never ran + # T3.2's telemetry fix" (see test_a6_fails_when_trainer_never_tracked_the_trace). + gt = {"t1_0001": SortedDict()} + trainers = {"0001": {"avail_change": [ + _avail_change(1, "AVL_TRAIN", "AVL_TRAIN", 0.0), + ]}} + sel = [_sel(1, 0.0), _sel(2, 900.0)] + res = trainer_trace_fidelity_parity(trainers, sel, "sim", gt) + assert res["ok"], res + assert res["mean_err"] == 0.0 diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_ladder.py b/lib/python/examples/async_cifar10/scripts/parity/test_ladder.py index 2ff3bb397..c04421659 100644 --- a/lib/python/examples/async_cifar10/scripts/parity/test_ladder.py +++ b/lib/python/examples/async_cifar10/scripts/parity/test_ladder.py @@ -214,6 +214,63 @@ def test_avail_timebase_detects_trajectory_shift(): assert not results["avail_timebase"]["ok"], "A3 should catch the shift" +def test_avail_timebase_passes_aligned(): + """A3 passes when sim eligible-count trajectory matches real within tolerance.""" + real_agg, real_tr = _build_mode(40, advance=10.0, with_vclock=False) + sim_agg, sim_tr = _build_mode(40, advance=10.0, with_vclock=True) + # Identical num_eligible (already set to 10 by _build_mode) — must pass. + results, _ = _verdict(real_agg, sim_agg, real_tr, sim_tr) + assert results["avail_timebase"]["ok"], "aligned trajectory should pass A3" + + +def test_avail_timebase_skips_without_eligible_data(): + """A3 skips when selection events carry no num_eligible field.""" + from parity.checks import avail_timebase_parity + real_agg = {"selection_train": [{"event": "selection", "round": r} for r in range(1, 21)]} + sim_agg = {"selection_train": [{"event": "selection", "round": r} for r in range(1, 21)]} + res = avail_timebase_parity(real_agg, sim_agg) + assert res.get("status") == "SKIP" or res["ok"], "no num_eligible → A3 must skip or pass" + + +def test_duty_cycle_skips_without_avail_change_telemetry(): + """A4 skips when no avail_change telemetry is present (default for syn_0 runs).""" + from parity.checks import duty_cycle_parity + real_tr, sim_tr = {}, {} + for tid in TRAINERS: + real_tr[tid] = {"task_recv": [], "trainer_round": []} + sim_tr[tid] = {"task_recv": [], "trainer_round": []} + res = duty_cycle_parity(real_tr, sim_tr) + assert res["ok"] and res.get("status") == "SKIP", "no telemetry → A4 must skip" + + +def test_duty_cycle_passes_matched_fractions(): + """A4 passes when sim and real duty-cycles match. + + avail_change telemetry carries {old_state, new_state} (build_avail_change), + so "available" = new_state startswith AVL_*. + """ + from parity.checks import duty_cycle_parity + # 3 transitions per trainer: →AVL_TRAIN / →UN_AVL / →AVL_TRAIN → on_frac = 2/3 + evs = [{"new_state": "AVL_TRAIN"}, {"new_state": "UN_AVL"}, + {"new_state": "AVL_TRAIN"}] + real_tr = {tid: {"avail_change": evs} for tid in TRAINERS} + sim_tr = {tid: {"avail_change": evs} for tid in TRAINERS} + res = duty_cycle_parity(real_tr, sim_tr) + assert res["ok"], f"matched duty-cycles must pass A4: {res}" + + +def test_duty_cycle_fails_mismatch(): + """A4 fails when sim duty-cycle diverges from real by more than tolerance.""" + from parity.checks import duty_cycle_parity + # Real: mostly available (on_frac=0.8); sim: mostly unavailable (on_frac=0.2). + real_evs = [{"new_state": "AVL_TRAIN"}] * 8 + [{"new_state": "UN_AVL"}] * 2 + sim_evs = [{"new_state": "AVL_TRAIN"}] * 2 + [{"new_state": "UN_AVL"}] * 8 + real_tr = {tid: {"avail_change": real_evs} for tid in TRAINERS} + sim_tr = {tid: {"avail_change": sim_evs} for tid in TRAINERS} + res = duty_cycle_parity(real_tr, sim_tr) + assert not res["ok"], f"duty-cycle mismatch (0.8 vs 0.2) must fail A4: {res}" + + def test_eligibility_pointmass_passes_on_mean(): """A2: real num_eligible is a constant point-mass (300), sim 298.9 ± tiny. KS saturates to ~1 but the means match — must PASS on the mean (PARITY.md §3i), diff --git a/lib/python/examples/async_cifar10/scripts/parity/test_send_gate_wait_fidelity.py b/lib/python/examples/async_cifar10/scripts/parity/test_send_gate_wait_fidelity.py new file mode 100644 index 000000000..ccc6ff104 --- /dev/null +++ b/lib/python/examples/async_cifar10/scripts/parity/test_send_gate_wait_fidelity.py @@ -0,0 +1,108 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Batch 3 T3.4 — A8 send_gate_wait_fidelity_parity. + +Same synthetic-drift unit-test pattern as T3.2/T3.3 (test_ground_truth.py / +test_agg_belief_fidelity.py), applied to the trainer-side [SEND_GATE] wait +duration: does the observed send_gate_wait_s match what the raw trace says +the wait SHOULD have been, given send_gate_sct (the trainer's own +trace-time-basis clock sampled right before the gate check)? +""" + +from __future__ import annotations + +import os +import sys + +from sortedcontainers import SortedDict + +_SCRIPTS = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if _SCRIPTS not in sys.path: + sys.path.insert(0, _SCRIPTS) + +from parity.checks import send_gate_wait_fidelity_parity # noqa: E402 + + +def _task_send(round_num, send_gate_wait_s, send_gate_sct): + return { + "event": "task_send", "round": round_num, "task_to_perform": "train", + "send_gate_wait_s": send_gate_wait_s, "send_gate_sct": send_gate_sct, + } + + +def test_a8_skips_without_ground_truth(): + trainers = {"0001": {"task_send": [_task_send(1, 200.0, 700.0)]}} + res = send_gate_wait_fidelity_parity(trainers, None) + assert res["ok"] and res.get("status") == "SKIP" + + +def test_a8_skips_when_no_matching_trainer(): + gt = {"t1_9999": SortedDict({600.0: "UN_AVL"})} + trainers = {"0001": {"task_send": [_task_send(1, 200.0, 700.0)]}} + res = send_gate_wait_fidelity_parity(trainers, gt) + assert res.get("status") == "SKIP" + + +def test_a8_skips_when_no_gate_fields_present(): + # sim telemetry (or telemetry predating T3.4): send_gate_wait_s/sct absent. + gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})} + trainers = {"0001": {"task_send": [ + {"event": "task_send", "round": 1, "task_to_perform": "train"}, + ]}} + res = send_gate_wait_fidelity_parity(trainers, gt) + assert res.get("status") == "SKIP" + + +def test_a8_passes_when_observed_matches_ground_truth(): + # Ground truth: AVL_TRAIN [0,600), UN_AVL [600,900), AVL_TRAIN [900,inf). + # Trainer completed compute at sct=700 (mid-outage) -> should wait 200s. + gt = {"t1_0001": SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"})} + trainers = {"0001": {"task_send": [_task_send(1, 200.0, 700.0)]}} + res = send_gate_wait_fidelity_parity(trainers, gt) + assert res["ok"], res + assert res["mean_err_s"] == 0.0 + assert res["n_scored"] == 1 + + +def test_a8_zero_wait_when_already_available(): + gt = {"t1_0001": SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"})} + trainers = {"0001": {"task_send": [_task_send(1, 0.0, 100.0)]}} + res = send_gate_wait_fidelity_parity(trainers, gt) + assert res["ok"], res + assert res["mean_err_s"] == 0.0 + + +def test_a8_fails_on_injected_wait_drift(): + # A promptness bug: observed wait is 300s short of what ground truth says. + gt = {"t1_0001": SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"})} + trainers = {"0001": {"task_send": [_task_send(1, 50.0, 700.0)]}} # expect 200.0 + res = send_gate_wait_fidelity_parity(trainers, gt, mean_tol_s=10.0) + assert not res["ok"], res + assert res["mean_err_s"] == 150.0 + + +def test_a8_excludes_uncomparable_never_recovers_events(): + # Trace never recovers after sct -> excluded from scoring, not penalized. + gt = {"t1_0001": SortedDict({600.0: "UN_AVL"})} + trainers = {"0001": {"task_send": [ + _task_send(1, 50.0, 700.0), # uncomparable (no recovery in trace) + _task_send(2, 0.0, 100.0), # already available -> comparable, err=0 + ]}} + res = send_gate_wait_fidelity_parity(trainers, gt) + assert res["ok"], res + assert res["n_events"] == 2 + assert res["n_scored"] == 1 + assert res["n_uncomparable"] == 1 + + +def test_a8_population_rollup_across_multiple_events(): + gt = {"t1_0001": SortedDict({600.0: "UN_AVL", 900.0: "AVL_TRAIN"})} + trainers = {"0001": {"task_send": [ + _task_send(1, 200.0, 700.0), # exact match, err=0 + _task_send(2, 190.0, 700.0), # err=10 + ]}} + res = send_gate_wait_fidelity_parity(trainers, gt, mean_tol_s=10.0, + within_tau_s=15.0) + assert res["n_scored"] == 2 + assert res["mean_err_s"] == 5.0 + assert res["ok"] diff --git a/lib/python/examples/async_cifar10/scripts/run_felix_streaming.sh b/lib/python/examples/async_cifar10/scripts/run_felix_streaming.sh index 7f5b94a1e..d639ed5a8 100755 --- a/lib/python/examples/async_cifar10/scripts/run_felix_streaming.sh +++ b/lib/python/examples/async_cifar10/scripts/run_felix_streaming.sh @@ -69,7 +69,7 @@ src, out = sys.argv[1], sys.argv[2] d = yaml.safe_load(open(src)) for e in d["experiments"]: h = e["aggregator"]["config_overrides"]["hyperparameters"] - h.update(rounds=6, max_runtime_s=180, evalEveryNRounds=2, + h.update(rounds=6, max_experiment_runtime_s=180, evalEveryNRounds=2, targetAccuracy=0.2, stableEvalsAboveTarget=2, min_trainers_to_start=48, min_trainers_join_timeout_s=120) h["checkpoint"]["every_n_rounds"] = 2 diff --git a/lib/python/examples/async_cifar10/scripts/smoke_suite.sh b/lib/python/examples/async_cifar10/scripts/smoke_suite.sh new file mode 100755 index 000000000..a1fe02753 --- /dev/null +++ b/lib/python/examples/async_cifar10/scripts/smoke_suite.sh @@ -0,0 +1,467 @@ +#!/usr/bin/env bash +# ============================================================================ +# smoke_suite.sh — Sequential smoke campaign with per-run timeout guard. +# +# Runs five ordered steps. Each individual (baseline, mode) invocation of +# debug_run.sh is wrapped in a wall-clock timeout: if the run does not +# self-terminate within (runtime_s + timeout_buffer_s), it is killed via +# SIGTERM → SIGKILL on the whole process group so no orphan trainers remain. +# The suite then continues with the next run. +# +# Steps +# 1 pytest — unit tests (flame/tests/), expected: 536p/7s +# 2 syn_0 sim — byte-identity regression, all 6 baselines +# 3 syn_20 sim — all 6 baselines (availability active, fast mode) +# 4 syn_20 both — all 6 baselines × sim + real (parity gate) +# 5 syn_50 starvation — feddance + oort, both modes (B2.0.2 regression) +# Expected: [SIM_STARVATION] events present, no [SIM_WALL_CEILING], +# self-stops via "stopping run" in both modes. +# +# Per-run checks (applied to the Python agg output log): +# stopping_run count of "stopping run" lines — must be > 0 +# wall_ceiling count of [SIM_WALL_CEILING] lines — must be 0 +# starvation count of [SIM_STARVATION] lines — informational +# +# Report is written to /report.txt and printed at the end. +# +# Usage: +# smoke_suite.sh [OPTIONS] +# +# Options: +# --runtime-syn0-s N Budget (wall/vclock) for syn_0 runs [default: 900] +# --runtime-syn20-s N Budget for syn_20 runs [default: 1800] +# --runtime-syn50-s N Budget for syn_50 starvation runs [default: 3600] +# --timeout-buffer-s N Extra wall-sec before force-kill [default: 600] +# --kill-settle-s N GPU memory settle wait after force-kill [default: 20] +# --steps LIST Comma-separated steps to run (1–5) [default: 1,2,3,4,5] +# --baselines NAMES Space-separated baseline list (steps 2–4) [default: all 6] +# --starvation-baselines NAMES Baselines for step 5 [default: feddance oort] +# --num-trainers N Shrink the cohort below the parity config's 300 +# (forwarded to debug_run.sh --num-trainers on every +# run) [default: "" = use the parity config's 300] +# --output-dir DIR Log + report directory [default: /tmp/smoke_suite_] +# --background Re-exec via nohup+disown and return immediately; +# survives the launching shell/SSH session closing. +# Prints the PID, nohup log, and report path, then +# exits 0 right away — the suite keeps running +# detached. Use this for unattended/overnight runs. +# --dry-run Print commands without running them +# --help +# ============================================================================ +set -uo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +EX_DIR="$(cd "$SCRIPT_DIR/.." && pwd)" # async_cifar10/ +LIB_DIR="$(cd "$EX_DIR/../.." && pwd)" # lib/python/ +DEBUG_RUN="$SCRIPT_DIR/debug_run.sh" + +# ── Defaults ───────────────────────────────────────────────────────────────── +RUNTIME_SYN0_S=900 +RUNTIME_SYN20_S=1800 +RUNTIME_SYN50_S=3600 +TIMEOUT_BUFFER_S=600 +KILL_SETTLE_S=20 # GPU settle wait (seconds) after a force-killed run +ALL_BASELINES="felix oort oort_star refl feddance fedbuff" +STARV_BASELINES="feddance oort" +STEPS="1,2,3,4,5" +OUTPUT_DIR="/tmp/smoke_suite_$(date +%Y%m%d_%H%M%S)" +DRY_RUN=0 +BACKGROUND=0 +NUM_TRAINERS="" + +# ── Progress counters (set after arg-parse via _compute_total_runs) ─────────── +TOTAL_RUNS=0 +COMPLETED_RUNS=0 + +# ── Arg parsing ────────────────────────────────────────────────────────────── +usage() { + grep '^#' "$0" | grep -v '^#!/' | sed 's/^# \{0,1\}//' + exit 0 +} + +ORIG_ARGS=("$@") # preserved pre-shift for the --background re-exec below + +while [[ $# -gt 0 ]]; do + case "$1" in + --runtime-syn0-s) RUNTIME_SYN0_S="$2"; shift 2 ;; + --runtime-syn20-s) RUNTIME_SYN20_S="$2"; shift 2 ;; + --runtime-syn50-s) RUNTIME_SYN50_S="$2"; shift 2 ;; + --timeout-buffer-s) TIMEOUT_BUFFER_S="$2"; shift 2 ;; + --kill-settle-s) KILL_SETTLE_S="$2"; shift 2 ;; + --steps) STEPS="$2"; shift 2 ;; + --baselines) ALL_BASELINES="$2"; shift 2 ;; + --starvation-baselines) STARV_BASELINES="$2"; shift 2 ;; + --output-dir) OUTPUT_DIR="$2"; shift 2 ;; + --num-trainers) NUM_TRAINERS="$2"; shift 2 ;; + --dry-run) DRY_RUN=1; shift ;; + --background) BACKGROUND=1; shift ;; + --help|-h) usage ;; + *) echo "Unknown arg: $1" >&2; usage ;; + esac +done + +# ── --background: re-exec detached, return control immediately ─────────────── +# Guarded by SMOKE_SUITE_BG so the re-exec'd child (which still sees +# --background in ORIG_ARGS) runs the real suite instead of looping. +if [[ "$BACKGROUND" == "1" && -z "${SMOKE_SUITE_BG:-}" ]]; then + mkdir -p "$OUTPUT_DIR" + NOHUP_LOG="$OUTPUT_DIR/nohup.log" + SMOKE_SUITE_BG=1 nohup bash "$0" "${ORIG_ARGS[@]}" >"$NOHUP_LOG" 2>&1 < /dev/null & + disown + echo "[smoke_suite] backgrounded — PID $! (survives this shell/SSH session closing)" + echo "[smoke_suite] nohup log : $NOHUP_LOG" + echo "[smoke_suite] report : $OUTPUT_DIR/report.txt (written when the suite finishes)" + echo "[smoke_suite] progress : tail -f $NOHUP_LOG" + exit 0 +fi + +# ── Setup ──────────────────────────────────────────────────────────────────── +mkdir -p "$OUTPUT_DIR/runs" +SUITE_LOG="$OUTPUT_DIR/suite.log" +REPORT="$OUTPUT_DIR/report.txt" +SUITE_START=$(date +%s) + +_log() { echo "[$(date '+%F %T')] $*" | tee -a "$SUITE_LOG"; } +_step() { _log ""; _log "══════ STEP $* ══════"; } + +# ── Result tracking ────────────────────────────────────────────────────────── +# Each entry: "label|status|stopping_run|wall_ceiling|starvation" +declare -a RUN_RESULTS=() + +_record() { + RUN_RESULTS+=("${1}|${2}|${3}|${4}|${5}") + COMPLETED_RUNS=$(( COMPLETED_RUNS + 1 )) +} + +# ── Total-run count (computed once after arg-parse) ────────────────────────── +_compute_total_runs() { + local total=0 + local n_all; n_all=$(echo "$ALL_BASELINES" | wc -w) + local n_starv; n_starv=$(echo "$STARV_BASELINES" | wc -w) + local _s + IFS=',' read -ra _sa <<< "$STEPS" + for _s in "${_sa[@]}"; do + _s="${_s// /}" + case "$_s" in + 1) total=$(( total + 1 )) ;; + 2) total=$(( total + n_all )) ;; + 3) total=$(( total + n_all )) ;; + 4) total=$(( total + 2 * n_all )) ;; + 5) total=$(( total + 2 * n_starv )) ;; + esac + done + TOTAL_RUNS=$total +} + +# ── Per-run timeout wrapper ─────────────────────────────────────────────────── +# _run_baseline _n.yaml index-list file. + # Skips the index-split lookup in ConfigGenerator.generate_trainer_config(). + path_style: bool = False @dataclass @@ -33,6 +37,14 @@ class TrainerConfig: num_trainers: int = 300 start_id: int = 1 + # Which _alpha_n.yaml split file to read, i.e. the N the + # dataset was partitioned for. Defaults to num_trainers. Set it larger + # than num_trainers to spawn a subset cohort (the first num_trainers + # trainers) against an existing wider partition -- e.g. num_trainers=10 + # + split_num_trainers=300 runs a 10-trainer smoke off the n300 split + # without needing a dedicated n10 split file. See spawn_all's docstring: + # this N is a property of the partition, not of how many are spawned. + split_num_trainers: Optional[int] = None dataset: DatasetConfig = field(default_factory=DatasetConfig) availability: AvailabilityConfig = field(default_factory=AvailabilityConfig) battery_threshold: int = 50 # For 3-state modes @@ -43,16 +55,41 @@ class TrainerConfig: enable_training_delays: bool = True # Enable per-trainer training delays hyperparameters: Optional[dict] = None # Trainer-specific hyperparameters (e.g., batchSize, learningRate) config_overrides: Optional[dict] = None # Deep-merged into per-trainer config last (wins over baseline) + # When set, the runner injects hyperparameters.client_idx = + # (trainer_id - 1) % client_idx_modulo per trainer, for path-style + # datasets (e.g. H5 partitions) that need N trainers wrapped onto M + # data partitions. None = no per-trainer client_idx injection. + client_idx_modulo: Optional[int] = None @dataclass class AggregatorConfig: - """Aggregator configuration.""" + """Aggregator configuration. + + `selector`/`tracking_mode` do NOT configure the aggregator -- they are + descriptive labels (log filename, snapshot/execution_config records) + only. The real selector/optimizer/hyperparameters come exclusively from + `config_template` -> baseline -> `config_overrides` (see + runner.py:_build_aggregator_config). The runner validates `selector` + against the real merged value and raises on mismatch, so a stale label + is caught rather than silently ignored. + """ config_template: Optional[str] = None # Path to aggregator JSON config (optional when using baseline) selector: str = "oort" tracking_mode: str = "oracular" # oracular, default - agg_goal: int = 10 + # Single source of truth for the aggregation-goal count. When set, the + # runner fans this value into every real runtime consumer as the final + # merge layer, so they can never drift apart: + # - hyperparameters.aggGoal: aggregator's wait-for-N-contributions + # threshold (config.hyperparameters.aggregation_goal). + # - selector.kwargs.aggGoal: read by fedbuff/async_random/async_oort/ + # oracle selectors. + # - selector.kwargs.aggr_num: read by oort/refl_oort/feddance + # selectors (same concept, different kwarg name). + # None = leave whatever config_template/baseline/config_overrides + # already produced untouched. + agg_goal: Optional[int] = None log_to_wandb: bool = False wandb_run_name: Optional[str] = None config_overrides: Optional[dict] = None # Deep-merged into aggregator JSON last (wins over baseline) @@ -92,12 +129,20 @@ class ExampleConfig: @dataclass class MetadataPaths: - """Shared-metadata locations. Paths may be absolute or repo-relative.""" + """Shared-metadata locations. Paths may be absolute or repo-relative. + + Only `dir` and `registry` are real -- `MetadataLoader` (spawner.py) + takes a single root directory and reads fixed `dataset_splits/` and + `availability_traces/` subdirectories under it; there is no per- + component override hook to plug a separate location into. Don't re-add + `dataset_splits_dir`/`traces_dir`-shaped fields here unless + `MetadataLoader` is actually changed to accept them -- that pairing + (declared-but-never-wired field) is the exact bug class this file's + `AggregatorConfig.agg_goal` history is a cautionary tale for. + """ dir: Optional[str] = None registry: Optional[str] = None - dataset_splits_dir: Optional[str] = None - traces_dir: Optional[str] = None @dataclass @@ -179,6 +224,7 @@ def from_yaml(cls, yaml_path: Path) -> "ExperimentBatch": trainer=TrainerConfig( num_trainers=trainer_data.get("num_trainers", 300), start_id=trainer_data.get("start_id", 1), + split_num_trainers=trainer_data.get("split_num_trainers"), dataset=( DatasetConfig(**dataset_data) if dataset_data @@ -194,6 +240,7 @@ def from_yaml(cls, yaml_path: Path) -> "ExperimentBatch": enable_training_delays=trainer_data.get("enable_training_delays", True), hyperparameters=trainer_data.get("hyperparameters"), config_overrides=trainer_data.get("config_overrides"), + client_idx_modulo=trainer_data.get("client_idx_modulo"), ), aggregator=AggregatorConfig(**agg_data) if agg_data else None, execution=( diff --git a/lib/python/flame/launch/runner.py b/lib/python/flame/launch/runner.py index e7137a727..86eba2de3 100644 --- a/lib/python/flame/launch/runner.py +++ b/lib/python/flame/launch/runner.py @@ -11,6 +11,7 @@ import json import os +import yaml import re import signal import subprocess @@ -121,6 +122,7 @@ def run_experiment(self, exp: ExperimentConfig) -> None: agg_cfg, agg_provenance = self._build_aggregator_config( exp, agg_config_path, baseline_entry ) + self._validate_selector_label(exp, agg_cfg) # Propagate the simulation time mode to the aggregator (it needs to # know whether to order updates by a virtual clock or by arrival). agg_cfg.setdefault("hyperparameters", {})["time_mode"] = exp.trainer.time_mode @@ -159,6 +161,9 @@ def run_experiment(self, exp: ExperimentConfig) -> None: os.environ["FLAME_TELEMETRY_DIR"] = str(self.telemetry_dir) # UTF-8 child stdio so status glyphs don't crash on latin-1 locales. os.environ.setdefault("PYTHONIOENCODING", "utf-8") + # Fault handler: on SIGSEGV/SIGFPE/etc. Python prints a C-level traceback + # to stderr (merged into _aggregator.log) before the process dies. + os.environ.setdefault("PYTHONFAULTHANDLER", "1") # CPU partition: reserve a few cores for the single, message-processing # -bound aggregator so the 300 pinned trainers don't time-slice it @@ -225,6 +230,7 @@ def run_experiment(self, exp: ExperimentConfig) -> None: "aggregator": [str(c) for c in agg_spawn_cmd], "trainers": [str(c) for c in trainer_spawn_cmd], }, + agg_cfg=agg_cfg, ) save_execution_config(exec_config, self.current_exp_dir / "execution_config.yaml") @@ -232,6 +238,7 @@ def run_experiment(self, exp: ExperimentConfig) -> None: snapshot.create_snapshot( exp, paths["metadata_dir"], agg_cfg_path_out, trainer_spawn_cmd, agg_spawn_cmd, + agg_cfg=agg_cfg, ) trainer_ids = list( @@ -261,27 +268,49 @@ def run_experiment(self, exp: ExperimentConfig) -> None: config_gen.set_baseline_overrides(merged_t) print(format_provenance("trainer", t_prov)) + # client_idx_modulo wraps N trainers onto M data partitions for + # path-style datasets (e.g. fwdllm's H5 partitions) -- each + # trainer needs a different hyperparameters.client_idx, computed + # from its own trainer_id, not a value shared across the batch. + per_trainer_overrides = None + if exp.trainer.client_idx_modulo: + modulo = exp.trainer.client_idx_modulo + per_trainer_overrides = { + tid: {"hyperparameters.client_idx": (tid - 1) % modulo} + for tid in trainer_ids + } + self.trainer_spawner.spawn_all( trainer_ids, alpha=exp.trainer.dataset.dirichlet_alpha, availability_mode=exp.trainer.availability.mode, trainer_main_path=paths["trainer_main"], + skip_index_splits=exp.trainer.dataset.path_style, + dataset_name=exp.trainer.dataset.name, + # Split-file selector is independent of the spawn cohort size: + # split_num_trainers (the N the partition was built for) falls + # back to num_trainers when unset. trainer_ids above still + # spawns exactly num_trainers trainers. + num_trainers=exp.trainer.split_num_trainers or exp.trainer.num_trainers, + per_trainer_overrides=per_trainer_overrides, **config_overrides, ) print(f"\nexperiment running. logs: {agg_log}, {trainers_log}") # Wait for the aggregator to finish all rounds first, then give - # trainers a short grace window to process the EOT broadcast and - # exit cleanly. Without this, wait_all()'s per-trainer timeout fires - # immediately after spawn and kills trainers every 30s regardless of + # trainers a short grace window (shared across the whole cohort, + # not serialized per-process) to process the EOT broadcast and + # exit cleanly. Without this, wait_all()'s timeout fires + # immediately after spawn and kills trainers regardless of # whether training is still in progress. - # Watchdog: the aggregator self-stops at max_runtime_s (real) / sim_wall_ceiling_s - # (sim). If it instead DEADLOCKS (MQTT/barrier) it would block this wait forever and - # hang the batch. Bound the wait at the run's budget + a generous grace and hard-kill - # on timeout so the batch proceeds to _cleanup/_sweep_stragglers instead of hanging. + # Watchdog: the aggregator self-stops at max_experiment_runtime_s (real) / + # sim_wall_ceiling_s (sim). If it instead DEADLOCKS (MQTT/barrier) it would + # block this wait forever and hang the batch. Bound the wait at the run's + # budget + a generous grace and hard-kill on timeout so the batch proceeds + # to _cleanup/_sweep_stragglers instead of hanging. hp = agg_cfg.get("hyperparameters", {}) or {} try: - budget_s = max(float(hp.get("max_runtime_s") or 0.0), + budget_s = max(float(hp.get("max_experiment_runtime_s") or 0.0), float(hp.get("sim_wall_ceiling_s") or 0.0)) except (TypeError, ValueError): budget_s = 0.0 @@ -292,7 +321,9 @@ def run_experiment(self, exp: ExperimentConfig) -> None: print(f" ⚠ aggregator still running after watchdog {wd_msg} — " f"assuming deadlock; killing it (run budget was {budget_s:.0f}s)") self.aggregator_spawner.terminate() - print(" aggregator done, waiting for trainers to exit...") + agg_rc = getattr(self.aggregator_spawner.process, "returncode", None) + rc_msg = f"exit={agg_rc}" if agg_rc == 0 else f"exit={agg_rc} ⚠" + print(f" aggregator done ({rc_msg}), waiting for trainers to exit...") self.trainer_spawner.wait_all(timeout_per_trainer=30.0) print("\nexperiment completed.") @@ -373,18 +404,55 @@ def _resolve_aggregator_main( return exp.example.aggregator_main or "aggregator/pytorch/main.py" # async selectors require the asyncfl stack; everything else is sync. + # "fwdllm" is its own stack: FedFwd's TopAggregator + # (flame.mode.horizontal.syncfl.fwdllm_aggregator) is a FedFwd-specific + # implementation, not the generic syncfl.top_aggregator, so the regex + # below can't detect it under the normal top_aggregator match. Unlike + # the other stacks, fwdllm supports both sync and async baselines + # (fwdllm/fwdllm_plus run sync, fluxtune runs async) gated purely by the + # selector's `is_async` kwarg -- so it's deliberately not in + # _ASYNC_STACKS; its async-ness is decided in _validate_stack itself. _ASYNC_STACKS = {"asyncfl", "coord_asyncfl"} _ASYNC_SELECTORS = {"async_oort", "async_random", "fedbuff"} + # _sweep_stragglers() pkill/pgrep patterns. fwdllm's entrypoints have no + # pytorch/ subdirectory, so they need their own patterns alongside the + # cifar10-shaped ones -- add one line per new example's entrypoint paths. + _STRAGGLER_PATTERNS = ( + "trainer/pytorch/main.py", + "aggregator/pytorch/main_", + "fwdllm/trainer/main.py", + "fwdllm/aggregator/main_fedfwd_agg.py", + ) + _TRAINER_STRAGGLER_PATTERNS = ( + "trainer/pytorch/main.py", + "fwdllm/trainer/main.py", + ) + def _validate_stack(self, agg_main_path: Path, agg_cfg: dict) -> None: text = Path(agg_main_path).read_text() - m = re.search( - r"from flame\.mode\.horizontal\.(\w+)\.top_aggregator import", text - ) - stack = m.group(1) if m else "syncfl" - selector = (agg_cfg.get("selector") or {}).get("sort", "") - is_async_stack = stack in self._ASYNC_STACKS + if re.search( + r"from flame\.mode\.horizontal\.\w+\.fwdllm_aggregator import", text + ): + stack = "fwdllm" + else: + m = re.search( + r"from flame\.mode\.horizontal\.(\w+)\.top_aggregator import", text + ) + stack = m.group(1) if m else "syncfl" + selector_cfg = agg_cfg.get("selector") or {} + selector = selector_cfg.get("sort", "") is_async_sel = selector in self._ASYNC_SELECTORS + if stack == "fwdllm": + # fwdllm's aggregator dispatches sync vs async purely on the + # selector's declared `is_async` kwarg (see + # fwdllm_aggregator.py), not on stack membership -- so the + # invariant to enforce here is internal consistency: an async + # selector must declare is_async=true, and a sync selector + # (e.g. `random`) must declare is_async=false/unset. + is_async_stack = bool((selector_cfg.get("kwargs") or {}).get("is_async", False)) + else: + is_async_stack = stack in self._ASYNC_STACKS if is_async_stack != is_async_sel: raise ValueError( f"selector/stack mismatch: selector={selector!r} " @@ -392,6 +460,26 @@ def _validate_stack(self, agg_main_path: Path, agg_cfg: dict) -> None: f"{stack!r} (async={is_async_stack}). main={agg_main_path}" ) + def _validate_selector_label(self, exp: ExperimentConfig, agg_cfg: dict) -> None: + """`aggregator.selector` is a descriptive label (log filename, + snapshot/execution_config records) -- it does not configure the + real selector, which comes from config_template/baseline/ + config_overrides (see AggregatorConfig docstring). Catch the label + drifting from reality here rather than letting it silently mislabel + every record of the run. + """ + if not exp.aggregator or not exp.aggregator.selector: + return + real_selector = (agg_cfg.get("selector") or {}).get("sort") + if real_selector and exp.aggregator.selector != real_selector: + raise ValueError( + f"aggregator.selector label {exp.aggregator.selector!r} does not " + f"match the real merged selector {real_selector!r} (from " + f"config_template/baseline/config_overrides). Fix the label " + f"under experiment.aggregator.selector, or check why the real " + f"selector resolved differently than intended." + ) + def _build_aggregator_config( self, exp: ExperimentConfig, @@ -408,7 +496,10 @@ def _build_aggregator_config( if not template_path.exists(): raise FileNotFoundError(f"aggregator config_template not found: {template_path}") with open(template_path) as f: - tmpl = json.load(f) + if template_path.suffix in (".yaml", ".yml"): + tmpl = yaml.safe_load(f) + else: + tmpl = json.load(f) layers.append((f"config_template:{template_path.name}", tmpl)) if baseline_entry: @@ -421,6 +512,29 @@ def _build_aggregator_config( ("experiment.aggregator.config_overrides", exp.aggregator.config_overrides) ) + # agg_goal is a single source of truth: fan it into every real + # runtime consumer as the final, highest-precedence layer so they + # can never disagree (see AggregatorConfig.agg_goal docstring). + # Selector implementations spell "how many to select/aggregate" + # under two different kwarg names depending on family -- aggGoal + # (fedbuff/async_random/async_oort/oracle) vs. aggr_num + # (oort/refl_oort/feddance) -- so set both; selectors that don't + # read a given key simply ignore the extra entry (kwargs is an + # unvalidated freeform dict, flame/config.py:Selector). + if exp.aggregator and exp.aggregator.agg_goal is not None: + layers.append(( + "experiment.aggregator.agg_goal", + { + "hyperparameters": {"aggGoal": exp.aggregator.agg_goal}, + "selector": { + "kwargs": { + "aggGoal": exp.aggregator.agg_goal, + "aggr_num": exp.aggregator.agg_goal, + } + }, + }, + )) + merged, provenance = merge_with_provenance(layers) return merged, provenance @@ -489,7 +603,7 @@ def _sweep_stragglers(self, gpu_settle_timeout_s: float = 45.0) -> None: Matches ONLY the example's main scripts — never the batch runner itself (``run_experiment``) — so it is safe to call from inside the batch loop.""" - for pat in ("trainer/pytorch/main.py", "aggregator/pytorch/main_"): + for pat in self._STRAGGLER_PATTERNS: try: subprocess.run(["pkill", "-9", "-f", pat], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) @@ -499,10 +613,15 @@ def _sweep_stragglers(self, gpu_settle_timeout_s: float = 45.0) -> None: deadline = time.time() + gpu_settle_timeout_s while time.time() < deadline: try: - out = subprocess.run( - ["pgrep", "-f", "trainer/pytorch/main.py"], - capture_output=True, text=True, check=False) - if not out.stdout.strip(): + still_running = False + for pat in self._TRAINER_STRAGGLER_PATTERNS: + out = subprocess.run( + ["pgrep", "-f", pat], + capture_output=True, text=True, check=False) + if out.stdout.strip(): + still_running = True + break + if not still_running: break except Exception: break diff --git a/lib/python/flame/launch/snapshot.py b/lib/python/flame/launch/snapshot.py index 68d240058..9f50d39e4 100644 --- a/lib/python/flame/launch/snapshot.py +++ b/lib/python/flame/launch/snapshot.py @@ -33,6 +33,7 @@ def create_snapshot( aggregator_config_path: Path, trainer_spawn_command: List[str], aggregator_spawn_command: List[str], + agg_cfg: Dict = None, ): """ Create complete experiment snapshot. @@ -43,12 +44,15 @@ def create_snapshot( aggregator_config_path: Path to aggregator JSON config trainer_spawn_command: Command used to spawn trainers aggregator_spawn_command: Command used to spawn aggregator + agg_cfg: The real, merged aggregator config (if available) -- used + to record the effective `agg_goal` instead of the + possibly-unset `exp_config.aggregator.agg_goal` typed field. """ snapshot_data = { "snapshot_version": "1.0", "timestamp": datetime.now().isoformat(), "hostname": subprocess.check_output(["hostname"]).decode().strip(), - "experiment": self._serialize_experiment_config(exp_config), + "experiment": self._serialize_experiment_config(exp_config, agg_cfg), "spawn_commands": { "aggregator": aggregator_spawn_command, "trainers": trainer_spawn_command, @@ -73,8 +77,15 @@ def create_snapshot( print(f" ✓ Snapshot saved: {self.snapshot_file}") print(f" ✓ Metadata location recorded: {metadata_dir}") - def _serialize_experiment_config(self, exp_config: ExperimentConfig) -> Dict: + def _serialize_experiment_config( + self, exp_config: ExperimentConfig, agg_cfg: Dict = None + ) -> Dict: """Serialize experiment config to dict.""" + effective_agg_goal = ( + (agg_cfg or {}).get("hyperparameters", {}).get("aggGoal") + if agg_cfg is not None + else (exp_config.aggregator.agg_goal if exp_config.aggregator else None) + ) return { "name": exp_config.name, "description": exp_config.description, @@ -96,7 +107,7 @@ def _serialize_experiment_config(self, exp_config: ExperimentConfig) -> Dict: "config_template": exp_config.aggregator.config_template, "selector": exp_config.aggregator.selector, "tracking_mode": exp_config.aggregator.tracking_mode, - "agg_goal": exp_config.aggregator.agg_goal, + "agg_goal": effective_agg_goal, } if exp_config.aggregator else None diff --git a/lib/python/flame/launch/spawner.py b/lib/python/flame/launch/spawner.py index ac27dbe8d..d1dbd6230 100644 --- a/lib/python/flame/launch/spawner.py +++ b/lib/python/flame/launch/spawner.py @@ -59,9 +59,24 @@ def get_dataset_split( trainer_key = f"trainer_{trainer_id:03d}" return self.dataset_splits[split_key]["trainer_data_splits"][trainer_key] - def get_synthetic_trace(self, trace_name: str) -> List: - """Get synthetic availability trace.""" - return self.synthetic_traces["traces"][trace_name]["pattern"] + def get_synthetic_trace( + self, trace_name: str, trainer_id: Optional[int] = None + ) -> List: + """Get synthetic availability trace. + + trainer_id=None returns the shared `pattern` entry. Pass trainer_id to + resolve that trainer's own `per_trainer` entry via the same resolver + (flame.availability.trace.load_trace) the aggregator already uses. + """ + if trainer_id is None: + return self.synthetic_traces["traces"][trace_name]["pattern"] + from flame.availability.trace import load_trace + + trainer_key = f"trainer_{trainer_id:03d}" + trace_dict = load_trace( + trace_name, trainer_key, base_dir=str(self.metadata_dir / "availability_traces") + ) + return [[ts, state] for ts, state in trace_dict.items()] def get_mobiperf_trace(self, trainer_id: int, variant: str = "2st") -> List: """Get mobiperf trace for a trainer.""" @@ -97,6 +112,7 @@ def generate_trainer_config( availability_mode: str = "mobiperf_2st", dataset_name: str = "cifar10", num_trainers: int = 300, + skip_index_splits: bool = False, **overrides, ) -> Dict: """Build a full trainer config dict from base + metadata + overrides. @@ -106,6 +122,12 @@ def generate_trainer_config( 2. baseline_overrides (set via set_baseline_overrides, deep-merged) 3. per-trainer values from shared metadata (taskid, indices, traces) 4. **overrides dotted-key kwargs (job.id, hyperparameters.X) + + skip_index_splits: True for path-style datasets (e.g. H5 file paths) + that have no _metadata/dataset_splits/_alpha_n.yaml + index-list file -- skips the get_dataset_split() lookup and the + trainer_indices_list injection entirely, instead of KeyError-ing on a + split file that will never exist for this dataset. """ from copy import deepcopy @@ -118,17 +140,21 @@ def generate_trainer_config( trainer_meta = self.metadata.get_trainer_metadata(trainer_id) config["taskid"] = trainer_meta["task_id"] - dataset_indices = self.metadata.get_dataset_split( - alpha, trainer_id, dataset_name, num_trainers - ) - # Update hyperparameters if "hyperparameters" not in config: config["hyperparameters"] = {} - config["hyperparameters"]["trainer_indices_list"] = dataset_indices - config["hyperparameters"]["training_delay_s"] = trainer_meta["training_delay_s"] - + if not skip_index_splits: + dataset_indices = self.metadata.get_dataset_split( + alpha, trainer_id, dataset_name, num_trainers + ) + config["hyperparameters"]["trainer_indices_list"] = dataset_indices + # training_delay_s deprecated in favour of computation_time_ms (per-device dict, in ms) + config["hyperparameters"]["computation_time_ms"] = trainer_meta["computation_time_ms"] + config["hyperparameters"]["satellite_index"] = trainer_meta["satellite_index"] + config["hyperparameters"]["satellite_latencies_path"] = str( + self.metadata.metadata_dir / "leo" / "satellite_latencies.npy" + ) # Set training_delay_enabled from overrides (default True) training_delay_enabled = overrides.get("hyperparameters.training_delay_enabled", "True") config["hyperparameters"]["training_delay_enabled"] = training_delay_enabled @@ -142,13 +168,13 @@ def generate_trainer_config( elif availability_mode.startswith("syn_"): trace_name = availability_mode config["hyperparameters"][f"avl_events_{trace_name}"] = ( - self.metadata.get_synthetic_trace(trace_name) + self.metadata.get_synthetic_trace(trace_name, trainer_id) ) # Add all synthetic traces (for flexibility) for trace_name in ["syn_0", "syn_20", "syn_50"]: config["hyperparameters"][f"avl_events_{trace_name}"] = ( - self.metadata.get_synthetic_trace(trace_name) + self.metadata.get_synthetic_trace(trace_name, trainer_id) ) # Add all mobiperf traces @@ -232,6 +258,9 @@ def spawn_trainer( alpha: float, availability_mode: str, trainer_main_path: Path, + skip_index_splits: bool = False, + dataset_name: str = "cifar10", + num_trainers: int = 300, **config_overrides, ) -> subprocess.Popen: """ @@ -242,6 +271,24 @@ def spawn_trainer( alpha: Dirichlet alpha availability_mode: Availability trace mode trainer_main_path: Path to trainer main.py + skip_index_splits: True for path-style datasets with no + _metadata/dataset_splits/ index-list file (see + ConfigGenerator.generate_trainer_config). + dataset_name: Forwarded to generate_trainer_config()'s dataset + split lookup. Caller MUST pass the experiment's real + trainer.dataset.name -- the "cifar10" default here exists + only so direct/manual callers don't need to specify it for + the common case, not as a silent fallback for the launcher. + num_trainers: Forwarded to generate_trainer_config()'s dataset + split lookup (selects which _alpha_n.yaml + split file to read). Caller MUST pass the experiment's real + trainer.num_trainers -- the 300 default here is the same + "don't require it for manual calls" exception as + dataset_name, not a safe fallback. Passing the wrong value + silently loads a *different*, structurally valid split file + (e.g. n=300's instead of n=48's) rather than erroring, which + is exactly the bug this parameter was added to close (no + caller threaded it through before). **config_overrides: Additional config overrides Returns: @@ -249,7 +296,9 @@ def spawn_trainer( """ # Generate config config = self.config_gen.generate_trainer_config( - trainer_id, alpha, availability_mode, **config_overrides + trainer_id, alpha, availability_mode, + dataset_name=dataset_name, num_trainers=num_trainers, + skip_index_splits=skip_index_splits, **config_overrides ) # Serialize config to JSON string @@ -317,6 +366,10 @@ def spawn_all( alpha: float, availability_mode: str, trainer_main_path: Path, + skip_index_splits: bool = False, + dataset_name: str = "cifar10", + num_trainers: int = 300, + per_trainer_overrides: Optional[Dict[int, Dict]] = None, **config_overrides, ): """ @@ -327,7 +380,26 @@ def spawn_all( alpha: Dirichlet alpha availability_mode: Availability trace mode trainer_main_path: Path to trainer main.py - **config_overrides: Additional config overrides + skip_index_splits: True for path-style datasets with no + _metadata/dataset_splits/ index-list file. + dataset_name: The experiment's real trainer.dataset.name -- + selects which _alpha_n.yaml split file to + read (see spawn_trainer's docstring for why the "cifar10" + default here must not be relied on by the launcher). + num_trainers: The experiment's real trainer.num_trainers -- + selects which _alpha_n.yaml split file to + read. Pass it explicitly rather than inferring + len(trainer_ids); the split file's means "this dataset + was partitioned for N trainers total," a property of the + experiment, not of whichever id range happens to be passed + here. + per_trainer_overrides: Optional {trainer_id: {dotted.key: value}} + dict of overrides that vary per trainer (e.g. a computed + hyperparameters.client_idx), merged on top of the shared + **config_overrides for that specific trainer_id. Unlike + **config_overrides (identical for every trainer), + per_trainer_overrides lets each trainer's config differ. + **config_overrides: Additional config overrides shared by all trainers """ print(f"\nSpawning {len(trainer_ids)} trainers...") print(f" Alpha: {alpha}") @@ -336,12 +408,18 @@ def spawn_all( print() for trainer_id in trainer_ids: + trainer_overrides = dict(config_overrides) + if per_trainer_overrides and trainer_id in per_trainer_overrides: + trainer_overrides.update(per_trainer_overrides[trainer_id]) self.spawn_trainer( trainer_id, alpha, availability_mode, trainer_main_path, - **config_overrides, + skip_index_splits=skip_index_splits, + dataset_name=dataset_name, + num_trainers=num_trainers, + **trainer_overrides, ) time.sleep(self.sleep_between_spawns) @@ -356,34 +434,49 @@ def spawn_all( def wait_all(self, timeout_per_trainer: float = 30.0): """Wait for all trainer processes to complete. - Each trainer gets ``timeout_per_trainer`` seconds after the aggregator - exits to process the EOT broadcast and self-terminate. Trainers that - are blocked in ``await_join`` (waiting for the next task from an - aggregator that has already left) will never self-exit, so we force- - terminate them after the window. Without this the runner hangs + All trainers share a single ``timeout_per_trainer`` second window + after the aggregator exits to process the EOT broadcast and + self-terminate, polled concurrently — not one process at a time, or + N stragglers would serialize the shutdown into N * timeout_per_trainer + (e.g. 5 stuck trainers at 30s each adds 2.5 minutes of pure idle + wait). Trainers blocked in ``await_join`` (waiting for the next task + from an aggregator that has already left) will never self-exit, so we + force-terminate whatever is left after the window, then kill anything + still alive after a short grace period. Without this the runner hangs indefinitely and the next sequential experiment never starts. """ - import signal as _signal + deadline = time.time() + timeout_per_trainer + pending = [p["process"] for p in self.processes] - deadline_per = timeout_per_trainer - for proc_info in self.processes: - proc = proc_info["process"] + while pending and time.time() < deadline: + pending = [p for p in pending if p.poll() is None] + if pending: + time.sleep(0.5) + + if not pending: + return + + print( + f" ({len(pending)} trainer(s) did not exit within " + f"{timeout_per_trainer:.0f}s; terminating)" + ) + for proc in pending: try: - proc.wait(timeout=deadline_per) + proc.terminate() except Exception: - # Timeout or other error — gracefully terminate then kill. - print( - f" (trainer PID {proc.pid} did not exit within " - f"{deadline_per}s; terminating)" - ) - try: - proc.terminate() - proc.wait(timeout=5) - except Exception: - try: - proc.kill() - except Exception: - pass + pass + + kill_deadline = time.time() + 5 + while pending and time.time() < kill_deadline: + pending = [p for p in pending if p.poll() is None] + if pending: + time.sleep(0.5) + + for proc in pending: + try: + proc.kill() + except Exception: + pass def terminate_all(self): """Terminate all trainer processes.""" diff --git a/lib/python/flame/mode/horizontal/asyncfl/top_aggregator.py b/lib/python/flame/mode/horizontal/asyncfl/top_aggregator.py index dedea4ea4..41e2fbda6 100644 --- a/lib/python/flame/mode/horizontal/asyncfl/top_aggregator.py +++ b/lib/python/flame/mode/horizontal/asyncfl/top_aggregator.py @@ -88,6 +88,16 @@ def internal_init(self) -> None: self._agg_goal_cnt = 0 self._agg_goal_weights = None self._agg_goal = self.config.hyperparameters.aggregation_goal or 1 + # An end may only contribute once per aggregation cycle (reset + # alongside _agg_goal_cnt in _reset_agg_goal_variables). Guards + # against a duplicate/late message from an end that was reclaimed + # (selector SEND_TIMEOUT_WAIT_S) and reselected while its original + # response was still in flight -- mirrors + # fwdllm_aggregator._process_single_trainer_message's + # _per_agg_trainer_list guard, which the generic asyncfl path + # otherwise lacks. See examples/MIGRATING_TO_LAUNCHER.md's + # aggregator gotchas (§2). + self._agg_cycle_contributed_ends: set = set() self._updates_in_queue = 0 self._updates_recevied = {} @@ -102,6 +112,16 @@ def internal_init(self) -> None: self._sim_buffer = SimReorderBuffer() self._sim_committed: set = set() self._sim_pending_commit: set = set() + # C.2 send-time withhold: an in-flight update whose trainer is UN_AVL at + # its completion (sct) is HELD here (end -> (sct, (msg, metadata))) and + # re-injected into the buffer at its delivery_ts (commits stale). The + # delivery_ts itself lives in the ClientAvailability pending_withheld ledger. + self._sim_withheld_payload: dict = {} + # end -> (orig_sct, delivery_ts) for an update currently re-injected into the + # buffer awaiting its late (stale) commit. Lets the commit body recognize a + # withheld delivery (vs a fresh/straggler commit) so it tags the "withheld" + # past-dating bucket and emits the withheld_delivery rung with the true delay. + self._sim_withheld_delivering: dict = {} self._sim_enqueue_round = {} # end -> round it entered the reorder buffer # Virtual-completion gate: the aggregator's record of each in-flight trainer's # EXPECTED completion = dispatch vclock + its MODELED budget. Lets _sim_recv_min hold @@ -198,6 +218,9 @@ def _reset_agg_goal_variables(self): # reset agg goal count self._agg_goal_cnt = 0 + # reset the per-cycle duplicate-contribution guard (see internal_init) + self._agg_cycle_contributed_ends = set() + # reset agg goal weights self._agg_goal_weights = None logger.debug( @@ -283,6 +306,11 @@ def _sim_end_has_ready_msg(channel, end) -> bool: except Exception: return False + # C.2 / C.3 commit-loop wiring (_sim_pop_committable, _sim_reinject_ready_withheld, + # _sim_abandon_stalled) is shared, library-level in ClientAvailability so the oort + # stack rides the identical logic. The asyncfl gate tracker (_sim_inflight_expected) + # is reached via the mixin's guarded _avail_drop_inflight hook. + def _sim_recv_min(self, channel, recv_ends): """Barrier: drain the in-flight set, then commit the smallest sim_completion_ts. The virtual clock advances TO each committed completion @@ -294,6 +322,8 @@ def _sim_recv_min(self, channel, recv_ends): verifies the clock is now sct-driven.""" if not hasattr(self, "_sim_inflight_expected"): # bare-init guard (tests) self._sim_inflight_expected = {} + self._sim_withheld_payload = {} + self._sim_withheld_delivering = {} self._sim_trainer_budget = {} self._sim_budget_running_mean = 12.0 self._sim_budget_n = 0 @@ -418,8 +448,13 @@ def _ingest(msg, metadata): self._note_sim_fill(barrier_wait, drained_all) # Pop the minimum regardless of recv_ends membership so buffered updates - # are not lost when an end is cleaned up before its commit. - popped = self._sim_buffer.pop_min() + # are not lost when an end is cleaned up before its commit. First re-inject + # any withheld update whose delivery_ts has arrived (C.2), then pop the + # smallest update that is actually committable — an in-flight trainer that is + # UN_AVL at its completion (sct) is send-gated: held now, delivered stale at + # delivery_ts. Gate off ⇒ both are no-ops / a single pop (byte-identical). + self._sim_reinject_ready_withheld() + popped = self._sim_pop_committable(channel) if popped is None: return None, ("", datetime.now()) _end, sct, (m, md) = popped @@ -447,6 +482,17 @@ def _ingest(msg, metadata): self._sim_commit_count = {} self._sim_commit_count[_end] = self._sim_commit_count.get(_end, 0) + 1 self._sim_committed.add(_end) + # C.2 withheld delivery: this commit is the late (stale) delivery of an + # update that was send-gated while its trainer was UN_AVL. Tag it so the + # past-dating attribution uses the "withheld" bucket (intended staleness, + # not a pacing bug) and emit the withheld_delivery rung with the true + # down-window delay (delivery_ts − original sct) and resulting staleness. + # Async (fedbuff weighting) accept-stale ⇒ accepted=True; sync feddance + # reject-over-tolerance is wired in Stage E. + _withheld_meta = self._sim_take_withheld_delivering(_end) + _is_withheld = _withheld_meta is not None + if _is_withheld: + self._emit_withheld_delivery(_end, m, _withheld_meta[0], _withheld_meta[1]) # start this end's post-commit re-dispatch cooldown. Held out of # selection (in _distribute_weights) until vclock >= sct + gap, so it # returns with a fresher model_version -- the gap spaces completions @@ -501,7 +547,9 @@ def _ingest(msg, metadata): # rounds ago this update was trained (current round - its MODEL_VERSION). _mv = m.get(MessageType.MODEL_VERSION) if isinstance(m, dict) else None _round_lag = (self._round - int(_mv)) if _mv is not None else None - if self._round <= 1: + if _is_withheld: + _src = "withheld" # intended late stale delivery, not a pacing bug + elif self._round <= 1: _src = "round1" elif _was_recommit: _src = "redispatch" @@ -601,7 +649,40 @@ def _aggregate_weights(self, tag: str) -> None: recv_ends = [] # buffer still has entries to drain — don't block else: logger.debug(f"[AGG_RECV] no live recv ends (round={self._round}); skipping") - time.sleep(0.5) + # F.2: in sim, advance vclock to next availability event instead of + # wall-sleeping — covers felix and fedbuff asyncfl starvation paths. + if self.simulated and self.trainer_event_dict is not None: + _nxt = self._next_avail_vclock() + _budget = float( + getattr(self.config.hyperparameters, "max_experiment_runtime_s", float("inf")) + ) + if _nxt is not None and _nxt > self._vclock.now and self._vclock.now < _budget: + self._vclock.advance(_nxt) + logger.info( + f"[SIM_STARVATION] round={self._round} no recv ends; " + f"vclock→{_nxt:.1f}" + ) + else: + # Trace horizon or budget reached — stop instead of spinning. + self._work_done = True + logger.info( + f"[SIM_STARVATION] trace horizon or budget reached at " + f"vclock={self._vclock.now:.1f}s (nxt={_nxt}, " + f"budget={_budget:.0f}s, round={self._round}); stopping run." + ) + else: + _max_rt = getattr(self.config.hyperparameters, "max_experiment_runtime_s", None) + if _max_rt: + _wall_elapsed = time.time() - self.agg_start_time_ts + if _wall_elapsed >= float(_max_rt): + self._work_done = True + logger.info( + f"max_experiment_runtime_s={_max_rt}s reached " + f"(wall_elapsed={_wall_elapsed:.0f}s) at round {self._round}; " + f"stopping run." + ) + return + time.sleep(0.5) return if self.simulated: msg, metadata = self._sim_recv_min(channel, recv_ends) @@ -613,6 +694,10 @@ def _aggregate_weights(self, tag: str) -> None: if not msg: logger.debug(f"[AGG_RECV] No data from {end}; skipping it, agg_model_version={self._round}") return + # T3.3 commit-checkpoint belief (real mode only — sim's own commit + # loop already recorded it inside _sim_withhold_if_unavail). + if not self.simulated: + self._record_commit_belief(end) _t_msg_start = datetime.now() # start of per-message processing (vii) # NOTE: Only 2 types of messages are expected here: (i) model @@ -633,6 +718,15 @@ def _aggregate_weights(self, tag: str) -> None: f"agg_current_version={self._round}" ) + if end in self._agg_cycle_contributed_ends: + logger.info( + f"Duplicate contribution from {end} for agg cycle " + f"round={self._round} (agg_goal_cnt={self._agg_goal_cnt}); " + f"ignoring." + ) + channel.cleanup_provided_ends(end) + return + channel.set_end_property( end, PROP_LAST_SELECTED_ROUND, msg[MessageType.MODEL_VERSION] ) @@ -1008,6 +1102,7 @@ def _aggregate_weights(self, tag: str) -> None: tres = TrainResult(weights, count, version, stat_utility) _cs0 = time.time() self.cache[end] = tres # in-memory (MemCache) + self._agg_cycle_contributed_ends.add(end) self._agg_cache_store_s = time.time() - _cs0 logger.debug(f"received {len(self.cache)} trainer updates in cache") update_staleness_val = self._round - tres.version @@ -1223,8 +1318,8 @@ def _aggregate_weights(self, tag: str) -> None: if self.simulated: self._sim_hold_busy_slots(channel) - def oracular_trainer_avail_check(self, end: str) -> bool: - logger.debug("In oracular_trainer_avail_check") + def _trace_read_avail_check(self, end: str) -> bool: + logger.debug("In _trace_read_avail_check") picked_trainer_is_available = True @@ -1337,7 +1432,7 @@ def check_trainer_availability(self, end: str) -> bool: if self.track_trainer_avail["enabled"] == "False": return True elif self.track_trainer_avail["type"] == "ORACULAR": - picked_trainer_is_available = self.oracular_trainer_avail_check(end) + picked_trainer_is_available = self._trace_read_avail_check(end) elif self.track_trainer_avail["type"] == "HEARTBEAT": picked_trainer_is_available = self.hearbeat_trainer_avail_check(end) @@ -1420,8 +1515,34 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None: # Settle channel state before selection (real only); 0 removes this brake. time.sleep(self._real_distribute_settle_s) + # C.3: re-clock the 90s abandon to the vclock and free stalled slots so a + # replacement is selectable this round (no-op when the gate is off). + # Sim-only: real mode already has a native wall-clock abandon in the + # selector itself (SEND_TIMEOUT_WAIT_S), so this would be redundant there. + if self.simulated: + self._sim_abandon_stalled(channel) + # D.1: for proactive_inflight_evict baselines (felix only), free any + # in-flight slot the trace now shows as UN_AVL -- no 90s wait. Both modes: + # trace-read eviction has no real-mode equivalent (unlike the abandon + # above), so gating it sim-only left real-mode felix runs with no way to + # drop a stalled UN_AVL trainer from recv_ends, hanging forever once + # enough trainers went quiet (see Batch 4 finding 1, UNAVAILABILITY_DESIGN.md). + self._sim_evict_unavail_inflight(channel) + if self.trainer_event_dict is not None: - curr_unavail_trainer_list = self.get_curr_unavail_trainers() + # D.2: task-aware — also excludes AVL_EVAL from "train" dispatch and + # AVL_TRAIN from "eval" dispatch (inert where a baseline never + # dispatches eval, Challenge 8). + curr_unavail_trainer_list = self.get_curr_task_ineligible_trainers( + task_to_perform + ) + # invariant 2: a trainer with a withheld update stays out of the + # eligible pool until its delivery_ts (§4.5 residence, sct→delivery_ts). + _held_withheld = self.withheld_held_ends() + if _held_withheld: + curr_unavail_trainer_list = list( + set(curr_unavail_trainer_list) | _held_withheld + ) else: curr_unavail_trainer_list = [] @@ -1456,16 +1577,22 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None: channel.set_curr_unavailable_trainers( trainer_unavail_list=curr_unavail_trainer_list ) + # Stamp PROP_AVL_STATE on every known end (incl. in-flight ones D.1/C.3 + # just evicted) so emit_selection's avail_composition/per_trainer reflect + # the oracular read instead of staying all-UNKNOWN. + self._avail_stamp_end_states(channel) - # Expose current vclock to selector so it can attach it to selection events. - if self.simulated: - channel.properties["vclock_now"] = self._vclock.now + # Expose current availability-timeline time to selector so it can attach + # it to selection events. _avail_now() covers both modes — real used to + # be skipped here (see syncfl/top_aggregator.py for the parity fallout). + channel.properties["vclock_now"] = self._avail_now() # Per-baseline online oracle: refresh candidate stat-utility to true values # before selection. No-op unless oracle_utility_injection is enabled. self._inject_oracle_utilities(channel, task_to_perform) - ends = channel.ends(VAL_CH_STATE_SEND, task_to_perform) + ends = channel.ends(VAL_CH_STATE_SEND, task_to_perform, + agg_version_state=(self._round, None, None)) if not ends: logger.debug(f"No trainers found for tag {tag}") return @@ -1520,6 +1647,11 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None: if not _staggered: if self.simulated: base_msg[MessageType.SIM_SEND_TS] = _round_now + else: + # T3.0: broadcast the trace-read origin so a trainer's own + # wall-clock availability lookups anchor to the SAME point the + # aggregator uses. + base_msg[MessageType.AGG_START_TS] = self.agg_start_time_ts _shared_payload = channel.dumps(base_msg) _send_t0 = time.time() # [DISTRIBUTE_TIMING] diff --git a/lib/python/flame/mode/horizontal/oort/top_aggregator.py b/lib/python/flame/mode/horizontal/oort/top_aggregator.py index 14836c014..ea15e4029 100644 --- a/lib/python/flame/mode/horizontal/oort/top_aggregator.py +++ b/lib/python/flame/mode/horizontal/oort/top_aggregator.py @@ -126,16 +126,40 @@ def _oort_sim_recv(self, channel, end_ids): # under-fire (in-flight drains to ~0.15 instead of real's ~4.6). try: while True: + # C.2: re-inject any withheld update whose delivery_ts has arrived + # (no-op when the gate is off ⇒ pop loop unchanged, byte-identical). + self._sim_reinject_ready_withheld() popped = buf.pop_min() if popped is None: break end, sct, (msg, md) = popped - if carryover: + # A re-injected late stale delivery has already completed and is + # exempt from BOTH the carry-over gate (it is not still-computing) + # and the send-gate (its trainer is AVL_* at delivery_ts). + _is_withheld_delivery = end in getattr( + self, "_sim_withheld_delivering", {} + ) + if carryover and not _is_withheld_delivery: _tr = msg.get(MessageType.MODEL_VERSION, 0) if (self._round - _tr) > 0 and sct > vclock_round_start: held_over.append((end, sct, (msg, md))) continue + # C.2 send-gate: a COMPLETED update whose trainer is UN_AVL at sct + # is held and delivered stale at delivery_ts. Applied AFTER carry-over + # so a still-computing future-sct straggler (which has not reached its + # send-gate) stays in-flight (Challenge 7 composition). + if not _is_withheld_delivery and self._sim_withhold_if_unavail( + channel, end, sct, (msg, md) + ): + continue + # Late stale delivery: emit the withheld_delivery rung (best-effort). + # Batch 3 T3.5 (K11): advance before emitting, matching asyncfl's + # existing order — see _emit_withheld_delivery's docstring for why + # this specific advance is provably a no-op here either way. + _wd = self._sim_take_withheld_delivering(end) self._advance_sim_clock(sct) + if _wd is not None: + self._emit_withheld_delivery(end, msg, _wd[0], _wd[1]) _srd = msg.get(MessageType.SIM_CLIENT_TASK_TRAIN_DURATION_S) _sst = channel.get_end_property(end, PROP_SIM_SEND_TS) if _srd is not None: @@ -226,6 +250,24 @@ def _aggregate_weights(self, tag: str) -> None: received_end_count = 0 + # Real mode only: bound recv_fifo with a wall-clock timeout (default + # trainer_recv_wall_timeout_s=90s, >> the 18s max trainer speed in + # async_cifar10) so unavailable trainers can't stall the aggregator + # indefinitely; capped at the remaining max_experiment_runtime_s + # budget so the process never overshoots it. Sim mode leaves + # _recv_timeout=None — the vclock drives termination there instead. + _recv_timeout = None + if not self.simulated: + _stall = float(getattr( + self.config.hyperparameters, "trainer_recv_wall_timeout_s", 90.0 + )) + _max_rt = getattr(self.config.hyperparameters, "max_experiment_runtime_s", None) + if _max_rt: + _remaining = max(1.0, float(_max_rt) - (time.time() - self.agg_start_time_ts)) + _recv_timeout = min(_stall, _remaining) + else: + _recv_timeout = _stall + # simulated: commit the aggr_num updates with the smallest # sim_completion_ts (the k that would physically finish first in real), # reordering away physical arrival jitter and advancing the virtual @@ -237,7 +279,7 @@ def _aggregate_weights(self, tag: str) -> None: self._round_start_vclock = self._vclock.now _recv = self._oort_sim_recv(channel, end_ids) else: - _recv = channel.recv_fifo(end_ids, aggr_num) + _recv = channel.recv_fifo(end_ids, aggr_num, timeout=_recv_timeout) for msg, metadata in _recv: end, _ = metadata @@ -246,6 +288,11 @@ def _aggregate_weights(self, tag: str) -> None: logger.info(f"[MSG_SKIP] No data from ...{end[-8:]}; skipping it") continue + # T3.3 commit-checkpoint belief (real mode only — sim's own commit + # loop already recorded it inside _sim_withhold_if_unavail). + if not self.simulated: + self._record_commit_belief(end) + # Calculate staleness trainer_round = msg.get(MessageType.MODEL_VERSION, 0) staleness = self._round - trainer_round @@ -348,7 +395,7 @@ def _aggregate_weights(self, tag: str) -> None: _recv2 = ( self._oort_sim_recv(channel, end_ids) if self.simulated - else channel.recv_fifo(end_ids, 1) + else channel.recv_fifo(end_ids, 1, timeout=_recv_timeout) ) for msg, metadata in _recv2: end, _ = metadata @@ -358,6 +405,11 @@ def _aggregate_weights(self, tag: str) -> None: continue progressed = True + # T3.3 commit-checkpoint belief (real mode only — sim's own + # commit loop already recorded it inside _sim_withhold_if_unavail). + if not self.simulated: + self._record_commit_belief(end) + # Calculate staleness trainer_round = msg.get(MessageType.MODEL_VERSION, 0) staleness = self._round - trainer_round @@ -608,31 +660,30 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None: aggr_num = self.config.selector.kwargs.get("aggr_num", 10) overcommitment = getattr(channel._selector, 'overcommitment', 1.3) desired_selection = int(aggr_num * overcommitment) - - # Configuration for wait-retry mechanism - max_retries = self.config.selector.kwargs.get('max_selection_retries', 5) - retry_wait_seconds = self.config.selector.kwargs.get('selection_retry_wait', 2.0) - min_trainers_ratio = self.config.selector.kwargs.get('min_trainers_ratio', 0.5) # At least 50% of aggr_num - - # CRITICAL: If min_trainers_ratio >= overcommitment, wait for FULL desired_selection - # This prevents sending weights to partial sets that may never respond - if min_trainers_ratio >= overcommitment: - min_required_trainers = desired_selection # Wait for all 13 trainers - logger.info( - f"[DISTRIBUTE] Round {self._round}: Strict mode - will wait for FULL desired_selection={desired_selection} trainers" - ) - else: - min_required_trainers = max(1, int(aggr_num * min_trainers_ratio)) - + logger.info( - f"[DISTRIBUTE] Round {self._round}: Desired selection={desired_selection} " - f"(aggr_num={aggr_num}, overcommit={overcommitment}), " - f"min_required={min_required_trainers}" + f"[DISTRIBUTE] Round {self._round}: desired_selection={desired_selection} " + f"(aggr_num={aggr_num}, overcommit={overcommitment})" ) # before distributing weights, update it from global model self._update_weights() + # C.3: re-clock the 90s abandon to the vclock and free stalled slots so a + # replacement is selectable this round (no-op when the gate is off). + # Sim-only: real mode already has a native wall-clock abandon in the + # selector itself (SEND_TIMEOUT_WAIT_S), so this would be redundant there. + if self.simulated: + self._sim_abandon_stalled(channel) + # D.1: for availability_aware baselines, proactively free any in-flight + # slot the trace now shows as UN_AVL -- no 90s wait. Both modes: trace-read + # eviction has no real-mode equivalent (unlike the abandon above), so + # gating it sim-only left real-mode felix runs with no way to drop a + # stalled UN_AVL trainer from recv_ends (see Batch 4 finding 1, + # UNAVAILABILITY_DESIGN.md). No-op here (oort's proactive_inflight_evict + # is False), kept for symmetry with the other two stacks. + self._sim_evict_unavail_inflight(channel) + # Per-baseline online oracle: overwrite candidate stat-utility with true # current values before the selector ranks. No-op unless enabled. self._inject_oracle_utilities(channel, task_to_perform) @@ -640,7 +691,19 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None: # before invoking channel.ends() to select, set the # trainer_unavail if it isn't None if self.trainer_event_dict is not None: - curr_unavail_trainer_list = self.get_curr_unavail_trainers() + # D.2: task-aware — also excludes AVL_EVAL from "train" dispatch and + # AVL_TRAIN from "eval" dispatch (inert where a baseline never + # dispatches eval, e.g. oort, Challenge 8). + curr_unavail_trainer_list = self.get_curr_task_ineligible_trainers( + task_to_perform + ) + # invariant 2: a trainer with a withheld update stays out of the + # eligible pool until its delivery_ts (§4.5 residence, sct→delivery_ts). + _held_withheld = self.withheld_held_ends() + if _held_withheld: + curr_unavail_trainer_list = list( + set(curr_unavail_trainer_list) | _held_withheld + ) else: curr_unavail_trainer_list = [] @@ -669,97 +732,104 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None: channel.set_curr_unavailable_trainers( trainer_unavail_list=curr_unavail_trainer_list ) + # Stamp PROP_AVL_STATE on every known end (incl. in-flight ones D.1/C.3 + # just evicted) so emit_selection's avail_composition/per_trainer reflect + # the oracular read instead of staying all-UNKNOWN. + self._avail_stamp_end_states(channel) + + # Expose current availability-timeline time to selector so it can attach + # it to selection events (C.6.1 — restores per-trainer avl_state identity + # at emit time). _avail_now() covers both modes — real used to be + # skipped here (see syncfl/top_aggregator.py for the parity fallout). + channel.properties["vclock_now"] = self._avail_now() logger.debug( f"Sending weights to trainers with task_to_perform = {task_to_perform}" ) - - # CRITICAL FIX: Implement wait-retry mechanism for trainer selection - # If insufficient trainers are available, wait and retry instead of proceeding - selected_ends = None - retry_count = 0 - - while retry_count <= max_retries: - # Get currently available trainer ends - all_ends = list(channel._ends.keys()) - - # Get unavailable trainers - if self.trainer_event_dict is not None: - unavail_trainers = set(self.get_curr_unavail_trainers()) - else: - unavail_trainers = set() - - # Get in-flight trainers (already selected, waiting for updates) - in_flight_trainers = getattr(channel._selector, 'selected_ends', set()) - if not isinstance(in_flight_trainers, set): - in_flight_trainers = set(in_flight_trainers) if in_flight_trainers else set() - - # Calculate eligible trainers - eligible_trainers = [ - end for end in all_ends - if end not in unavail_trainers and end not in in_flight_trainers - ] - - num_eligible = len(eligible_trainers) - - logger.info( - f"[DISTRIBUTE] Round {self._round}, Attempt {retry_count + 1}/{max_retries + 1}: " - f"total_ends={len(all_ends)}, unavailable={len(unavail_trainers)}, " - f"in_flight={len(in_flight_trainers)}, eligible={num_eligible}, " - f"required={min_required_trainers}" + + # F.2: Pre-selection threshold check — return-early if pool is scarce. + # Threshold = desired_selection (full overcommitted batch); unbounded retry, + # no max_retries ceiling, no "proceed anyway" fallback for sync FL. + _in_flight = getattr(channel._selector, 'selected_ends', set()) + if not isinstance(_in_flight, set): + _in_flight = set(_in_flight) if _in_flight else set() + _connected = set(channel._ends.keys()) + num_eligible = len(_connected - set(curr_unavail_trainer_list) - _in_flight) + + # Cohort-floor guardrail: if desired_selection > connected cohort size + # (e.g. n=12 with desired_selection=13), the starvation gate fires + # every round and exhausts the budget with zero training (observed + # Jun 29, accidental n=12 oort). Clamp + warn once instead of + # silently degenerating into an all-starvation run. + _starv_threshold = min(desired_selection, len(_connected)) + if desired_selection > len(_connected) and not getattr( + self, "_oort_cohort_floor_warned", False + ): + logger.warning( + f"[COHORT_FLOOR] desired_selection={desired_selection} > connected " + f"cohort={len(_connected)}: the overcommitted batch can never be met. " + f"Clamping starvation threshold to {len(_connected)}. Increase " + f"num_trainers to >= desired_selection for a valid oort starvation run." ) - - # Check if we have enough eligible trainers - if num_eligible >= min_required_trainers: - logger.info( - f"[DISTRIBUTE] Round {self._round}: Sufficient trainers available " - f"({num_eligible} >= {min_required_trainers}), proceeding with selection. " - f"Will select min({desired_selection}, {num_eligible}) trainers." - ) - break - else: - # Insufficient trainers - log warning - logger.warning( - f"[DISTRIBUTE] Round {self._round}, Attempt {retry_count + 1}: " - f"INSUFFICIENT trainers! eligible={num_eligible} < required={min_required_trainers}. " - f"Breakdown: total={len(all_ends)}, unavail={len(unavail_trainers)}, " - f"in_flight={len(in_flight_trainers)}" + self._oort_cohort_floor_warned = True + + if num_eligible < _starv_threshold: + if self.simulated and self.trainer_event_dict is not None: + _nxt = self._next_avail_vclock() + _budget = float( + getattr(self.config.hyperparameters, "max_experiment_runtime_s", float("inf")) ) - - if retry_count < max_retries: - logger.warning( - f"[DISTRIBUTE] Waiting {retry_wait_seconds}s before retry {retry_count + 2}/{max_retries + 1}..." + if _nxt is not None and _nxt > self._vclock.now and self._vclock.now < _budget: + self._vclock.advance(_nxt) + self._sim_abandon_stalled(channel) + curr_unavail_trainer_list = self.get_curr_task_ineligible_trainers( + task_to_perform ) - time.sleep(retry_wait_seconds) - retry_count += 1 - # Update unavailability list before retry - if self.trainer_event_dict is not None: - curr_unavail_trainer_list = self.get_curr_unavail_trainers() - channel.set_curr_unavailable_trainers( - trainer_unavail_list=curr_unavail_trainer_list + _held = self.withheld_held_ends() + if _held: + curr_unavail_trainer_list = list( + set(curr_unavail_trainer_list) | _held ) + channel.set_curr_unavailable_trainers( + trainer_unavail_list=curr_unavail_trainer_list + ) + self._avail_stamp_end_states(channel) + channel.properties["vclock_now"] = self._vclock.now + logger.info( + f"[SIM_STARVATION] round={self._round} eligible={num_eligible} " + f"< {_starv_threshold}; vclock→{_nxt}" + ) else: - # Max retries exceeded - proceed with warning - logger.error( - f"[DISTRIBUTE] Round {self._round}: Max retries ({max_retries}) exceeded. " - f"Proceeding with ONLY {num_eligible} trainers (required: {min_required_trainers}, " - f"desired: {desired_selection}). THIS MAY IMPACT TRAINING QUALITY!" + # Trace horizon or budget reached — stop instead of spinning. + self._work_done = True + logger.info( + f"[SIM_STARVATION] trace horizon or budget reached at " + f"vclock={self._vclock.now:.1f}s (nxt={_nxt}, " + f"budget={_budget:.0f}s, round={self._round}); stopping run." ) - break + else: + _max_rt = getattr(self.config.hyperparameters, "max_experiment_runtime_s", None) + if _max_rt: + _wall_elapsed = time.time() - self.agg_start_time_ts + if _wall_elapsed >= float(_max_rt): + self._work_done = True + logger.info( + f"max_experiment_runtime_s={_max_rt}s reached " + f"(wall_elapsed={_wall_elapsed:.0f}s) at round {self._round}; " + f"stopping run." + ) + return + time.sleep(0.5) + return - # Now perform the actual selection + # Threshold met — proceed with selection. selected_ends = channel.ends(VAL_CH_STATE_SEND, task_to_perform) - - if not selected_ends or len(selected_ends) == 0: - logger.error( - f"[DISTRIBUTE] Round {self._round}: No trainers selected! " - f"Cannot proceed with weight distribution." - ) + if not selected_ends: return - + logger.info( - f"[DISTRIBUTE] Round {self._round}: Selected {len(selected_ends)} trainers. " - f"Will aggregate when {min(aggr_num, len(selected_ends))} updates received." + f"[DISTRIBUTE] Round {self._round}: selected {len(selected_ends)} trainers " + f"(eligible={num_eligible}, desired={desired_selection})" ) # Same model goes to every recipient this round; build + serialize once. @@ -772,6 +842,10 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None: } if self.simulated: msg[MessageType.SIM_SEND_TS] = _sim_send_ts + else: + # T3.0: broadcast the trace-read origin so a trainer's own wall-clock + # availability lookups anchor to the SAME point the aggregator uses. + msg[MessageType.AGG_START_TS] = self.agg_start_time_ts _payload = channel.dumps(msg) _send_t0 = time.time() for end in selected_ends: diff --git a/lib/python/flame/mode/horizontal/syncfl/fwdllm_aggregator.py b/lib/python/flame/mode/horizontal/syncfl/fwdllm_aggregator.py index 04e39b395..8423004d2 100644 --- a/lib/python/flame/mode/horizontal/syncfl/fwdllm_aggregator.py +++ b/lib/python/flame/mode/horizontal/syncfl/fwdllm_aggregator.py @@ -21,17 +21,18 @@ import psutil import time from datetime import datetime +from pathlib import Path +from typing import Optional, Union import sklearn import numpy as np -import ast -import os -import json +import yaml from sortedcontainers import SortedDict import torch.nn.functional as F from flame.channel import VAL_CH_STATE_HTBT_RECV, VAL_CH_STATE_RECV, VAL_CH_STATE_SEND from flame.common.constants import DeviceType from flame.common.util import weights_to_device, weights_to_model_device -from flame.config import OptimizerType +from flame.config import OptimizerType, TrainerAvailState +from flame.end import PROP_END_AVL_STATE from flame.mode.composer import CloneComposer import pickle from flame.mode.horizontal.syncfl.top_aggregator import ( @@ -43,7 +44,10 @@ confusion_matrix, matthews_corrcoef, ) -from flame.mode.horizontal.asyncfl.top_aggregator import TopAggregator as AsyncTopAgg +from flame.mode.horizontal.asyncfl.top_aggregator import ( + RECV_TIMEOUT_WAIT_S, + TopAggregator as AsyncTopAgg, +) from flame.mode.message import MessageType from flame.mode.horizontal.client_duration import real_client_task_train_duration from flame.mode.tasklet import Loop, Tasklet @@ -59,13 +63,15 @@ ) import functorch as fc import torch -import glob from torch.nn import CrossEntropyLoss import flame.monitor.runtime from flame.monitor.runtime import FwdLLMStage, timer_decorator import math +from flame import telemetry +from flame.telemetry.events import build_agg_eval, build_agg_round, build_utility_belief + logger = logging.getLogger(__name__) @@ -73,6 +79,27 @@ SEND_TIMEOUT_WAIT_S = 90 # 90 seconds timeout +# How long a trainer can sit in the per-round reselection cache +# (_round_selected_ends, reselect_each_iteration=False) without a real +# accepted contribution before it's treated as stuck and pruned/backfilled, +# same as an explicit departure (see _prune_departed_from_round_cache). +# Deliberately much longer than SEND_TIMEOUT_WAIT_S/RECV_TIMEOUT_WAIT_S +# (per-message waits) since this measures a full contribution cycle +# (dispatch -> real training -> accepted response), not one recv call. +ROUND_CACHE_STUCK_TIMEOUT_S = 300 # 5 minutes + +# Default location of the shared examples/_metadata bundle, resolved relative +# to this library file (lib/python/flame/mode/horizontal/syncfl/ -> lib/python +# /examples/_metadata) rather than to any specific example's legacy directory +# -- this is what makes the oracular path example-agnostic, mirroring +# async_cifar10/aggregator/pytorch/main_oort_sync_agg.py's resolution. +_METADATA_DIR = Path(__file__).resolve().parents[4] / "examples" / "_metadata" +_TRACE_KEY_TO_MOBIPERF_SUB = { + "mobiperf_2st": "states_2st", + "mobiperf_3st_50": "states_3st_50", + "mobiperf_3st_75": "states_3st_75", +} + import hashlib @@ -258,6 +285,26 @@ def internal_init(self) -> None: self.var = None self.ends_not_selected_yet = False self.iteration_per_data_id = 0 + + # Selection granularity for the sync path (fwdllm/fwdllm_plus): + # True (default, preserves pre-existing behavior) = re-select + # trainers on every SEND-state call, i.e. every iteration of every + # databin. False = select once per round and reuse that selection + # across all databins/iterations until self._round advances. The + # async path (fluxtune) is untouched by this flag. + self._reselect_each_iteration = bool( + getattr( + self.config.hyperparameters, "reselect_each_iteration", True + ) + ) + self._round_selected_ends = None + self._round_selected_ends_round = None + # end_id -> time.time() of its last real accepted contribution (or + # of first entering the cache, if it hasn't contributed yet) -- lets + # _prune_departed_from_round_cache also evict a member that's stuck + # but not formally departed (see ROUND_CACHE_STUCK_TIMEOUT_S). + self._round_cache_activity_ts: dict = {} + self._optimizer_sort_value = self.config.optimizer.sort OPTIMIZERS_SUPPORTING_GRAD_AGGREGATION = (OptimizerType.FEDBUFF,) self._weighted_aggregation_enabled = ( @@ -322,14 +369,10 @@ def internal_init(self) -> None: # maintain a set of all trainers that have sent heartbeats previously self.all_trainers = set() - try: - self.minInitialTrainers = self.config.selector.kwargs.get( - "minInitialTrainers" - ) - assert self.minInitialTrainers is not None - except (KeyError, AssertionError): + self.minInitialTrainers = self.config.selector.kwargs.get("minInitialTrainers") + if self.is_async and self.minInitialTrainers is None: raise KeyError( - "minInitialTrainers must be specified in selector config & must not be None for determinism" + "minInitialTrainers must be specified in selector config for async fwdllm" ) self.trainer_unavail_durations = None self._cached_test_data = None @@ -478,40 +521,63 @@ def _process_trainer_heartbeat(self, msg, end) -> None: else: logger.warning(f"Got invalid {msg} while processing heartbeat") - def read_trainer_unavailability(self, trace=None) -> None: - logger.info(f"Came to read_trainer_unavailability, trace: {trace}") - trainer_events_dict = {} + def read_trainer_unavailability( + self, trace=None, metadata_dir: Optional[Union[str, Path]] = None + ) -> dict: + """Build task_id -> SortedDict(timestamp -> state) for `trace`. - current_dir = os.path.dirname(os.path.abspath(__file__)) - files_path = os.path.join( - current_dir, "../../../../examples/fwdllm/expts/run_tc_expts/json_scripts" - ) - search_pattern = os.path.join(files_path, "trainer_*.json") - json_files = glob.glob(search_pattern) + Reads from the shared examples/_metadata/ bundle (registry + + traces), mirroring + async_cifar10/aggregator/pytorch/main_oort_sync_agg.py's pattern -- + not from the legacy per-trainer json_scripts/trainer_*.json files. + """ + logger.info(f"Reading trainer unavailability for trace: {trace}") + + metadata_dir = Path(metadata_dir) if metadata_dir is not None else _METADATA_DIR + + registry_path = metadata_dir / "trainer_registry.yaml" + with open(registry_path) as f: + registry = yaml.safe_load(f)["trainers"] - if not json_files: - logger.warning(f"No JSON files found matching pattern: {search_pattern}") - return {} + if trace in _TRACE_KEY_TO_MOBIPERF_SUB: + sub = _TRACE_KEY_TO_MOBIPERF_SUB[trace] + with open(metadata_dir / "availability_traces/mobiperf_traces.yaml") as f: + traces = yaml.safe_load(f)["traces"] - logger.info(f"Found {len(json_files)} JSON files to process.") + def lookup(tk: str, trainer_id: int) -> list: + return traces[f"device_{trainer_id:03d}"][sub] - for file_path in json_files: - with open(file_path) as f: - trainer_json = json.load(f) - curr_trainer_id = trainer_json["taskid"] - event_list = ast.literal_eval(trainer_json["hyperparameters"][trace]) + elif trace and trace.startswith("syn_"): + with open(metadata_dir / "availability_traces/synthetic_traces.yaml") as f: + syn = yaml.safe_load(f)["traces"] + if trace not in syn: + logger.warning(f"trace {trace!r} not found in synthetic_traces.yaml") + return None + entry = syn[trace] + per_trainer = entry.get("per_trainer", {}).get("n300", {}) + pattern = entry.get("pattern", []) - # SortedDict for efficient timestamp lookup - state_dict = SortedDict() + def lookup(tk: str, trainer_id: int) -> list: + return per_trainer.get(tk) or pattern - # Process the events - for timestamp, event_name in event_list: - state_dict[timestamp] = event_name + else: + logger.warning(f"unsupported trace name: {trace!r}") + return None - trainer_events_dict[curr_trainer_id] = state_dict - logger.info(f"Completed file read for {file_path}") + trainer_events_dict = {} + for tk, meta in registry.items(): + trainer_id = meta["trainer_id"] + task_id = meta["task_id"] + events = lookup(tk, trainer_id) + state_dict = SortedDict() + for timestamp, state in events: + state_dict[timestamp] = state + trainer_events_dict[task_id] = state_dict - logger.info("Completed reading all trainer unavailability from files") + logger.info( + f"Loaded availability traces for {len(trainer_events_dict)} trainers " + f"(trace={trace})" + ) return trainer_events_dict def aggregate_grads_from_trainers( @@ -641,7 +707,19 @@ def _aggregate_grads_async(self, tag: str) -> None: return # time.sleep(0.1) # Slight delay to allow messages to arrive - msg, metadata = next(channel.recv_fifo(channel.ends(VAL_CH_STATE_RECV), 1)) + # timeout=RECV_TIMEOUT_WAIT_S bounds the block on a quiet in-flight + # trainer (default is block forever -- see channel.recv_fifo's + # docstring). Without this, if a selected trainer never responds, + # this call never returns, the composer loop never cycles back to + # _distribute_weights, and _check_early_stop_conditions() (which + # enforces max_runtime_s/max_data_id_progress) never gets a chance + # to run -- the run hangs past its configured budget until manually + # killed. Matches the same pattern asyncfl/top_aggregator.py's + # _aggregate_weights already uses for this exact reason. + msg, metadata = next( + channel.recv_fifo(channel.ends(VAL_CH_STATE_RECV), 1, + timeout=RECV_TIMEOUT_WAIT_S) + ) end, timestamp = metadata if not msg: logger.debug(f"No data from {end}; skipping it") @@ -665,23 +743,69 @@ def _aggregate_grads_async(self, tag: str) -> None: @timer_decorator def _process_single_trainer_message(self, channel, msg, end, timestamp): + # An end may only contribute once per (round, data_id, + # iteration_per_data_id) collection cycle -- _per_agg_trainer_list is + # reset only when that tuple advances (_process_aggregation_goal_met). + # The trainer self-enforces this too, but resending WEIGHTS to the + # round's frozen trainer set on every distribute loop (per-round + # reselect) makes a duplicate/late message possible; guard here too. + if end in self._per_agg_trainer_list: + logger.info( + f"Duplicate contribution from {end} for round={self._round}, " + f"data_id={self.data_id}, iteration={self.iteration_per_data_id}; " + f"ignoring." + ) + if self.is_async: + channel.cleanup_provided_ends(end) + else: + channel.cleanup_recvd_end(end) + return False + if MessageType.MODEL_VERSION in msg: version = msg[MessageType.MODEL_VERSION] if version != self._model_version: logger.info( f"Received grad with staleness={self._model_version-version}." ) - if self.reject_stale_updates == True: + # Mode semantics: Hyperparameters.staleness_policy (flame/config.py). + # Implementation note: model_version alone already identifies + # (round, data_id) when inc_model_version_per_data_id is set (it + # only advances on a data_id transition), so "round_data_id" needs + # no extra fields; "exact" additionally checks iteration_per_data_id. + policy = getattr(self, "staleness_policy", "none") + stale, stale_reason = False, None + if policy == "round_data_id": if version != self._model_version: - logger.info( - f"Rejecting trainer update from {end} of version {version}, " - f"agg self._model_version: {self._model_version}. Will return." + stale, stale_reason = True, ( + f"version={version} != agg model_version={self._model_version}" ) - if self.is_async: - channel.cleanup_provided_ends(end) - else: - channel.cleanup_recvd_end(end) - return False + elif policy == "exact": + msg_iter = msg.get(MessageType.ITERATION_PER_DATA_ID) + if version != self._model_version: + stale, stale_reason = True, ( + f"version={version} != agg model_version={self._model_version}" + ) + elif msg_iter != self.iteration_per_data_id: + stale, stale_reason = True, ( + f"iteration_per_data_id={msg_iter} != " + f"agg iteration_per_data_id={self.iteration_per_data_id}" + ) + elif policy != "none": + logger.warning( + f"Unrecognized staleness_policy={policy!r}; treating as 'none' " + f"(no staleness gate)." + ) + + if stale: + logger.info( + f"Rejecting trainer update from {end} under " + f"staleness_policy={policy} ({stale_reason})." + ) + if self.is_async: + channel.cleanup_provided_ends(end) + else: + channel.cleanup_recvd_end(end) + return False if MessageType.GRADIENTS in msg and MessageType.GRADIENTS_FOR_VAR_CHECK in msg: logger.info( @@ -725,6 +849,12 @@ def _process_single_trainer_message(self, channel, msg, end, timestamp): logger.debug(f"received data from {end}") channel.set_end_property(end, PROP_ROUND_END_TIME, (self._round, timestamp)) + # This end has just made real progress -- restart its round-cache + # stuck-timeout clock (see ROUND_CACHE_STUCK_TIMEOUT_S / + # _prune_departed_from_round_cache). No-op if reselect_each_iteration + # is True (that path never populates this dict) or end isn't + # currently cached (dict grows a harmless extra key either way). + self._round_cache_activity_ts[end] = time.time() channel._selector.ordered_updates_recv_ends.append(end) self._updates_in_queue += 1 @@ -752,10 +882,14 @@ def _process_single_trainer_message(self, channel, msg, end, timestamp): logger.debug( f"Calling aggregate_grads_for_trainers with grad_for_var_check: {_calculate_hash(grad_for_var_check)}" ) + # Use this message's stat_utility, not the channel property -- + # the property is set below, after this call, so reading it here + # was always None on a trainer's first contribution (crashing + # fedbuff's weight_factor() on `1 + None`). self.aggregate_grads_from_trainers( trainer_gradients, version_for_rate=version_for_rate, - stat_utility=channel.get_end_property(end, PROP_STAT_UTILITY), + stat_utility=msg[MessageType.STAT_UTILITY], grad_for_var_check=grad_for_var_check, jvp_for_snr_check=jvp_for_snr_check, ) @@ -775,6 +909,38 @@ def _process_single_trainer_message(self, channel, msg, end, timestamp): channel.set_end_property(end, PROP_DATASET_SIZE, count) if MessageType.STAT_UTILITY in msg: + # Believed (PROP_STAT_UTILITY before this overwrite, i.e. the + # value from this end's PREVIOUS contribution) vs actual (this + # message's fresh value) -- the staleness of whatever the + # selector/aggregator last knew about this end's utility. + # fwdllm_aggregator.py previously never emitted this (only + # asyncfl/top_aggregator.py did), so selected_utility_believed_ + # vs_actual*/selected_utility_belief_gap* were structurally + # impossible for fwdllm-family baselines regardless of selector. + if telemetry.is_enabled(): + try: + _believed = channel.get_end_property(end, PROP_STAT_UTILITY) + _mv = msg.get(MessageType.MODEL_VERSION) + ev, f = build_utility_belief( + round_num=self._round, + end_id=end, + believed=float(_believed) if _believed is not None else None, + actual=float(msg[MessageType.STAT_UTILITY]), + # fwdllm's round stays coarse (can sit at 1 for an + # entire run); self._model_version advances every + # completed aggregation cycle (same quantity + # agg_round's own staleness list uses), so it's the + # meaningful staleness axis here, not round-based. + staleness=(self._model_version - _mv) + if isinstance(_mv, int) else None, + extra={ + "data_id": self.data_id, + "iteration_per_data_id": self.iteration_per_data_id, + }, + ) + telemetry.emit(ev, **f) + except Exception as e: # telemetry must never break training + logger.debug(f"utility_belief telemetry emit failed: {e}") logger.info( f"received stat_utility from {end} " f"msg[MessageType.STAT_UTILITY] {msg[MessageType.STAT_UTILITY]}" @@ -789,7 +955,15 @@ def _process_single_trainer_message(self, channel, msg, end, timestamp): logger.info( f"Received grads from {end}. It was trained on model version {version}, with {count} samples" ) - channel.remove_from_selected_ends(end) + # Not remove_from_selected_ends(): it never clears the selector's + # all_selected set, permanently blocking this trainer from future + # reselection. Async selectors only implement the batch + # _cleanup_recvd_ends/_cleanup_provided_ends path; cleanup_recvd_end() + # is sync-only (random selector). + if self.is_async: + channel.cleanup_provided_ends(end) + else: + channel.cleanup_recvd_end(end) return True def _log_and_reset_model_version_stats(self): @@ -909,6 +1083,22 @@ def _process_aggregation_goal_met(self, tag, channel, is_async=False): f"Aggregation goal {self._agg_goal} reached. Performing FwdLLM aggregation." ) + # Snapshot for this cycle's agg_round telemetry (emitted further down, + # after self._per_agg_trainer_list is cleared and self._model_version + # may have advanced -- see build_agg_round call below). + _cycle_contributors = list(self._per_agg_trainer_list) + _cycle_target_version = self._model_version + _cycle_speed_s = [] + _cycle_stat_utility = [] + _cycle_staleness = [] + # end_id -> wall seconds between send (PROP_ROUND_START_TIME) and + # this contribution being received/processed (set alongside + # PROP_ROUND_DURATION in _process_single_trainer_message) -- the + # same quantity asyncfl/top_aggregator.py reports as agg_observed_s, + # letting analyze_run.py's aggregator-overhead sanity plots + # (runtime_agg_vs_trainer/runtime_overhead_*) work for fwdllm too. + _cycle_agg_observed_s = {} + # Accumulate model-version-window stats; reset only when variance threshold is breached. for trainer_update in self._per_agg_trainer_list: self._model_version_unique_trainers.add(trainer_update) @@ -919,6 +1109,8 @@ def _process_aggregation_goal_met(self, tag, channel, is_async=False): self._model_version_trainer_stats["train_duration"].append( train_duration.total_seconds() ) + _cycle_speed_s.append(train_duration.total_seconds()) + _cycle_agg_observed_s[trainer_update] = train_duration.total_seconds() partial_stat_utility = channel.get_end_property( trainer_update, PROP_STAT_UTILITY ) @@ -926,6 +1118,10 @@ def _process_aggregation_goal_met(self, tag, channel, is_async=False): self._model_version_trainer_stats["partial_stat_utility"].append( partial_stat_utility ) + _cycle_stat_utility.append(partial_stat_utility) + _trainer_version = self._trainer_last_model_version.get(trainer_update) + if _trainer_version is not None: + _cycle_staleness.append(_cycle_target_version - _trainer_version) self.grad_pool.append(self.grad) format_hash = lambda d: [_calculate_hash(v) for v in d] @@ -985,6 +1181,27 @@ def _process_aggregation_goal_met(self, tag, channel, is_async=False): logger.info( f"Round {self._round}, Data ID {self.data_id} Eval Loss: {result['eval_loss']}" ) + if telemetry.is_enabled(): + try: + ev, fields = build_agg_eval( + round_num=self._round, + metrics={ + "test-loss": result.get("eval_loss"), + "test-accuracy": result.get("acc"), + "mcc": result.get("mcc"), + # fwdllm's round is coarse (advances only once all + # total_data_bins data_ids finish) -- data_id/ + # iteration_per_data_id let the analyzer's + # progress_key() (scripts/analysis/analyze_run.py) + # place this eval on a meaningful x-axis instead of + # collapsing every eval in a round onto one point. + "data_id": self.data_id, + "iteration_per_data_id": self.iteration_per_data_id, + }, + ) + telemetry.emit(ev, **fields) + except Exception as e: # telemetry must never break training + logger.debug(f"agg_eval telemetry emit failed: {e}") self.data_id += 1 self.iteration_per_data_id = 0 self._is_model_updated = True @@ -1004,6 +1221,19 @@ def _process_aggregation_goal_met(self, tag, channel, is_async=False): self.data_id = 0 channel.set_property("round", self._round) + # fwdllm's TopAggregator extends the asyncfl base (not + # syncfl's), which has no rounds-based stop condition of its + # own -- self._work_done is otherwise never set here, so the + # composer loop (Loop(loop_check_fn=lambda: self._work_done)) + # never exits and the aggregator process runs forever + # regardless of hyperparameters.rounds. + self._work_done = self._round > self.config.hyperparameters.rounds + if self._work_done: + logger.info( + f"rounds={self.config.hyperparameters.rounds} reached " + f"at round {self._round}; stopping run." + ) + else: logger.info( f"Variance check FAILED. Retrying on same data_id {self.data_id}." @@ -1011,6 +1241,32 @@ def _process_aggregation_goal_met(self, tag, channel, is_async=False): self.iteration_per_data_id += 1 self._is_model_updated = False + if telemetry.is_enabled(): + try: + ev, fields = build_agg_round( + round_num=self._round, + agg_goal=self._agg_goal, + agg_goal_count=self._agg_goal_cnt, + updates_in_queue=self._updates_in_queue, + staleness=_cycle_staleness, + stat_utility=_cycle_stat_utility, + trainer_speed_s=_cycle_speed_s, + contributing_trainers=_cycle_contributors, + agg_observed_s=_cycle_agg_observed_s, + extra={ + "data_id": self.data_id, + "iteration_per_data_id": self.iteration_per_data_id, + "var": self.var, + "var_threshold": getattr(self, "var_threshold", None), + "var_good_enough": self.var_good_enough, + "force_commit_planned": _force_commit_planned, + "is_async": is_async, + }, + ) + telemetry.emit(ev, **fields) + except Exception as e: # telemetry must never break training + logger.debug(f"agg_round telemetry emit failed: {e}") + self._updates_in_queue -= self._agg_goal self._per_agg_trainer_list = [] @@ -1070,7 +1326,15 @@ def sync_collect_and_accumulate_grads(self, tag, channel): logger.info(f"We are waiting to clear up queue") num_min_req = min(num_min_req, 1) - for msg, metadata in channel.recv_fifo(channel.ends(), num_min_req): + # timeout=RECV_TIMEOUT_WAIT_S bounds the block on quiet in-flight + # trainers (default is block forever -- see channel.recv_fifo's + # docstring). Without this, if a selected trainer never responds, + # this call never returns, the composer loop never gets to + # re-check _check_early_stop_conditions() (max_runtime_s/ + # max_data_id_progress), and the run hangs past its configured + # budget until manually killed. Same fix as _aggregate_grads_async. + for msg, metadata in channel.recv_fifo(channel.ends(), num_min_req, + timeout=RECV_TIMEOUT_WAIT_S): end, timestamp = metadata if not msg: logger.info(f"No data from {end}; skipping it") @@ -1313,7 +1577,7 @@ def check_trainer_availability(self, end: str) -> bool: if self.track_trainer_avail["enabled"] == "False": return True elif self.track_trainer_avail["type"] == "ORACULAR": - picked_trainer_is_available = self.oracular_trainer_avail_check(end) + picked_trainer_is_available = self._trace_read_avail_check(end) elif self.track_trainer_avail["type"] == "HEARTBEAT": picked_trainer_is_available = self.hearbeat_trainer_avail_check(end) @@ -1390,6 +1654,125 @@ def _update_state_after_payload_prepared(self): self.jvp_for_snr_check_list = [] self._is_model_updated = False + @staticmethod + def _rearm_recv_eligibility(channel, ends): + """Re-add `ends` to the selector's RECV-eligible set. + + Skipping the SEND-state call below (cache hit) also skips the only + thing that normally repopulates `selected_ends`, which backs + `channel.ends(VAL_CH_STATE_RECV)`. Each processed contribution + removes its end from it via `cleanup_recvd_end(s)`; without this, + it permanently empties out after one pass over the cached trainers. + """ + selector = getattr(channel, "_selector", None) + if selector is not None and hasattr(selector, "selected_ends"): + selector.selected_ends = set(selector.selected_ends) | set(ends) + + def _prune_departed_from_round_cache(self, channel): + """Drop ends from `self._round_selected_ends` that have since + departed (disconnected, or explicitly reported `UN_AVL`) -- or that + have gone `ROUND_CACHE_STUCK_TIMEOUT_S` without a real accepted + contribution despite still being formally connected (e.g. a trainer + that never finished receiving its initial weights: still shows up + as connected/AVL_TRAIN, so neither check below catches it, yet it + never actually responds). + + The selector-level reclaim (`_cleanup_removed_ends`, invoked by + `channel.remove`/`channel.update_state`) forgets a departed end at + the selector's own bookkeeping level, but nothing else prunes it + from this aggregator's own per-round cache. Left unpruned, the + cache-size check below keeps reporting "full" forever with a + member that can never respond, and the round stalls waiting on a + contribution that can never arrive. Confirmed exactly this + happening on a real n=100 run (see + examples/MIGRATING_TO_LAUNCHER.md §9): the aggregator's working set + stayed capped at ~30 of 100 trainers for 90 minutes, one cached + member sat at `model_version=-1` (never initialized) the entire + time, and progress fully stalled for the run's last 47 minutes -- + none of it caught by the departure checks below, since that + trainer never disconnected or reported UN_AVL. + """ + if not self._round_selected_ends: + return + now = time.time() + still_present = [] + for end in self._round_selected_ends: + if not channel.has(end): + logger.info( + f"[ReselectGate] pruning departed (removed) end {end} " + f"from per-round cache for round={self._round}" + ) + self._round_cache_activity_ts.pop(end, None) + continue + if channel.get_end_property(end, PROP_END_AVL_STATE) == TrainerAvailState.UN_AVL: + logger.info( + f"[ReselectGate] pruning departed (UN_AVL) end {end} " + f"from per-round cache for round={self._round}" + ) + self._round_cache_activity_ts.pop(end, None) + continue + last_active = self._round_cache_activity_ts.get(end, now) + if now - last_active > ROUND_CACHE_STUCK_TIMEOUT_S: + logger.info( + f"[ReselectGate] pruning stuck (no accepted contribution " + f"in {now - last_active:.0f}s > {ROUND_CACHE_STUCK_TIMEOUT_S}s) " + f"end {end} from per-round cache for round={self._round}" + ) + self._round_cache_activity_ts.pop(end, None) + continue + still_present.append(end) + if len(still_present) != len(self._round_selected_ends): + self._round_selected_ends = still_present + + def _select_ends_respecting_reselect_gate(self, channel, task_to_perform: str): + """Return the SEND-state-selected ends, honoring + `self._reselect_each_iteration`. + + True (default): re-invoke the selector every call. False: accumulate + selections into a per-round cache, re-invoking the selector each + call until the cache reaches `self._agg_goal` (trainers join the + channel asynchronously, so one early call may only see a few of + them); then reuse the cache until `self._round` advances. + """ + if self._round_selected_ends_round != self._round: + self._round_selected_ends = None + self._round_selected_ends_round = self._round + self._round_cache_activity_ts = {} + + if not self._reselect_each_iteration: + self._prune_departed_from_round_cache(channel) + + if not self._reselect_each_iteration and self._round_selected_ends is not None: + target = getattr(self, "_agg_goal", len(self._round_selected_ends)) + if len(self._round_selected_ends) >= target: + ends = list(self._round_selected_ends) + logger.info( + f"[ReselectGate] reselect_each_iteration=False; reusing " + f"cached per-round selection ends={ends} for round={self._round}" + ) + self._rearm_recv_eligibility(channel, ends) + return ends + + new_ends = channel.ends(VAL_CH_STATE_SEND, task_to_perform) + if not self._reselect_each_iteration and new_ends: + merged = list(self._round_selected_ends or []) + for end in new_ends: + if end not in merged: + merged.append(end) + # First time this end enters the cache -- starts its + # stuck-timeout clock (reset again on each real accepted + # contribution, see _process_single_trainer_message). + self._round_cache_activity_ts[end] = time.time() + self._round_selected_ends = merged + logger.info( + f"[ReselectGate] reselect_each_iteration=False; accumulated " + f"per-round selection ends={merged} " + f"({len(merged)}/{getattr(self, '_agg_goal', '?')}) for round={self._round}" + ) + self._rearm_recv_eligibility(channel, merged) + return merged + return new_ends + @timer_decorator def _distribute_weights_sync( self, tag: str, task_to_perform: str = "train" @@ -1441,7 +1824,7 @@ def _distribute_weights_sync( f"Aggregator version state (model_version, data_id, iteration_id): {self._curr_agg_version}" ) - ends = channel.ends(VAL_CH_STATE_SEND, task_to_perform) + ends = self._select_ends_respecting_reselect_gate(channel, task_to_perform) logger.info(f"ends: {ends}") if ends is None or len(ends) >= self._agg_goal: self.ends_not_selected_yet = True @@ -1641,7 +2024,59 @@ def _distribute_weights_async( self.ends_not_selected_yet = False logger.info("Distributed to c ends and can wait for k updates") + def _check_early_stop_conditions(self) -> None: + """Optional caps for short/smoke runs, checked independently of + whether an aggregation goal is ever met: `max_data_id_progress` + (stop once `self.data_id` reaches it) and `max_runtime_s` (stop once + this much wall time has elapsed since the aggregator started). + Whichever fires first wins. Both are unset (None) by default, so + production runs are unaffected. Called from `_distribute_weights`, + which runs on every composer tick on both the sync and async paths + -- unlike the rounds-based stop in `_process_aggregation_goal_met`, + this also fires when aggregation never completes. + """ + if self._work_done: + return + + max_data_id = getattr( + self.config.hyperparameters, "max_data_id_progress", None + ) + if max_data_id is not None and self.data_id >= max_data_id: + logger.info( + f"max_data_id_progress={max_data_id} reached " + f"(data_id={self.data_id}); stopping run." + ) + self._work_done = True + return + + max_runtime_s = getattr(self.config.hyperparameters, "max_runtime_s", None) + if max_runtime_s is not None: + elapsed = time.time() - self.agg_start_time_ts + if elapsed >= float(max_runtime_s): + logger.info( + f"max_runtime_s={max_runtime_s}s reached " + f"(elapsed={elapsed:.0f}s); stopping run." + ) + self._work_done = True + + def _async_inner_loop_done(self) -> bool: + """Exit condition for the async/hybrid compose path's inner + `asyncfl_loop` (see `compose()`). + + Must OR in `self._work_done`, not just check the agg-goal match: the + outer `loop` only re-checks `_work_done` once this inner loop's + ender (`task_get_weights`) completes, which can block for a long + time if contributions trickle in slowly. Without this OR, + `_check_early_stop_conditions()` reaching a cap (e.g. + `max_data_id_progress`) mid-distribute sets `_work_done`, but the + inner loop keeps spinning until an agg-goal happens to complete on + its own -- silently swallowing the early-stop until the launcher's + external watchdog force-kills the process instead. + """ + return self._agg_goal_cnt == self._agg_goal or self._work_done + def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None: + self._check_early_stop_conditions() if self.is_async: logger.info("Inside distribute of async") self._distribute_weights_async(tag, task_to_perform) @@ -1694,9 +2129,7 @@ def compose(self) -> None: loop = Loop(loop_check_fn=lambda: self._work_done) # create a loop object for asyncfl to manage concurrency as # well as aggregation goal - asyncfl_loop = Loop( - loop_check_fn=lambda: self._agg_goal_cnt == self._agg_goal - ) + asyncfl_loop = Loop(loop_check_fn=self._async_inner_loop_done) logger.info("Hybrid compose") # chain them again with new tasklets introduced in this class @@ -1761,6 +2194,7 @@ def compose(self) -> None: # >> task_get_heartbeat >> task_aggregate_grads_sync ) + >> c.tasklet("inform_end_of_training") # >> c.tasklet("load_data") c.tasklet("initialize") # >> task_get_heartbeat task_put_train c.tasklet("heartbeat") loop( # >> task_reset_agg_goal_vars # >> asyncfl_loop(task_put >> diff --git a/lib/python/flame/mode/horizontal/syncfl/fwdllm_trainer.py b/lib/python/flame/mode/horizontal/syncfl/fwdllm_trainer.py index 16206ee4c..af5e2b537 100644 --- a/lib/python/flame/mode/horizontal/syncfl/fwdllm_trainer.py +++ b/lib/python/flame/mode/horizontal/syncfl/fwdllm_trainer.py @@ -211,7 +211,7 @@ def _fetch_weights(self, tag: str) -> None: self._round = msg[MessageType.ROUND] logger.info( - f"Checking DataID: {self.data_id}| MessageType.DATA_ID in msg: {msg[MessageType.DATA_ID]}| IterationPerDataID: {self.iteration_per_data_id}| MessageType.ITERATION_PER_DATA_ID in msg: {msg[MessageType.ITERATION_PER_DATA_ID]}" + f"Checking DataID: {self.data_id}| MessageType.DATA_ID in msg: {msg.get(MessageType.DATA_ID)}| IterationPerDataID: {self.iteration_per_data_id}| MessageType.ITERATION_PER_DATA_ID in msg: {msg.get(MessageType.ITERATION_PER_DATA_ID)}" ) logger.info(f"isMessageType.Weights?: {MessageType.WEIGHTS in msg}") @@ -509,6 +509,11 @@ def _send_grads(self, tag: str) -> None: MessageType.JVP_FOR_SNR_CHECK: self.jvp_for_snr_check, MessageType.DATASET_SIZE: self.dataset_size, MessageType.MODEL_VERSION: self._model_version, + # Echoes the iteration this update answers, so the aggregator's + # staleness_policy="exact" mode (see flame/config.py) can reject + # updates answering a since-superseded iteration of the same + # data_id, not just a stale model_version/data_id. + MessageType.ITERATION_PER_DATA_ID: self.iteration_per_data_id, MessageType.DATASAMPLER_METADATA: self.datasampler.get_metadata(), MessageType.STAT_UTILITY: self._stat_utility, # - rn FedSgdTrainer has no utility diff --git a/lib/python/flame/mode/horizontal/syncfl/top_aggregator.py b/lib/python/flame/mode/horizontal/syncfl/top_aggregator.py index e062923bb..95a1c0066 100644 --- a/lib/python/flame/mode/horizontal/syncfl/top_aggregator.py +++ b/lib/python/flame/mode/horizontal/syncfl/top_aggregator.py @@ -24,6 +24,7 @@ import numpy as np from diskcache import Cache +from flame.availability.client_availability import ClientAvailability from flame.channel_manager import ChannelManager from flame.common.constants import DeviceType from flame.common.custom_abcmeta import ABCMeta, abstract_attribute @@ -98,7 +99,7 @@ def reset(self, *args, **kwargs): MIN_TRAINERS_JOIN_TIMEOUT_S = 180 -class TopAggregator(Role, metaclass=ABCMeta): +class TopAggregator(ClientAvailability, Role, metaclass=ABCMeta): """Top level Aggregator implements an ML aggregation role.""" @abstract_attribute @@ -182,7 +183,7 @@ def internal_init(self) -> None: # Target-accuracy stopping: count consecutive evals at/above the target # test accuracy; stop once we reach `stable_evals_above_target`. Reset on - # any dip. `rounds`/`max_runtime_s` remain the safety cap. + # any dip. `rounds`/`max_experiment_runtime_s` remain the safety cap. self._target_accuracy = getattr( self.config.hyperparameters, "target_accuracy", None ) @@ -217,6 +218,16 @@ def internal_init(self) -> None: self._trainers_used_in_curr_round = [] self.agg_start_time_ts = time.time() + # Initialize availability substrate (ClientAvailability). Sets + # trainer_event_dict=None when sim_unavailability=False → no-op on + # all current runs; gate-on enables the oracular trace-read path. + self._init_availability(self.config) + + # E.1: shared sim reorder buffer for withheld-update re-injection + # (mirrors asyncfl's _sim_buffer; stays empty when gate is off). + self._sim_buffer = SimReorderBuffer() + self._sim_committed: set = set() + self._updates_recevied = {} self._agg_training_stats = {} @@ -356,7 +367,18 @@ def _sync_sim_recv_first_k(self, channel, ends, first_k): Sync aggregation is order-independent (weighted average), so parity only requires the right *set* of k committers and the round duration. + + E.1: applies the availability send-gate (_sim_withhold_if_unavail) to + each popped update so trainers that went UN_AVL before their completion + have their update held and delivered stale at delivery_ts. After the + first_k barrier loop, drains _sim_buffer for any withheld updates now + due (re-injected stale bonus; E.2 accept-stale for feddance/FedAvg). + Gate off (trainer_event_dict=None) ⇒ byte-identical to prior behaviour. """ + # E.1: re-inject withheld updates whose delivery_ts ≤ current vclock + # into self._sim_buffer (no-op when gate is off). + self._sim_reinject_ready_withheld() + # Barrier: drain the whole selected set in one recv_fifo pass, then pick # the first_k smallest sim_completion_ts (never before a smaller is in). buf = SimReorderBuffer() @@ -382,19 +404,27 @@ def _sync_sim_recv_first_k(self, channel, ends, first_k): f"buf_depth={len(buf)}" ) - committed = [] - for _ in range(min(first_k, len(buf))): - popped = buf.pop_min() - if popped is None: + # Drain buf (fresh updates from current cohort), applying the send-gate. + # Pop smallest-sct first; try to fill first_k even when some are withheld. + all_popped = [] + while True: + p = buf.pop_min() + if p is None: break - end, sct, (msg, md) = popped - # Lazy deserialize: trainer pre-serialized weights as raw bytes so - # N-K non-committed messages didn't pay tensor-reconstruction cost. - # Reconstruct only for this committed update. + all_popped.append(p) + + committed = [] + for end, sct, (msg, md) in all_popped: + # Lazy deserialize before gate check (payload may be needed for stash). if MessageType.WEIGHTS_BYTES in msg: msg[MessageType.WEIGHTS] = cloudpickle.loads( msg.pop(MessageType.WEIGHTS_BYTES) ) + # E.1: send-gate — withhold if trainer is UN_AVL at completion. + if self._sim_withhold_if_unavail(channel, end, sct, (msg, md)): + continue + if len(committed) >= first_k: + break # first_k quota met; remaining straggler updates dropped self._advance_sim_clock(sct) _sst = channel.get_end_property(end, PROP_SIM_SEND_TS) _srd = msg.get(MessageType.SIM_CLIENT_TASK_TRAIN_DURATION_S) @@ -409,6 +439,34 @@ def _sync_sim_recv_first_k(self, channel, ends, first_k): f"T_v={self._vclock.now:.1f}" ) committed.append((msg, md)) + + # E.1 / E.2: drain withheld-delivery bonus. After the barrier advances the + # clock, re-inject any newly-due entries, then commit them as stale bonus + # updates (accept-stale; no new scalar — E.2 for feddance/FedAvg). + self._sim_reinject_ready_withheld() + while True: + wh = self._sim_buffer.pop_min() + if wh is None: + break + wend, wdts, (wmsg, wmd) = wh + if MessageType.WEIGHTS_BYTES in wmsg: + wmsg[MessageType.WEIGHTS] = cloudpickle.loads( + wmsg.pop(MessageType.WEIGHTS_BYTES) + ) + # Batch 3 T3.5 (K11): advance before emitting, matching asyncfl's + # existing order — see _emit_withheld_delivery's docstring for why + # this specific advance is provably a no-op here either way, but + # the uniform ordering is kept as a defensive rule across stacks. + _wd = self._sim_take_withheld_delivering(wend) + self._advance_sim_clock(wdts) + if _wd is not None: + self._emit_withheld_delivery(wend, wmsg, _wd[0], _wd[1]) + logger.info( + f"[SYNC_WITHHELD_DELIVER] end={str(wend)[-4:]} " + f"delivery_ts={wdts:.1f} T_v={self._vclock.now:.1f}" + ) + committed.append((wmsg, wmd)) + return committed @staticmethod @@ -484,7 +542,33 @@ def _aggregate_weights(self, tag: str) -> None: _resolved_k = first_k if first_k > 0 else len(ends) updates = self._sync_sim_recv_first_k(channel, ends, _resolved_k) else: - updates = channel.recv_fifo(ends, first_k=first_k) + # B2.0.1 / Challenge 16: bound the real recv barrier with a wall-clock + # timeout. The sync barrier waits for first_k=agg_goal of the selected + # set; under unavailability the withheld trainers never send, so an + # un-timed recv_fifo blocks forever (the feddance n=12 real hang: round + # 1 dispatched 12, ~6 withheld, recv_fifo stalled on the 10th for 46 + # min until the watchdog killed it). Mirror the oort real-recv timeout + # and the sim 90s vclock abandon: wait up to trainer_recv_wall_timeout_s + # (default 90s, >> the ~18s max trainer compute, so live stragglers + # still land) per next message, capped at the remaining experiment + # budget so the round proceeds with whatever arrived and + # increment_round's budget check can then fire. WALL-CLOCK only; sim + # path is unchanged. Harmless with the gate OFF — all first_k arrive + # well within the timeout, so recv_fifo returns before it triggers. + _stall = float(getattr( + self.config.hyperparameters, "trainer_recv_wall_timeout_s", 90.0 + )) + _max_rt = getattr( + self.config.hyperparameters, "max_experiment_runtime_s", None + ) + if _max_rt: + _remaining = max( + 1.0, float(_max_rt) - (time.time() - self.agg_start_time_ts) + ) + _recv_timeout = min(_stall, _remaining) + else: + _recv_timeout = _stall + updates = channel.recv_fifo(ends, first_k=first_k, timeout=_recv_timeout) # receive local model parameters from trainers # [U6 real barrier-anchor] Real applies all K updates at ONE post-loop @@ -499,6 +583,11 @@ def _aggregate_weights(self, tag: str) -> None: logger.debug(f"No data from {end}; skipping it") continue + # T3.3 commit-checkpoint belief (real mode only — sim's own commit + # loop already recorded it inside _sim_withhold_if_unavail). + if not self.simulated: + self._record_commit_belief(end) + logger.debug(f"received data from {end}") channel.set_end_property(end, PROP_ROUND_END_TIME, (round, timestamp)) @@ -741,6 +830,23 @@ def put(self, tag: str, task_to_perform: str = "train") -> None: self.dist_tag = tag self._distribute_weights(tag, task_to_perform) + def _mark_join_barrier_done(self) -> None: + """Latch the one-shot join barrier and re-anchor the real-mode trace-read + origin to "now" (round-0 start), not aggregator __init__. + + `agg_start_time_ts` is stamped at __init__, before the join wait runs. + Sim is unaffected (`_avail_now()` reads `_vclock.now`, which only + starts advancing at round-0 selection). Real reads `time.time() - + agg_start_time_ts`, so without this re-anchor the join wait (~300s + wall at n=300, real OS process spawn/connect) is silently baked into + every trace read -- real ends up ~300s ahead of sim/ground-truth (see + UNAVAILABILITY_DESIGN.md's B2.0.3). Self-correcting to however long + the join actually takes. + """ + self._join_barrier_done = True + if not self.simulated: + self.agg_start_time_ts = time.time() + def _await_min_trainers(self, channel) -> None: """One-shot startup barrier: block until ``min_trainers_to_start`` ends have joined the channel before the first selection. @@ -759,7 +865,7 @@ def _await_min_trainers(self, channel) -> None: return min_start = getattr(self.config.hyperparameters, "min_trainers_to_start", None) if not min_start or int(min_start) <= 0: - self._join_barrier_done = True + self._mark_join_barrier_done() return min_start = int(min_start) # Allow override: large cohorts (e.g. n300 at sleep_between_spawns=1s take @@ -772,7 +878,7 @@ def _await_min_trainers(self, channel) -> None: n = len(channel._ends) if n >= min_start: logger.info(f"[JOIN_BARRIER] {n}/{min_start} trainers joined; starting") - self._join_barrier_done = True + self._mark_join_barrier_done() return logger.info(f"[JOIN_BARRIER] waiting for {min_start} trainers to join; have {n}") time.sleep(1.0) @@ -780,7 +886,7 @@ def _await_min_trainers(self, channel) -> None: f"[JOIN_BARRIER] timed out after {timeout_s:.0f}s; " f"proceeding with {len(channel._ends)}/{min_start} trainers" ) - self._join_barrier_done = True + self._mark_join_barrier_done() @timer_decorator def _inject_oracle_utilities(self, channel, task_to_perform: str) -> None: @@ -812,22 +918,129 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None: # before distributing weights, update it from global model self._update_weights() + # E.1: re-clock the 90s abandon to the vclock and free stalled slots so a + # replacement is selectable this round (no-op when the gate is off). + # Sim-only: real mode already has a native wall-clock abandon in the + # selector itself (SEND_TIMEOUT_WAIT_S), so this would be redundant there. + if self.simulated: + self._sim_abandon_stalled(channel) + # D.1: for availability_aware baselines, proactively free any in-flight + # slot the trace now shows as UN_AVL -- no 90s wait. Both modes: trace-read + # eviction has no real-mode equivalent (unlike the abandon above), so + # gating it sim-only left real-mode felix runs with no way to drop a + # stalled UN_AVL trainer from recv_ends (see Batch 4 finding 1, + # UNAVAILABILITY_DESIGN.md). No-op here (refl/feddance's + # proactive_inflight_evict is False), kept for symmetry with asyncfl. + self._sim_evict_unavail_inflight(channel) + + # E.1: oracular gate — build the unavailability list for this selection. + if self.trainer_event_dict is not None: + curr_unavail_trainer_list = self.get_curr_task_ineligible_trainers( + task_to_perform + ) + # invariant 2: a trainer with a withheld update stays out of the + # eligible pool until its delivery_ts. + _held_withheld = self.withheld_held_ends() + if _held_withheld: + curr_unavail_trainer_list = list( + set(curr_unavail_trainer_list) | _held_withheld + ) + else: + curr_unavail_trainer_list = [] + channel.set_curr_unavailable_trainers( + trainer_unavail_list=curr_unavail_trainer_list + ) + # Stamp PROP_AVL_STATE so emit_selection's avail_composition/per_trainer + # reflect the oracular read instead of staying all-UNKNOWN. + self._avail_stamp_end_states(channel) + # Per-baseline online oracle: overwrite candidate stat-utility with the # TRUE current value (computed from the just-updated global model) before # the selector ranks. No-op unless oracle_utility_injection is enabled. self._inject_oracle_utilities(channel, task_to_perform) + # Expose current availability-timeline time to selector so it can attach + # it to selection events (C.6.1 — mirrors the same exposure in + # oort/asyncfl top_aggregators). _avail_now() covers both modes (sim + # vclock / real wall-elapsed-since-agg_start) — real used to be skipped + # here, leaving real selection events with no shared time-base and + # forcing parity's A4dur to fall back to a wrong, join-ramp-skewed + # origin (ts of first selection event, not agg_start). + channel.properties["vclock_now"] = self._avail_now() + logger.debug( f"Sending weights to trainers with task_to_perform = {task_to_perform}" ) + + # F.2: Pre-selection threshold check — return-early if pool is scarce. + # Threshold = agg_goal: sync FL must have exactly agg_goal eligible trainers + # before starting a round. Random selector (fwdllm syncfl) uses this same + # aggregator; the pre-selection threshold ensures it is never called with + # fewer than agg_goal eligible trainers. + _agg_goal = self.config.hyperparameters.aggregation_goal + _threshold = _agg_goal if _agg_goal and _agg_goal > 0 else 1 + _in_flight = getattr(channel._selector, 'selected_ends', set()) + if not isinstance(_in_flight, set): + _in_flight = set(_in_flight) if _in_flight else set() + num_eligible = len( + set(channel._ends.keys()) - set(curr_unavail_trainer_list) - _in_flight + ) + + if num_eligible < _threshold: + if self.simulated and self.trainer_event_dict is not None: + _nxt = self._next_avail_vclock() + _budget = float( + getattr(self.config.hyperparameters, "max_experiment_runtime_s", float("inf")) + ) + if _nxt is not None and _nxt > self._vclock.now and self._vclock.now < _budget: + self._vclock.advance(_nxt) + self._sim_abandon_stalled(channel) + curr_unavail_trainer_list = self.get_curr_task_ineligible_trainers( + task_to_perform + ) + _held = self.withheld_held_ends() + if _held: + curr_unavail_trainer_list = list( + set(curr_unavail_trainer_list) | _held + ) + channel.set_curr_unavailable_trainers( + trainer_unavail_list=curr_unavail_trainer_list + ) + self._avail_stamp_end_states(channel) + channel.properties["vclock_now"] = self._vclock.now + logger.info( + f"[SIM_STARVATION] round={self._round} eligible={num_eligible} " + f"< {_threshold}; vclock→{_nxt}" + ) + else: + # Trace horizon or budget reached — stop instead of spinning. + self._work_done = True + logger.info( + f"[SIM_STARVATION] trace horizon or budget reached at " + f"vclock={self._vclock.now:.1f}s (nxt={_nxt}, " + f"budget={_budget:.0f}s, round={self._round}); stopping run." + ) + else: + _max_rt = getattr(self.config.hyperparameters, "max_experiment_runtime_s", None) + if _max_rt: + _wall_elapsed = time.time() - self.agg_start_time_ts + if _wall_elapsed >= float(_max_rt): + self._work_done = True + logger.info( + f"max_experiment_runtime_s={_max_rt}s reached " + f"(wall_elapsed={_wall_elapsed:.0f}s) at round {self._round}; " + f"stopping run." + ) + return + time.sleep(0.5) + return + + # Threshold met — proceed with selection. # SEND state: pick (new) trainers to send the model to. With a buffered # selector (random) this fills concurrency; stateless selectors ignore # the state and return their normal selection. selected_ends = channel.ends(VAL_CH_STATE_SEND, task_to_perform) if not selected_ends: - # ends() can be None/empty before trainers join + get selected - # (notably in simulated mode where the loop spins without sleeps). - time.sleep(0.5) return datasampler_metadata = self.datasampler.get_metadata(self._round, selected_ends) @@ -842,6 +1055,11 @@ def _distribute_weights(self, tag: str, task_to_perform: str = "train") -> None: } if self.simulated: msg[MessageType.SIM_SEND_TS] = _sim_send_ts + else: + # T3.0: broadcast the trace-read origin so a trainer's own wall-clock + # availability lookups anchor to the SAME point the aggregator uses + # (post-join-barrier-reanchor), not a per-trainer local origin. + msg[MessageType.AGG_START_TS] = self.agg_start_time_ts _payload = channel.dumps(msg) _send_t0 = time.time() # [DISTRIBUTE_TIMING] for end in selected_ends: @@ -869,7 +1087,18 @@ def inform_end_of_training(self) -> None: logger.debug(f"channel not found for tag {self.dist_tag}") return - channel.broadcast({MessageType.EOT: self._work_done}) + payload = {MessageType.EOT: self._work_done} + # Sim trainers only advance _sim_now() on dispatch, so one that goes + # quiet (withheld/evicted UN_AVL) never catches its avl_state up to + # later trace transitions (UNAVAILABILITY_DESIGN.md's Batch 4 finding + # 2). Piggyback the final vclock on this broadcast (reaches every + # connected end regardless of dispatch state) as a last wake-up for + # _refresh_avl_state() to flush queued transitions before exit. Gated + # on the availability feature (byte-identical broadcast payload when + # off); real mode's clock never freezes, so it doesn't need this. + if self.simulated and getattr(self, "trainer_event_dict", None) is not None: + payload[MessageType.SIM_SEND_TS] = self._avail_now() + channel.broadcast(payload) logger.debug("done broadcasting end-of-training") def run_analysis(self): @@ -908,14 +1137,16 @@ def increment_round(self): self._round += 1 self._work_done = self._round > self._rounds - # Optional runtime cap: stop once max_runtime_s has elapsed. - # In simulated mode use the virtual clock (vclock_now = simulated seconds - # elapsed) so the run covers max_runtime_s of *virtual* time, not wall - # time. In real mode use wall-clock elapsed. - _max_rt = getattr(self.config.hyperparameters, "max_runtime_s", None) + # Optional runtime cap: stop once max_experiment_runtime_s has elapsed. + # Clock interpretation is mode-dependent: + # real mode → wall-clock seconds (time.time() elapsed) + # sim mode → virtual-clock seconds (vclock.now) + # This lets one YAML value govern both modes: the same 1800s means + # "30 wall-clock minutes" in real and "1800 virtual seconds" in sim. + _max_rt = getattr(self.config.hyperparameters, "max_experiment_runtime_s", None) # sim_wall_ceiling_s: tight wall-clock guard for sim mode (iii-b). - # A sim run should finish in <= max_runtime_s wall (it runs faster than - # real when the parity bug is fixed). Default = max_runtime_s (1×). + # A sim run should finish in <= max_experiment_runtime_s wall (it runs + # faster than real when the parity bug is fixed). Default = 1× budget. # Separate from max_wall_runtime_s (kept for backward compat, used as # secondary fallback if sim_wall_ceiling_s is absent). _sim_wall_ceil = getattr(self.config.hyperparameters, "sim_wall_ceiling_s", None) @@ -927,15 +1158,15 @@ def increment_round(self): else: elapsed = time.time() - self.agg_start_time_ts clock_label = "wall" - if elapsed > float(_max_rt): + if elapsed >= float(_max_rt): logger.info( - f"max_runtime_s={_max_rt}s reached ({clock_label}_elapsed={elapsed:.0f}s) " + f"max_experiment_runtime_s={_max_rt}s reached ({clock_label}_elapsed={elapsed:.0f}s) " f"at round {self._round}; stopping run." ) self._work_done = True # Failsafe: in sim mode the primary check is virtual time. - # sim_wall_ceiling_s (default = max_runtime_s = 1×) caps the wall time - # a sim may use — a well-behaved sim finishes in ≤ real-mode wall time. + # sim_wall_ceiling_s (default = max_experiment_runtime_s × 1) caps the + # wall time a sim may use — well-behaved sim finishes in ≤ real wall time. if self.simulated and not self._work_done: _wall_elapsed = time.time() - self.agg_start_time_ts if _sim_wall_ceil: @@ -948,7 +1179,7 @@ def increment_round(self): logger.warning( f"[SIM_WALL_CEILING] sim_wall_ceiling={_failsafe_s:.0f}s reached " f"(wall_elapsed={_wall_elapsed:.0f}s, " - f"vclock={self._vclock.now:.0f}s, max_runtime_s={_max_rt}s) " + f"vclock={self._vclock.now:.0f}s, max_experiment_runtime_s={_max_rt}s) " f"at round {self._round}. " f"Sim is slower than real — investigate per-round parity (bug iii-c). " f"Stopping run." @@ -1160,67 +1391,6 @@ def _update_weights(self): elif self.framework == MLFramework.TENSORFLOW: self.weights = self.model.get_weights() - def get_curr_unavail_trainers(self) -> list: - curr_unavail_trainer_list = [] - - # Ensure trainer_event_dict exists - if self.trainer_event_dict is not None: - # Aggregator time since start, on the SAME timeline the trace's event - # timestamps live on. In simulated mode that is the virtual clock - # (sim-seconds); wall-clock would be a few seconds total while the - # virtual timeline spans the whole trace, making every window look - # available. Trainer-side availability already keys off _sim_now() - # (sim_send_ts); this mirrors it for the aggregator-side oracular path. - agg_time_since_start_s = ( - self._vclock.now if self.simulated - else time.time() - self.agg_start_time_ts - ) - - for trainer_id, event_dict in list(self.trainer_event_dict.items()): - logger.debug( - f"Checking trainer {trainer_id}'s availability. Event_dict is: {event_dict}" - ) - - if not event_dict: - continue # Skip if no events for trainer - - # Binary search for closest past event - idx = event_dict.bisect_right(agg_time_since_start_s) - 1 - logger.debug(f"Trainer_id: {trainer_id} got index: {idx}") - - if idx >= 0: - most_recent_event = event_dict.peekitem(idx) - logger.debug( - f"Trainer_id: {trainer_id} got most_recent_event: {most_recent_event}" - ) - - most_recent_event_ts = most_recent_event[0] - most_recent_event_state = most_recent_event[1] - - if most_recent_event_state == "UN_AVL": - logger.debug( - f"Trainer {trainer_id} is unavailable since time {most_recent_event_ts}." - ) - curr_unavail_trainer_list.append(trainer_id) - elif most_recent_event_state == "AVL_TRAIN": - logger.debug( - f"Trainer {trainer_id} is available since time {most_recent_event_ts}." - ) - else: - logger.warning( - f"Trainer {trainer_id} was in state {most_recent_event_state} since time {most_recent_event_ts}, needs to be handled." - ) - - # TODO: To be more memory efficient, we can delete - # events that are way past their time and already used - - # Return the list of currently unavailable trainers - logger.debug( - f"Current curr_unavail_trainer_list: {curr_unavail_trainer_list} has {len(curr_unavail_trainer_list)} ends out of total {len(self.trainer_event_dict)} ends dict" - ) - - return curr_unavail_trainer_list - def compose(self) -> None: """Compose role with tasklets.""" diff --git a/lib/python/flame/mode/horizontal/syncfl/trainer.py b/lib/python/flame/mode/horizontal/syncfl/trainer.py index 53fb2c541..ef06afce0 100644 --- a/lib/python/flame/mode/horizontal/syncfl/trainer.py +++ b/lib/python/flame/mode/horizontal/syncfl/trainer.py @@ -256,6 +256,14 @@ def _fetch_weights(self, tag: str) -> None: if MessageType.SIM_SEND_TS in msg: self._sim_send_ts = msg[MessageType.SIM_SEND_TS] + # Cache the aggregator's trace-read origin (real mode only) so this + # trainer's own wall-clock availability lookups share the exact + # origin the aggregator uses, instead of deriving one from its own + # process-start time. Re-cached every dispatch (cheap, idempotent, + # self-healing if an early message was missed). + if MessageType.AGG_START_TS in msg: + self._agg_start_origin = msg[MessageType.AGG_START_TS] + if telemetry.is_enabled(): _sim_send_ts_val = getattr(self, "_sim_send_ts", None) _time_mode = getattr(self, "time_mode", "real") @@ -271,6 +279,13 @@ def _fetch_weights(self, tag: str) -> None: if MessageType.EOT in msg: self._work_done = msg[MessageType.EOT] + # Give a sim-mode trainer that hasn't been dispatched in a while + # one last chance to catch its avl_state/telemetry up to the + # trace, using the SIM_SEND_TS this EOT broadcast may carry + # (captured above). hasattr-guarded: example-specific hook, not + # every Trainer subclass defines it. + if hasattr(self, "_refresh_avl_state"): + self._refresh_avl_state() if MessageType.DATASAMPLER_METADATA in msg: self.datasampler.handle_metadata_from_aggregator( @@ -344,20 +359,34 @@ def _send_weights(self, tag: str) -> None: f"### SEND WEIGHTS for tag: {tag} " f"and trainer_id: {self.trainer_id}, model_version: {self._round}, and avl_state = {self.avl_state}" ) - # if switch to do three_state_avl is on and the trainer is - # unavailable - check the wait_to_become_avl switch depending - # on the switch we decide whether to wait for availability or - # exit + # [SEND_GATE] real-mode send-time gate: hold the upload (already- + # completed result) until the trainer is AVL_* again. Decoupled from + # client_notify["enabled"] (v1 keeps it OFF -- the aggregator learns + # oracularly, not via this push). Sim-only is a no-op here since sim + # time can't advance while blocked on time.sleep -- sim availability + # is instead enforced agg-side by ClientAvailability's send-time + # withhold, keyed on the trainer-reported completion time. + # + # Sample send_gate_sct (trainer's own trace-time clock) right before + # the gate check regardless of whether it engages, so A8 can confirm + # the no-wait case too. Real mode only; hasattr-guarded since + # _sim_now() is example-specific, not on this generic base class. + _send_gate_sct = ( + self._sim_now() + if not getattr(self, "simulated", False) and hasattr(self, "_sim_now") + else None + ) if ( - self.client_notify["enabled"] == "True" + not getattr(self, "simulated", False) and self.avl_state == TrainerAvailState.UN_AVL ): if self.wait_until_next_avl == "True": logger.warning( f"Trainer id {self.trainer_id} is unavailable to send weights. Waiting for it to be available again" ) - while self.avl_state == TrainerAvailState.UN_AVL: - time.sleep(1) + with self._phase("send_gate_wait_s"): + while self.avl_state == TrainerAvailState.UN_AVL: + time.sleep(1) else: logger.warning( f"Trainer id {self.trainer_id} is unavailable to send weights since wait_until_next_avl = {self.wait_until_next_avl}. Exiting sending weights." @@ -467,6 +496,12 @@ def _send_weights(self, tag: str) -> None: wall_recv_ts=getattr(self, "_wall_recv_ts", None), wall_send_ts=_wall_send_ts, time_mode=getattr(self, "time_mode", "real"), + send_gate_wait_s=( + float(self._phase_times.get("send_gate_wait_s", 0.0)) + if not getattr(self, "simulated", False) + else None + ), + send_gate_sct=_send_gate_sct, ) telemetry.emit(ev, **fields) diff --git a/lib/python/flame/mode/message.py b/lib/python/flame/mode/message.py index 3afa1b721..89d1ac8bf 100644 --- a/lib/python/flame/mode/message.py +++ b/lib/python/flame/mode/message.py @@ -87,3 +87,12 @@ class MessageType(Enum): WALL_RECV_TS = 39 # wall-clock unix timestamp (float) when trainer's channel.recv() returns (weights received from agg) CLIENT_TASK_TRAIN_COMPUTE_S = 40 # modeled compute duration in seconds: max(real_gpu_time, training_delay_s); stamped by trainer unconditionally (real and sim) WEIGHTS_BYTES = 41 # pre-serialized weights (raw cloudpickle bytes) for lazy sync-barrier deserialization in sim mode + + # Real-mode-only counterpart to SIM_SEND_TS: the aggregator's own + # availability trace-read origin (agg_start_time_ts, re-anchored at + # join-barrier resolution, see _mark_join_barrier_done()), broadcast on + # every dispatch so a trainer's own wall-clock trace lookups share the + # aggregator's exact origin instead of deriving their own (join-ramp + # skew, same class of bug as B2.0.3). Sim mode never sends this -- its + # shared origin is the single _vclock, already exposed via SIM_SEND_TS. + AGG_START_TS = 42 diff --git a/lib/python/flame/optimizer/fedbuff.py b/lib/python/flame/optimizer/fedbuff.py index 862ec3d92..a3f4c666c 100644 --- a/lib/python/flame/optimizer/fedbuff.py +++ b/lib/python/flame/optimizer/fedbuff.py @@ -72,6 +72,13 @@ def __init__(self, **kwargs): except KeyError: raise KeyError("Dataset name not specified in the config") + # Explicit learning rate, independent of dataset_name. When set, + # this wins over the dataset_name lookup table below -- lets each + # baseline declare its own rate instead of relying on fedbuff's + # hardcoded cifar-10/google-speech table (which has no entry for + # other examples, e.g. fwdllm/fluxtune). + self.learning_rate = kwargs.get("learning_rate", None) + # Set aggregation rate type between old (just staleness) and # new (tradeoff staleness and stat utility) Current options: # {"old", "new"} @@ -230,7 +237,9 @@ def _scale_add_agg_weights_pytorch( # argument later TODO: (DG) Hyper-parameters for AsyncOORT # need tuning? Which all hyper-parameters apart from LR # need to be tuned? - if self.use_oort_lr == "False": + if self.learning_rate is not None: + learning_rate = self.learning_rate + elif self.use_oort_lr == "False": # for fedbuff asyncfl if self.dataset_name == "cifar-10": learning_rate = 40.9 # Used with CIFAR-10 @@ -272,8 +281,9 @@ def _scale_add_agg_weights_pytorch( def _scale_add_agg_weights_tensorflow( self, base_weights: ModelWeights, agg_goal_weights: ModelWeights, agg_goal: int ) -> ModelWeights: + learning_rate = self.learning_rate if self.learning_rate is not None else 1.0 for idx in range(len(base_weights)): - base_weights[idx] += agg_goal_weights[idx] / agg_goal + base_weights[idx] += learning_rate * (agg_goal_weights[idx] / agg_goal) return base_weights def _aggregate_pytorch(self, tres, rate): diff --git a/lib/python/flame/plugin/__init__.py b/lib/python/flame/plugin/__init__.py index 26967b4d1..55b6ad9f7 100644 --- a/lib/python/flame/plugin/__init__.py +++ b/lib/python/flame/plugin/__init__.py @@ -55,7 +55,7 @@ def __init__(self, plugins_path: str = "/etc/flame/plugin") -> None: cls_name, package, ptype = self.parse_plugin(filepath) self.register_plugin(cls_name, package, ptype) except FileNotFoundError as e: - logger.warn(f"{e.filename} not found; stop plugin registration.") + logger.warning(f"{e.filename} not found; stop plugin registration.") return def parse_plugin(self, filepath: str) -> Tuple[str, str, PluginType]: diff --git a/lib/python/flame/selector/__init__.py b/lib/python/flame/selector/__init__.py index dbbd9d8db..8177b1ad6 100644 --- a/lib/python/flame/selector/__init__.py +++ b/lib/python/flame/selector/__init__.py @@ -142,6 +142,7 @@ def emit_selection( if hasattr(speed, "total_seconds") else speed, "selected": end_id in chosen_set, + "avl_state": state_name, } if per_trainer_extra and end_id in per_trainer_extra: entry.update(per_trainer_extra[end_id]) diff --git a/lib/python/flame/selector/async_oort.py b/lib/python/flame/selector/async_oort.py index 870672492..c14bbe030 100644 --- a/lib/python/flame/selector/async_oort.py +++ b/lib/python/flame/selector/async_oort.py @@ -361,6 +361,7 @@ def select( task_to_perform=task_to_perform, agg_version_state=agg_version_state, trainer_version_states=trainer_version_states, + connected_ends=ends, # Challenge 13: full pool for cleanup ) if len(results) is not 0: @@ -1400,6 +1401,7 @@ def _handle_send_state( task_to_perform: str = "train", agg_version_state=None, # (model_version, data_id, iteration_id) trainer_version_states: dict[str, tuple[int, int, int]] = None, + connected_ends: dict[str, End] = None, ) -> SelectorReturnType: selected_ends = self.selected_ends[self.requester] logger.debug( @@ -1408,9 +1410,89 @@ def _handle_send_state( logger.debug( f"Inside handle send state: trainer version states {trainer_version_states}" ) + + # Invalidate previous all_selected entry if you don't get an + # update in SEND_TIMEOUT_WAIT_S. The client might have dropped + # the message with transient unavailability. Must run before + # extra (below) is computed and before the extra==0 early + # return -- a reclaim gated behind the very slot-exhaustion + # check it's supposed to relieve can never fire once + # concurrency saturates. Must also free selected_ends, not just + # all_selected: extra is computed from len(selected_ends), so a + # reclaim that only touches all_selected leaves the concurrency + # slot stuck occupied forever (see + # examples/MIGRATING_TO_LAUNCHER.md's aggregator gotchas for the + # deadlock this caused). + curr_all_selected_ends = list(self.all_selected.keys()) + for end in curr_all_selected_ends: + current_time_s = time.time() + if end in self.all_selected.keys(): + # Check again to avoid possible case of race condition + # when all_selected has been updated from another + # thread + trainer_weight_send_timestamp_s = self.all_selected[end] + if ( + trainer_weight_send_timestamp_s + < (current_time_s - SEND_TIMEOUT_WAIT_S) + ) and (end not in self.ordered_updates_recv_ends): + # trainer hasn't returned with an update in + # SEND_TIMEOUT_WAIT_S delete it from + # self.all_selected so that it is eligible to be + # sampled again + logger.info( + f"Removing end {end} from self.all_selected " + f"since havent " + f"got its update in {SEND_TIMEOUT_WAIT_S}. " + f"Last weight send timestamp was: {trainer_weight_send_timestamp_s}" + ) + + # Tracking timeouts and time spend waiting TODO: + # (DG) Check if it is okay to have it triggered + # for oracular too? TODO: (DG) pass + # timeout_duration as a flag from config, also + # pass enable/disable it? + if end in self.track_trainer_timeouts: + self.track_trainer_timeouts[end] += 1 + else: + self.track_trainer_timeouts[end] = 1 + + # Capture total time spent in timeouts + num_of_timeouts_occured = 0 + for k, v in self.track_trainer_timeouts.items(): + num_of_timeouts_occured += v + + total_time_spent_timeouts_s = ( + num_of_timeouts_occured * SEND_TIMEOUT_WAIT_S + ) + + logger.debug( + f"Timeout for trainer: {end} with count " + f"{self.track_trainer_timeouts[end]}. " + f"num_of_timeouts_occured : " + f"{num_of_timeouts_occured}, " + f"total_time_spent_timeouts_s: " + f"{total_time_spent_timeouts_s}, " + f"Timeout frequency: {self.track_trainer_timeouts}" + ) + + # delete the end from self.all_selected AND from + # selected_ends -- the latter is what extra's + # concurrency accounting actually counts, so this is + # the fix that lets a timed-out slot actually reopen. + if end in self.all_selected.keys(): + del self.all_selected[end] + selected_ends.discard(end) + + # Challenge 13: cleanup must check CONNECTED membership, not availability- + # eligibility — an in-flight trainer that merely went UN_AVL (or is the + # wrong task-type) is absent from the filtered `ends` but still connected; + # removing it makes the aggregator forget it is waiting. An empty eligible + # pool would otherwise wipe ALL shared selected_ends → hang. Use the full + # connected pool when provided; fall back to `ends` for backward compat. + _connected = connected_ends if connected_ends is not None else ends # Check for invalid selections and remove them for end_id in list(selected_ends): - if end_id not in ends: + if end_id not in _connected: # something happened to end of end_id (e.g., # connection loss) let's remove it from selected_ends # so that you can fill that spot with another trainer @@ -1470,68 +1552,6 @@ def _handle_send_state( # NOTE: (DG) Assuming that shuffled_end_ids is not needed - # Invalidate previous all_selected entry if you don't get an - # update in UPDATE_TIMEOUT_WAIT_S. The client might have - # dropped the message with transient unavailability. - - # TODO: (DG) Check if it is still needed after - # cleanup_remove_end() method - curr_all_selected_ends = list(self.all_selected.keys()) - for end in curr_all_selected_ends: - current_time_s = time.time() - if end in self.all_selected.keys(): - # Check again to avoid possible case of race condition - # when all_selected has been updated from another - # thread - trainer_weight_send_timestamp_s = self.all_selected[end] - if ( - trainer_weight_send_timestamp_s - < (current_time_s - SEND_TIMEOUT_WAIT_S) - ) and (end not in self.ordered_updates_recv_ends): - # trainer hasn't returned with an update in - # SEND_TIMEOUT_WAIT_S delete it from - # self.all_selected so that it is eligible to be - # sampled again - logger.info( - f"Removing end {end} from self.all_selected " - f"since havent " - f"got its update in {SEND_TIMEOUT_WAIT_S}. " - f"Last weight send timestamp was: {trainer_weight_send_timestamp_s}" - ) - - # Tracking timeouts and time spend waiting TODO: - # (DG) Check if it is okay to have it triggered - # for oracular too? TODO: (DG) pass - # timeout_duration as a flag from config, also - # pass enable/disable it? - if end in self.track_trainer_timeouts: - self.track_trainer_timeouts[end] += 1 - else: - self.track_trainer_timeouts[end] = 1 - - # Capture total time spent in timeouts - num_of_timeouts_occured = 0 - for k, v in self.track_trainer_timeouts.items(): - num_of_timeouts_occured += v - - total_time_spent_timeouts_s = ( - num_of_timeouts_occured * SEND_TIMEOUT_WAIT_S - ) - - logger.debug( - f"Timeout for trainer: {end} with count " - f"{self.track_trainer_timeouts[end]}. " - f"num_of_timeouts_occured : " - f"{num_of_timeouts_occured}, " - f"total_time_spent_timeouts_s: " - f"{total_time_spent_timeouts_s}, " - f"Timeout frequency: {self.track_trainer_timeouts}" - ) - - # delete the end from self.all_selected - if end in self.all_selected.keys(): - del self.all_selected[end] - # Run pacer that controls round_threshold. TRAIN-ONLY: the reference # Oort pacer is the *training* selector's (it reads exploited train # utility, advances once per training round). felix's eval hand leaves diff --git a/lib/python/flame/selector/async_random.py b/lib/python/flame/selector/async_random.py index 5c975de0a..40fb955e6 100644 --- a/lib/python/flame/selector/async_random.py +++ b/lib/python/flame/selector/async_random.py @@ -197,6 +197,7 @@ def select( task_to_perform=task_to_perform, agg_version_state=agg_version_state, trainer_version_states=trainer_version_states, + connected_ends=ends, # Challenge 13: full pool for cleanup ) if len(results) is not 0: @@ -460,54 +461,26 @@ def _handle_send_state( task_to_perform: str = "train", agg_version_state=None, # (model_version, data_id, iteration_id) trainer_version_states: dict[str, tuple[int, int, int]] = None, + connected_ends: dict[str, End] = None, ) -> SelectorReturnType: selected_ends = self.selected_ends[self.requester] logger.debug(f"Inside handle send state: aggregator version state {agg_version_state}") logger.debug( f"Inside handle send state: trainer version states {trainer_version_states}" ) - # Check for invalid selections and remove them - for end_id in list(selected_ends): - if end_id not in ends: - # something happened to end of end_id (e.g., - # connection loss) let's remove it from selected_ends - # so that you can fill that spot with another trainer - logger.info( - f"Removing invalid prior selection! " - f"No end id {end_id} in ends, " - f"removing from selected_ends. " - f"NOT from all_selected right now " - f"cause aggregation for that " - f"round hasnt completed yet" - ) - selected_ends.remove(end_id) - # NOTE: Not removing end_id from all_selected since it - # might have already participated in the same round - # (if it is still in all_ends) - - logger.debug(f"Current selected_ends: {selected_ends}") - - extra = max(0, concurrency - len(selected_ends)) - - logger.debug( - f"c: {concurrency}, " - f"len(selected_ends): {len(selected_ends)}, extra: {extra}, selected_ends: {selected_ends}," - f"len(ends): {len(ends)}" - ) - candidates = [] - - if extra == 0: - logger.debug(f"extra: {extra}, nothing to select") - return {} - - round = channel_props["round"] if "round" in channel_props else 0 - logger.debug(f"let's select {extra} ends for round {round}") - # Invalidate previous all_selected entry if you don't get an - # update in UPDATE_TIMEOUT_WAIT_S. The client might have - # dropped the message with transient unavailability. - + # update in SEND_TIMEOUT_WAIT_S. The client might have dropped + # the message with transient unavailability. Must run before + # extra (below) is computed and before the extra==0 early + # return -- a reclaim gated behind the very slot-exhaustion + # check it's supposed to relieve can never fire once + # concurrency saturates. Must also free selected_ends, not just + # all_selected: extra is computed from len(selected_ends), so a + # reclaim that only touches all_selected leaves the concurrency + # slot stuck occupied forever (see async_oort.py's identical fix + # and examples/MIGRATING_TO_LAUNCHER.md's aggregator gotchas for + # the deadlock this caused). curr_all_selected_ends = list(self.all_selected.keys()) for end in curr_all_selected_ends: current_time_s = time.time() @@ -555,9 +528,57 @@ def _handle_send_state( f"Timeout frequency: {self.track_trainer_timeouts}" ) - # delete the end from self.all_selected + # delete the end from self.all_selected AND from + # selected_ends -- the latter is what extra's + # concurrency accounting actually counts, so this is + # the fix that lets a timed-out slot actually reopen. if end in self.all_selected.keys(): del self.all_selected[end] + selected_ends.discard(end) + + # Challenge 13: cleanup must check CONNECTED membership, not availability- + # eligibility — an in-flight trainer that merely went UN_AVL (or is the + # wrong task-type) is absent from the filtered `ends` but still connected; + # removing it makes the aggregator forget it is waiting. An empty eligible + # pool would otherwise wipe ALL shared selected_ends → hang. Use the full + # connected pool when provided; fall back to `ends` for backward compat. + _connected = connected_ends if connected_ends is not None else ends + # Check for invalid selections and remove them + for end_id in list(selected_ends): + if end_id not in _connected: + # something happened to end of end_id (e.g., + # connection loss) let's remove it from selected_ends + # so that you can fill that spot with another trainer + logger.info( + f"Removing invalid prior selection! " + f"No end id {end_id} in ends, " + f"removing from selected_ends. " + f"NOT from all_selected right now " + f"cause aggregation for that " + f"round hasnt completed yet" + ) + selected_ends.remove(end_id) + # NOTE: Not removing end_id from all_selected since it + # might have already participated in the same round + # (if it is still in all_ends) + + logger.debug(f"Current selected_ends: {selected_ends}") + + extra = max(0, concurrency - len(selected_ends)) + + logger.debug( + f"c: {concurrency}, " + f"len(selected_ends): {len(selected_ends)}, extra: {extra}, selected_ends: {selected_ends}," + f"len(ends): {len(ends)}" + ) + candidates = [] + + if extra == 0: + logger.debug(f"extra: {extra}, nothing to select") + return {} + + round = channel_props["round"] if "round" in channel_props else 0 + logger.debug(f"let's select {extra} ends for round {round}") # TODO: (DG) Add code to allow only those ends (not in # all_selected) to be passed. filtered_ends consists of ends diff --git a/lib/python/flame/selector/fedbuff.py b/lib/python/flame/selector/fedbuff.py index e6b4c7f9b..02e677cc7 100644 --- a/lib/python/flame/selector/fedbuff.py +++ b/lib/python/flame/selector/fedbuff.py @@ -195,14 +195,17 @@ def select( results = {} if channel_props[KEY_CH_STATE] == VAL_CH_STATE_SEND: - results = self._handle_send_state(eligible_ends, concurrency) + results = self._handle_send_state( + eligible_ends, concurrency, connected_ends=ends + ) # Challenge 13: full pool for cleanup self.emit_selection( channel_props.get("round", 0), "train", ends, eligible_ends.keys(), list(results.keys()), - extra={"concurrency": concurrency, "requester": self.requester}, + extra={"concurrency": concurrency, "requester": self.requester, + "vclock_now": channel_props.get("vclock_now")}, ) elif channel_props[KEY_CH_STATE] == VAL_CH_STATE_RECV: @@ -440,13 +443,21 @@ def _cleanup_send_ends(self): del self.all_selected[end_id] def _handle_send_state( - self, ends: dict[str, End], concurrency: int + self, ends: dict[str, End], concurrency: int, + connected_ends: dict[str, End] = None, ) -> SelectorReturnType: selected_ends = self.selected_ends[self.requester] + # Challenge 13: cleanup must check CONNECTED membership, not availability- + # eligibility — an in-flight trainer that merely went UN_AVL (or is the + # wrong task-type) is absent from the filtered `ends` but still connected; + # removing it makes the aggregator forget it is waiting. An empty eligible + # pool would otherwise wipe ALL shared selected_ends → hang. Use the full + # connected pool when provided; fall back to `ends` for backward compat. + _connected = connected_ends if connected_ends is not None else ends # Check for invalid selections and remove them for end_id in list(selected_ends): - if end_id not in ends: + if end_id not in _connected: # something happened to end of end_id (e.g., # connection loss) let's remove it from selected_ends # so that you can fill that spot with another trainer @@ -539,9 +550,17 @@ def _handle_send_state( f"Timeout frequency: {self.track_trainer_timeouts}" ) - # delete the end from self.all_selected + # delete the end from self.all_selected AND from + # selected_ends -- extra (computed above) is derived + # from len(selected_ends), so a reclaim that only + # touches all_selected leaves the concurrency slot + # stuck occupied (see async_oort.py's identical fix + # and examples/MIGRATING_TO_LAUNCHER.md's aggregator + # gotchas for the fwdllm deadlock this class of bug + # caused). if end in self.all_selected.keys(): del self.all_selected[end] + selected_ends.discard(end) for end_id in shuffled_end_ids: if end_id in self.all_selected.keys(): diff --git a/lib/python/flame/selector/feddance.py b/lib/python/flame/selector/feddance.py index 2040dc1aa..fa4b0cf11 100644 --- a/lib/python/flame/selector/feddance.py +++ b/lib/python/flame/selector/feddance.py @@ -161,7 +161,8 @@ def select( self.emit_selection( round_num, task_to_perform, ends, eligible.keys(), selected, per_trainer_extra=ptx, - extra={"num_unavail": len(unavail)}, + extra={"num_unavail": len(unavail), + "vclock_now": channel_props.get("vclock_now")}, ) return {key: None for key in selected} diff --git a/lib/python/flame/selector/oort.py b/lib/python/flame/selector/oort.py index 94447e58d..648a2c851 100644 --- a/lib/python/flame/selector/oort.py +++ b/lib/python/flame/selector/oort.py @@ -245,7 +245,9 @@ def select( result = self.select_random(ends, num_of_ends) self.emit_selection( round, task_to_perform, all_ends, ends.keys(), - self.selected_ends, extra={"mode": "random_first_round"}, + self.selected_ends, + extra={"mode": "random_first_round", + "vclock_now": channel_props.get("vclock_now")}, ) return result @@ -264,7 +266,9 @@ def select( result = self.select_random(ends, num_of_ends) self.emit_selection( round, task_to_perform, all_ends, ends.keys(), - self.selected_ends, extra={"mode": "random_no_utility"}, + self.selected_ends, + extra={"mode": "random_no_utility", + "vclock_now": channel_props.get("vclock_now")}, ) return result @@ -337,6 +341,7 @@ def select( # pacer state: the percentile that sets pref (read pref divergence directly). "round_threshold": getattr(self, "round_threshold", None), "alpha": getattr(self, "alpha", None), + "vclock_now": channel_props.get("vclock_now"), # per-round speed-penalty summary over selected (see _system_util_summary) **self._system_util_summary(), }, diff --git a/lib/python/flame/selector/random.py b/lib/python/flame/selector/random.py index 8908ba300..7603f404b 100644 --- a/lib/python/flame/selector/random.py +++ b/lib/python/flame/selector/random.py @@ -261,10 +261,43 @@ def select( self.all_selected.update({key: None for key in self.selected_ends}) for candidate in selected_candidates: self.time_sent[candidate] = time.time() - + if round > self.round: self.round = round + # RandomSelector never called this before -- the only "selection" + # telemetry that existed for fwdllm/fwdllm_plus (both use this + # selector) came from the trainer's own trivial 1-candidate + # channel selector (a channel-implementation artifact -- see + # examples/MIGRATING_TO_LAUNCHER.md's telemetry gotchas), not + # the real aggregator-side FL-selection decision made here. + # This is that decision. + _extra = { + "concurrency": self.c, + "requester": channel_props.get(KEY_CH_SELECT_REQUESTER), + } + # fwdllm-family aggregators thread (model_version, data_id, + # iteration_id) through channel.ends(agg_version_state=...) -> + # select()'s kwargs (see fwdllm_aggregator.py). Attaching data_id/ + # iteration_per_data_id here lets analyze_run.py's progress_key() + # place this event on the same fine-grained axis as trainer_round/ + # agg_round/agg_eval, instead of collapsing onto fwdllm's + # coarse `round` (which can stay at 1 for an entire run). No-op + # (absent from extra) for callers that don't pass agg_version_state + # -- e.g. async_cifar10's fedavg baseline also uses this selector. + _avs = kwargs.get("agg_version_state") + if isinstance(_avs, (tuple, list)) and len(_avs) == 3: + _extra["data_id"] = _avs[1] + _extra["iteration_per_data_id"] = _avs[2] + self.emit_selection( + round, + task_to_perform, + ends, + avl_candidates, + selected_candidates, + extra=_extra, + ) + logger.info("select in send state") return {key: None for key in selected_candidates} diff --git a/lib/python/flame/selector/refl_oort.py b/lib/python/flame/selector/refl_oort.py index cd37efc3a..eed01a3fd 100644 --- a/lib/python/flame/selector/refl_oort.py +++ b/lib/python/flame/selector/refl_oort.py @@ -232,6 +232,7 @@ def select( "num_priority": len(priority_ends), "num_blacklist": len(blacklist), "exploration_factor": self.exploration_factor, + "vclock_now": channel_props.get("vclock_now"), }, ) return {key: None for key in newly_selected} diff --git a/lib/python/flame/telemetry/events.py b/lib/python/flame/telemetry/events.py index 6ee649d5b..237f09d8c 100644 --- a/lib/python/flame/telemetry/events.py +++ b/lib/python/flame/telemetry/events.py @@ -26,6 +26,9 @@ EVENT_INFLIGHT_RESIDENCE = "inflight_residence" # per-round in-flight drain accounting (oort sync) EVENT_UTILITY_BELIEF = "utility_belief" # believed (at selection) vs actual (at return) client utility EVENT_DISPATCH = "dispatch" # per-dispatch re-dispatch-stagger validation (felix) +EVENT_WITHHELD_DELIVERY = "withheld_delivery" # late stale delivery of a send-gated update +EVENT_ABANDON_TIMEOUT = "abandon_timeout" # 90s vclock slot-free of a stalled trainer +EVENT_AGG_BELIEF_CHANGE = "agg_belief_change" # aggregator's belief about a trainer's avail state KNOWN_EVENTS = frozenset( { @@ -40,6 +43,10 @@ EVENT_TASK_SEND, EVENT_INFLIGHT_RESIDENCE, EVENT_UTILITY_BELIEF, + EVENT_DISPATCH, + EVENT_WITHHELD_DELIVERY, + EVENT_ABANDON_TIMEOUT, + EVENT_AGG_BELIEF_CHANGE, } ) @@ -216,13 +223,28 @@ def build_util_disparity( def build_avail_change( - *, round_num: Optional[int], old_state: str, new_state: str + *, + round_num: Optional[int], + old_state: str, + new_state: str, + sim_now: Optional[float] = None, ) -> tuple[str, dict[str, Any]]: - """Trainer availability state transition.""" + """Trainer availability state transition. + + sim_now: the trainer's own trace-time-basis clock (``_sim_now()``) at the + moment the transition was applied — sim: virtual-clock seconds; real: + wall-elapsed since the shared AGG_START_TS origin (Batch 3 T3.0). Distinct + from the record's own wall ``ts`` (always epoch time.time(), meaningless + against a trace indexed in trace-seconds). Needed for A6 + (trainer_trace_fidelity, Batch 3 T3.2) to compare *when* a trainer applied + a transition against ground truth, not just *that* it eventually did. + Optional/back-compat: None for telemetry recorded before this field existed. + """ return EVENT_AVAIL_CHANGE, { "round": round_num, "old_state": old_state, "new_state": new_state, + "sim_now": sim_now, } @@ -258,6 +280,8 @@ def build_task_send( wall_recv_ts: Optional[float], wall_send_ts: float, time_mode: str, + send_gate_wait_s: Optional[float] = None, + send_gate_sct: Optional[float] = None, ) -> tuple[str, dict[str, Any]]: """Trainer finished a task and sent the update back to the aggregator. @@ -266,6 +290,16 @@ def build_task_send( ``[wall_recv_ts, wall_send_ts]`` brackets the trainer's true busy/in-flight window in real mode. That interval is the sound basis for real concurrency in validate_real: trainer_round's own ts cannot bracket it. + + send_gate_wait_s / send_gate_sct (Batch 3 T3.4, real mode only): the + [SEND_GATE] wait loop also runs strictly after trainer_round is emitted + (train() -> put()/_send_weights, per the tasklet composition), so — like + wall_send_ts above — task_send, not trainer_round, is the event that can + actually carry it. send_gate_sct is the trainer's own _sim_now() sampled + right before the gate check (same trace-time-basis clock T3.2's + avail_change.sim_now uses); send_gate_wait_s is the wall-time actually + spent blocked in the loop (0.0 when the gate never engaged). Always None + in sim mode (the gate is a real-mode-only mechanism). """ return EVENT_TASK_SEND, { "round": round_num, @@ -274,6 +308,8 @@ def build_task_send( "wall_recv_ts": wall_recv_ts, "wall_send_ts": wall_send_ts, "time_mode": time_mode, + "send_gate_wait_s": send_gate_wait_s, + "send_gate_sct": send_gate_sct, } @@ -377,6 +413,7 @@ def build_utility_belief( actual: Optional[float], staleness: Optional[int] = None, time_mode: Optional[str] = None, + extra: Optional[dict[str, Any]] = None, ) -> tuple[str, dict[str, Any]]: """Believed-vs-actual client statistical utility, per returning trainer. @@ -400,4 +437,115 @@ def build_utility_belief( fields["staleness"] = staleness if time_mode is not None: fields["time_mode"] = time_mode + if extra: + fields.update(extra) return EVENT_UTILITY_BELIEF, fields + + +def build_withheld_delivery( + *, + round_num: int, + end_id: str, + sct: float, + delivery_ts: float, + staleness: Optional[int] = None, + accepted: Optional[bool] = None, + time_mode: str = "sim", + actual_commit_ts: Optional[float] = None, +) -> tuple[str, dict[str, Any]]: + """A send-gated update committing late (stale) at its ``delivery_ts``. + + ``delivery_ts − sct`` is the down-window delay the completed update waited + while its trainer was ``UN_AVL`` (the compute-completes / gate-the-send / + deliver-late model). ``staleness`` = the current round minus the update's + ``MODEL_VERSION``; ``accepted`` records the staleness-gate outcome (async + fedbuff always accepts; sync feddance may reject over tolerance — Stage E). + Backs the ``withheld_delivery`` parity rung. + + actual_commit_ts (Batch 3 T3.5, K11): the aggregator's own clock + (``_avail_now()`` — vclock in sim, wall-elapsed in real) sampled at the + instant this update actually commits, i.e. AFTER the caller's + ``_advance_sim_clock``/equivalent for this specific update, not before — + the whole point is to catch reinjection-polling lag between ``delivery_ts`` + (the earliest legal commit time — already exactly what ``delivery_ts`` is, + no separate ``earliest_legally_committable_time`` bookkeeping needed for + this single-gate-type v1) and when the update actually lands. + ``commit_slack_s = actual_commit_ts - delivery_ts`` is derived by the + caller-facing K11 check, not stored here, to keep this builder a thin + field-carrier like its siblings. + """ + fields: dict[str, Any] = { + "round": round_num, + "end_id": end_id, + "sct": sct, + "delivery_ts": delivery_ts, + "delay_s": float(delivery_ts) - float(sct), + "time_mode": time_mode, + } + if staleness is not None: + fields["staleness"] = staleness + if accepted is not None: + fields["accepted"] = accepted + if actual_commit_ts is not None: + fields["actual_commit_ts"] = float(actual_commit_ts) + return EVENT_WITHHELD_DELIVERY, fields + + +def build_abandon_timeout( + *, + round_num: int, + end_id: str, + sim_send_ts: float, + vclock_now: float, + time_mode: str = "sim", + reason: str = "abandon_90s_vclock", +) -> tuple[str, dict[str, Any]]: + """A stalled in-flight trainer freed by a slot-free trigger. + + ``reason`` distinguishes C.3 90s-vclock abandons from D.1 aware boundary + evictions. ``vclock_now − sim_send_ts`` is the in-flight age at trigger. + Backs the ``abandon_timeout`` parity rung, which fails loudly if the + deadline is measured on the wall instead of the vclock. + """ + return EVENT_ABANDON_TIMEOUT, { + "round": round_num, + "end_id": end_id, + "sim_send_ts": sim_send_ts, + "vclock_now": vclock_now, + "age_s": float(vclock_now) - float(sim_send_ts), + "time_mode": time_mode, + "reason": reason, + } + + +def build_agg_belief_change( + *, + round_num: int, + end_id: str, + state: str, + observed_at: float, + checkpoint: str, + source: str = "trace_read", +) -> tuple[str, dict[str, Any]]: + """The aggregator's belief about `end_id`'s availability state (Batch 3 T3.3). + + ``checkpoint`` distinguishes WHERE the aggregator's view was read: + ``"selection"`` (pre-round eligibility read) or ``"commit"`` (state at an + update's completion time, whether or not the mechanism actually gates on + it — real mode never gates here, sim's send-gate does; recording both + lets A7 compare the aggregator's belief against ground truth regardless). + ``source`` is the knowledge MECHANISM the belief came from — ``trace_read`` + (v1, live) today, ``client_notify``/``predictive`` later (Stage H) — kept + mechanism-agnostic so a future populator just passes a different source + without any telemetry/checker/plot change. ``observed_at`` is the + trace-time-basis clock (vclock seconds / wall-elapsed since the shared + origin) at which the belief was read, NOT the record's own wall ``ts``. + """ + return EVENT_AGG_BELIEF_CHANGE, { + "round": round_num, + "end_id": end_id, + "state": state, + "observed_at": observed_at, + "checkpoint": checkpoint, + "source": source, + } diff --git a/lib/python/setup.py b/lib/python/setup.py index 3371118c4..5010464a0 100644 --- a/lib/python/setup.py +++ b/lib/python/setup.py @@ -39,12 +39,32 @@ "zstandard", ], extras_require={ - # Runtime deps for examples// workloads (torch + utilities). + # Runtime deps for examples// workloads. Installing this one extra + # is enough to run the smoke tests for BOTH the vision examples + # (async_cifar10, ...) and the NLP forward-mode examples (fwdllm). "examples": [ + # --- Shared (vision + speech + NLP) --- + # On CUDA driver >= 12.9 use setup_env.sh (force-reinstalls torch + # from the cu126 index) instead of a bare `pip install -e .[examples]`. "torch", "torchvision", + "torchaudio", # async_google_speech (audio feature extraction) "sortedcontainers", "wandb", + # --- fwdllm: DistilBERT forward-mode FL on agnews --- + # Modern mainline `transformers` + the standalone `adapters` add-on + # (the maintained successor to the un-buildable `adapter-transformers` + # fork; both ship prebuilt wheels, so no Rust/tokenizers compile). + # `adapters` pins `transformers` in lockstep (1.3.x requires + # transformers ~=4.57.6), so they are versioned together here. + # Verified set: transformers 4.57.6 / adapters 1.3.0 / tokenizers + # 0.22.2 / h5py 3.16.0 on torch 2.x + numpy 2.x + py3.11. + "transformers>=4.57,<4.58", + "adapters>=1.3,<1.4", + "h5py>=3", + "pandas>=2", + "scikit-learn>=1.3", + "setproctitle", ], "dev": [ "pytest", diff --git a/lib/python/tests/analysis/test_manifest.py b/lib/python/tests/analysis/test_manifest.py new file mode 100644 index 000000000..9daa07520 --- /dev/null +++ b/lib/python/tests/analysis/test_manifest.py @@ -0,0 +1,138 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Regression coverage for analyze_run.py's per-example telemetry manifest +(P5.4): _find_manifest_path(), load_manifest(), configure_from_manifest(). + +A manifest is optional -- an example with no telemetry_manifest.yaml (e.g. +async_cifar10) must fall back to the pre-manifest defaults (hardcoded +MODEL_PARAM_COUNT, fwdllm-shaped _DEFAULT_PROGRESS_HIERARCHY) unchanged. A +malformed manifest must not crash analysis. --model-params on the CLI must +never be clobbered by a manifest's model_param_count. +""" + +import os +import sys + +import pytest +import yaml + +sys.path.insert( + 0, + os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "..", + "scripts", "analysis"), +) + +import analyze_run as ar # noqa: E402 + + +@pytest.fixture(autouse=True) +def _restore_module_globals(): + """configure_from_manifest() mutates module-level globals that other + tests (e.g. test_progress_key.py) rely on being at their defaults -- + snapshot and restore around every test in this file.""" + saved = (ar.MODEL_PARAM_COUNT, ar.MODEL_MB, list(ar._PROGRESS_HIERARCHY), + ar._MODEL_PARAMS_CLI_OVERRIDDEN) + yield + (ar.MODEL_PARAM_COUNT, ar.MODEL_MB, ar._PROGRESS_HIERARCHY, + ar._MODEL_PARAMS_CLI_OVERRIDDEN) = saved + + +def _make_example(tmp_path, name, manifest_yaml=None): + """Build a .../examples//experiments//telemetry dir, optionally + with a telemetry_manifest.yaml next to `experiments/` (matching fwdllm's + real on-disk layout).""" + example_dir = tmp_path / "examples" / name + telemetry_dir = example_dir / "experiments" / "run_x" / "telemetry" + telemetry_dir.mkdir(parents=True) + if manifest_yaml is not None: + (example_dir / "telemetry_manifest.yaml").write_text(manifest_yaml) + return str(telemetry_dir) + + +FWDLLM_MANIFEST = """ +model_param_count: 450340 +progress_hierarchy: + - field: data_id + bound: 150 + - field: iteration_per_data_id + bound: 15 +""" + + +def test_find_manifest_path_locates_manifest_next_to_examples_root(tmp_path): + telemetry_dir = _make_example(tmp_path, "fwdllm", manifest_yaml=FWDLLM_MANIFEST) + found = ar._find_manifest_path(telemetry_dir) + assert found == os.path.join(tmp_path, "examples", "fwdllm", "telemetry_manifest.yaml") + + +def test_find_manifest_path_returns_none_when_absent(tmp_path): + """An example with no manifest (e.g. async_cifar10) -- absence is not an + error, just "use defaults".""" + telemetry_dir = _make_example(tmp_path, "async_cifar10", manifest_yaml=None) + assert ar._find_manifest_path(telemetry_dir) is None + + +def test_find_manifest_path_returns_none_outside_any_examples_root(tmp_path): + stray_dir = tmp_path / "not_an_example" / "telemetry" + stray_dir.mkdir(parents=True) + assert ar._find_manifest_path(str(stray_dir)) is None + + +def test_load_manifest_parses_declared_fields(tmp_path): + telemetry_dir = _make_example(tmp_path, "fwdllm", manifest_yaml=FWDLLM_MANIFEST) + manifest = ar.load_manifest(telemetry_dir) + assert manifest["model_param_count"] == 450340 + assert manifest["progress_hierarchy"] == [ + {"field": "data_id", "bound": 150}, + {"field": "iteration_per_data_id", "bound": 15}, + ] + + +def test_load_manifest_returns_none_when_absent(tmp_path): + telemetry_dir = _make_example(tmp_path, "async_cifar10", manifest_yaml=None) + assert ar.load_manifest(telemetry_dir) is None + + +def test_load_manifest_malformed_yaml_does_not_crash(tmp_path, capsys): + telemetry_dir = _make_example(tmp_path, "broken", manifest_yaml="{not: valid: yaml: [") + assert ar.load_manifest(telemetry_dir) is None + assert "warning" in capsys.readouterr().out + + +def test_configure_from_manifest_sets_globals_from_fwdllm_manifest(tmp_path): + telemetry_dir = _make_example(tmp_path, "fwdllm", manifest_yaml=FWDLLM_MANIFEST) + ar._MODEL_PARAMS_CLI_OVERRIDDEN = False + manifest = ar.configure_from_manifest(telemetry_dir) + assert manifest is not None + assert ar.MODEL_PARAM_COUNT == 450340 + assert ar.MODEL_MB == pytest.approx(450340 * 4 / 1e6) + assert ar._PROGRESS_HIERARCHY == [ + {"field": "data_id", "bound": 150}, + {"field": "iteration_per_data_id", "bound": 15}, + ] + + +def test_configure_from_manifest_falls_back_to_defaults_when_absent(tmp_path): + telemetry_dir = _make_example(tmp_path, "async_cifar10", manifest_yaml=None) + ar.MODEL_PARAM_COUNT = 999 # simulate a leftover value from a prior run + ar._MODEL_PARAMS_CLI_OVERRIDDEN = False + manifest = ar.configure_from_manifest(telemetry_dir) + assert manifest is None + assert ar.MODEL_PARAM_COUNT == 999 # untouched -- no manifest to apply + assert ar._PROGRESS_HIERARCHY == ar._DEFAULT_PROGRESS_HIERARCHY + + +def test_configure_from_manifest_respects_cli_override_guard(tmp_path): + """--model-params on the CLI must win over a manifest's model_param_count + (main() sets _MODEL_PARAMS_CLI_OVERRIDDEN=True before analyze() runs).""" + telemetry_dir = _make_example(tmp_path, "fwdllm", manifest_yaml=FWDLLM_MANIFEST) + ar.MODEL_PARAM_COUNT = 123456 + ar.MODEL_MB = 123456 * 4 / 1e6 + ar._MODEL_PARAMS_CLI_OVERRIDDEN = True + manifest = ar.configure_from_manifest(telemetry_dir) + assert manifest is not None # still loaded, for progress_hierarchy/event_categories + assert ar.MODEL_PARAM_COUNT == 123456 # not clobbered + assert ar._PROGRESS_HIERARCHY == [ + {"field": "data_id", "bound": 150}, + {"field": "iteration_per_data_id", "bound": 15}, + ] # progress_hierarchy still applies -- the CLI flag only guards model size diff --git a/lib/python/tests/analysis/test_progress_key.py b/lib/python/tests/analysis/test_progress_key.py new file mode 100644 index 000000000..45c34fc18 --- /dev/null +++ b/lib/python/tests/analysis/test_progress_key.py @@ -0,0 +1,69 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Regression coverage for analyze_run.py's progress_key() round-collapse fix. + +fwdllm-family runs can sit at trainer_round.round == 1 for hundreds of events +(a round only completes once all data bins finish), which collapsed any +analyzer plot bucketing by plain `round` onto a single x-value. progress_key() +folds in `data_id` (present on trainer_round records only) to restore a real +ordering, while staying a no-op for async_cifar10 (no `data_id` field). +""" + +import os +import sys + +sys.path.insert( + 0, + os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "..", + "scripts", "analysis"), +) + +from analyze_run import progress_key, trainer_rounds_by_round # noqa: E402 + + +def test_no_data_id_falls_back_to_plain_round(): + """async_cifar10 trainer_round records carry no data_id -- no-op.""" + assert progress_key({"round": 7}) == 7 + assert progress_key({"round": 0}) == 0 + + +def test_data_id_folds_into_round_major_ordering(): + """fwdllm trainer_round records: round is major, data_id is minor.""" + assert progress_key({"round": 1, "data_id": 0}) == 200 + assert progress_key({"round": 1, "data_id": 50}) == 250 + assert progress_key({"round": 2, "data_id": 0}) == 400 + + +def test_data_id_ordering_never_collides_across_rounds(): + """A later round's earliest data_id must sort after an earlier round's + latest data_id -- this is only guaranteed because the multiplier (200) + exceeds fwdllm's total_data_bins (150).""" + end_of_round_1 = progress_key({"round": 1, "data_id": 149}) + start_of_round_2 = progress_key({"round": 2, "data_id": 0}) + assert end_of_round_1 < start_of_round_2 + + +def test_fwdllm_round_collapse_is_fixed(): + """The concrete bug: 733 events all at round==1 collapse to one bucket + under plain round, but spread out under progress_key because data_id + varies 0..50 across them.""" + records = [ + {"event": "trainer_round", "round": 1, "data_id": data_id} + for data_id in range(51) + for _ in range(14) # ~733 events total, matching the real run's scale + ] + plain_rounds = {r["round"] for r in records} + assert len(plain_rounds) == 1 # the collapse, reproduced + + trbr = trainer_rounds_by_round(records) + assert len(trbr) == 51 # progress_key fixes it + + +def test_trainer_rounds_by_round_ignores_non_trainer_round_events(): + records = [ + {"event": "trainer_round", "round": 1, "data_id": 0}, + {"event": "selection", "round": 1}, + ] + trbr = trainer_rounds_by_round(records) + assert list(trbr.keys()) == [200] + assert len(trbr[200]) == 1 diff --git a/lib/python/tests/analysis/test_progress_key_wiring.py b/lib/python/tests/analysis/test_progress_key_wiring.py new file mode 100644 index 000000000..13f5a05c7 --- /dev/null +++ b/lib/python/tests/analysis/test_progress_key_wiring.py @@ -0,0 +1,147 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Regression coverage for wiring progress_key() into accuracy_by_round/ +loss_by_round/cumulative_comm_by_round (see +../../examples/MIGRATING_TO_LAUNCHER.md §5's manifest/progress_key +mechanism). fwdllm's `round` can sit at 1 for an entire run (round only +advances once all data bins finish), which previously collapsed every +agg_eval/selection event onto one x-value for these three functions +specifically. async_cifar10 records carry no data_id, so progress_key() +is a no-op there -- these tests must not change its behavior. +""" + +import os +import sys + +import pytest + +sys.path.insert( + 0, + os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "..", "..", + "scripts", "analysis"), +) + +import analyze_run as ar # noqa: E402 + + +@pytest.fixture(autouse=True) +def _restore_module_globals(): + saved = list(ar._PROGRESS_HIERARCHY) + yield + ar._PROGRESS_HIERARCHY = saved + + +def _use_fwdllm_hierarchy(): + """Matches lib/python/examples/fwdllm/telemetry_manifest.yaml's declared + hierarchy, without needing a manifest file on disk.""" + ar._PROGRESS_HIERARCHY = [ + {"field": "data_id", "bound": 150}, + {"field": "iteration_per_data_id", "bound": 15}, + ] + + +class TestAccuracyLossByRoundFolding: + def test_async_cifar10_no_data_id_unchanged(self): + records = [ + {"event": "agg_eval", "round": 1, "test-accuracy": 0.5}, + {"event": "agg_eval", "round": 2, "test-accuracy": 0.6}, + ] + acc = ar.accuracy_by_round(records) + assert acc == {1: 0.5, 2: 0.6} + + def test_fwdllm_collapse_is_fixed(self): + """The concrete bug: 30 agg_eval events all at round==1 (data_id + advancing 0..29) collapsed onto one bucket under plain round.""" + _use_fwdllm_hierarchy() + records = [ + {"event": "agg_eval", "round": 1, "data_id": i, + "iteration_per_data_id": 0, "test-accuracy": 0.5 + i * 0.01} + for i in range(30) + ] + acc = ar.accuracy_by_round(records) + assert len(acc) == 30 # was 1 under plain round + + def test_loss_by_round_same_fold(self): + _use_fwdllm_hierarchy() + records = [ + {"event": "agg_eval", "round": 1, "data_id": i, + "iteration_per_data_id": 0, "test-loss": 1.0 - i * 0.01} + for i in range(5) + ] + assert len(ar.loss_by_round(records)) == 5 + + +class TestCumulativeCommByRoundFolding: + def test_async_cifar10_no_data_id_unchanged(self): + records = [ + {"event": "selection", "round": 1, "task": "train", "chosen": ["a", "b"]}, + {"event": "selection", "round": 2, "task": "train", "chosen": ["a"]}, + ] + rounds, cum = ar.cumulative_comm_by_round(records) + assert rounds == [1, 2] + assert cum[0] < cum[1] # monotonically increasing + + def test_fwdllm_selection_events_fold_data_id(self): + """Real aggregator-side selection events (selector/random.py, P5.6) + carry data_id/iteration_per_data_id when the aggregator threads + agg_version_state through channel.ends() -- must spread across + distinct buckets instead of collapsing onto round==1.""" + _use_fwdllm_hierarchy() + records = [ + {"event": "selection", "round": 1, "task": "train", "chosen": ["a"], + "data_id": i, "iteration_per_data_id": 0} + for i in range(10) + ] + rounds, cum = ar.cumulative_comm_by_round(records) + assert len(rounds) == 10 + + def test_mixed_folded_and_plain_events_dont_collide(self): + """Trainer-side placeholder-selector events (P5.1) don't carry + data_id and degrade to a plain-round key; must coexist with the + far-larger folded keys from real aggregator-side events without + overwriting each other.""" + _use_fwdllm_hierarchy() + records = [ + # real aggregator-side event, folded key + {"event": "selection", "round": 1, "task": "train", "chosen": ["a"], + "data_id": 0, "iteration_per_data_id": 0}, + # trainer-side placeholder event, no data_id -> plain round key (1) + {"event": "selection", "round": 1, "task": "train", "chosen": ["agg1"]}, + ] + rounds, cum = ar.cumulative_comm_by_round(records) + assert len(rounds) == 2 # both buckets present, no collision + assert len(cum) == 2 + + def test_round_zero_warmup_still_excluded(self): + """The round-0 exclusion is checked on the raw round field, not + progress_key -- must still exclude genuine pre-training warmup even + though data_id is folded into the bucket key.""" + _use_fwdllm_hierarchy() + records = [ + {"event": "selection", "round": 0, "task": "train", "chosen": ["a"] * 100, + "data_id": 0, "iteration_per_data_id": 0}, + {"event": "selection", "round": 1, "task": "train", "chosen": ["a"], + "data_id": 0, "iteration_per_data_id": 0}, + ] + rounds, cum = ar.cumulative_comm_by_round(records) + assert len(rounds) == 1 # only the round>=1 event counted + + +class TestCommVsAccuracySeries: + def test_fwdllm_join_stays_consistent_after_folding(self): + """Both accuracy_by_round and cumulative_comm_by_round now key by + progress_key -- the <= cumulative join in comm_vs_accuracy_series + must still line up (same axis on both sides) and produce one point + per real eval, not one collapsed point.""" + _use_fwdllm_hierarchy() + records = [] + for i in range(5): + records.append({"event": "selection", "round": 1, "task": "train", + "chosen": ["a"], "data_id": i, "iteration_per_data_id": 0}) + records.append({"event": "agg_eval", "round": 1, "data_id": i, + "iteration_per_data_id": 0, "test-accuracy": 0.5 + i * 0.05}) + xs, ys = ar.comm_vs_accuracy_series(records) + assert len(xs) == 5 + assert len(ys) == 5 + # comm is cumulative -- non-decreasing as accuracy points advance + assert xs == sorted(xs) diff --git a/lib/python/tests/availability/test_agg_belief.py b/lib/python/tests/availability/test_agg_belief.py new file mode 100644 index 000000000..18a6ed9e0 --- /dev/null +++ b/lib/python/tests/availability/test_agg_belief.py @@ -0,0 +1,188 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Batch 3 T3.3 — aggregator belief-tracking hooks on ClientAvailability. + +_record_avail_belief / _record_commit_belief are mechanism-agnostic telemetry +hooks (agg_belief_change), not behavior — these tests assert the emission +schema and the commit-checkpoint gate-off/no-trace no-ops, plus that +_sim_withhold_if_unavail (the sim commit checkpoint) calls through to it. +""" + +import json + +import pytest +from sortedcontainers import SortedDict + +from flame import telemetry +from flame.availability.client_availability import ClientAvailability +from flame.telemetry.events import EVENT_AGG_BELIEF_CHANGE, build_agg_belief_change + + +@pytest.fixture(autouse=True) +def _reset_telemetry(): + telemetry.shutdown() + yield + telemetry.shutdown() + + +def _trace(*pairs): + d = SortedDict() + for ts, state in pairs: + d[float(ts)] = state + return d + + +class _Harness(ClientAvailability): + def __init__(self, trainer_event_dict=None, now=0.0, simulated=True): + self.trainer_event_dict = trainer_event_dict + self.pending_withheld = {} + self._sim_withheld_payload = {} + self._sim_withheld_delivering = {} + self._now = now + self.simulated = simulated + self._round = 3 + + def _avail_now(self): + return self._now + + +# --------------------------------------------------------------------------- +# build_agg_belief_change schema +# --------------------------------------------------------------------------- + +def test_build_agg_belief_change_schema(): + ev, f = build_agg_belief_change( + round_num=5, end_id="t1", state="UN_AVL", observed_at=120.0, + checkpoint="commit", source="trace_read", + ) + assert ev == EVENT_AGG_BELIEF_CHANGE + for key in ("round", "end_id", "state", "observed_at", "checkpoint", "source"): + assert key in f + assert f["checkpoint"] == "commit" + assert f["source"] == "trace_read" + + +# --------------------------------------------------------------------------- +# _record_avail_belief +# --------------------------------------------------------------------------- + +def test_record_avail_belief_noop_when_telemetry_disabled(): + h = _Harness() + h._record_avail_belief("t1", "AVL_TRAIN", observed_at=0.0, checkpoint="selection") + # No exception, no writer configured -- nothing to assert beyond "didn't crash". + + +def test_record_avail_belief_emits_when_enabled(tmp_path): + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + h = _Harness() + h._record_avail_belief("t1", "UN_AVL", observed_at=42.0, checkpoint="commit", + source="trace_read") + telemetry.shutdown() + path = tmp_path / "aggregator.jsonl" + lines = [json.loads(l) for l in path.read_text().splitlines() if l.strip()] + belief = [l for l in lines if l["event"] == EVENT_AGG_BELIEF_CHANGE] + assert len(belief) == 1 + assert belief[0]["end_id"] == "t1" + assert belief[0]["state"] == "UN_AVL" + assert belief[0]["observed_at"] == 42.0 + assert belief[0]["checkpoint"] == "commit" + assert belief[0]["round"] == 3 + + +# --------------------------------------------------------------------------- +# _record_commit_belief +# --------------------------------------------------------------------------- + +def test_record_commit_belief_noop_gate_off(tmp_path): + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + h = _Harness(trainer_event_dict=None) + h._record_commit_belief("t1", sct=100.0) + telemetry.shutdown() + lines = (tmp_path / "aggregator.jsonl").read_text().splitlines() + assert not any(json.loads(l)["event"] == EVENT_AGG_BELIEF_CHANGE for l in lines if l.strip()) + + +def test_record_commit_belief_noop_missing_trace(tmp_path): + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + h = _Harness(trainer_event_dict={"t2": _trace((0, "AVL_TRAIN"))}) + h._record_commit_belief("t1", sct=100.0) # t1 not in trainer_event_dict + telemetry.shutdown() + lines = (tmp_path / "aggregator.jsonl").read_text().splitlines() + assert not any(json.loads(l)["event"] == EVENT_AGG_BELIEF_CHANGE for l in lines if l.strip()) + + +def test_record_commit_belief_reads_state_at_sct(tmp_path): + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + trace = _trace((0, "AVL_TRAIN"), (600, "UN_AVL")) + h = _Harness(trainer_event_dict={"t1": trace}) + h._record_commit_belief("t1", sct=700.0) # after the 600s transition + telemetry.shutdown() + lines = [json.loads(l) for l in (tmp_path / "aggregator.jsonl").read_text().splitlines() if l.strip()] + belief = [l for l in lines if l["event"] == EVENT_AGG_BELIEF_CHANGE][0] + assert belief["state"] == "UN_AVL" + assert belief["observed_at"] == 700.0 + assert belief["checkpoint"] == "commit" + + +def test_record_commit_belief_defaults_to_avail_now(tmp_path): + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + trace = _trace((0, "AVL_TRAIN")) + h = _Harness(trainer_event_dict={"t1": trace}, now=55.0) + h._record_commit_belief("t1") # sct=None -> _avail_now() + telemetry.shutdown() + lines = [json.loads(l) for l in (tmp_path / "aggregator.jsonl").read_text().splitlines() if l.strip()] + belief = [l for l in lines if l["event"] == EVENT_AGG_BELIEF_CHANGE][0] + assert belief["observed_at"] == 55.0 + + +# --------------------------------------------------------------------------- +# _sim_withhold_if_unavail calls through to _record_commit_belief +# --------------------------------------------------------------------------- + +def test_sim_withhold_if_unavail_records_commit_belief(monkeypatch): + h = _Harness(trainer_event_dict={"t1": _trace((0, "AVL_TRAIN"))}) + calls = [] + monkeypatch.setattr(h, "_record_commit_belief", lambda end, sct=None: calls.append((end, sct))) + # Available the whole time -> gate returns False (commits now), but the + # belief must still have been recorded before that decision. + result = h._sim_withhold_if_unavail(channel=None, end="t1", sct=10.0, msgmd=None) + assert result is False + assert calls == [("t1", 10.0)] + + +def test_sim_withhold_if_unavail_gate_off_never_records_belief(monkeypatch): + h = _Harness(trainer_event_dict=None) + calls = [] + monkeypatch.setattr(h, "_record_commit_belief", lambda end, sct=None: calls.append((end, sct))) + result = h._sim_withhold_if_unavail(channel=None, end="t1", sct=10.0, msgmd=None) + assert result is False + assert calls == [] + + +# --------------------------------------------------------------------------- +# _emit_withheld_delivery (Batch 3 T3.5 — K11 commit_promptness) +# --------------------------------------------------------------------------- + +def test_emit_withheld_delivery_stamps_actual_commit_ts(tmp_path): + """actual_commit_ts must reflect the CALLER's clock at emission time + (_avail_now(), sampled fresh -- not orig_sct/delivery_ts, which are just + passed through). The caller is responsible for advancing its clock for + THIS commit before calling (see syncfl/oort top_aggregator.py's Batch 3 + T3.5 reorder) -- this test only asserts the harness's current _avail_now() + ends up on the emitted event, not the reorder itself (that's covered by + the existing top_aggregator withheld-commit-loop tests continuing to pass + unchanged, since the reorder touches only telemetry timing, not state).""" + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + h = _Harness(now=305.5) + h._emit_withheld_delivery("t1", {}, orig_sct=100.0, delivery_ts=300.0) + telemetry.shutdown() + lines = [json.loads(l) for l in (tmp_path / "aggregator.jsonl").read_text().splitlines() if l.strip()] + ev = [l for l in lines if l["event"] == "withheld_delivery"][0] + assert ev["sct"] == 100.0 + assert ev["delivery_ts"] == 300.0 + assert ev["actual_commit_ts"] == 305.5 + + +def test_emit_withheld_delivery_noop_when_telemetry_disabled(): + h = _Harness(now=100.0) + h._emit_withheld_delivery("t1", {}, orig_sct=0.0, delivery_ts=50.0) # must not raise diff --git a/lib/python/tests/availability/test_delivery_ledger.py b/lib/python/tests/availability/test_delivery_ledger.py new file mode 100644 index 000000000..22742bee2 --- /dev/null +++ b/lib/python/tests/availability/test_delivery_ledger.py @@ -0,0 +1,150 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Stage C substrate: delivery ledger + slot-free hook on ClientAvailability. + +These exercise the pure delivery-ledger logic (compute_delivery_ts, the +pending_withheld ordering/residence/commit helpers, and free_stalled_slot's +two-ledger effect) in isolation from the full sim aggregator. They assert the +three Stage C correctness invariants at the substrate level: + 1. no double-count / slot freed exactly once, + 2. a still-down trainer is excluded until its delivery_ts (never re-selected), + 3. withheld delivery commits in delivery_ts order (no past-dating). +And the gate-off no-op that preserves byte-identity. +""" + +from sortedcontainers import SortedDict + +from flame.availability.client_availability import ClientAvailability + + +def _trace(*pairs): + d = SortedDict() + for ts, state in pairs: + d[float(ts)] = state + return d + + +class _FakeSelector: + def __init__(self): + self.requester = "agg" + self.all_selected = {} + self.selected_ends = {"agg": set()} + + +class _FakeEnd: + def __init__(self): + self.props = {} + + def set_property(self, k, v): + self.props[k] = v + + +class _FakeChannel: + def __init__(self, ends): + self._selector = _FakeSelector() + self._ends = {e: _FakeEnd() for e in ends} + + def has(self, end): + return end in self._ends + + +class _Harness(ClientAvailability): + """Minimal mixin host with a controllable clock and gate state.""" + + def __init__(self, trainer_event_dict=None, now=0.0): + self.trainer_event_dict = trainer_event_dict + self.pending_withheld = {} + self._now = now + + def _avail_now(self): # override the vclock/wall source + return self._now + + +# down window: [100, 200); recovers (AVL_TRAIN) at 200. +_DOWN = _trace((0, "AVL_TRAIN"), (100, "UN_AVL"), (200, "AVL_TRAIN")) + + +def test_compute_delivery_ts_in_down_window(): + h = _Harness({"t1": _DOWN}, now=130) + # update completed at sct=150 while down; delivers when AVL again (200). + assert h.compute_delivery_ts("t1", sct=150) == 200.0 + + +def test_compute_delivery_ts_clamped_to_sct(): + # next_avail (200) is earlier than a late sct (260): delivery cannot + # precede completion, so delivery_ts = sct. + h = _Harness({"t1": _DOWN}, now=130) + assert h.compute_delivery_ts("t1", sct=260) == 260.0 + + +def test_compute_delivery_ts_never_recovers_is_inf(): + never = _trace((0, "AVL_TRAIN"), (100, "UN_AVL")) + h = _Harness({"t1": never}, now=130) + assert h.compute_delivery_ts("t1", sct=150) == float("inf") + + +def test_compute_delivery_ts_gate_off_returns_sct(): + h = _Harness(trainer_event_dict=None, now=130) + assert h.compute_delivery_ts("t1", sct=150) == 150.0 + + +def test_free_stalled_slot_frees_slot_and_registers_delivery(): + h = _Harness({"t1": _DOWN}, now=150) + ch = _FakeChannel(["t1"]) + ch._selector.all_selected["t1"] = 12345.0 + ch._selector.selected_ends["agg"].add("t1") + + dts = h.free_stalled_slot(ch, "t1", reason="abandon_90s", sct=150) + + assert dts == 200.0 + # slot ledger: released + assert "t1" not in ch._selector.all_selected + assert "t1" not in ch._selector.selected_ends["agg"] + assert ch._ends["t1"].props["state"] == "none" + # delivery ledger: registered + assert h.pending_withheld == {"t1": 200.0} + + +def test_free_stalled_slot_gate_off_is_noop(): + h = _Harness(trainer_event_dict=None, now=150) + ch = _FakeChannel(["t1"]) + ch._selector.all_selected["t1"] = 12345.0 + assert h.free_stalled_slot(ch, "t1", reason="x", sct=150) is None + # nothing freed, nothing registered (byte-identity preserved) + assert ch._selector.all_selected == {"t1": 12345.0} + assert h.pending_withheld == {} + + +def test_withheld_held_ends_excludes_until_delivery(): + h = _Harness({"t1": _DOWN}, now=150) + h.pending_withheld = {"t1": 200.0, "t2": 180.0} + # before either delivery_ts: both held (invariant 2) + h._now = 170 + assert h.withheld_held_ends() == {"t1", "t2"} + # past t2's delivery_ts: only t1 still held + h._now = 190 + assert h.withheld_held_ends() == {"t1"} + # past both: none held + h._now = 250 + assert h.withheld_held_ends() == set() + + +def test_ready_withheld_orders_by_delivery_ts_then_id(): + h = _Harness({"t1": _DOWN}, now=300) + h.pending_withheld = {"t3": 200.0, "t1": 200.0, "t2": 150.0} + # all due at now=300; order by (delivery_ts, end_id): t2,150 < t1,200 < t3,200 + assert h.ready_withheld() == [("t2", 150.0), ("t1", 200.0), ("t3", 200.0)] + + +def test_ready_withheld_excludes_future(): + h = _Harness({"t1": _DOWN}, now=190) + h.pending_withheld = {"t1": 200.0, "t2": 150.0} + assert h.ready_withheld() == [("t2", 150.0)] + + +def test_commit_withheld_pops(): + h = _Harness({"t1": _DOWN}, now=200) + h.pending_withheld = {"t1": 200.0} + assert h.commit_withheld("t1") == 200.0 + assert h.pending_withheld == {} + assert h.commit_withheld("t1") is None # idempotent: no double-count diff --git a/lib/python/tests/availability/test_live_wiring.py b/lib/python/tests/availability/test_live_wiring.py new file mode 100644 index 000000000..359cf8db2 --- /dev/null +++ b/lib/python/tests/availability/test_live_wiring.py @@ -0,0 +1,545 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Stage C live-wiring: the shared commit-loop primitives in ClientAvailability. + +The send-gate withhold / late re-commit / vclock-abandon EFFECT is library-level +(both the asyncfl _sim_recv_min pop site and the oort _sim_drain_buffer pop loop +call the same mixin methods). These exercise that shared core directly against a +real SimReorderBuffer and both selector shapes: + + * asyncfl selectors: selected_ends = dict[requester -> set], plus all_selected + * oort/refl/feddance: selected_ends = flat set, no all_selected + +They assert the three Stage C invariants at the wiring level: + 1. no double-count — an abandoned-then-arrived update commits exactly once, + 2. a still-down trainer is excluded until delivery_ts (held in the ledger), + 3. withheld delivery re-injects in delivery_ts order (no past-dating). +Plus the gate-off byte-identity no-op and the Challenge-7 composition contract +(why oort must gate carry-over BEFORE the send-gate). +""" + +import math + +from sortedcontainers import SortedDict + +from flame.availability.client_availability import ClientAvailability +from flame.config import TrainerAvailState +from flame.selector.properties import PROP_AVL_STATE, PROP_SIM_SEND_TS +from flame.sim import SimReorderBuffer + + +def _trace(*pairs): + d = SortedDict() + for ts, state in pairs: + d[float(ts)] = state + return d + + +# down window [100,200); recovers (AVL_TRAIN) at 200. +_DOWN = _trace((0, "AVL_TRAIN"), (100, "UN_AVL"), (200, "AVL_TRAIN")) +# late down window [300,400); used for future-sct composition. +_LATE_DOWN = _trace((0, "AVL_TRAIN"), (300, "UN_AVL"), (400, "AVL_TRAIN")) +# never recovers after going down. +_NEVER = _trace((0, "AVL_TRAIN"), (100, "UN_AVL")) + + +class _FakeEnd: + def __init__(self): + self.props = {} + + def set_property(self, k, v): + self.props[k] = v + + def get_property(self, k): + return self.props.get(k) + + +class _AsyncSelector: + """fedbuff/async_oort shape: dict-by-requester + all_selected.""" + + def __init__(self): + self.requester = "agg" + self.all_selected = {} + self.selected_ends = {"agg": set()} + + def add(self, end): + self.all_selected[end] = 0.0 + self.selected_ends["agg"].add(end) + + def holds(self, end): + return end in self.selected_ends["agg"] + + +class _OortSelector: + """oort/refl/feddance shape: flat set, no all_selected.""" + + def __init__(self): + self.selected_ends = set() + + def add(self, end): + self.selected_ends.add(end) + + def holds(self, end): + return end in self.selected_ends + + +class _Channel: + def __init__(self, selector, ends): + self._selector = selector + self._ends = {e: _FakeEnd() for e in ends} + self._props = {} + + def has(self, end): + return end in self._ends + + def get_end_property(self, end, key): + return self._props.get((end, key)) + + def set_end_property(self, end, key, value): + self._props[(end, key)] = value + + +class _Harness(ClientAvailability): + """Minimal mixin host with a controllable clock + a real reorder buffer.""" + + def __init__(self, trainer_event_dict=None, now=0.0, inflight_tracker=False): + self.trainer_event_dict = trainer_event_dict + # Mirrors _init_availability's derivation (production sets this once at + # load time, not per-call) — kept in sync here so harness tests exercise + # the same guard real runs do. + self._trace_has_avl_eval = bool(trainer_event_dict) and any( + TrainerAvailState.AVL_EVAL in trace.values() + for trace in trainer_event_dict.values() + ) + self.pending_withheld = {} + self._sim_withheld_payload = {} + self._sim_withheld_delivering = {} + self._sim_buffer = SimReorderBuffer() + self._sim_committed = set() + self._round = 5 + self._now = now + # asyncfl tracks an in-flight gate dict; oort does not. + if inflight_tracker: + self._sim_inflight_expected = {} + + def _avail_now(self): + return self._now + + +def _payload(tag): + # opaque to the helpers (only telemetry reads MODEL_VERSION, off in tests). + return ({"tag": tag}, (tag, None)) + + +# --------------------------------------------------------------------------- +# _sim_withhold_if_unavail — the shared per-update send-gate primitive +# --------------------------------------------------------------------------- + +def test_withhold_if_unavail_holds_unavailable_at_sct(): + h = _Harness({"t1": _DOWN}, now=130, inflight_tracker=True) + sel = _AsyncSelector(); sel.add("t1") + ch = _Channel(sel, ["t1"]) + h._sim_inflight_expected["t1"] = 999.0 + p = _payload("t1") + + # completed at sct=150 while UN_AVL -> held, slot freed, ledger registered. + assert h._sim_withhold_if_unavail(ch, "t1", 150.0, p) is True + assert h.pending_withheld == {"t1": 200.0} + assert h._sim_withheld_payload["t1"] == (150.0, p) + assert not sel.holds("t1") # slot freed + assert "t1" not in h._sim_inflight_expected # gate tracker cleared + + +def test_withhold_if_unavail_commits_when_available(): + h = _Harness({"t1": _DOWN}, now=260) + sel = _AsyncSelector(); sel.add("t1") + ch = _Channel(sel, ["t1"]) + # sct=260 is past the down window -> available -> committable, no withhold. + assert h._sim_withhold_if_unavail(ch, "t1", 260.0, _payload("t1")) is False + assert h.pending_withheld == {} + + +def test_withhold_if_unavail_gate_off_is_noop(): + h = _Harness(trainer_event_dict=None, now=150) + sel = _AsyncSelector(); sel.add("t1") + ch = _Channel(sel, ["t1"]) + assert h._sim_withhold_if_unavail(ch, "t1", 150.0, _payload("t1")) is False + assert sel.holds("t1") # nothing freed + assert h.pending_withheld == {} + + +def test_withhold_if_unavail_never_recovers_drops_payload(): + h = _Harness({"t1": _NEVER}, now=130) + sel = _OortSelector(); sel.add("t1") + ch = _Channel(sel, ["t1"]) + # undeliverable in-window: slot still freed + ledger registered (inf), but no + # payload stashed (Challenge 10 edge). + assert h._sim_withhold_if_unavail(ch, "t1", 150.0, _payload("t1")) is True + assert h.pending_withheld == {"t1": math.inf} + assert "t1" not in h._sim_withheld_payload + assert not sel.holds("t1") + + +def test_withhold_does_not_consult_round_start(): + # Contract that makes oort's carry-over-first ordering load-bearing + # (Challenge 7): the send-gate is a PURE per-update decision keyed on the + # trainer's state at sct — it would withhold a still-computing future-sct + # UN_AVL straggler if called directly. So the oort loop MUST apply carry-over + # (still-computing) before this, or it would free a slot that is still busy. + h = _Harness({"t1": _LATE_DOWN}, now=50) + sel = _OortSelector(); sel.add("t1") + ch = _Channel(sel, ["t1"]) + # sct=350 is in the future (still computing) AND UN_AVL at 350. + assert h._sim_withhold_if_unavail(ch, "t1", 350.0, _payload("t1")) is True + + +# --------------------------------------------------------------------------- +# _sim_pop_committable — asyncfl loop +# --------------------------------------------------------------------------- + +def test_pop_committable_skips_withheld_returns_next(): + h = _Harness({"t1": _DOWN, "t2": _DOWN}, now=130, inflight_tracker=True) + sel = _AsyncSelector(); sel.add("t1"); sel.add("t2") + ch = _Channel(sel, ["t1", "t2"]) + # t1 completes UN_AVL at 150 (held); t2 completes available at 260 (commit). + h._sim_buffer.add("t1", 150.0, _payload("t1")) + h._sim_buffer.add("t2", 260.0, _payload("t2")) + + popped = h._sim_pop_committable(ch) + assert popped is not None and popped[0] == "t2" + assert "t1" in h.pending_withheld and not sel.holds("t1") + # t2 is the only committable; buffer now empty. + assert h._sim_pop_committable(ch) is None + + +def test_pop_committable_gate_off_single_pop(): + h = _Harness(trainer_event_dict=None, now=0) + sel = _AsyncSelector(); sel.add("a") + ch = _Channel(sel, ["a"]) + h._sim_buffer.add("a", 10.0, _payload("a")) + popped = h._sim_pop_committable(ch) + assert popped[0] == "a" and popped[1] == 10.0 + assert h.pending_withheld == {} + + +# --------------------------------------------------------------------------- +# _sim_reinject_ready_withheld — ordering, residence, slot-only drop +# --------------------------------------------------------------------------- + +def test_reinject_adds_due_in_order_marks_delivering(): + h = _Harness({"t1": _DOWN}, now=200) + h.pending_withheld = {"t1": 200.0, "t2": 150.0} + p1, p2 = _payload("t1"), _payload("t2") + h._sim_withheld_payload = {"t1": (150.0, p1), "t2": (120.0, p2)} + + h._sim_reinject_ready_withheld() + # both due at now=200 -> both re-injected, ledger emptied, marked delivering. + assert h.pending_withheld == {} + assert h._sim_buffer.has("t1") and h._sim_buffer.has("t2") + assert h._sim_withheld_delivering["t1"] == (150.0, 200.0) + assert h._sim_withheld_delivering["t2"] == (120.0, 150.0) + # re-injected keyed at delivery_ts (commit order), so t2(150) pops before t1(200). + assert h._sim_buffer.pop_min()[0] == "t2" + + +def test_reinject_excludes_future(): + h = _Harness({"t1": _DOWN}, now=190) + h.pending_withheld = {"t1": 200.0} + h._sim_withheld_payload = {"t1": (150.0, _payload("t1"))} + h._sim_reinject_ready_withheld() + # not yet due (200 > 190): still held, not in buffer. + assert h.pending_withheld == {"t1": 200.0} + assert not h._sim_buffer.has("t1") + + +def test_reinject_keeps_slot_only_entry_until_payload_arrives(): + # Eviction registered an ESTIMATED delivery_ts before the trainer's update + # had physically completed. A reinject tick that lands after the estimate + # but before the payload shows up must NOT drop the ledger entry (Next + # actions §2 under-emission bug) — it stays registered, still excluded via + # withheld_held_ends() at the original dts is moot once now > dts, but the + # ledger entry itself must survive for the payload to be recognized later. + h = _Harness({"t1": _DOWN}, now=250) + h.pending_withheld = {"t1": 200.0} # no payload yet + h._sim_reinject_ready_withheld() + assert h.pending_withheld == {"t1": 200.0} # NOT dropped + assert not h._sim_buffer.has("t1") # nothing to deliver yet + assert "t1" not in h._sim_withheld_delivering + + # the physical update now arrives (actual sct=250, past the original + # estimate) via the normal pop path -> recognized as still-withheld, + # delivery_ts bumped to the real completion time (no past-dating). + sel = _OortSelector() + ch = _Channel(sel, ["t1"]) + p = _payload("t1") + h._sim_buffer.add("t1", 250.0, p) + assert h._sim_pop_committable(ch) is None # held, not committed + assert h.pending_withheld == {"t1": 250.0} # bumped from the estimate + assert h._sim_withheld_payload["t1"] == (250.0, p) + + h._sim_reinject_ready_withheld() + assert h.pending_withheld == {} + assert h._sim_buffer.has("t1") + assert h._sim_withheld_delivering["t1"] == (250.0, 250.0) + + +# --------------------------------------------------------------------------- +# Invariant 1 — abandoned-then-arrived commits exactly once +# --------------------------------------------------------------------------- + +def test_invariant1_abandoned_then_arrived_commits_once(): + h = _Harness({"t1": _DOWN}, now=150, inflight_tracker=True) + sel = _AsyncSelector() + ch = _Channel(sel, ["t1"]) + # abandon already registered the ledger (slot-only, no payload yet). + h.pending_withheld = {"t1": 200.0} + h._sim_inflight_expected["t1"] = 999.0 + + # the physical update now arrives in the buffer. + h._sim_buffer.add("t1", 155.0, _payload("t1")) + # pop: end is in pending_withheld -> stash payload, do NOT re-register/commit. + assert h._sim_pop_committable(ch) is None + assert h.pending_withheld == {"t1": 200.0} # unchanged (no double-reg) + assert h._sim_withheld_payload["t1"][0] == 155.0 # arrived payload stashed + assert "t1" not in h._sim_inflight_expected + + # at delivery_ts, reinject delivers it; pop commits exactly once. + h._now = 200 + h._sim_reinject_ready_withheld() + popped = h._sim_pop_committable(ch) + assert popped is not None and popped[0] == "t1" + assert h.pending_withheld == {} # fully drained + assert h._sim_pop_committable(ch) is None # no second commit + + +# --------------------------------------------------------------------------- +# C.3 — vclock abandon (both selector shapes) +# --------------------------------------------------------------------------- + +def _setup_abandon(selector_cls, inflight_tracker): + h = _Harness({"t1": _DOWN}, now=300, inflight_tracker=inflight_tracker) + sel = selector_cls(); sel.add("t1") + ch = _Channel(sel, ["t1"]) + if inflight_tracker: + h._sim_inflight_expected["t1"] = 12.0 + return h, sel, ch + + +def test_abandon_fires_past_90s_async_shape(): + h, sel, ch = _setup_abandon(_AsyncSelector, inflight_tracker=True) + ch.set_end_property("t1", PROP_SIM_SEND_TS, 300 - 100) # age 100 > 90 + h._sim_abandon_stalled(ch) + assert not sel.holds("t1") # slot freed -> replacement selectable + assert "t1" in h.pending_withheld # delivery ledger registered + assert "t1" not in h._sim_inflight_expected + + +def test_abandon_fires_past_90s_oort_shape(): + h, sel, ch = _setup_abandon(_OortSelector, inflight_tracker=False) + ch.set_end_property("t1", PROP_SIM_SEND_TS, 300 - 95) # age 95 > 90 + h._sim_abandon_stalled(ch) + assert not sel.holds("t1") + assert "t1" in h.pending_withheld + + +def test_abandon_does_not_fire_under_90s(): + h, sel, ch = _setup_abandon(_OortSelector, inflight_tracker=False) + ch.set_end_property("t1", PROP_SIM_SEND_TS, 300 - 50) # age 50 <= 90 + h._sim_abandon_stalled(ch) + assert sel.holds("t1") # still in-flight + assert h.pending_withheld == {} + + +def test_abandon_skips_buffered_committed_and_withheld(): + h, sel, ch = _setup_abandon(_OortSelector, inflight_tracker=False) + ch.set_end_property("t1", PROP_SIM_SEND_TS, 300 - 100) + # already arrived in the buffer -> not stalled. + h._sim_buffer.add("t1", 250.0, _payload("t1")) + h._sim_abandon_stalled(ch) + assert sel.holds("t1") and h.pending_withheld == {} + + +def test_abandon_gate_off_is_noop(): + h = _Harness(trainer_event_dict=None, now=300) + sel = _OortSelector(); sel.add("t1") + ch = _Channel(sel, ["t1"]) + ch.set_end_property("t1", PROP_SIM_SEND_TS, 0.0) + h._sim_abandon_stalled(ch) + assert sel.holds("t1") and h.pending_withheld == {} + + +# --------------------------------------------------------------------------- +# _sim_evict_unavail_inflight — Stage D.1 proactive boundary eviction +# --------------------------------------------------------------------------- +# Uses _DOWN: AVL_TRAIN[0,100) → UN_AVL[100,200) → AVL_TRAIN[200,∞) + + +def _harness_aware(now, ends=("t1",), selector_cls=_OortSelector): + """Harness with proactive_inflight_evict=True, vclock at `now`.""" + h = _Harness({"t1": _DOWN, "t2": _DOWN}, now=now) + h.proactive_inflight_evict = True + sel = selector_cls() + for e in ends: + sel.add(e) + ch = _Channel(sel, list(ends)) + return h, sel, ch + + +def test_evict_frees_slot_for_unavail_trainer_oort(): + # vclock=150 → t1 is UN_AVL [100,200); should be evicted immediately. + h, sel, ch = _harness_aware(150, ("t1",), _OortSelector) + h._sim_evict_unavail_inflight(ch) + assert not sel.holds("t1") + assert "t1" in h.pending_withheld + assert h.pending_withheld["t1"] == 200.0 # next AVL_TRAIN from trace + + +def test_evict_frees_slot_for_unavail_trainer_async(): + h, sel, ch = _harness_aware(150, ("t1",), _AsyncSelector) + h._sim_evict_unavail_inflight(ch) + assert not sel.holds("t1") + assert h.pending_withheld["t1"] == 200.0 + + +def test_evict_leaves_available_trainer(): + # vclock=50 → t1 is AVL_TRAIN; no eviction. + h, sel, ch = _harness_aware(50, ("t1",), _OortSelector) + h._sim_evict_unavail_inflight(ch) + assert sel.holds("t1") + assert h.pending_withheld == {} + + +def test_evict_skips_buffered_trainer(): + # t1 is UN_AVL at vclock=150 but its update already arrived in the buffer + # → not stalled → eviction skipped. + h, sel, ch = _harness_aware(150, ("t1",), _OortSelector) + h._sim_buffer.add("t1", 120.0, _payload("t1")) + h._sim_evict_unavail_inflight(ch) + assert sel.holds("t1") + assert h.pending_withheld == {} + + +def test_evict_skips_already_withheld(): + # Invariant 1: t1 already in pending_withheld → no double-count. + h, sel, ch = _harness_aware(150, ("t1",), _OortSelector) + h.pending_withheld["t1"] = 200.0 + h._sim_evict_unavail_inflight(ch) + assert sel.holds("t1") # nothing changed + assert h.pending_withheld == {"t1": 200.0} + + +def test_evict_noop_when_awareness_false(): + # proactive_inflight_evict=False → falls through to 90s abandon; evict is inert. + h, sel, ch = _harness_aware(150, ("t1",), _OortSelector) + h.proactive_inflight_evict = False + h._sim_evict_unavail_inflight(ch) + assert sel.holds("t1") + assert h.pending_withheld == {} + + +def test_evict_noop_when_gate_off(): + h = _Harness(trainer_event_dict=None, now=150) + h.proactive_inflight_evict = True + sel = _OortSelector(); sel.add("t1") + ch = _Channel(sel, ["t1"]) + h._sim_evict_unavail_inflight(ch) + assert sel.holds("t1") + assert h.pending_withheld == {} + + +def test_evict_multiple_trainers_partial(): + # t1 in UN_AVL[100,200), t2 has a different trace where it's AVL at vclock=150. + # Only t1 should be evicted. + _avl_trace = _trace((0, "AVL_TRAIN")) + h = _Harness({"t1": _DOWN, "t2": _avl_trace}, now=150) + h.proactive_inflight_evict = True + sel = _OortSelector(); sel.add("t1"); sel.add("t2") + ch = _Channel(sel, ["t1", "t2"]) + h._sim_evict_unavail_inflight(ch) + assert not sel.holds("t1") + assert sel.holds("t2") + assert "t1" in h.pending_withheld + assert "t2" not in h.pending_withheld + + +# --------------------------------------------------------------------------- +# _avail_stamp_end_states — avail_composition/avl_state blind-spot fix +# --------------------------------------------------------------------------- + +def test_stamp_end_states_writes_every_known_end(): + # t1 in-flight UN_AVL[100,200) (e.g. just D.1-evicted); t2 plain AVL_TRAIN. + # Both are stamped, including the in-flight/evicted one — the whole point + # is this no longer depends on being in a "fresh candidate" subset. + h = _Harness({"t1": _DOWN, "t2": _trace((0, "AVL_TRAIN"))}, now=150) + sel = _OortSelector(); sel.add("t1") + ch = _Channel(sel, ["t1", "t2"]) + h._avail_stamp_end_states(ch) + assert ch.get_end_property("t1", PROP_AVL_STATE) == TrainerAvailState.UN_AVL + assert ch.get_end_property("t2", PROP_AVL_STATE) == TrainerAvailState.AVL_TRAIN + + +def test_stamp_end_states_defaults_avl_train_when_no_trace(): + h = _Harness({"t1": _DOWN}, now=150) + sel = _OortSelector() + ch = _Channel(sel, ["t1", "t2"]) # t2 has no per-trainer trace entry + h._avail_stamp_end_states(ch) + assert ch.get_end_property("t2", PROP_AVL_STATE) == TrainerAvailState.AVL_TRAIN + + +def test_stamp_end_states_noop_when_gate_off(): + h = _Harness(trainer_event_dict=None, now=150) + sel = _OortSelector() + ch = _Channel(sel, ["t1"]) + h._avail_stamp_end_states(ch) + assert ch.get_end_property("t1", PROP_AVL_STATE) is None + + +# --------------------------------------------------------------------------- +# get_curr_task_ineligible_trainers — D.2 task-type (AVL_TRAIN/AVL_EVAL) gate +# --------------------------------------------------------------------------- + +_TRAIN_THEN_EVAL = _trace((0, "AVL_TRAIN"), (100, "AVL_EVAL")) + + +def test_task_ineligible_excludes_un_avl_for_both_tasks(): + h = _Harness({"t1": _DOWN}, now=150) # UN_AVL[100,200) + assert h.get_curr_task_ineligible_trainers("train") == ["t1"] + assert h.get_curr_task_ineligible_trainers("eval") == ["t1"] + + +def test_task_ineligible_excludes_avl_eval_from_train_dispatch(): + h = _Harness({"t1": _TRAIN_THEN_EVAL}, now=150) # AVL_EVAL at t=150 + assert h.get_curr_task_ineligible_trainers("train") == ["t1"] + assert h.get_curr_task_ineligible_trainers("eval") == [] + + +def test_task_ineligible_excludes_avl_train_from_eval_dispatch(): + h = _Harness({"t1": _TRAIN_THEN_EVAL}, now=50) # AVL_TRAIN at t=50 + assert h.get_curr_task_ineligible_trainers("eval") == ["t1"] + assert h.get_curr_task_ineligible_trainers("train") == [] + + +def test_task_ineligible_unknown_task_matches_unavail_only(): + h = _Harness({"t1": _TRAIN_THEN_EVAL}, now=150) # AVL_EVAL + assert h.get_curr_task_ineligible_trainers("htbt") == [] + + +def test_task_ineligible_gate_off_is_noop(): + h = _Harness(trainer_event_dict=None, now=150) + assert h.get_curr_task_ineligible_trainers("train") == [] + assert h.get_curr_task_ineligible_trainers("eval") == [] + + +def test_task_ineligible_2state_trace_does_not_exclude_avl_train_from_eval(): + # Regression (found via a real felix syn_0 hang, Jun 28): syn_0/syn_20 are + # 2-state (AVL_TRAIN/UN_AVL only, no AVL_EVAL ever). Excluding AVL_TRAIN + # from eval on such a trace makes eval's eligible pool PERMANENTLY EMPTY, + # which corrupts the selector's shared in-flight tracking for train too + # (async_oort.py/fedbuff.py _handle_send_state's "invalid prior selection" + # cleanup wipes selected_ends when ends={}) — the aggregator stops reading + # completed train responses entirely. _trace_has_avl_eval must gate this off + # for a trace that never produces AVL_EVAL for ANY trainer. + h = _Harness({"t1": _DOWN, "t2": _trace((0, "AVL_TRAIN"))}, now=50) # all AVL_TRAIN + assert h._trace_has_avl_eval is False + assert h.get_curr_task_ineligible_trainers("eval") == [] + assert h.get_curr_task_ineligible_trainers("train") == [] diff --git a/lib/python/tests/availability/test_starvation_termination.py b/lib/python/tests/availability/test_starvation_termination.py new file mode 100644 index 000000000..a1622dfb4 --- /dev/null +++ b/lib/python/tests/availability/test_starvation_termination.py @@ -0,0 +1,201 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Regression tests for B2.0.2 — starvation self-termination. + +Bug: when the trace horizon is reached, _next_avail_vclock() returns None +(or a value <= vclock.now), the starvation branch returned without advancing +and without setting _work_done, causing infinite spins until the wall ceiling. +The budget check in increment_round used strict > so vclock exactly at budget +never stopped either. + +These tests verify that both conditions now terminate correctly. +""" + +import math +import types + +import pytest +from sortedcontainers import SortedDict + +from flame.availability.client_availability import ClientAvailability +from flame.availability.trace import next_avail_after + + +# --------------------------------------------------------------------------- +# Minimal clock + trace helpers +# --------------------------------------------------------------------------- + +def _trace(*pairs): + d = SortedDict() + for ts, state in pairs: + d[float(ts)] = state + return d + + +# A trace where all trainers go UN_AVL at t=500 and never recover. +_EXHAUST = _trace((0, "AVL_TRAIN"), (500, "UN_AVL")) + +# A trace where trainer recovers much later — used to verify _next_avail_vclock +# returns a finite future value when not exhausted. +_RECOVER = _trace((0, "AVL_TRAIN"), (500, "UN_AVL"), (800, "AVL_TRAIN")) + + +class _VClock: + def __init__(self, now): + self._now = float(now) + + @property + def now(self): + return self._now + + def advance(self, ts): + if float(ts) > self._now: + self._now = float(ts) + + +class _Harness(ClientAvailability): + """Minimal ClientAvailability host for starvation-termination tests.""" + + def __init__(self, trainer_event_dict, vclock_now, budget, simulated=True): + self.trainer_event_dict = trainer_event_dict + self._trace_has_avl_eval = False + self.pending_withheld = {} + self._sim_withheld_payload = {} + self._sim_withheld_delivering = {} + self._vclock = _VClock(vclock_now) + self._work_done = False + self._round = 1 + self.simulated = simulated + self.avail_select_filter = True + self.proactive_inflight_evict = False + self.agg_start_time_ts = 0.0 # for real-mode wall-elapsed check + # Minimal config mock + hp = types.SimpleNamespace( + max_experiment_runtime_s=budget, + aggregation_goal=5, + ) + self.config = types.SimpleNamespace(hyperparameters=hp) + + def _avail_now(self): + return self._vclock.now + + +# --------------------------------------------------------------------------- +# _next_avail_vclock behaviour +# --------------------------------------------------------------------------- + +def test_next_avail_vclock_returns_none_when_trace_exhausted(): + """All trainers permanently UN_AVL → no future recovery → None.""" + h = _Harness({"t1": _EXHAUST, "t2": _EXHAUST}, vclock_now=600, budget=1800) + result = h._next_avail_vclock() + assert result is None, f"Expected None, got {result}" + + +def test_next_avail_vclock_returns_future_when_recovery_exists(): + """Trainer recovers at t=800; query at t=600 → 800.0 returned.""" + h = _Harness({"t1": _EXHAUST, "t2": _RECOVER}, vclock_now=600, budget=1800) + result = h._next_avail_vclock() + assert result == 800.0, f"Expected 800.0, got {result}" + + +def test_next_avail_vclock_returns_none_at_budget_horizon(): + """Trace's only future transition is exactly at the budget horizon. + + next_avail_after returns math.inf when there is no finite future AVL + transition; candidates list stays empty → None returned. + """ + # The trace goes UN_AVL at 1800 (= budget). No AVL after that. + _AT_BUDGET = _trace((0, "AVL_TRAIN"), (1800, "UN_AVL")) + h = _Harness({"t1": _AT_BUDGET}, vclock_now=1800, budget=1800) + result = h._next_avail_vclock() + assert result is None, f"Expected None at budget horizon, got {result}" + + +# --------------------------------------------------------------------------- +# Starvation termination logic — directly test the decision logic +# --------------------------------------------------------------------------- + +def _run_starvation_sim_branch(h): + """Mirror the starvation sim branch from distribute() / aggregate(). + + Calls _next_avail_vclock(), checks the termination condition, and sets + h._work_done=True if termination is warranted. Returns (_nxt, _budget). + """ + _nxt = h._next_avail_vclock() + _budget = float( + getattr(h.config.hyperparameters, "max_experiment_runtime_s", float("inf")) + ) + if _nxt is not None and _nxt > h._vclock.now and h._vclock.now < _budget: + h._vclock.advance(_nxt) + # (in production: refresh unavail list etc.) + else: + # Trace horizon or budget reached — stop instead of spinning. + h._work_done = True + return _nxt, _budget + + +def test_starvation_terminates_when_nxt_is_none(): + """_next_avail_vclock returns None → work_done=True, no infinite spin.""" + h = _Harness({"t1": _EXHAUST}, vclock_now=600, budget=1800) + _nxt, _ = _run_starvation_sim_branch(h) + assert _nxt is None + assert h._work_done is True + + +def test_starvation_terminates_when_vclock_at_budget(): + """vclock exactly at budget → work_done=True (was: 1800>1800=False, never stopped).""" + # _RECOVER has AVL at 800, but vclock is already at budget (1800). + h = _Harness({"t1": _RECOVER}, vclock_now=1800, budget=1800) + _nxt, _budget = _run_starvation_sim_branch(h) + # _nxt could be None (no future AVL after 1800) or > 1800; either way terminates. + assert h._work_done is True + + +def test_starvation_terminates_when_vclock_past_budget(): + """vclock > budget → work_done=True.""" + h = _Harness({"t1": _RECOVER}, vclock_now=1850, budget=1800) + _run_starvation_sim_branch(h) + assert h._work_done is True + + +def test_starvation_advances_when_future_avail_within_budget(): + """Normal scarcity: _nxt < budget → vclock advances, work_done stays False.""" + h = _Harness({"t1": _RECOVER}, vclock_now=600, budget=1800) + _nxt, _ = _run_starvation_sim_branch(h) + assert _nxt == 800.0 + assert h._vclock.now == 800.0 + assert h._work_done is False + + +# --------------------------------------------------------------------------- +# increment_round budget check: >= (was strict >) +# --------------------------------------------------------------------------- + +def test_budget_check_triggers_at_exact_equality(): + """elapsed == budget must stop the run (>= check, not strict >). + + Previously: 1800 > 1800 = False → never stopped. + Fixed: 1800 >= 1800 = True → stops. + """ + # We test the condition directly rather than calling increment_round, which + # requires a full aggregator stack. The fix is: elapsed >= budget triggers. + budget = 1800.0 + elapsed = 1800.0 # exactly at budget + assert elapsed >= budget, "Fix regression: >= check must fire at exact equality" + + # Confirm strict-> would have missed it (documents the original bug). + assert not (elapsed > budget), "Strict > missed this case (original bug)" + + +def test_budget_check_triggers_above(): + """elapsed > budget also stops (sanity — regression of original > behaviour).""" + budget = 1800.0 + elapsed = 1801.0 + assert elapsed >= budget + + +def test_budget_check_does_not_trigger_below(): + """elapsed < budget should NOT stop.""" + budget = 1800.0 + elapsed = 1799.0 + assert not (elapsed >= budget) diff --git a/lib/python/tests/availability/test_state_fidelity.py b/lib/python/tests/availability/test_state_fidelity.py new file mode 100644 index 000000000..a66231ad2 --- /dev/null +++ b/lib/python/tests/availability/test_state_fidelity.py @@ -0,0 +1,457 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""T4 — State-fidelity tests for ClientAvailability. + +Deterministic, no cluster. Drives tiny synthetic traces through the mixin's +selection-filter and delivery-ledger methods: + + T-state-exact state_at() matches the trace at every AVL/UN_AVL boundary + T-eval-pool AVL_EVAL trainers excluded from train, included in eval + T-withhold-deliver mid-flight UN_AVL → withheld, then delivered-stale + T-aware-vs-reactive avail_select_filter ON vs OFF; proactive_inflight_evict + T-starvation-sync exactly one vclock advance; self-terminates (B2.0.2 regression) +""" + +import math +import types + +import pytest +from sortedcontainers import SortedDict + +from flame.availability.client_availability import ClientAvailability +from flame.availability.trace import next_avail_after, state_at +from flame.config import TrainerAvailState + + +# --------------------------------------------------------------------------- +# Trace builders +# --------------------------------------------------------------------------- + +def _trace(*pairs): + d = SortedDict() + for ts, state in pairs: + d[float(ts)] = state + return d + + +# Standard 2-state: down [300, 600), recovers at 600. +_T1 = _trace((0, "AVL_TRAIN"), (300, "UN_AVL"), (600, "AVL_TRAIN")) + +# 3-state: eval-only window [200, 400). +_T2_EVAL = _trace((0, "AVL_TRAIN"), (200, "AVL_EVAL"), (400, "AVL_TRAIN")) + +# Never recovers after going down. +_NEVER = _trace((0, "AVL_TRAIN"), (300, "UN_AVL")) + + +# --------------------------------------------------------------------------- +# Stubs +# --------------------------------------------------------------------------- + +class _VClock: + def __init__(self, now): + self._now = float(now) + + @property + def now(self): + return self._now + + def advance(self, ts): + if float(ts) > self._now: + self._now = float(ts) + + +class _FakeEnd: + def __init__(self): + self.props = {} + + def set_property(self, k, v): + self.props[k] = v + + def get_property(self, k): + return self.props.get(k) + + +class _FlatSelector: + """oort/refl/feddance shape: flat set, no all_selected.""" + + def __init__(self): + self.selected_ends = set() + + def add(self, end): + self.selected_ends.add(end) + + +class _Channel: + def __init__(self, selector, ends): + self._selector = selector + self._ends = {e: _FakeEnd() for e in ends} + self._props = {} + + def has(self, end): + return end in self._ends + + def set_end_property(self, end, key, value): + self._props[(end, key)] = value + + def get_end_property(self, end, key): + return self._props.get((end, key)) + + +class _Harness(ClientAvailability): + """Minimal ClientAvailability host for state-fidelity tests.""" + + def __init__( + self, + trainer_event_dict, + vclock_now=0.0, + budget=1800.0, + avail_select_filter=True, + proactive_inflight_evict=False, + simulated=True, + ): + self.trainer_event_dict = trainer_event_dict + self._trace_has_avl_eval = bool(trainer_event_dict) and any( + TrainerAvailState.AVL_EVAL in trace.values() + for trace in trainer_event_dict.values() + ) + self.pending_withheld = {} + self._sim_withheld_payload = {} + self._sim_withheld_delivering = {} + self.avail_select_filter = avail_select_filter + self.proactive_inflight_evict = proactive_inflight_evict + self._vclock = _VClock(vclock_now) + self._work_done = False + self._round = 1 + self.simulated = simulated + self.agg_start_time_ts = 0.0 + hp = types.SimpleNamespace( + max_experiment_runtime_s=budget, + aggregation_goal=5, + ) + self.config = types.SimpleNamespace(hyperparameters=hp) + + def _avail_now(self): + return self._vclock.now + + +# =========================================================================== +# T-state-exact +# =========================================================================== + +class TestStateExact: + """state_at() matches the 2-state trace at every boundary, both directions.""" + + def _st(self, t): + return state_at(_T1, t) + + def test_pre_window_avl_train(self): + assert self._st(0.0) == TrainerAvailState.AVL_TRAIN + assert self._st(299.9) == TrainerAvailState.AVL_TRAIN + + def test_at_down_boundary_unavl(self): + assert self._st(300.0) == TrainerAvailState.UN_AVL + + def test_inside_down_window_unavl(self): + assert self._st(450.0) == TrainerAvailState.UN_AVL + assert self._st(599.9) == TrainerAvailState.UN_AVL + + def test_at_recovery_boundary_avl_train(self): + assert self._st(600.0) == TrainerAvailState.AVL_TRAIN + + def test_post_recovery_avl_train(self): + assert self._st(900.0) == TrainerAvailState.AVL_TRAIN + + def test_get_curr_unavail_includes_down_trainer(self): + h = _Harness({"t1": _T1}, vclock_now=450) + assert "t1" in h.get_curr_unavail_trainers() + + def test_get_curr_unavail_empty_pre_window(self): + h = _Harness({"t1": _T1}, vclock_now=100) + assert h.get_curr_unavail_trainers() == [] + + def test_get_curr_unavail_empty_post_recovery(self): + h = _Harness({"t1": _T1}, vclock_now=700) + assert h.get_curr_unavail_trainers() == [] + + def test_ineligible_matches_unavail_for_2state_train(self): + """On a 2-state trace, ineligible('train') == unavail (no AVL_EVAL present).""" + h = _Harness({"t1": _T1}, vclock_now=450) + assert h.get_curr_task_ineligible_trainers("train") == h.get_curr_unavail_trainers() + + def test_state_at_empty_trace_default_avl(self): + """Empty SortedDict (syn_0) → always AVL_TRAIN.""" + assert state_at(SortedDict(), 9999.0) == TrainerAvailState.AVL_TRAIN + + +# =========================================================================== +# T-eval-pool +# =========================================================================== + +class TestEvalPool: + """3-state trace: AVL_EVAL trainer excluded from train, included in eval.""" + + def _harness(self, t): + return _Harness( + {"t1": _T2_EVAL, "t2": _T1}, + vclock_now=t, + ) + + def test_eval_trainer_excluded_from_train(self): + """t1 is AVL_EVAL at t=250 → excluded from 'train' dispatch.""" + h = self._harness(250) + ineligible = h.get_curr_task_ineligible_trainers("train") + assert "t1" in ineligible + assert "t2" not in ineligible # t2 is AVL_TRAIN at 250 + + def test_eval_trainer_not_excluded_from_eval(self): + """t1 is AVL_EVAL at t=250 → NOT excluded from 'eval' dispatch.""" + h = self._harness(250) + assert "t1" not in h.get_curr_task_ineligible_trainers("eval") + + def test_unavl_trainer_excluded_from_both(self): + """t2 is UN_AVL at t=400 → excluded from train AND eval.""" + h = self._harness(400) + assert "t2" in h.get_curr_task_ineligible_trainers("train") + assert "t2" in h.get_curr_task_ineligible_trainers("eval") + + def test_avl_train_trainer_eligible_for_train_not_eval(self): + """t2 at t=100 (AVL_TRAIN) in a 3-state trace: eligible for train only. + In a 3-state environment, only AVL_EVAL trainers participate in eval; + AVL_TRAIN trainers are excluded from eval dispatch (not UN_AVL, just wrong role). + """ + h = self._harness(100) + assert "t2" not in h.get_curr_task_ineligible_trainers("train") + # AVL_TRAIN is the excluded_state for "eval" when _trace_has_avl_eval=True + assert "t2" in h.get_curr_task_ineligible_trainers("eval") + + def test_trace_has_avl_eval_detected(self): + """_trace_has_avl_eval is True when any trace contains AVL_EVAL.""" + h = self._harness(0) + assert h._trace_has_avl_eval is True + + def test_trace_has_avl_eval_false_for_2state(self): + """2-state traces (AVL_TRAIN/UN_AVL only) → _trace_has_avl_eval=False.""" + h = _Harness({"t1": _T1}) + assert h._trace_has_avl_eval is False + + +# =========================================================================== +# T-withhold-deliver +# =========================================================================== + +class TestWithholdDeliver: + """mid-flight UN_AVL → withheld then delivered-stale; delivery_ts is correct.""" + + def test_delivery_ts_when_down_at_sct(self): + """Trainer is UN_AVL at sct=400 → delivery waits for recovery at 600.""" + h = _Harness({"t1": _T1}) + assert h.compute_delivery_ts("t1", sct=400.0) == 600.0 + + def test_delivery_ts_immediate_when_avl_at_sct(self): + """Trainer is AVL_TRAIN at sct=100 → immediate delivery (= sct).""" + h = _Harness({"t1": _T1}) + assert h.compute_delivery_ts("t1", sct=100.0) == 100.0 + + def test_delivery_ts_inf_when_never_recovers(self): + """Trace never recovers → math.inf (Challenge 10 guard).""" + h = _Harness({"t1": _NEVER}) + assert h.compute_delivery_ts("t1", sct=400.0) == math.inf + + def test_delivery_ts_at_recovery_boundary(self): + """sct exactly at down boundary (300) → delivery at 600 (UN_AVL at 300).""" + h = _Harness({"t1": _T1}) + assert h.compute_delivery_ts("t1", sct=300.0) == 600.0 + + def test_free_stalled_slot_populates_ledger(self): + """free_stalled_slot registers delivery_ts in pending_withheld.""" + h = _Harness({"t1": _T1}, vclock_now=0.0) + sel = _FlatSelector() + sel.add("t1") + ch = _Channel(sel, ["t1"]) + delivery_ts = h.free_stalled_slot(ch, "t1", reason="test", sct=400.0) + assert delivery_ts == 600.0 + assert h.pending_withheld["t1"] == 600.0 + + def test_withheld_held_before_delivery_ts(self): + """withheld_held_ends() includes end when vclock < delivery_ts.""" + h = _Harness({"t1": _T1}, vclock_now=500) + h.pending_withheld["t1"] = 600.0 + assert "t1" in h.withheld_held_ends() + + def test_withheld_not_held_at_delivery_ts(self): + """withheld_held_ends() is empty when vclock == delivery_ts.""" + h = _Harness({"t1": _T1}, vclock_now=600) + h.pending_withheld["t1"] = 600.0 + assert "t1" not in h.withheld_held_ends() + + def test_withheld_not_held_after_delivery_ts(self): + """withheld_held_ends() is empty when vclock > delivery_ts.""" + h = _Harness({"t1": _T1}, vclock_now=700) + h.pending_withheld["t1"] = 600.0 + assert "t1" not in h.withheld_held_ends() + + def test_ready_withheld_ordered_by_delivery_ts(self): + """ready_withheld() returns (end, dts) sorted ascending by dts.""" + h = _Harness({"t1": _T1, "t2": _T1}, vclock_now=700) + h.pending_withheld = {"t1": 600.0, "t2": 650.0} + due = h.ready_withheld() + assert [e for e, _ in due] == ["t1", "t2"] + + def test_free_stalled_slot_noop_when_gate_off(self): + """Gate off (trainer_event_dict=None) → free_stalled_slot is a no-op.""" + h = _Harness(None, vclock_now=0.0) + sel = _FlatSelector() + ch = _Channel(sel, []) + result = h.free_stalled_slot(ch, "t1", reason="test", sct=100.0) + assert result is None + assert h.pending_withheld == {} + + def test_commit_withheld_removes_from_ledger(self): + """commit_withheld() pops the end from pending_withheld.""" + h = _Harness({"t1": _T1}) + h.pending_withheld["t1"] = 600.0 + h.commit_withheld("t1") + assert "t1" not in h.pending_withheld + + +# =========================================================================== +# T-aware-vs-reactive +# =========================================================================== + +class TestAwareVsReactive: + """avail_select_filter ON vs OFF; proactive_inflight_evict divergence.""" + + def test_select_filter_on_excludes_unavl(self): + h = _Harness({"t1": _T1}, vclock_now=450, avail_select_filter=True) + assert "t1" in h.get_curr_unavail_trainers() + + def test_select_filter_off_returns_empty(self): + """Unaware baselines (oort/fedbuff): selection filter bypassed → empty.""" + h = _Harness({"t1": _T1}, vclock_now=450, avail_select_filter=False) + assert h.get_curr_unavail_trainers() == [] + + def test_select_filter_off_ineligible_empty_both_tasks(self): + """Unaware: ineligible list always [] for both train and eval.""" + h = _Harness({"t1": _T1}, vclock_now=450, avail_select_filter=False) + assert h.get_curr_task_ineligible_trainers("train") == [] + assert h.get_curr_task_ineligible_trainers("eval") == [] + + def test_proactive_evict_on_frees_slot_at_boundary(self): + """proactive_inflight_evict=True: in-flight UN_AVL trainer is evicted.""" + h = _Harness( + {"t1": _T1}, vclock_now=450, + avail_select_filter=True, proactive_inflight_evict=True, + ) + sel = _FlatSelector() + sel.add("t1") # mark t1 as in-flight + ch = _Channel(sel, ["t1"]) + h._sim_evict_unavail_inflight(ch) + # Slot freed: t1 removed from selected_ends + assert "t1" not in sel.selected_ends + # Delivery ledger populated + assert "t1" in h.pending_withheld + assert h.pending_withheld["t1"] == 600.0 + + def test_proactive_evict_off_leaves_slot(self): + """proactive_inflight_evict=False: in-flight trainer slot untouched.""" + h = _Harness( + {"t1": _T1}, vclock_now=450, + avail_select_filter=True, proactive_inflight_evict=False, + ) + sel = _FlatSelector() + sel.add("t1") + ch = _Channel(sel, ["t1"]) + h._sim_evict_unavail_inflight(ch) + # Slot NOT freed + assert "t1" in sel.selected_ends + assert "t1" not in h.pending_withheld + + def test_proactive_evict_ignores_avl_trainer(self): + """proactive_inflight_evict=True: in-flight AVL trainer NOT evicted.""" + h = _Harness( + {"t1": _T1}, vclock_now=100, # t1 is AVL_TRAIN at t=100 + avail_select_filter=True, proactive_inflight_evict=True, + ) + sel = _FlatSelector() + sel.add("t1") + ch = _Channel(sel, ["t1"]) + h._sim_evict_unavail_inflight(ch) + assert "t1" in sel.selected_ends # slot kept + assert "t1" not in h.pending_withheld + + +# =========================================================================== +# T-starvation-sync +# =========================================================================== + +class TestStarvationSync: + """Scripted scarcity → exactly one vclock advance; self-terminates (B2.0.2).""" + + _EXHAUST = _trace((0, "AVL_TRAIN"), (500, "UN_AVL")) + _RECOVER = _trace((0, "AVL_TRAIN"), (500, "UN_AVL"), (800, "AVL_TRAIN")) + + def _run_branch(self, h): + """Mirror the starvation sim branch: advance or set work_done.""" + _nxt = h._next_avail_vclock() + _budget = float( + getattr(h.config.hyperparameters, "max_experiment_runtime_s", float("inf")) + ) + if _nxt is not None and _nxt > h._vclock.now and h._vclock.now < _budget: + h._vclock.advance(_nxt) + else: + h._work_done = True + return _nxt + + def test_single_advance_to_recovery_time(self): + """One starvation call → vclock jumps exactly to the recovery transition.""" + h = _Harness({"t1": self._EXHAUST, "t2": self._RECOVER}, vclock_now=600) + _nxt = self._run_branch(h) + assert _nxt == 800.0 + assert h._vclock.now == 800.0 + assert h._work_done is False + + def test_terminates_when_no_recovery(self): + """All trainers exhausted → work_done=True on first call.""" + h = _Harness({"t1": self._EXHAUST, "t2": self._EXHAUST}, vclock_now=600) + _nxt = self._run_branch(h) + assert _nxt is None + assert h._work_done is True + + def test_terminates_at_budget(self): + """vclock == budget → work_done=True (the B2.0.2 fix: >= not >).""" + h = _Harness({"t1": self._RECOVER}, vclock_now=1800, budget=1800) + self._run_branch(h) + assert h._work_done is True + + def test_terminates_past_budget(self): + """vclock > budget → work_done=True.""" + h = _Harness({"t1": self._RECOVER}, vclock_now=1850, budget=1800) + self._run_branch(h) + assert h._work_done is True + + def test_next_avail_vclock_minimum_across_trainers(self): + """Returns the EARLIEST next recovery when multiple trainers are down.""" + early = _trace((0, "AVL_TRAIN"), (500, "UN_AVL"), (700, "AVL_TRAIN")) + late = _trace((0, "AVL_TRAIN"), (500, "UN_AVL"), (900, "AVL_TRAIN")) + h = _Harness({"t1": early, "t2": late}, vclock_now=600) + assert h._next_avail_vclock() == 700.0 + + def test_next_avail_vclock_includes_pending_withheld(self): + """A withheld delivery_ts is a candidate too (re-enters pool earlier).""" + # Both trainers exhausted, but pending_withheld shows one due at 650. + h = _Harness({"t1": self._EXHAUST, "t2": self._EXHAUST}, vclock_now=600) + h.pending_withheld["t1"] = 650.0 + nxt = h._next_avail_vclock() + assert nxt == 650.0 + + def test_next_avail_vclock_none_when_gate_off(self): + """Gate off (trainer_event_dict=None) → None (no trace to scan).""" + h = _Harness(None, vclock_now=100) + assert h._next_avail_vclock() is None + + def test_k1_monotone_vclock_never_goes_back(self): + """vclock.advance() is strictly monotone — calling it with past value is no-op.""" + h = _Harness({"t1": self._RECOVER}, vclock_now=850) + h._vclock.advance(800.0) # past value + assert h._vclock.now == 850.0 # unchanged diff --git a/lib/python/tests/launch/test_baseline_wiring.py b/lib/python/tests/launch/test_baseline_wiring.py new file mode 100644 index 000000000..3dc59a785 --- /dev/null +++ b/lib/python/tests/launch/test_baseline_wiring.py @@ -0,0 +1,251 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Config-gen wiring tests: verify 6-baseline matrix HP after merge. + +These tests catch mis-wiring before cluster time by simulating the runner's +baseline.aggregator + experiment.config_overrides merge for each sim experiment +in the parity YAML and asserting the correct availability flags. + +No subprocess spawning, no GPU, no MQTT — pure YAML/dict tests. +""" + +from __future__ import annotations + +from pathlib import Path + +import pytest +import yaml + +from flame.launch.baselines import deep_merge, load_baselines + +# ── Paths ───────────────────────────────────────────────────────────────────── +_EXAMPLES = Path(__file__).parents[2] / "examples" +_METADATA_DIR = _EXAMPLES / "_metadata" +_PARITY_YAML = ( + _EXAMPLES + / "async_cifar10/expt_scripts_2026/felix_oort_refl_feddance_alpha0.1_parity.yaml" +) + + +@pytest.fixture(scope="module") +def baselines(): + return load_baselines(_METADATA_DIR) + + +@pytest.fixture(scope="module") +def parity_experiments(): + with open(_PARITY_YAML) as f: + data = yaml.safe_load(f) + return data.get("experiments", data) if isinstance(data, dict) else data + + +def _sim_exp(parity_experiments, name: str) -> dict: + """Return the sim experiment with the given name.""" + for exp in parity_experiments: + if exp["name"] == name: + return exp + raise KeyError(f"experiment {name!r} not in parity YAML") + + +def _merged_hp(baselines, parity_experiments, exp_name: str, baseline_name: str) -> dict: + """Merge baseline.aggregator.hyperparameters with experiment config_overrides HP.""" + bl = baselines[baseline_name] + bl_hp = (bl.get("aggregator") or {}).get("hyperparameters") or {} + exp = _sim_exp(parity_experiments, exp_name) + exp_hp = ( + (exp.get("aggregator") or {}) + .get("config_overrides", {}) + .get("hyperparameters") or {} + ) + return deep_merge(bl_hp, exp_hp) + + +# ── Catalog presence ─────────────────────────────────────────────────────────── + +class TestBaselineCatalogPresence: + def test_all_six_baselines_in_catalog(self, baselines): + required = {"felix", "oort", "oort_star", "refl", "feddance", "fedbuff"} + missing = required - set(baselines) + assert not missing, f"Missing from baselines.yaml: {missing}" + + def test_oort_star_uses_oort_selector(self, baselines): + assert baselines["oort_star"]["aggregator"]["selector"]["sort"] == "oort" + + def test_oort_star_uses_fedavg_optimizer(self, baselines): + assert baselines["oort_star"]["aggregator"]["optimizer"]["sort"] == "fedavg" + + def test_oort_star_has_oracular_tracking(self, baselines): + hp = baselines["oort_star"]["aggregator"]["hyperparameters"] + tta = hp["trackTrainerAvail"] + assert tta["enabled"] == "True" + assert tta["type"] == "ORACULAR" + + def test_all_six_baselines_in_parity_yaml(self, parity_experiments): + present = {e["baseline"] for e in parity_experiments if "baseline" in e} + required = {"felix", "oort", "oort_star", "refl", "feddance", "fedbuff"} + missing = required - present + assert not missing, f"Baselines not in parity YAML: {missing}" + + +# ── Per-baseline HP verification ─────────────────────────────────────────────── + +class TestFelixWiring: + def test_avail_select_filter_on(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "felix_n300_alpha0.1_syn0_stream_sim", "felix") + assert hp["avail_select_filter"] == "True" + + def test_proactive_inflight_evict_on(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "felix_n300_alpha0.1_syn0_stream_sim", "felix") + assert hp["proactive_inflight_evict"] == "True" + + def test_sim_unavailability_on(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "felix_n300_alpha0.1_syn0_stream_sim", "felix") + assert hp.get("sim_unavailability") == "True" + + def test_trackTrainerAvail_disabled(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "felix_n300_alpha0.1_syn0_stream_sim", "felix") + tta = hp.get("trackTrainerAvail") or {} + assert str(tta.get("enabled", "False")).strip().lower() != "true", ( + "felix uses client_notify, not oracular" + ) + + +class TestOortWiring: + def test_avail_select_filter_off(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "oort_n300_alpha0.1_syn0_stream_sim", "oort") + assert hp["avail_select_filter"] == "False" + + def test_proactive_inflight_evict_off(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "oort_n300_alpha0.1_syn0_stream_sim", "oort") + assert hp["proactive_inflight_evict"] == "False" + + def test_trackTrainerAvail_enabled(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "oort_n300_alpha0.1_syn0_stream_sim", "oort") + tta = hp.get("trackTrainerAvail") or {} + assert str(tta.get("enabled", "False")).strip().lower() == "true" + assert tta.get("type", "").upper() == "ORACULAR" + + def test_trace_name_set(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "oort_n300_alpha0.1_syn0_stream_sim", "oort") + tta = hp.get("trackTrainerAvail") or {} + assert tta.get("trace"), "oort must have trackTrainerAvail.trace for starvation-advance" + + +class TestOortStarWiring: + def test_avail_select_filter_on(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "oort_star_n300_alpha0.1_syn0_stream_sim", "oort_star") + assert hp["avail_select_filter"] == "True" + + def test_proactive_inflight_evict_off(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "oort_star_n300_alpha0.1_syn0_stream_sim", "oort_star") + assert hp["proactive_inflight_evict"] == "False" + + def test_trackTrainerAvail_enabled(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "oort_star_n300_alpha0.1_syn0_stream_sim", "oort_star") + tta = hp.get("trackTrainerAvail") or {} + assert str(tta.get("enabled", "False")).strip().lower() == "true" + assert tta.get("type", "").upper() == "ORACULAR" + + def test_differs_from_oort_only_in_filter(self, baselines, parity_experiments): + oort_hp = _merged_hp(baselines, parity_experiments, + "oort_n300_alpha0.1_syn0_stream_sim", "oort") + ostar_hp = _merged_hp(baselines, parity_experiments, + "oort_star_n300_alpha0.1_syn0_stream_sim", "oort_star") + # avail_select_filter is the only flag that differs + assert oort_hp["avail_select_filter"] == "False" + assert ostar_hp["avail_select_filter"] == "True" + assert oort_hp["proactive_inflight_evict"] == ostar_hp["proactive_inflight_evict"] + oort_tta = oort_hp.get("trackTrainerAvail", {}) + ostar_tta = ostar_hp.get("trackTrainerAvail", {}) + assert oort_tta.get("enabled") == ostar_tta.get("enabled") + assert oort_tta.get("type") == ostar_tta.get("type") + + +class TestReflWiring: + def test_avail_select_filter_on(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "refl_n300_alpha0.1_syn0_stream_sim", "refl") + assert hp["avail_select_filter"] == "True" + + def test_proactive_inflight_evict_off(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "refl_n300_alpha0.1_syn0_stream_sim", "refl") + assert hp["proactive_inflight_evict"] == "False" + + def test_trackTrainerAvail_enabled(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "refl_n300_alpha0.1_syn0_stream_sim", "refl") + tta = hp.get("trackTrainerAvail") or {} + assert str(tta.get("enabled", "False")).strip().lower() == "true" + assert tta.get("type", "").upper() == "ORACULAR" + + +class TestFedDanceWiring: + def test_avail_select_filter_on(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "feddance_n300_alpha0.1_syn0_stream_sim", "feddance") + assert hp["avail_select_filter"] == "True" + + def test_proactive_inflight_evict_off(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "feddance_n300_alpha0.1_syn0_stream_sim", "feddance") + assert hp["proactive_inflight_evict"] == "False" + + def test_trackTrainerAvail_disabled(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "feddance_n300_alpha0.1_syn0_stream_sim", "feddance") + tta = hp.get("trackTrainerAvail") or {} + assert str(tta.get("enabled", "False")).strip().lower() != "true", ( + "feddance has its own check-in predictor, not oracular" + ) + + +class TestFedBuffWiring: + def test_avail_select_filter_off(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "fedbuff_n300_alpha0.1_syn0_stream_sim", "fedbuff") + assert hp["avail_select_filter"] == "False" + + def test_proactive_inflight_evict_off(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "fedbuff_n300_alpha0.1_syn0_stream_sim", "fedbuff") + assert hp["proactive_inflight_evict"] == "False" + + def test_sim_unavailability_on(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "fedbuff_n300_alpha0.1_syn0_stream_sim", "fedbuff") + assert hp.get("sim_unavailability") == "True", ( + "fedbuff must activate the availability gate via sim_unavailability " + "(unaware baseline: gate loads trace but does not filter selection pool)" + ) + + def test_availability_trace_set(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "fedbuff_n300_alpha0.1_syn0_stream_sim", "fedbuff") + has_trace = ( + hp.get("availability_trace") + or (hp.get("client_notify") or {}).get("trace") + ) + assert has_trace, ( + "fedbuff must have availability_trace (or client_notify.trace) so " + "_init_availability can load the syn_0 trace without warning" + ) + + def test_trackTrainerAvail_disabled(self, baselines, parity_experiments): + hp = _merged_hp(baselines, parity_experiments, + "fedbuff_n300_alpha0.1_syn0_stream_sim", "fedbuff") + tta = hp.get("trackTrainerAvail") or {} + assert str(tta.get("enabled", "False")).strip().lower() != "true", ( + "fedbuff should not use oracular tracking" + ) diff --git a/lib/python/tests/launch/test_baselines.py b/lib/python/tests/launch/test_baselines.py index d1ed4848f..747b74cfa 100644 --- a/lib/python/tests/launch/test_baselines.py +++ b/lib/python/tests/launch/test_baselines.py @@ -166,3 +166,76 @@ def test_other_baselines_present(self): assert "refl" in b assert "feddance" in b assert "oort" in b + + +class TestFwdllmBaselines: + """fwdllm/fwdllm_plus/fluxtune/fluxtune_dynkc replace the retired + fedfwd_async_random_dynkc/fedfwd_oracular.""" + + @pytest.fixture + def baselines(self): + shared = Path(__file__).resolve().parents[2] / "examples" / "_metadata" + if not (shared / "baselines.yaml").is_file(): + pytest.skip("shared baselines.yaml not present in this checkout") + return load_baselines(shared) + + def test_retired_keys_are_gone(self, baselines): + assert "fedfwd_async_random_dynkc" not in baselines + assert "fedfwd_oracular" not in baselines + + def test_all_four_present(self, baselines): + for name in ("fwdllm", "fwdllm_plus", "fluxtune", "fluxtune_dynkc"): + assert name in baselines + + def test_fwdllm_is_sync_random_fedavg_unaware(self, baselines): + b = baselines["fwdllm"]["aggregator"] + assert b["selector"]["sort"] == "random" + assert b["selector"]["kwargs"]["is_async"] is False + assert b["optimizer"]["sort"] == "fedavg" + assert b["hyperparameters"]["trackTrainerAvail"]["enabled"] == "False" + assert b["hyperparameters"]["reselect_each_iteration"] is False + assert ( + baselines["fwdllm"]["trainer"]["hyperparameters"]["client_notify"]["enabled"] + == "False" + ) + + def test_fwdllm_plus_is_sync_random_fedavg_oracular(self, baselines): + b = baselines["fwdllm_plus"]["aggregator"] + assert b["selector"]["sort"] == "random" + assert b["selector"]["kwargs"]["is_async"] is False + assert b["optimizer"]["sort"] == "fedavg" + assert b["hyperparameters"]["trackTrainerAvail"]["enabled"] == "True" + assert b["hyperparameters"]["trackTrainerAvail"]["type"] == "ORACULAR" + assert b["hyperparameters"]["reselect_each_iteration"] is True + + def test_fluxtune_is_async_oort_fedbuff_with_explicit_lr(self, baselines): + b = baselines["fluxtune"]["aggregator"] + assert b["selector"]["sort"] == "async_oort" + assert b["selector"]["kwargs"]["is_async"] is True + assert b["optimizer"]["sort"] == "fedbuff" + assert b["optimizer"]["kwargs"]["learning_rate"] == 0.075 + assert b["hyperparameters"]["trackTrainerAvail"]["enabled"] == "False" + trainer_hp = baselines["fluxtune"]["trainer"]["hyperparameters"] + assert trainer_hp["select_perturbation_using_jvp"] is True + assert trainer_hp["client_notify"]["enabled"] == "True" + assert "3st" in trainer_hp["client_notify"]["trace"] + + def test_fluxtune_dynamic_kc_is_config_driven_and_off_by_default(self, baselines): + """Owner clarification: unlike felix (always fixed K/C), fluxtune's + K/C policy must be config-driven -- dynamic_kc defaults to disabled + (fixed K/C, like felix) but exposes enabled + policy so it can be + flipped on per experiment without forking the selector.""" + dkc = baselines["fluxtune"]["aggregator"]["selector"]["kwargs"]["dynamic_kc"] + assert dkc["enabled"] is False + assert "policy" in dkc + + def test_fluxtune_dynkc_preserves_legacy_production_default(self, baselines): + """Frozen parity artifact: must keep the exact selector/optimizer + shape (including the known dataset_name copy-paste bug) of the + retired fedfwd_async_random_dynkc, just renamed.""" + b = baselines["fluxtune_dynkc"]["aggregator"] + assert b["selector"]["sort"] == "async_random" + assert b["selector"]["kwargs"]["dynamic_kc"]["enabled"] is True + assert b["optimizer"]["sort"] == "fedbuff" + assert "learning_rate" not in b["optimizer"]["kwargs"] + assert b["optimizer"]["kwargs"]["dataset_name"] == "google-speech" diff --git a/lib/python/tests/launch/test_config_generator.py b/lib/python/tests/launch/test_config_generator.py index f777dadc0..8686fc595 100644 --- a/lib/python/tests/launch/test_config_generator.py +++ b/lib/python/tests/launch/test_config_generator.py @@ -65,3 +65,350 @@ def test_overrides_applied(self, gen): ) assert cfg["job"]["id"] == "experiment-xyz" assert cfg["hyperparameters"]["batchSize"] == 64 + + +FWDLLM_TRAINER_BASE = ( + Path(__file__).resolve().parents[2] + / "examples" + / "fwdllm" + / "configs" + / "trainer_base.yaml" +) +FWDLLM_AGGREGATOR_MAIN = ( + Path(__file__).resolve().parents[2] + / "examples" + / "fwdllm" + / "aggregator" + / "main_fedfwd_agg.py" +) + + +@pytest.mark.skipif( + not SHARED_METADATA.is_dir() or not FWDLLM_TRAINER_BASE.is_file(), + reason="shared metadata or fwdllm trainer_base not present", +) +class TestFwdllmEndToEndConfigGeneration: + """For each of the four fwdllm baselines, generate the aggregator + a + trainer config end-to-end (extends the single retired + fedfwd_async_random_dynkc coverage to all four).""" + + @pytest.fixture + def baselines(self): + from flame.launch.baselines import load_baselines + + return load_baselines(SHARED_METADATA) + + @pytest.fixture + def gen(self, loader): + from flame.launch.spawner import ConfigGenerator + + return ConfigGenerator(loader, FWDLLM_TRAINER_BASE) + + @pytest.mark.parametrize( + "baseline_name", ["fwdllm", "fwdllm_plus", "fluxtune", "fluxtune_dynkc"] + ) + def test_trainer_config_generates_without_keyerror( + self, gen, baselines, baseline_name + ): + gen.set_baseline_overrides(baselines[baseline_name].get("trainer", {})) + cfg = gen.generate_trainer_config( + trainer_id=1, + alpha=0.1, + availability_mode="syn_0", + dataset_name="agnews", + num_trainers=10, + skip_index_splits=True, + **{"hyperparameters.client_idx": 0}, + ) + assert cfg["hyperparameters"]["client_idx"] == 0 + assert "trainer_indices_list" not in cfg["hyperparameters"] + + @pytest.mark.parametrize( + "baseline_name,expected", + [ + ("fwdllm", {"client_notify.enabled": "False"}), + ("fwdllm_plus", {"client_notify.enabled": "False"}), + ( + "fluxtune", + { + "select_perturbation_using_jvp": True, + "client_notify.enabled": "True", + }, + ), + ("fluxtune_dynkc", {"client_notify.enabled": "False"}), + ], + ) + def test_trainer_config_matches_matrix( + self, gen, baselines, baseline_name, expected + ): + gen.set_baseline_overrides(baselines[baseline_name].get("trainer", {})) + cfg = gen.generate_trainer_config( + trainer_id=1, + alpha=0.1, + availability_mode="syn_0", + dataset_name="agnews", + num_trainers=10, + skip_index_splits=True, + ) + hp = cfg["hyperparameters"] + for dotted_key, want in expected.items(): + cur = hp + for part in dotted_key.split(".")[:-1]: + cur = cur[part] + assert cur[dotted_key.split(".")[-1]] == want + + @pytest.mark.parametrize( + "baseline_name,expected", + [ + ( + "fwdllm", + { + "selector.sort": "random", + "optimizer.sort": "fedavg", + "hyperparameters.reselect_each_iteration": False, + }, + ), + ( + "fwdllm_plus", + { + "selector.sort": "random", + "optimizer.sort": "fedavg", + "hyperparameters.reselect_each_iteration": True, + }, + ), + ( + "fluxtune", + {"selector.sort": "async_oort", "optimizer.sort": "fedbuff"}, + ), + ( + "fluxtune_dynkc", + {"selector.sort": "async_random", "optimizer.sort": "fedbuff"}, + ), + ], + ) + def test_aggregator_config_matches_matrix_and_validates( + self, baselines, baseline_name, expected + ): + import json + + from flame.launch.baselines import deep_merge + from flame.launch.runner import ExperimentRunner + + tmpl = json.load(open(SHARED_METADATA / "aggregator_base.json")) + merged = deep_merge(tmpl, baselines[baseline_name]["aggregator"]) + for dotted_key, want in expected.items(): + cur = merged + for part in dotted_key.split(".")[:-1]: + cur = cur[part] + assert cur[dotted_key.split(".")[-1]] == want + + # Real entrypoint, not a synthetic fixture -- locks in the + # main_fedfwd_agg.py marker import that makes the stack-detection + # regex find the fwdllm stack on this file. + runner = ExperimentRunner(FWDLLM_AGGREGATOR_MAIN.parents[1]) + runner._validate_stack(FWDLLM_AGGREGATOR_MAIN, merged) + + +FWDLLM_EXPT_SCRIPTS = ( + Path(__file__).resolve().parents[2] / "examples" / "fwdllm" / "expt_scripts" +) + + +@pytest.mark.skipif( + not SHARED_METADATA.is_dir() or not FWDLLM_TRAINER_BASE.is_file(), + reason="shared metadata or fwdllm trainer_base not present", +) +class TestFwdllmSmokeYamlsResolve: + """The n10_smoke.yaml for each of the three owner-spec baselines (fwdllm, + fwdllm_plus, fluxtune) must load, resolve its baseline, generate a + trainer config, and pass _validate_stack against the real entrypoint -- + this is the dry-run Smoke Test D does live, kept as a permanent + regression test for all three so real/sim parity runs stay covered.""" + + @pytest.mark.parametrize( + "yaml_name,expected_baseline", + [ + ("fwdllm_n10_smoke.yaml", "fwdllm"), + ("fwdllm_plus_n10_smoke.yaml", "fwdllm_plus"), + ("fluxtune_n10_smoke.yaml", "fluxtune"), + ], + ) + def test_smoke_yaml_end_to_end(self, yaml_name, expected_baseline): + import json + + from flame.launch.baselines import deep_merge, load_baselines + from flame.launch.experiment_config import load_experiment_config + from flame.launch.runner import ExperimentRunner + from flame.launch.spawner import ConfigGenerator, MetadataLoader + + path = FWDLLM_EXPT_SCRIPTS / yaml_name + if not path.is_file(): + pytest.skip(f"{yaml_name} not present in this checkout") + + exp = load_experiment_config(path).experiments[0] + assert exp.baseline == expected_baseline + assert exp.trainer.num_trainers == 10 + + baselines = load_baselines(SHARED_METADATA) + baseline = baselines[exp.baseline] + + meta = MetadataLoader(SHARED_METADATA) + cg = ConfigGenerator(meta, FWDLLM_TRAINER_BASE) + cg.set_baseline_overrides(baseline.get("trainer", {})) + cfg = cg.generate_trainer_config( + 1, + alpha=0.1, + availability_mode=exp.trainer.availability.mode, + dataset_name=exp.trainer.dataset.name, + num_trainers=10, + skip_index_splits=exp.trainer.dataset.path_style, + **{"hyperparameters.client_idx": 0}, + ) + assert cfg["hyperparameters"]["client_idx"] == 0 + assert "trainer_indices_list" not in cfg["hyperparameters"] + + tmpl = json.load(open(SHARED_METADATA / "aggregator_base.json")) + merged_agg = deep_merge(tmpl, baseline["aggregator"]) + merged_agg = deep_merge(merged_agg, exp.aggregator.config_overrides or {}) + + runner = ExperimentRunner(FWDLLM_AGGREGATOR_MAIN.parents[1]) + runner._validate_stack(FWDLLM_AGGREGATOR_MAIN, merged_agg) + + +class TestTrainerSpawnerForwardsDatasetIdentity: + """Regression guard for the agg_goal-class bug found in TrainerSpawner: + spawn_trainer()/spawn_all() used to silently drop dataset_name/ + num_trainers on the floor instead of forwarding them to + ConfigGenerator.generate_trainer_config(), which then fell back to its + own defaults ("cifar10", 300) regardless of the real experiment -- e.g. + a 48-trainer experiment would load the cifar10_alpha_n300.yaml split + file instead of cifar10_alpha_n48.yaml whenever both exist, silently + handing every trainer the wrong (but structurally valid, non-crashing) + partition. See MIGRATING_TO_LAUNCHER.md's "real config vs. dead fields" + section.""" + + class _RecordingConfigGenerator: + def __init__(self): + self.calls = [] + + def generate_trainer_config(self, trainer_id, alpha, availability_mode, + dataset_name="cifar10", num_trainers=300, + skip_index_splits=False, **overrides): + self.calls.append( + {"trainer_id": trainer_id, "dataset_name": dataset_name, + "num_trainers": num_trainers} + ) + return {"taskid": "t", "hyperparameters": {}, "job": {}} + + def _spawner(self, recording_gen): + from flame.launch.spawner import TrainerSpawner + + return TrainerSpawner(recording_gen, num_gpus=1, cpu_pinning=False) + + def test_spawn_trainer_forwards_dataset_name_and_num_trainers( + self, tmp_path, monkeypatch + ): + import subprocess + + monkeypatch.setattr( + subprocess, "Popen", + lambda *a, **k: type("P", (), {"pid": 1})(), + ) + gen = self._RecordingConfigGenerator() + spawner = self._spawner(gen) + spawner.spawn_trainer( + trainer_id=5, alpha=0.1, availability_mode="syn_0", + trainer_main_path=tmp_path / "main.py", + dataset_name="agnews", num_trainers=48, + ) + assert gen.calls == [ + {"trainer_id": 5, "dataset_name": "agnews", "num_trainers": 48} + ] + + def test_spawn_all_forwards_dataset_name_and_num_trainers( + self, tmp_path, monkeypatch + ): + import subprocess + + monkeypatch.setattr( + subprocess, "Popen", + lambda *a, **k: type("P", (), {"pid": 1})(), + ) + gen = self._RecordingConfigGenerator() + spawner = self._spawner(gen) + spawner.spawn_all( + trainer_ids=[1, 2, 3], alpha=0.1, availability_mode="syn_0", + trainer_main_path=tmp_path / "main.py", + dataset_name="agnews", num_trainers=48, + ) + assert all( + c["dataset_name"] == "agnews" and c["num_trainers"] == 48 + for c in gen.calls + ) + assert len(gen.calls) == 3 + + def test_spawn_all_defaults_match_generate_trainer_config_defaults( + self, tmp_path, monkeypatch + ): + """Callers that don't pass dataset_name/num_trainers (e.g. direct, + non-launcher use) must fall back to the same defaults + generate_trainer_config itself documents -- not silently diverge.""" + import subprocess + + monkeypatch.setattr( + subprocess, "Popen", + lambda *a, **k: type("P", (), {"pid": 1})(), + ) + gen = self._RecordingConfigGenerator() + spawner = self._spawner(gen) + spawner.spawn_trainer( + trainer_id=1, alpha=0.1, availability_mode="syn_0", + trainer_main_path=tmp_path / "main.py", + ) + assert gen.calls == [ + {"trainer_id": 1, "dataset_name": "cifar10", "num_trainers": 300} + ] + + +class TestSyntheticTracePerTrainer: + """Regression for Open B (UNAVAILABILITY_DESIGN.md): get_synthetic_trace used + to always return the shared `pattern` entry regardless of trainer_id, + ignoring synthetic_traces.yaml's per-trainer entries. trainer_054's own + trace (first event t=13800s) differs from syn_20's shared pattern + (t=600s).""" + + def test_shared_pattern_when_trainer_id_omitted(self, loader): + pattern = loader.get_synthetic_trace("syn_20") + assert pattern[0] == [0, "AVL_TRAIN"] + assert pattern[1][0] == 600 + + def test_per_trainer_used_when_trainer_id_given(self, loader): + trace_054 = loader.get_synthetic_trace("syn_20", trainer_id=54) + pattern = loader.get_synthetic_trace("syn_20") + assert trace_054 != pattern + assert trace_054[0] == [0.0, "AVL_TRAIN"] + assert trace_054[1][0] == 13800 + + def test_different_trainers_get_different_traces(self, loader): + trace_054 = loader.get_synthetic_trace("syn_20", trainer_id=54) + trace_005 = loader.get_synthetic_trace("syn_20", trainer_id=5) + assert trace_054 != trace_005 + + def test_generate_trainer_config_bakes_in_per_trainer_trace(self, gen): + cfg = gen.generate_trainer_config( + trainer_id=54, alpha=0.1, availability_mode="syn_20" + ) + events = cfg["hyperparameters"]["avl_events_syn_20"] + assert events[1][0] == 13800 + + def test_generate_trainer_config_differs_across_trainers(self, gen): + cfg_054 = gen.generate_trainer_config( + trainer_id=54, alpha=0.1, availability_mode="syn_20" + ) + cfg_005 = gen.generate_trainer_config( + trainer_id=5, alpha=0.1, availability_mode="syn_20" + ) + assert ( + cfg_054["hyperparameters"]["avl_events_syn_20"] + != cfg_005["hyperparameters"]["avl_events_syn_20"] + ) diff --git a/lib/python/tests/launch/test_debug_run_trace_substitution.py b/lib/python/tests/launch/test_debug_run_trace_substitution.py new file mode 100644 index 000000000..03b79c534 --- /dev/null +++ b/lib/python/tests/launch/test_debug_run_trace_substitution.py @@ -0,0 +1,176 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Regression coverage for debug_run.sh's `--trace` substitution. + +`make_debug_yaml`'s generator is Python embedded in a bash heredoc (no +importable module exists for it), so these tests extract and exec the actual +heredoc source out of debug_run.sh itself -- never a hand-copied +reimplementation that could silently drift from what actually runs. + +Regression target: the generator used to patch the *aggregator's* trace +config (`h["trackTrainerAvail"]["trace"]` / `h["client_notify"]["trace"]` / +`h["availability_trace"]`) on `--trace` override, but never touched the +*trainer's* `hyperparameters.client_notify.trace` -- so every trainer, real +and sim, silently ran against the trainer_base.yaml default (`syn_0`, +always-available) regardless of the requested trace. See +UNAVAILABILITY_DESIGN.md Batch 3 T3.1. +""" + +from __future__ import annotations + +import re +import sys +from pathlib import Path + +import pytest +import yaml + +_DEBUG_RUN_SH = ( + Path(__file__).parents[2] + / "examples/async_cifar10/scripts/debug_run.sh" +) +_SCR_DIR = ( + Path(__file__).parents[2] + / "examples/async_cifar10/expt_scripts_2026" +) + + +def _extract_make_debug_yaml_source() -> str: + """Pull the Python heredoc body of make_debug_yaml() out of debug_run.sh.""" + text = _DEBUG_RUN_SH.read_text(encoding="utf-8") + m = re.search( + r"make_debug_yaml\(\) \{.*?<<'PY'\n(.*?)\nPY\n", text, re.DOTALL + ) + assert m, "could not locate make_debug_yaml()'s PY heredoc in debug_run.sh" + return m.group(1) + + +@pytest.fixture(scope="module") +def generator_source() -> str: + return _extract_make_debug_yaml_source() + + +def _run_generator( + source: str, + tmp_path: Path, + baselines: str, + trace: str, + mode: str = "both", + runtime_s: int = 100, +) -> list[dict]: + """Exec the extracted generator with a controlled argv; return experiments.""" + outpath = tmp_path / "out.yaml" + argv = [ + "make_debug_yaml", + str(_SCR_DIR), + baselines, + str(runtime_s), + str(outpath), + "0", # smoke + "", # sim_wall_ceiling_s + mode, + trace, + "", # num_trainers override + ] + old_argv = sys.argv + sys.argv = argv + try: + exec(compile(source, "make_debug_yaml", "exec"), {}) + finally: + sys.argv = old_argv + assert outpath.is_file(), "generator produced no output (no baseline matched?)" + with open(outpath) as f: + return yaml.safe_load(f)["experiments"] + + +class TestTrainerTraceSubstitution: + """The bug: trainer.config_overrides.hyperparameters.client_notify.trace + must track --trace, independent of which aggregator-side branch (legacy + trackTrainerAvail / HP-level client_notify / availability_trace) a given + baseline takes.""" + + @pytest.mark.parametrize( + "baseline", + ["felix", "oort", "oort_star", "refl", "feddance", "fedbuff"], + ) + def test_trainer_client_notify_trace_matches_override( + self, generator_source, tmp_path, baseline + ): + exps = _run_generator(generator_source, tmp_path, baseline, trace="syn_20") + assert exps, f"no experiments generated for baseline={baseline}" + for exp in exps: + trace = ( + exp["trainer"]["config_overrides"]["hyperparameters"] + ["client_notify"]["trace"] + ) + assert trace == "syn_20", ( + f"{exp['name']}: trainer client_notify.trace={trace!r}, " + f"expected 'syn_20' (--trace override was not propagated to " + f"the trainer)" + ) + + def test_trainer_client_notify_trace_tracks_different_overrides( + self, generator_source, tmp_path + ): + for trace in ("syn_0", "syn_20", "syn_50"): + exps = _run_generator( + generator_source, tmp_path, "feddance", trace=trace + ) + for exp in exps: + got = ( + exp["trainer"]["config_overrides"]["hyperparameters"] + ["client_notify"]["trace"] + ) + assert got == trace, f"{exp['name']}: expected {trace!r}, got {got!r}" + + def test_no_trace_override_leaves_trainer_config_untouched( + self, generator_source, tmp_path + ): + """No --trace: don't inject a client_notify block that wasn't there.""" + exps = _run_generator(generator_source, tmp_path, "feddance", trace="") + for exp in exps: + t_hp = exp["trainer"].get("config_overrides", {}).get("hyperparameters", {}) + assert "client_notify" not in t_hp + + def test_aggregator_trace_still_substituted(self, generator_source, tmp_path): + """Regression guard: fixing the trainer side must not break the + pre-existing aggregator-side substitution paths.""" + exps = _run_generator(generator_source, tmp_path, "feddance", trace="syn_50") + for exp in exps: + h = exp["aggregator"]["config_overrides"]["hyperparameters"] + assert h.get("availability_trace") == "syn_50" + assert h.get("simUnavailability") is True + + exps = _run_generator(generator_source, tmp_path, "oort", trace="syn_50") + for exp in exps: + h = exp["aggregator"]["config_overrides"]["hyperparameters"] + assert h["trackTrainerAvail"]["trace"] == "syn_50" + + +class TestMultiTraceSubstitution: + """--trace accepts a space-separated list: one full experiment set per + trace, queued in a single generated YAML/run.""" + + def test_two_traces_double_the_experiment_count(self, generator_source, tmp_path): + single = _run_generator(generator_source, tmp_path, "felix", trace="syn_20") + both = _run_generator(generator_source, tmp_path, "felix", trace="syn_20 syn_50") + assert len(both) == 2 * len(single) + + def test_each_trace_propagates_to_its_own_experiments( + self, generator_source, tmp_path + ): + exps = _run_generator(generator_source, tmp_path, "felix", trace="syn_20 syn_50") + by_trace = { + trace: [ + e for e in exps + if e["trainer"]["config_overrides"]["hyperparameters"] + ["client_notify"]["trace"] == trace + ] + for trace in ("syn_20", "syn_50") + } + assert len(by_trace["syn_20"]) == len(by_trace["syn_50"]) == len(exps) // 2 + + def test_experiment_names_disambiguate_by_trace(self, generator_source, tmp_path): + exps = _run_generator(generator_source, tmp_path, "felix", trace="syn_20 syn_50") + names = [e["name"] for e in exps] + assert len(names) == len(set(names)), f"duplicate names: {names}" diff --git a/lib/python/tests/launch/test_runner_paths.py b/lib/python/tests/launch/test_runner_paths.py index 2df2c0338..012ace1c5 100644 --- a/lib/python/tests/launch/test_runner_paths.py +++ b/lib/python/tests/launch/test_runner_paths.py @@ -7,6 +7,7 @@ import pytest from flame.launch.experiment_config import ( + AggregatorConfig, ExampleConfig, ExperimentConfig, MetadataPaths, @@ -93,3 +94,171 @@ def test_metadata_dir_at_constructor(self, fake_example_dir, tmp_path): exp = ExperimentConfig(name="x") paths = runner._resolve_example_paths(exp) assert paths["metadata_dir"] == shared.resolve() + + +class TestValidateStack: + """fwdllm is selector-driven (is_async kwarg), all other stacks are + stack-set-driven (_ASYNC_STACKS membership).""" + + @pytest.fixture + def fwdllm_main(self, tmp_path): + p = tmp_path / "main_fedfwd_agg.py" + p.write_text( + "from flame.mode.horizontal.syncfl.fwdllm_aggregator import TopAggregator\n" + ) + return p + + @pytest.fixture + def asyncfl_main(self, tmp_path): + p = tmp_path / "main_asyncfl_agg.py" + p.write_text( + "from flame.mode.horizontal.asyncfl.top_aggregator import TopAggregator\n" + ) + return p + + @pytest.fixture + def syncfl_main(self, tmp_path): + p = tmp_path / "main_sync_agg.py" + p.write_text( + "from flame.mode.horizontal.syncfl.top_aggregator import TopAggregator\n" + ) + return p + + def test_fwdllm_sync_random_no_raise(self, fake_example_dir, fwdllm_main): + runner = ExperimentRunner(fake_example_dir) + agg_cfg = {"selector": {"sort": "random", "kwargs": {"is_async": False}}} + runner._validate_stack(fwdllm_main, agg_cfg) + + def test_fwdllm_async_oort_no_raise(self, fake_example_dir, fwdllm_main): + runner = ExperimentRunner(fake_example_dir) + agg_cfg = {"selector": {"sort": "async_oort", "kwargs": {"is_async": True}}} + runner._validate_stack(fwdllm_main, agg_cfg) + + def test_fwdllm_random_declared_async_raises(self, fake_example_dir, fwdllm_main): + runner = ExperimentRunner(fake_example_dir) + agg_cfg = {"selector": {"sort": "random", "kwargs": {"is_async": True}}} + with pytest.raises(ValueError): + runner._validate_stack(fwdllm_main, agg_cfg) + + def test_fwdllm_async_oort_declared_sync_raises(self, fake_example_dir, fwdllm_main): + runner = ExperimentRunner(fake_example_dir) + agg_cfg = {"selector": {"sort": "async_oort", "kwargs": {"is_async": False}}} + with pytest.raises(ValueError): + runner._validate_stack(fwdllm_main, agg_cfg) + + def test_asyncfl_async_random_no_raise(self, fake_example_dir, asyncfl_main): + """Regression guard: non-fwdllm stacks are unaffected.""" + runner = ExperimentRunner(fake_example_dir) + agg_cfg = {"selector": {"sort": "async_random"}} + runner._validate_stack(asyncfl_main, agg_cfg) + + def test_syncfl_async_random_raises(self, fake_example_dir, syncfl_main): + """Regression guard: sync stack + async selector still rejected.""" + runner = ExperimentRunner(fake_example_dir) + agg_cfg = {"selector": {"sort": "async_random"}} + with pytest.raises(ValueError): + runner._validate_stack(syncfl_main, agg_cfg) + + def test_real_fwdllm_entrypoint_detected_for_both_sync_and_async( + self, fake_example_dir + ): + """Regression guard against the real entrypoint, not a synthetic + fixture: examples/fwdllm/aggregator/main_fedfwd_agg.py doesn't + import fwdllm_aggregator.TopAggregator directly (it imports + FedSGDAggregator, which extends TopAggregator in a separate file), + so the static stack-detection regex needs a same-file marker import + to find it -- see that file's TopAggregator import comment.""" + real_main = ( + Path(__file__).resolve().parents[2] + / "examples" + / "fwdllm" + / "aggregator" + / "main_fedfwd_agg.py" + ) + assert real_main.is_file(), real_main + runner = ExperimentRunner(fake_example_dir) + + runner._validate_stack( + real_main, + {"selector": {"sort": "random", "kwargs": {"is_async": False}}}, + ) + runner._validate_stack( + real_main, + {"selector": {"sort": "async_oort", "kwargs": {"is_async": True}}}, + ) + with pytest.raises(ValueError): + runner._validate_stack( + real_main, + {"selector": {"sort": "async_oort", "kwargs": {"is_async": False}}}, + ) + + +class TestAggGoalFanOut: + """`AggregatorConfig.agg_goal` must be a single source of truth: when + set, it has to land in every real runtime consumer (hyperparameters. + aggGoal, selector.kwargs.aggGoal, selector.kwargs.aggr_num) so they + can't silently disagree -- see AggregatorConfig.agg_goal's docstring + for why there are two differently-named selector kwargs.""" + + def test_agg_goal_fans_into_hyperparameters_and_both_selector_kwargs( + self, fake_example_dir + ): + runner = ExperimentRunner(fake_example_dir) + exp = ExperimentConfig( + name="x", + aggregator=AggregatorConfig(selector="oort", agg_goal=7), + ) + # Baseline layer sets a different value (10) than the experiment's + # agg_goal (7) -- agg_goal must win as the final, highest-precedence + # layer. + baseline = { + "aggregator": { + "hyperparameters": {"aggGoal": 10}, + "selector": {"sort": "oort", "kwargs": {"aggr_num": 10}}, + } + } + agg_cfg, provenance = runner._build_aggregator_config(exp, None, baseline) + assert agg_cfg["hyperparameters"]["aggGoal"] == 7 + assert agg_cfg["selector"]["kwargs"]["aggGoal"] == 7 + assert agg_cfg["selector"]["kwargs"]["aggr_num"] == 7 + assert provenance["hyperparameters.aggGoal"] == "experiment.aggregator.agg_goal" + + def test_agg_goal_none_leaves_lower_layers_untouched(self, fake_example_dir): + """The smoke-test bug this guards against: omitting agg_goal must + not silently fall back to some other default -- it must leave + whatever config_template/baseline/config_overrides produced.""" + runner = ExperimentRunner(fake_example_dir) + exp = ExperimentConfig(name="x", aggregator=AggregatorConfig(agg_goal=None)) + baseline = { + "aggregator": { + "selector": {"sort": "async_oort", "kwargs": {"aggGoal": 5}}, + "hyperparameters": {"aggGoal": 5}, + } + } + agg_cfg, _ = runner._build_aggregator_config(exp, None, baseline) + assert agg_cfg["hyperparameters"]["aggGoal"] == 5 + assert agg_cfg["selector"]["kwargs"]["aggGoal"] == 5 + assert "aggr_num" not in agg_cfg["selector"]["kwargs"] + + +class TestSelectorLabelValidation: + """`aggregator.selector` is a descriptive label only (log filename / + snapshot records) -- it must be validated against the real merged + selector so a stale label is caught, not silently mislabeling every + record of the run.""" + + def test_matching_label_does_not_raise(self, fake_example_dir): + runner = ExperimentRunner(fake_example_dir) + exp = ExperimentConfig(name="x", aggregator=AggregatorConfig(selector="oort")) + runner._validate_selector_label(exp, {"selector": {"sort": "oort"}}) + + def test_mismatched_label_raises(self, fake_example_dir): + runner = ExperimentRunner(fake_example_dir) + exp = ExperimentConfig(name="x", aggregator=AggregatorConfig(selector="random")) + with pytest.raises(ValueError): + runner._validate_selector_label(exp, {"selector": {"sort": "oort"}}) + + def test_no_aggregator_block_does_not_raise(self, fake_example_dir): + runner = ExperimentRunner(fake_example_dir) + exp = ExperimentConfig(name="x") + runner._validate_selector_label(exp, {"selector": {"sort": "oort"}}) diff --git a/lib/python/tests/mode/test_agg_start_ts_broadcast.py b/lib/python/tests/mode/test_agg_start_ts_broadcast.py new file mode 100644 index 000000000..b705af7b4 --- /dev/null +++ b/lib/python/tests/mode/test_agg_start_ts_broadcast.py @@ -0,0 +1,288 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Batch 3 T3.0: broadcast the aggregator's trace-read origin to trainers. + +Real mode's `_avail_now()`/`_sim_now()`-equivalent needs a SHARED origin +between aggregator and trainer, exactly like sim's shared `_vclock` instance. +Before this, a real-mode trainer had no way to know `agg_start_time_ts` (the +join-barrier-reanchored origin, see test_join_barrier_reanchor.py) at all, so +any trainer-side wall-clock trace lookup would have had to derive its own +origin (e.g. its own process-start time) -- reintroducing a per-trainer +join-ramp-style skew, the same class of bug as B2.0.3 just moved to the +trainer side. `MessageType.AGG_START_TS` closes that: the aggregator stamps +it on every real-mode dispatch (mirroring how `SIM_SEND_TS` is stamped for +sim), and the trainer caches it, using it as the origin for `_sim_now()`'s +real-mode branch instead of `trainer_start_ts`. +""" + +from __future__ import annotations + +import types + +import pytest + +from flame.mode.message import MessageType + + +# ── Minimal channel mocks (mirrors tests/mode/test_async_staggered_redispatch.py) ── + +class _DistChannel: + """Records every dispatched payload/property, no real transport.""" + + def __init__(self, ends): + self._ends = {e: None for e in ends} + self.properties = {} + self.props = {} + self.sent = {} + self._selector = types.SimpleNamespace(selected_ends=set()) + + def await_join(self): + pass + + def ends(self, state, task=None, **kw): + return list(self._ends.keys()) + + def dumps(self, msg): + return dict(msg) + + def send_payload(self, end, payload): + self.sent[end] = payload + + def set_end_property(self, end, key, value): + self.props.setdefault(end, {})[key] = value + + def set_curr_unavailable_trainers(self, trainer_unavail_list=None): + self.unavail = list(trainer_unavail_list or []) + + +def _stub_common(agg, channel, *, simulated): + agg.simulated = simulated + agg.agg_start_time_ts = 1_700_000_000.0 + agg._round = 3 + agg.trainer_event_dict = None # gate off: skip the oracular unavailable-list path + agg.cm = types.SimpleNamespace(get_by_tag=lambda tag: channel) + agg._await_min_trainers = lambda ch: None + agg._update_weights = lambda: None + agg._inject_oracle_utilities = lambda ch, task: None + agg._avail_stamp_end_states = lambda ch: None + agg._avail_now = lambda: 0.0 + agg._sim_abandon_stalled = lambda ch: None + agg._sim_evict_unavail_inflight = lambda ch: None + agg.datasampler = types.SimpleNamespace(get_metadata=lambda r, e: {}) + agg.weights = {} + + +def _make_syncfl_agg(channel, *, simulated): + from flame.mode.horizontal.syncfl.top_aggregator import TopAggregator + + class _Concrete(TopAggregator): + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + agg = _Concrete.__new__(_Concrete) + _stub_common(agg, channel, simulated=simulated) + agg.config = types.SimpleNamespace( + hyperparameters=types.SimpleNamespace(aggregation_goal=1) + ) + return agg + + +def _make_oort_agg(channel, *, simulated): + from flame.mode.horizontal.oort.top_aggregator import TopAggregator + + class _Concrete(TopAggregator): + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + agg = _Concrete.__new__(_Concrete) + _stub_common(agg, channel, simulated=simulated) + agg.config = types.SimpleNamespace( + selector=types.SimpleNamespace(kwargs={"aggr_num": 1}), + hyperparameters=types.SimpleNamespace(sim_inflight_residence=False), + ) + return agg + + +@pytest.fixture(autouse=True) +def _identity_weights(monkeypatch): + import flame.mode.horizontal.syncfl.top_aggregator as syncfl_mod + import flame.mode.horizontal.oort.top_aggregator as oort_mod + + monkeypatch.setattr(syncfl_mod, "weights_to_device", lambda w, d: w) + monkeypatch.setattr(oort_mod, "weights_to_device", lambda w, d: w) + + +class TestAggregatorBroadcastsOrigin: + """Every real-mode dispatch carries AGG_START_TS; sim never does.""" + + def test_syncfl_real_mode_stamps_agg_start_ts(self): + ch = _DistChannel(["e1", "e2"]) + agg = _make_syncfl_agg(ch, simulated=False) + agg._distribute_weights("tag", "train") + assert ch.sent["e1"][MessageType.AGG_START_TS] == agg.agg_start_time_ts + assert ch.sent["e2"][MessageType.AGG_START_TS] == agg.agg_start_time_ts + assert MessageType.SIM_SEND_TS not in ch.sent["e1"] + + def test_syncfl_sim_mode_never_stamps_agg_start_ts(self): + from flame.sim import VirtualClock + + ch = _DistChannel(["e1", "e2"]) + agg = _make_syncfl_agg(ch, simulated=True) + agg._vclock = VirtualClock() + agg._vclock.advance(42.0) + agg._distribute_weights("tag", "train") + assert MessageType.AGG_START_TS not in ch.sent["e1"] + assert ch.sent["e1"][MessageType.SIM_SEND_TS] == 42.0 + + def test_oort_real_mode_stamps_agg_start_ts(self): + ch = _DistChannel(["e1", "e2"]) + agg = _make_oort_agg(ch, simulated=False) + agg._distribute_weights("tag", "train") + assert ch.sent["e1"][MessageType.AGG_START_TS] == agg.agg_start_time_ts + assert MessageType.SIM_SEND_TS not in ch.sent["e1"] + + def test_oort_sim_mode_never_stamps_agg_start_ts(self): + from flame.sim import VirtualClock + + ch = _DistChannel(["e1", "e2"]) + agg = _make_oort_agg(ch, simulated=True) + agg._vclock = VirtualClock() + agg._vclock.advance(17.0) + agg._distribute_weights("tag", "train") + assert MessageType.AGG_START_TS not in ch.sent["e1"] + assert ch.sent["e1"][MessageType.SIM_SEND_TS] == 17.0 + + def test_asyncfl_real_mode_stamps_agg_start_ts(self): + # asyncfl's staggered path is sim-only (_staggered requires + # self.simulated); real mode always takes the shared/batched branch, + # so it's enough to exercise that one. + from flame.mode.horizontal.asyncfl.top_aggregator import TopAggregator + from flame.sim import VirtualClock + + class _Concrete(TopAggregator): + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + ch = _DistChannel(["e1", "e2"]) + agg = _Concrete.__new__(_Concrete) + _stub_common(agg, ch, simulated=False) + agg._vclock = VirtualClock() + agg._sim_staggered_redispatch = False + agg._sim_inflight_residence = False + agg._sim_free_slot_ts = __import__("collections").deque(maxlen=128) + agg._sim_last_commit_sct = {} + agg._sim_inflight_expected = {} + agg._sim_trainer_budget = {} + agg._sim_budget_min = 12.0 + agg._sim_redispatch_gap_s = 0.0 + agg._sim_cooldown_until = {} + agg._real_distribute_settle_s = 0.0 + agg._track_trainer_version_duration_s = {} + agg.weights = {} + agg._distribute_weights("tag", "train") + assert ch.sent["e1"][MessageType.AGG_START_TS] == agg.agg_start_time_ts + + +class TestTrainerCachesOrigin: + """syncfl/trainer.py's message handling caches AGG_START_TS (real mode).""" + + def _make_trainer(self): + from flame.mode.horizontal.syncfl.trainer import Trainer + + class _Concrete(Trainer): + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + t = _Concrete.__new__(_Concrete) + t.trainer_id = "trainer-under-test" + t._round = 0 + t._work_done = False + t.task_to_perform = "train" + t._agg_start_origin = None + return t + + def _fetch(self, trainer, msg): + """Drive _fetch_weights with a minimal channel (no WEIGHTS payload, + so the torch-dependent model-loading branch is never entered).""" + selector = types.SimpleNamespace(ordered_updates_recv_ends=[]) + channel = types.SimpleNamespace( + _selector=selector, + await_join=lambda: None, + one_end=lambda state: "agg-end", + recv=lambda end: (msg, None), + cleanup_recvd_ends=lambda: None, + ) + trainer.cm = types.SimpleNamespace(get_by_tag=lambda tag: channel) + trainer._fetch_weights("tag") + + def test_caches_agg_start_ts_from_message(self): + t = self._make_trainer() + origin = 1_700_000_123.456 + self._fetch(t, {MessageType.ROUND: 1, MessageType.AGG_START_TS: origin}) + assert t._agg_start_origin == origin + + def test_no_agg_start_ts_in_message_leaves_cache_untouched(self): + t = self._make_trainer() + t._agg_start_origin = 111.0 + self._fetch(t, {MessageType.ROUND: 1}) + assert t._agg_start_origin == 111.0 # unchanged, not reset to None + + def test_re_caches_on_every_dispatch(self): + t = self._make_trainer() + self._fetch(t, {MessageType.ROUND: 1, MessageType.AGG_START_TS: 100.0}) + assert t._agg_start_origin == 100.0 + self._fetch(t, {MessageType.ROUND: 2, MessageType.AGG_START_TS: 100.0}) + assert t._agg_start_origin == 100.0 + + +# PyTorchCifar10Trainer._sim_now()'s real-mode branch is example-specific code +# (examples/async_cifar10/trainer/pytorch/main.py), not core flame -- see +# examples/async_cifar10/trainer/pytorch/test_agg_start_ts_sim_now.py. diff --git a/lib/python/tests/mode/test_async_sim_ordering.py b/lib/python/tests/mode/test_async_sim_ordering.py index 08bd4cfc5..8d0d33654 100644 --- a/lib/python/tests/mode/test_async_sim_ordering.py +++ b/lib/python/tests/mode/test_async_sim_ordering.py @@ -349,6 +349,88 @@ def _boom(): self._call(sel, concurrency=2, cooling_count=0) +class TestSendTimeoutReclaimsConcurrencySlot: + """Regression: a selected end that never returns an update within + SEND_TIMEOUT_WAIT_S must be reclaimed from BOTH ``all_selected`` and + ``selected_ends``, and that reclaim must happen before the extra==0 + short-circuit. Previously the reclaim ran *after* the short-circuit and + only cleared all_selected (never selected_ends, which is what `extra`'s + concurrency accounting counts) -- so one non-responding trainer + permanently pinned `extra` at 0 and no further selection ever happened + again for the rest of the run. See + examples/MIGRATING_TO_LAUNCHER.md's aggregator gotchas (fwdllm example) + for the full-stall this caused in fluxtune at n30 scale. + """ + + STALE_END = "t_stuck" + + @classmethod + def _stub_selector(cls, stale: bool): + import time + + from flame.selector.async_oort import SEND_TIMEOUT_WAIT_S, AsyncOortSelector + + sel = AsyncOortSelector.__new__(AsyncOortSelector) + sel.requester = "agg" + sel.selected_ends = {"agg": {cls.STALE_END}} + send_ts = time.time() - (SEND_TIMEOUT_WAIT_S + 1 if stale else 0) + sel.all_selected = {cls.STALE_END: send_ts} + sel.ordered_updates_recv_ends = [] + sel.track_trainer_timeouts = {} + return sel + + def _call(self, sel, concurrency=1): + # STALE_END must be a currently-known end (present in `ends`) so the + # pre-existing "invalid selection" cleanup a few lines below (which + # drops any selected_ends entry absent from `ends`, e.g. on + # disconnect) doesn't confound this test -- only the + # SEND_TIMEOUT_WAIT_S reclaim under test should decide its fate here. + ends = {f"t{i}": _FakeEnd() for i in range(5)} + ends[self.STALE_END] = _FakeEnd() + return sel._handle_send_state( + ends=ends, + concurrency=concurrency, + channel_props={"round": 1}, + trainer_unavail_list=[], + task_to_perform="train", + agg_version_state=(1, 0, 0), + trainer_version_states={}, + ) + + def test_stale_end_freed_from_both_dicts_and_unblocks_selection(self): + sel = self._stub_selector(stale=True) + + class _Tripwire(Exception): + pass + + def _boom(): + raise _Tripwire() + + sel.pacer = _boom + # Reaching the tripwire proves extra != 0, i.e. the reclaim ran + # before the extra==0 short-circuit and actually freed the slot. + with pytest.raises(_Tripwire): + self._call(sel, concurrency=1) + + assert self.STALE_END not in sel.all_selected + assert self.STALE_END not in sel.selected_ends["agg"] + + def test_fresh_end_not_reclaimed_still_short_circuits(self): + # Control: an end selected moments ago (not past SEND_TIMEOUT_WAIT_S) + # must NOT be reclaimed -- concurrency stays saturated and extra==0 + # still short-circuits before pacer() ever runs. + sel = self._stub_selector(stale=False) + pacer_called = [] + sel.pacer = lambda: pacer_called.append(True) + + result = self._call(sel, concurrency=1) + + assert result == {} + assert not pacer_called + assert self.STALE_END in sel.all_selected + assert self.STALE_END in sel.selected_ends["agg"] + + class TestGateProbesLiveInflight: """§3g: the gate must probe the LIVE in-flight set (_sim_inflight_expected), not just the recv_ends snapshot taken once per cycle. Otherwise it holds the diff --git a/lib/python/tests/mode/test_async_staggered_redispatch.py b/lib/python/tests/mode/test_async_staggered_redispatch.py index b4719ca8f..bda8ed6ae 100644 --- a/lib/python/tests/mode/test_async_staggered_redispatch.py +++ b/lib/python/tests/mode/test_async_staggered_redispatch.py @@ -13,6 +13,7 @@ """ import inspect +import time import types from collections import deque @@ -98,7 +99,7 @@ def __init__(self, send_ends): def await_join(self): pass - def ends(self, state, task=None): + def ends(self, state, task=None, agg_version_state=None, trainer_version_states=None): return list(self._send_ends) def dumps(self, msg): @@ -120,6 +121,7 @@ def has(self, end): def _make_dist_agg(channel, *, staggered, simulated=True, free_slots=()): agg = _ConcreteAgg.__new__(_ConcreteAgg) agg.simulated = simulated + agg.agg_start_time_ts = time.time() agg._round = 5 agg._vclock = VirtualClock() agg._vclock.advance(100.0) diff --git a/lib/python/tests/mode/test_asyncfl_duplicate_contribution.py b/lib/python/tests/mode/test_asyncfl_duplicate_contribution.py new file mode 100644 index 000000000..de1bce2c9 --- /dev/null +++ b/lib/python/tests/mode/test_asyncfl_duplicate_contribution.py @@ -0,0 +1,145 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""An end must contribute at most once per aggregation cycle in the generic +asyncfl TopAggregator (flame/mode/horizontal/asyncfl/top_aggregator.py). + +Unlike fwdllm_aggregator.TopAggregator (which has a dedicated +_per_agg_trainer_list guard, see test_fwdllm_duplicate_contribution.py), the +generic asyncfl aggregator had no equivalent check. That was safe only as +long as the selector's SEND_TIMEOUT_WAIT_S reclaim was itself broken (see +../../examples/MIGRATING_TO_LAUNCHER.md's aggregator gotchas): a stuck trainer's slot never actually +reopened, so it could never be reselected while its original response was +still in flight. Fixing that reclaim (async_oort.py/async_random.py/ +fedbuff.py) makes a genuine duplicate-contribution newly reachable, so this +guard (_agg_cycle_contributed_ends) closes the same gap here. +""" + +from types import SimpleNamespace + +import torch + +from flame.mode.horizontal.asyncfl.top_aggregator import TopAggregator +from flame.mode.message import MessageType + + +class _FakeSelector: + def __init__(self): + self.ordered_updates_recv_ends = [] + + +class _FakeChannel: + """Yields a canned sequence of (msg, (end_id, timestamp)) pairs, one per + recv_fifo call, mirroring the real one-message-per-call contract.""" + + def __init__(self, messages): + self._messages = list(messages) + self._end_props = {} + self.cleaned_up = [] + self._selector = _FakeSelector() + + def ends(self, state=None): + return ["t1"] + + def has(self, end_id): + return True + + def recv_fifo(self, recv_ends, first_k=0, timeout=None): + yield self._messages.pop(0) + + def set_end_property(self, end_id, key, value): + self._end_props[(end_id, key)] = value + + def get_end_property(self, end_id, key): + return self._end_props.get((end_id, key)) + + def cleanup_provided_ends(self, end_ids): + self.cleaned_up.append(end_ids) + + +class _ConcreteAgg(TopAggregator): + """Concrete stub so we can instantiate without the abstract methods.""" + + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + +def _make_agg(): + """A TopAggregator with only the state _aggregate_weights touches, + configured so agg_goal is never reached (avoids needing to stub the + optimizer.scale_add_agg_weights/_update_model finalization path).""" + agg = _ConcreteAgg.__new__(_ConcreteAgg) + agg.simulated = False + agg._agg_goal = 5 # high enough that 2 messages never trip finalization + agg._agg_goal_cnt = 0 + agg._agg_goal_weights = None + agg._agg_cycle_contributed_ends = set() + agg._updates_in_queue = 0 + agg._updates_recevied = {} + agg._per_round_update_list = [] + agg._per_trainer_staleness_track = {} + agg._round_update_values = {"staleness": [], "stat_utility": [], "trainer_speed": []} + agg._round = 1 + agg.reject_stale_updates = "False" + agg._track_trainer_version_duration_s = {} + agg.cache = {} + agg.model = torch.nn.Linear(1, 1) + agg.optimizer = SimpleNamespace(do=lambda agg_w, cache, total, version, staleness_factor: agg_w) + return agg + + +def _msg_for(end_id, version=1): + return ( + { + MessageType.WEIGHTS: {"weight": torch.zeros(1, 1)}, + MessageType.MODEL_VERSION: version, + MessageType.DATASET_SIZE: 10, + }, + (end_id, 0.0), + ) + + +class TestAsyncflDuplicateContributionGuard: + def test_second_contribution_from_same_end_same_cycle_is_ignored(self): + agg = _make_agg() + channel = _FakeChannel([_msg_for("t1"), _msg_for("t1")]) + agg.cm = SimpleNamespace(get_by_tag=lambda tag: channel) + + agg._aggregate_weights("param-channel") + assert "t1" in agg.cache + assert agg._agg_goal_cnt == 1 + assert channel.cleaned_up == [] + + # Second message from the SAME end within the same (unreset) cycle + # must be rejected, not double-counted. + agg._aggregate_weights("param-channel") + assert agg._agg_goal_cnt == 1 + assert channel.cleaned_up == ["t1"] + + def test_different_ends_both_counted(self): + agg = _make_agg() + channel = _FakeChannel([_msg_for("t1"), _msg_for("t2")]) + agg.cm = SimpleNamespace(get_by_tag=lambda tag: channel) + + agg._aggregate_weights("param-channel") + agg._aggregate_weights("param-channel") + + assert agg._agg_goal_cnt == 2 + assert channel.cleaned_up == [] + + def test_reset_agg_goal_variables_clears_guard_for_next_cycle(self): + agg = _make_agg() + agg._agg_cycle_contributed_ends = {"t1"} + agg._reset_agg_goal_variables() + assert agg._agg_cycle_contributed_ends == set() diff --git a/lib/python/tests/mode/test_eot_avail_catchup.py b/lib/python/tests/mode/test_eot_avail_catchup.py new file mode 100644 index 000000000..a26df27a6 --- /dev/null +++ b/lib/python/tests/mode/test_eot_avail_catchup.py @@ -0,0 +1,161 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Batch 4 finding 2 (UNAVAILABILITY_DESIGN.md): a sim-mode trainer that goes +quiet (correctly withheld/evicted as UN_AVL, so never dispatched again) has a +frozen `_sim_now()` and so can never catch its `avail_change` telemetry up to +later trace transitions on its own. `inform_end_of_training`'s existing +`channel.broadcast(...)` already reaches every connected end regardless of +dispatch state, so it now piggybacks the aggregator's final `_avail_now()` +(gated on sim mode + the availability feature being on, so the broadcast +payload is byte-identical when off) -- one last wake-up letting +`_refresh_avl_state()` flush any queued transitions before the trainer exits. + +Two halves, mirroring test_agg_start_ts_broadcast.py's structure: + * aggregator side: inform_end_of_training's broadcast payload. + * trainer side: _fetch_weights calls _refresh_avl_state() on EOT receipt. +""" + +from __future__ import annotations + +import types + +import pytest + +from flame.mode.message import MessageType + + +# ---- Aggregator side ------------------------------------------------------- + +class _BroadcastChannel: + """Records the last broadcast payload, no real transport.""" + + def __init__(self): + self.broadcasts = [] + + def broadcast(self, payload): + self.broadcasts.append(dict(payload)) + + +def _make_syncfl_agg(*, simulated, gate_on, vclock_now=42.0): + from flame.mode.horizontal.syncfl.top_aggregator import TopAggregator + from flame.sim import VirtualClock + + class _Concrete(TopAggregator): + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + agg = _Concrete.__new__(_Concrete) + agg.simulated = simulated + agg._work_done = True + agg.trainer_event_dict = {"e1": object()} if gate_on else None + agg.agg_start_time_ts = 1_700_000_000.0 + channel = _BroadcastChannel() + agg.cm = types.SimpleNamespace(get_by_tag=lambda tag: channel) + agg.dist_tag = "tag" + if simulated: + agg._vclock = VirtualClock() + agg._vclock.advance(vclock_now) + return agg, channel + + +class TestInformEndOfTrainingCarriesFinalClock: + def test_sim_mode_gate_on_carries_sim_send_ts(self): + agg, ch = _make_syncfl_agg(simulated=True, gate_on=True, vclock_now=77.0) + agg.inform_end_of_training() + assert ch.broadcasts[0][MessageType.SIM_SEND_TS] == 77.0 + assert ch.broadcasts[0][MessageType.EOT] is True + + def test_sim_mode_gate_off_omits_sim_send_ts(self): + """Byte-identical broadcast payload when the availability feature is off.""" + agg, ch = _make_syncfl_agg(simulated=True, gate_on=False) + agg.inform_end_of_training() + assert MessageType.SIM_SEND_TS not in ch.broadcasts[0] + assert ch.broadcasts[0] == {MessageType.EOT: True} + + def test_real_mode_omits_sim_send_ts(self): + """Real mode's clock never freezes -- no catch-up broadcast needed.""" + agg, ch = _make_syncfl_agg(simulated=False, gate_on=True) + agg.inform_end_of_training() + assert MessageType.SIM_SEND_TS not in ch.broadcasts[0] + assert ch.broadcasts[0] == {MessageType.EOT: True} + + +# ---- Trainer side ----------------------------------------------------------- + +class TestTrainerFlushesCatchupOnEot: + def _make_trainer(self, *, with_refresh_hook): + from flame.mode.horizontal.syncfl.trainer import Trainer + + class _Concrete(Trainer): + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + t = _Concrete.__new__(_Concrete) + t.trainer_id = "trainer-under-test" + t._round = 0 + t._work_done = False + t.task_to_perform = "train" + t._agg_start_origin = None + if with_refresh_hook: + t._refresh_calls = 0 + + def _refresh(): + t._refresh_calls += 1 + + t._refresh_avl_state = _refresh + return t + + def _fetch(self, trainer, msg): + selector = types.SimpleNamespace(ordered_updates_recv_ends=[]) + channel = types.SimpleNamespace( + _selector=selector, + await_join=lambda: None, + one_end=lambda state: "agg-end", + recv=lambda end: (msg, None), + cleanup_recvd_ends=lambda: None, + ) + trainer.cm = types.SimpleNamespace(get_by_tag=lambda tag: channel) + trainer._fetch_weights("tag") + + def test_eot_triggers_refresh_when_hook_present(self): + t = self._make_trainer(with_refresh_hook=True) + self._fetch(t, {MessageType.EOT: True, MessageType.SIM_SEND_TS: 900.0}) + assert t._work_done is True + assert t._refresh_calls == 1 + + def test_eot_without_hook_is_safe_noop(self): + """Not every Trainer subclass defines _refresh_avl_state (example- + specific) -- the hasattr guard must not raise for those.""" + t = self._make_trainer(with_refresh_hook=False) + assert not hasattr(t, "_refresh_avl_state") + self._fetch(t, {MessageType.EOT: True}) # must not raise + assert t._work_done is True + + def test_non_eot_message_does_not_trigger_refresh(self): + t = self._make_trainer(with_refresh_hook=True) + self._fetch(t, {MessageType.ROUND: 3}) + assert t._refresh_calls == 0 diff --git a/lib/python/tests/mode/test_fwdllm_agg_telemetry.py b/lib/python/tests/mode/test_fwdllm_agg_telemetry.py new file mode 100644 index 000000000..c5300be37 --- /dev/null +++ b/lib/python/tests/mode/test_fwdllm_agg_telemetry.py @@ -0,0 +1,458 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""fwdllm's aggregator emitted zero telemetry (see +../../examples/MIGRATING_TO_LAUNCHER.md's telemetry gotchas) -- unlike +asyncfl/top_aggregator.py, it never called telemetry.emit() for agg_eval/ +agg_round, so plots/performance/ and plots/insights/ were structurally empty +for every fwdllm-family baseline regardless of what the analyzer did. + +This covers the fix: _process_aggregation_goal_met now emits agg_eval (right +after eval_model(), only on the variance-check-passed path) and agg_round +(once per completed aggregation cycle, on both the passed and failed paths) +when telemetry is enabled, and stays a true no-op (no emit call at all) when +it isn't. +""" + +from datetime import timedelta + +import torch + +from flame import telemetry +from flame.mode.horizontal.syncfl.fwdllm_aggregator import ( + PROP_ROUND_START_TIME, + PROP_STAT_UTILITY, + TopAggregator, +) +from flame.mode.message import MessageType +from flame.selector.properties import PROP_CLIENT_TASK_TRAIN_DURATION + + +class _FakeChannel: + def __init__(self, durations=None, utilities=None): + self._durations = durations or {} + self._utilities = utilities or {} + self.cleaned_up_rounds = [] + self.round_prop = None + + def get_end_property(self, end, key): + if key == PROP_CLIENT_TASK_TRAIN_DURATION: + return self._durations.get(end) + if key == PROP_STAT_UTILITY: + return self._utilities.get(end) + return None + + def set_property(self, key, value): + if key == "round": + self.round_prop = value + + def cleanup_recvd_ends(self): + self.cleaned_up_rounds.append("cleaned") + + +class _FakeHyperparameters: + inc_model_version_per_data_id = True + rounds = 1000 + + +class _FakeConfig: + hyperparameters = _FakeHyperparameters() + + +class _FakeAggregator: + """Binds the real _process_aggregation_goal_met onto a minimal stand-in. + + Only stubs the heavy ML plumbing (aggregate/eval_model/model + functionalization) that method touches but which is irrelevant to the + telemetry-emission logic under test -- everything else (round/data_id + bookkeeping, telemetry field construction) runs for real. + """ + + _process_aggregation_goal_met = TopAggregator._process_aggregation_goal_met + + def __init__(self, contributors, var_good_enough, staleness_map=None, + total_data_bins=150): + self._per_agg_trainer_list = list(contributors) + self._agg_goal_cnt = len(contributors) + self._agg_goal = len(contributors) or 1 + self._model_version_unique_trainers = set() + self._model_version_trainer_stats = { + "train_duration": [], "partial_stat_utility": [], + } + self._trainer_last_model_version = staleness_map or {} + self._model_version = 5 + self._round = 1 + self.data_id = 3 + self.iteration_per_data_id = 0 + self.total_data_bins = total_data_bins + self._updates_in_queue = len(contributors) + self._updates_received = {c: 1 for c in contributors} + self._max_iter_per_data_id = None + self._dynamic_kc_controller = None + self._n_aggs_completed = 0 + self._var_pass_count = 0 + self._var_total_count = 0 + self.var = 0.1 + self.var_good_enough = var_good_enough + self.var_threshold = 0.3 + self.grad_pool = [] + self.grad = [torch.zeros(1)] + self.model = torch.nn.Linear(1, 1) + self.config = _FakeConfig() + self._eval_result = {"eval_loss": 0.42, "acc": 0.9, "mcc": 0.5} + + # Stubs for the heavy ML machinery this method calls but which this + # test doesn't need to exercise for real. + import functorch as fc + self.fmodel, self.params, self.buffers = fc.make_functional_with_buffers( + self.model + ) + + def aggregate(self, round_num): + pass # normally sets self.var/self.var_good_enough as a side effect + + def add_local_trained_result(self, *a, **k): + pass + + def eval_model(self): + return dict(self._eval_result), None, [] + + def _log_and_reset_model_version_stats(self): + pass + + +class TestAggEvalTelemetry: + def test_emitted_on_variance_pass_with_expected_fields(self, tmp_path): + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + agg = _FakeAggregator(contributors=["t1"], var_good_enough=True) + channel = _FakeChannel( + durations={"t1": timedelta(seconds=5)}, + utilities={"t1": 1.5}, + ) + + agg._process_aggregation_goal_met(tag="aggregate", channel=channel) + + lines = (tmp_path / "aggregator.jsonl").read_text().splitlines() + import json + events = [json.loads(l) for l in lines] + evals = [e for e in events if e["event"] == "agg_eval"] + assert len(evals) == 1 + assert evals[0]["test-loss"] == 0.42 + assert evals[0]["test-accuracy"] == 0.9 + # data_id snapshot must be the pre-increment value (the data_id + # that was actually evaluated), not the post-increment one. + assert evals[0]["data_id"] == 3 + assert evals[0]["round"] == 1 + finally: + telemetry.shutdown() + + def test_not_emitted_on_variance_fail(self, tmp_path): + """eval_model() only runs on the variance-check-passed path, so no + agg_eval event should appear when the check fails.""" + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + agg = _FakeAggregator(contributors=["t1"], var_good_enough=False) + channel = _FakeChannel() + + agg._process_aggregation_goal_met(tag="aggregate", channel=channel) + + import json + lines = (tmp_path / "aggregator.jsonl").read_text().splitlines() + events = [json.loads(l) for l in lines] + assert not [e for e in events if e["event"] == "agg_eval"] + finally: + telemetry.shutdown() + + def test_noop_when_telemetry_disabled(self, tmp_path): + """No configure() call -- telemetry stays disabled; must not raise + and must not write anything.""" + assert not telemetry.is_enabled() + agg = _FakeAggregator(contributors=["t1"], var_good_enough=True) + channel = _FakeChannel(durations={"t1": timedelta(seconds=5)}) + + agg._process_aggregation_goal_met(tag="aggregate", channel=channel) + + assert not (tmp_path / "aggregator.jsonl").exists() + + +class TestAggRoundTelemetry: + def test_emitted_every_cycle_regardless_of_variance_outcome(self, tmp_path): + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + agg = _FakeAggregator(contributors=["t1", "t2"], var_good_enough=False) + channel = _FakeChannel( + durations={"t1": timedelta(seconds=5), "t2": timedelta(seconds=7)}, + utilities={"t1": 1.0, "t2": 2.0}, + ) + + agg._process_aggregation_goal_met(tag="aggregate", channel=channel) + + import json + lines = (tmp_path / "aggregator.jsonl").read_text().splitlines() + events = [json.loads(l) for l in lines] + rounds = [e for e in events if e["event"] == "agg_round"] + assert len(rounds) == 1 + r = rounds[0] + assert sorted(r["contributing_trainers"]) == ["t1", "t2"] + assert sorted(r["trainer_speed_s"]) == [5.0, 7.0] + assert sorted(r["stat_utility"]) == [1.0, 2.0] + finally: + telemetry.shutdown() + + def test_staleness_computed_against_pre_cycle_model_version(self, tmp_path): + """staleness = the model version this cycle aggregated against, minus + each contributor's last-known trained-on version -- captured BEFORE + self._model_version potentially advances later in the same call.""" + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + agg = _FakeAggregator( + contributors=["t1"], var_good_enough=True, + staleness_map={"t1": 3}, # agg's _model_version starts at 5 + ) + channel = _FakeChannel( + durations={"t1": timedelta(seconds=1)}, utilities={"t1": 0.1} + ) + + agg._process_aggregation_goal_met(tag="aggregate", channel=channel) + + import json + lines = (tmp_path / "aggregator.jsonl").read_text().splitlines() + events = [json.loads(l) for l in lines] + rounds = [e for e in events if e["event"] == "agg_round"] + assert rounds[0]["staleness"] == [2] # 5 - 3, not 6 - 3 + finally: + telemetry.shutdown() + + def test_contributor_list_captured_before_reset(self, tmp_path): + """_per_agg_trainer_list is cleared at the end of this method -- + agg_round's contributing_trainers must reflect this cycle's + contributors, not the post-reset empty list.""" + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + agg = _FakeAggregator(contributors=["a", "b", "c"], var_good_enough=False) + channel = _FakeChannel() + + agg._process_aggregation_goal_met(tag="aggregate", channel=channel) + + assert agg._per_agg_trainer_list == [] # confirms the real reset ran + import json + lines = (tmp_path / "aggregator.jsonl").read_text().splitlines() + events = [json.loads(l) for l in lines] + rounds = [e for e in events if e["event"] == "agg_round"] + assert sorted(rounds[0]["contributing_trainers"]) == ["a", "b", "c"] + finally: + telemetry.shutdown() + + def test_noop_when_telemetry_disabled(self, tmp_path): + assert not telemetry.is_enabled() + agg = _FakeAggregator(contributors=["t1"], var_good_enough=False) + channel = _FakeChannel() + + agg._process_aggregation_goal_met(tag="aggregate", channel=channel) + + assert not (tmp_path / "aggregator.jsonl").exists() + + def test_agg_observed_s_keyed_by_end_id(self, tmp_path): + """agg_observed_s reuses the same PROP_ROUND_DURATION values already + read for trainer_speed_s, but as an {end_id: seconds} dict -- lets + analyze_run.py's runtime_agg_vs_trainer/runtime_overhead_* plots work + for fwdllm too (Part 6 follow-on to P5.2).""" + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + agg = _FakeAggregator(contributors=["t1", "t2"], var_good_enough=False) + channel = _FakeChannel( + durations={"t1": timedelta(seconds=5), "t2": timedelta(seconds=7)}, + ) + + agg._process_aggregation_goal_met(tag="aggregate", channel=channel) + + import json + lines = (tmp_path / "aggregator.jsonl").read_text().splitlines() + events = [json.loads(l) for l in lines] + rounds = [e for e in events if e["event"] == "agg_round"] + assert rounds[0]["agg_observed_s"] == {"t1": 5.0, "t2": 7.0} + finally: + telemetry.shutdown() + + +class _UtilityFakeChannel: + """Generic fake for _process_single_trainer_message's channel calls -- + stores per-end properties in a dict, doesn't care about specific PROP_* + identities beyond PROP_STAT_UTILITY/PROP_ROUND_START_TIME (both read by + the code path under test).""" + + class _Selector: + def __init__(self): + self.ordered_updates_recv_ends = [] + + def __init__(self, stat_utility=None): + self._stat_utility = dict(stat_utility or {}) + self._selector = self._Selector() + + def get_end_property(self, end, key): + if key == PROP_STAT_UTILITY: + return self._stat_utility.get(end) + if key == PROP_ROUND_START_TIME: + return None # skip PROP_ROUND_DURATION computation, irrelevant here + return None + + def set_end_property(self, end, key, value): + if key == PROP_STAT_UTILITY: + self._stat_utility[end] = value + + def set_property(self, key, value): + pass + + def cleanup_recvd_end(self, end): + pass + + def cleanup_provided_ends(self, end): + pass + + +class _UtilityFakeAggregator: + """Minimal stand-in exposing only the state + _process_single_trainer_message's STAT_UTILITY/utility_belief branch + touches -- the GRADIENTS branch is stubbed out (aggregate_grads_from_ + trainers is a no-op) since it's irrelevant to the telemetry under test.""" + + process = TopAggregator._process_single_trainer_message + + def __init__(self, model_version=5, data_id=3, iteration_per_data_id=0, + is_async=False): + self._per_agg_trainer_list = [] + self._trainer_last_model_version = {} + self._updates_received = {} + self._updates_in_queue = 0 + self._agg_goal_cnt = 0 + self._round_cache_activity_ts = {} + self._model_version = model_version + self.data_id = data_id + self.iteration_per_data_id = iteration_per_data_id + self.is_async = is_async + self._round = 1 + self.grad_pool = [] + + def aggregate_grads_from_trainers(self, *args, **kwargs): + pass + + +def _msg(model_version=5, stat_utility=0.7): + # GRADIENTS/GRADIENTS_FOR_VAR_CHECK go through _calculate_hash() (log-only, + # unrelated to the telemetry under test) which calls .detach() on them -- + # must be real tensors, not plain lists. + return { + MessageType.MODEL_VERSION: model_version, + MessageType.GRADIENTS: torch.zeros(1), + MessageType.GRADIENTS_FOR_VAR_CHECK: torch.zeros(1), + MessageType.STAT_UTILITY: stat_utility, + } + + +class TestUtilityBeliefTelemetry: + """fwdllm_aggregator.py never emitted utility_belief -- only + asyncfl/top_aggregator.py did -- so selected_utility_believed_vs_actual*/ + selected_utility_belief_gap* were structurally impossible for fwdllm- + family baselines regardless of selector (see + ../../examples/MIGRATING_TO_LAUNCHER.md §9). Covers the fix in + _process_single_trainer_message's STAT_UTILITY branch.""" + + def test_emits_believed_and_actual(self, tmp_path): + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + agg = _UtilityFakeAggregator() + channel = _UtilityFakeChannel(stat_utility={"t1": 0.3}) # prior belief + + agg.process(channel, _msg(stat_utility=0.9), "t1", timestamp=0) + + import json + events = [json.loads(l) for l in + (tmp_path / "aggregator.jsonl").read_text().splitlines()] + ub = [e for e in events if e["event"] == "utility_belief"] + assert len(ub) == 1 + assert ub[0]["believed"] == 0.3 + assert ub[0]["actual"] == 0.9 + assert ub[0]["end_id"] == "t1" + finally: + telemetry.shutdown() + + def test_believed_none_on_first_ever_return(self, tmp_path): + """No prior PROP_STAT_UTILITY for this end -- believed must be None, + not a crash or a fabricated 0.""" + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + agg = _UtilityFakeAggregator() + channel = _UtilityFakeChannel() + + agg.process(channel, _msg(stat_utility=0.5), "t1", timestamp=0) + + import json + events = [json.loads(l) for l in + (tmp_path / "aggregator.jsonl").read_text().splitlines()] + ub = [e for e in events if e["event"] == "utility_belief"] + assert ub[0]["believed"] is None + assert ub[0]["actual"] == 0.5 + finally: + telemetry.shutdown() + + def test_staleness_uses_model_version_not_round(self, tmp_path): + """fwdllm's round can sit at 1 for an entire run -- staleness must be + computed against self._model_version (the cycle-advancing quantity, + matching agg_round's own staleness convention from P5.2), not round.""" + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + agg = _UtilityFakeAggregator(model_version=8) + channel = _UtilityFakeChannel() + + agg.process(channel, _msg(model_version=5, stat_utility=0.5), "t1", timestamp=0) + + import json + events = [json.loads(l) for l in + (tmp_path / "aggregator.jsonl").read_text().splitlines()] + ub = [e for e in events if e["event"] == "utility_belief"] + assert ub[0]["staleness"] == 3 # 8 - 5 + finally: + telemetry.shutdown() + + def test_carries_data_id_and_iteration_for_progress_key(self, tmp_path): + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + agg = _UtilityFakeAggregator(data_id=42, iteration_per_data_id=2) + channel = _UtilityFakeChannel() + + agg.process(channel, _msg(stat_utility=0.5), "t1", timestamp=0) + + import json + events = [json.loads(l) for l in + (tmp_path / "aggregator.jsonl").read_text().splitlines()] + ub = [e for e in events if e["event"] == "utility_belief"] + assert ub[0]["data_id"] == 42 + assert ub[0]["iteration_per_data_id"] == 2 + finally: + telemetry.shutdown() + + def test_noop_when_telemetry_disabled(self, tmp_path): + assert not telemetry.is_enabled() + agg = _UtilityFakeAggregator() + channel = _UtilityFakeChannel() + + agg.process(channel, _msg(stat_utility=0.5), "t1", timestamp=0) + + assert not (tmp_path / "aggregator.jsonl").exists() + + +class TestRoundCacheActivityResetOnContribution: + """A real accepted contribution must restart the round-cache + stuck-timeout clock (see TestStuckCachePruning in + test_fwdllm_reselection.py) -- otherwise a trainer that eventually does + respond, just slowly, would still get evicted next time the cache is + checked.""" + + def test_accepted_contribution_updates_activity_ts(self): + agg = _UtilityFakeAggregator() + channel = _UtilityFakeChannel() + agg._round_cache_activity_ts["t1"] = 0.0 # ancient/never-set + + agg.process(channel, _msg(stat_utility=0.5), "t1", timestamp=0) + + assert agg._round_cache_activity_ts["t1"] > 0.0 diff --git a/lib/python/tests/mode/test_fwdllm_duplicate_contribution.py b/lib/python/tests/mode/test_fwdllm_duplicate_contribution.py new file mode 100644 index 000000000..5d5302be0 --- /dev/null +++ b/lib/python/tests/mode/test_fwdllm_duplicate_contribution.py @@ -0,0 +1,79 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""An end must contribute at most once per (round, data_id, +iteration_per_data_id) collection cycle -- _process_single_trainer_message +must reject a repeat contribution from an end already in +_per_agg_trainer_list, rather than double-counting it.""" + +from flame.mode.horizontal.syncfl.fwdllm_aggregator import TopAggregator + + +class _FakeChannel: + def __init__(self): + self.cleaned_up = [] + self.provided_cleaned_up = [] + + def cleanup_recvd_end(self, end): + self.cleaned_up.append(end) + + def cleanup_provided_ends(self, end): + self.provided_cleaned_up.append(end) + + +class _FakeAggregator: + """Minimal stand-in exposing only the state the duplicate-contribution + guard touches.""" + + def __init__(self, already_contributed, is_async=False): + self._per_agg_trainer_list = list(already_contributed) + self._agg_goal_cnt = len(already_contributed) + self._round = 1 + self.data_id = 0 + self.iteration_per_data_id = 0 + self.is_async = is_async + + process = TopAggregator._process_single_trainer_message + + +class TestDuplicateContributionGuard: + def test_rejects_repeat_contribution_in_same_cycle(self): + agg = _FakeAggregator(already_contributed=["t1"]) + channel = _FakeChannel() + + result = agg.process(channel, {}, "t1", timestamp=0) + + assert result is False + assert channel.cleaned_up == ["t1"] + # Must not be double-counted. + assert agg._agg_goal_cnt == 1 + assert agg._per_agg_trainer_list == ["t1"] + + def test_does_not_touch_first_time_contributors(self): + agg = _FakeAggregator(already_contributed=["t1"]) + channel = _FakeChannel() + + # t2 hasn't contributed yet -- the duplicate guard must not fire + # (an empty msg fails later validation instead, via the unrelated + # "Invalid message" branch -- confirms we got past the guard). + assert "t2" not in agg._per_agg_trainer_list + result = agg.process(channel, {}, "t2", timestamp=0) + + assert result is False + assert channel.cleaned_up == [] + + def test_async_path_uses_cleanup_provided_ends_not_cleanup_recvd_end(self): + """Regression test: async selectors (async_oort, async_random) only + implement the batch _cleanup_recvd_ends/_cleanup_provided_ends path, + not the per-end _cleanup_recvd_end that channel.cleanup_recvd_end() + requires (only RandomSelector implements that). Calling + cleanup_recvd_end() on the async path crashed fluxtune in production + with AttributeError: 'AsyncOortSelector' object has no attribute + '_cleanup_recvd_end'.""" + agg = _FakeAggregator(already_contributed=["t1"], is_async=True) + channel = _FakeChannel() + + result = agg.process(channel, {}, "t1", timestamp=0) + + assert result is False + assert channel.cleaned_up == [] + assert channel.provided_cleaned_up == ["t1"] diff --git a/lib/python/tests/mode/test_fwdllm_early_stop_conditions.py b/lib/python/tests/mode/test_fwdllm_early_stop_conditions.py new file mode 100644 index 000000000..460dcd6b3 --- /dev/null +++ b/lib/python/tests/mode/test_fwdllm_early_stop_conditions.py @@ -0,0 +1,156 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Smoke-test stop bar: a run should stop once `self.data_id` reaches +`hyperparameters.max_data_id_progress`, or once `hyperparameters.max_runtime_s` +of wall time has elapsed since the aggregator started -- whichever comes +first. Both caps are independent of `rounds`/`total_data_bins` and are +checked from `_distribute_weights`, which runs on every composer tick on +both the sync and async paths -- unlike the rounds-based stop in +`_process_aggregation_goal_met`, this also fires when an aggregation goal is +never met. + +Also covers `_async_inner_loop_done`: the async/hybrid compose path's inner +`asyncfl_loop` must also exit on `_work_done`, not just an agg-goal match -- +see `TestAsyncInnerLoopExitsOnWorkDone` below.""" + +import time +from types import SimpleNamespace + +from flame.mode.horizontal.syncfl.fwdllm_aggregator import TopAggregator + + +class _FakeAggregator: + """Minimal stand-in exposing only the state + `_check_early_stop_conditions`/`_distribute_weights` touch.""" + + def __init__( + self, + data_id=0, + max_data_id_progress=None, + max_runtime_s=None, + agg_start_time_ts=None, + is_async=False, + ): + self._work_done = False + self.data_id = data_id + self.is_async = is_async + self.agg_start_time_ts = ( + agg_start_time_ts if agg_start_time_ts is not None else time.time() + ) + self.config = SimpleNamespace( + hyperparameters=SimpleNamespace( + max_data_id_progress=max_data_id_progress, + max_runtime_s=max_runtime_s, + ) + ) + + def _distribute_weights_sync(self, tag, task_to_perform="train"): + pass + + def _distribute_weights_async(self, tag, task_to_perform="train"): + pass + + check = TopAggregator._check_early_stop_conditions + _check_early_stop_conditions = TopAggregator._check_early_stop_conditions + distribute = TopAggregator._distribute_weights + + +class TestEarlyStopConditions: + def test_unset_caps_never_stop(self): + agg = _FakeAggregator(data_id=999) + agg.check() + assert agg._work_done is False + + def test_max_data_id_progress_stops_once_reached(self): + agg = _FakeAggregator(data_id=10, max_data_id_progress=10) + agg.check() + assert agg._work_done is True + + def test_max_data_id_progress_not_yet_reached(self): + agg = _FakeAggregator(data_id=9, max_data_id_progress=10) + agg.check() + assert agg._work_done is False + + def test_max_runtime_s_stops_once_elapsed(self): + agg = _FakeAggregator( + max_runtime_s=1.0, agg_start_time_ts=time.time() - 2.0 + ) + agg.check() + assert agg._work_done is True + + def test_max_runtime_s_not_yet_elapsed(self): + agg = _FakeAggregator(max_runtime_s=600.0, agg_start_time_ts=time.time()) + agg.check() + assert agg._work_done is False + + def test_whichever_fires_first_data_id_before_runtime(self): + """data_id cap reached well before the runtime cap -- data_id should + be the one that trips, and it should win even though both are set.""" + agg = _FakeAggregator( + data_id=10, + max_data_id_progress=10, + max_runtime_s=600.0, + agg_start_time_ts=time.time(), + ) + agg.check() + assert agg._work_done is True + + def test_whichever_fires_first_runtime_before_data_id(self): + agg = _FakeAggregator( + data_id=1, + max_data_id_progress=10, + max_runtime_s=1.0, + agg_start_time_ts=time.time() - 2.0, + ) + agg.check() + assert agg._work_done is True + + def test_already_work_done_is_a_noop(self): + """Once stopped, the check must not re-derive or overwrite state.""" + agg = _FakeAggregator(data_id=5, max_data_id_progress=10) + agg._work_done = True + agg.check() + assert agg._work_done is True + + def test_distribute_weights_checks_stop_conditions_on_sync_path(self): + agg = _FakeAggregator(data_id=10, max_data_id_progress=10, is_async=False) + agg.distribute("tag", "train") + assert agg._work_done is True + + def test_distribute_weights_checks_stop_conditions_on_async_path(self): + agg = _FakeAggregator(data_id=10, max_data_id_progress=10, is_async=True) + agg.distribute("tag", "train") + assert agg._work_done is True + + +class _FakeAsyncLoopAggregator: + """Minimal stand-in exposing only the state + `_async_inner_loop_done` touches.""" + + def __init__(self, agg_goal_cnt, agg_goal, work_done): + self._agg_goal_cnt = agg_goal_cnt + self._agg_goal = agg_goal + self._work_done = work_done + + inner_loop_done = TopAggregator._async_inner_loop_done + + +class TestAsyncInnerLoopExitsOnWorkDone: + """Reproduces a live smoke-test finding: `_check_early_stop_conditions()` + can set `_work_done`, but the process keeps running until the launcher's + external watchdog force-kills it, because the async/hybrid compose + path's inner `asyncfl_loop` only checked `_agg_goal_cnt == _agg_goal`, + never `_work_done` -- so it kept spinning, and the outer loop (which + does check `_work_done`) never got a chance to observe it.""" + + def test_exits_on_work_done_even_if_agg_goal_not_met(self): + agg = _FakeAsyncLoopAggregator(agg_goal_cnt=0, agg_goal=3, work_done=True) + assert agg.inner_loop_done() is True + + def test_exits_on_agg_goal_met_even_if_work_not_done(self): + agg = _FakeAsyncLoopAggregator(agg_goal_cnt=3, agg_goal=3, work_done=False) + assert agg.inner_loop_done() is True + + def test_does_not_exit_while_neither_condition_holds(self): + agg = _FakeAsyncLoopAggregator(agg_goal_cnt=1, agg_goal=3, work_done=False) + assert agg.inner_loop_done() is False diff --git a/lib/python/tests/mode/test_fwdllm_oracular_avail.py b/lib/python/tests/mode/test_fwdllm_oracular_avail.py new file mode 100644 index 000000000..aeb0875a1 --- /dev/null +++ b/lib/python/tests/mode/test_fwdllm_oracular_avail.py @@ -0,0 +1,67 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Tests for fwdllm_aggregator.read_trainer_unavailability() -- it must read +availability traces from a `_metadata` bundle (registry + traces), not from +the legacy json_scripts/trainer_*.json directory.""" + +import glob as glob_module + +import yaml + +from flame.mode.horizontal.syncfl.fwdllm_aggregator import TopAggregator + + +def _write_metadata(tmp_path): + metadata_dir = tmp_path / "_metadata" + (metadata_dir / "availability_traces").mkdir(parents=True) + + registry = { + "trainers": { + "trainer_001": { + "trainer_id": 1, + "task_id": "task-aaa", + }, + "trainer_002": { + "trainer_id": 2, + "task_id": "task-bbb", + }, + } + } + (metadata_dir / "trainer_registry.yaml").write_text(yaml.safe_dump(registry)) + + mobiperf_traces = { + "traces": { + "device_001": {"states_2st": [[0, "AVL_TRAIN"], [100, "UN_AVL"]]}, + "device_002": {"states_2st": [[0, "UN_AVL"], [50, "AVL_TRAIN"]]}, + } + } + (metadata_dir / "availability_traces" / "mobiperf_traces.yaml").write_text( + yaml.safe_dump(mobiperf_traces) + ) + return metadata_dir + + +def test_reads_from_metadata_bundle(tmp_path): + metadata_dir = _write_metadata(tmp_path) + + result = TopAggregator.read_trainer_unavailability( + None, trace="mobiperf_2st", metadata_dir=metadata_dir + ) + + assert set(result.keys()) == {"task-aaa", "task-bbb"} + assert dict(result["task-aaa"]) == {0: "AVL_TRAIN", 100: "UN_AVL"} + assert dict(result["task-bbb"]) == {0: "UN_AVL", 50: "AVL_TRAIN"} + + +def test_does_not_read_json_scripts(tmp_path, monkeypatch): + metadata_dir = _write_metadata(tmp_path) + + def fail_glob(*args, **kwargs): + raise AssertionError("must not glob legacy json_scripts/ directory") + + monkeypatch.setattr(glob_module, "glob", fail_glob) + + result = TopAggregator.read_trainer_unavailability( + None, trace="mobiperf_2st", metadata_dir=metadata_dir + ) + assert len(result) == 2 diff --git a/lib/python/tests/mode/test_fwdllm_recv_timeout.py b/lib/python/tests/mode/test_fwdllm_recv_timeout.py new file mode 100644 index 000000000..bcd487fb8 --- /dev/null +++ b/lib/python/tests/mode/test_fwdllm_recv_timeout.py @@ -0,0 +1,90 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""fwdllm_aggregator.py's _aggregate_grads_async (fluxtune/async) and +sync_collect_and_accumulate_grads (fwdllm/fwdllm_plus/sync) both called +channel.recv_fifo() with no timeout -- which defaults to blocking forever +(see channel.recv_fifo's docstring). If a selected/in-flight trainer went +quiet, the call never returned, the composer loop never cycled back to +_distribute_weights, and _check_early_stop_conditions() (which enforces +--max-runtime-s/--max-data-id) never got a chance to run -- confirmed via a +real fluxtune run (run_20260701_225428_fluxtune_n10_smoke) that hung 11+ +minutes past its 600s budget until manually killed. This covers the fix: +both call sites now pass timeout=RECV_TIMEOUT_WAIT_S, matching the pattern +asyncfl/top_aggregator.py already uses for the identical reason. +""" + +from flame.mode.horizontal.asyncfl.top_aggregator import RECV_TIMEOUT_WAIT_S +from flame.mode.horizontal.syncfl.fwdllm_aggregator import TopAggregator + + +class _FakeChannel: + """Records every recv_fifo() call's args; ends() returns a fixed pool. + recv_fifo always yields a single (None, ...) -- callers under test only + need to observe the call args and return cleanly, not process a real + message.""" + + def __init__(self, ends_result): + self._ends_result = ends_result + self.recv_fifo_calls = [] + + def ends(self, state=None): + return self._ends_result + + def recv_fifo(self, end_ids, first_k, timeout=None): + self.recv_fifo_calls.append( + {"end_ids": end_ids, "first_k": first_k, "timeout": timeout} + ) + yield None, ("", None) + + +class _FakeChannelManager: + def __init__(self, channel): + self._channel = channel + + def get_by_tag(self, tag): + return self._channel + + +class TestAggregateGradsAsyncBoundedRecv: + """fluxtune's path (is_async=True).""" + + class _FakeAggregator: + _aggregate_grads_async = TopAggregator._aggregate_grads_async + + def __init__(self, channel): + self.cm = _FakeChannelManager(channel) + + def test_recv_fifo_called_with_recv_timeout_wait_s(self): + channel = _FakeChannel(ends_result=["t1", "t2"]) + agg = self._FakeAggregator(channel) + + agg._aggregate_grads_async("aggregate") + + assert len(channel.recv_fifo_calls) == 1 + assert channel.recv_fifo_calls[0]["timeout"] == RECV_TIMEOUT_WAIT_S + assert channel.recv_fifo_calls[0]["first_k"] == 1 + + +class TestSyncCollectBoundedRecv: + """fwdllm/fwdllm_plus's path (is_async=False).""" + + class _FakeAggregator: + sync_collect_and_accumulate_grads = ( + TopAggregator.sync_collect_and_accumulate_grads + ) + + def __init__(self, channel, agg_goal=3): + self._agg_goal = agg_goal + self.ends_not_selected_yet = False + self._round = 1 + self.data_id = 0 + self.iteration_per_data_id = 0 + + def test_recv_fifo_called_with_recv_timeout_wait_s(self): + channel = _FakeChannel(ends_result=["t1", "t2", "t3"]) + agg = self._FakeAggregator(channel) + + agg.sync_collect_and_accumulate_grads("aggregate", channel) + + assert len(channel.recv_fifo_calls) == 1 + assert channel.recv_fifo_calls[0]["timeout"] == RECV_TIMEOUT_WAIT_S diff --git a/lib/python/tests/mode/test_fwdllm_reselection.py b/lib/python/tests/mode/test_fwdllm_reselection.py new file mode 100644 index 000000000..1d3387c50 --- /dev/null +++ b/lib/python/tests/mode/test_fwdllm_reselection.py @@ -0,0 +1,278 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Tests for the `reselect_each_iteration` selection-granularity gate: +per-round (False) selects once and reuses the same trainer set for the +whole round; per-iteration (True, default) re-invokes the selector every +call.""" + +import time + +from flame.config import TrainerAvailState +from flame.mode.horizontal.syncfl.fwdllm_aggregator import ( + ROUND_CACHE_STUCK_TIMEOUT_S, + TopAggregator, +) + + +class _FakeSelector: + """Stand-in for RandomSelector exposing only `selected_ends`.""" + + def __init__(self): + self.selected_ends = set() + + +class _FakeChannel: + """Records each `ends()` call and returns the next canned selection. + + Also models end departure: `_removed` mimics a fully disconnected end + (as `channel.remove()` would leave it -- `has()` returns False); + `_unavail` mimics an end that explicitly reported `UN_AVL` but is + still connected (as `channel.update_state()` would leave it -- `has()` + still True, but its avl-state property reads `UN_AVL`). + """ + + def __init__(self, selections): + self._selections = list(selections) + self.calls = 0 + self._selector = _FakeSelector() + self._removed = set() + self._unavail = set() + + def ends(self, state, task_to_perform): + self.calls += 1 + return self._selections[min(self.calls - 1, len(self._selections) - 1)] + + def has(self, end_id): + return end_id not in self._removed + + def get_end_property(self, end_id, key): + if end_id in self._unavail: + return TrainerAvailState.UN_AVL + return None + + +class _FakeAggregator: + """Minimal stand-in exposing only the state + `_select_ends_respecting_reselect_gate` touches.""" + + def __init__(self, reselect_each_iteration, agg_goal=None): + self._reselect_each_iteration = reselect_each_iteration + self._round_selected_ends = None + self._round_selected_ends_round = None + self._round_cache_activity_ts = {} + self._round = 0 + if agg_goal is not None: + self._agg_goal = agg_goal + + select = TopAggregator._select_ends_respecting_reselect_gate + _rearm_recv_eligibility = staticmethod(TopAggregator._rearm_recv_eligibility) + _prune_departed_from_round_cache = ( + TopAggregator._prune_departed_from_round_cache + ) + + +def _drive_two_databins_two_iterations(agg, channel): + """2 databins x 2 iterations each, within one round.""" + for _databin in range(2): + for _iteration in range(2): + agg.select(channel, "train") + + +class TestReselectGate: + def test_per_round_selects_once_then_again_after_rollover(self): + agg = _FakeAggregator(reselect_each_iteration=False) + channel = _FakeChannel(selections=[["t1", "t2"]]) + + _drive_two_databins_two_iterations(agg, channel) + assert channel.calls == 1 + assert agg.select(channel, "train") == ["t1", "t2"] + assert channel.calls == 1 + + # Round rollover: advance self._round, as + # _process_aggregation_goal_met does at the databin-wraparound point. + agg._round += 1 + channel._selections = [["t3", "t4"]] + channel.calls = 0 + ends = agg.select(channel, "train") + assert ends == ["t3", "t4"] + assert channel.calls == 1 + + # Still cached for the rest of the new round. + agg.select(channel, "train") + assert channel.calls == 1 + + def test_per_iteration_selects_every_call(self): + agg = _FakeAggregator(reselect_each_iteration=True) + channel = _FakeChannel(selections=[["t1"], ["t2"], ["t3"], ["t4"]]) + + _drive_two_databins_two_iterations(agg, channel) + assert channel.calls == 4 + + def test_per_round_does_not_cache_empty_selection(self): + """An empty/None selection (no trainers joined yet) must not be + cached as the round's selection -- retry on the next call.""" + agg = _FakeAggregator(reselect_each_iteration=False) + channel = _FakeChannel(selections=[None, None, ["t1"]]) + + assert agg.select(channel, "train") is None + assert agg.select(channel, "train") is None + assert agg.select(channel, "train") == ["t1"] + assert channel.calls == 3 + + # Now cached -- a 4th call must not invoke the selector again. + assert agg.select(channel, "train") == ["t1"] + assert channel.calls == 3 + + def test_per_round_accumulates_partial_selections_until_agg_goal(self): + """Must keep merging in newly-selected trainers until the cache + reaches `_agg_goal`, not freeze on the first partial result.""" + agg = _FakeAggregator(reselect_each_iteration=False, agg_goal=3) + channel = _FakeChannel(selections=[["t1"], ["t2"], ["t3"]]) + + assert agg.select(channel, "train") == ["t1"] + assert agg.select(channel, "train") == ["t1", "t2"] + assert agg.select(channel, "train") == ["t1", "t2", "t3"] + assert channel.calls == 3 + + # Cache has reached agg_goal -- further calls must not re-query. + assert agg.select(channel, "train") == ["t1", "t2", "t3"] + assert channel.calls == 3 + + def test_cache_hit_rearms_selector_recv_eligibility(self): + """Regression test (2026-06-28 live-run hang): a cache hit must + re-arm selected_ends, or it drains to empty after one pass and + the receive side permanently stalls.""" + agg = _FakeAggregator(reselect_each_iteration=False, agg_goal=2) + channel = _FakeChannel(selections=[["t1", "t2"]]) + + ends = agg.select(channel, "train") + assert ends == ["t1", "t2"] + assert channel._selector.selected_ends == {"t1", "t2"} + + # Simulate cleanup_recvd_end draining both after iteration 0. + channel._selector.selected_ends.clear() + assert channel._selector.selected_ends == set() + + ends = agg.select(channel, "train") + assert ends == ["t1", "t2"] + assert channel.calls == 1 # still cache-hit, no re-query + assert channel._selector.selected_ends == {"t1", "t2"} + + def test_accumulate_path_also_rearms_selector_recv_eligibility(self): + """The accumulate-until-agg_goal path re-arms too, so behavior + doesn't depend on which branch is taken.""" + agg = _FakeAggregator(reselect_each_iteration=False, agg_goal=2) + channel = _FakeChannel(selections=[["t1"], ["t2"]]) + + agg.select(channel, "train") + assert channel._selector.selected_ends == {"t1"} + + agg.select(channel, "train") + assert channel._selector.selected_ends == {"t1", "t2"} + + +class TestStaleCachePruning: + """Regression tests for the `_round_selected_ends` stale-cache gap: + a cached-but-departed end must be pruned so the cache-size check stops + reporting "full" and the round can backfill the freed slot, instead of + stalling forever on a contribution that can never arrive.""" + + def test_disconnected_end_pruned_and_backfilled(self): + agg = _FakeAggregator(reselect_each_iteration=False, agg_goal=2) + channel = _FakeChannel(selections=[["t1", "t2"], ["t3"]]) + + assert agg.select(channel, "train") == ["t1", "t2"] + assert channel.calls == 1 + + # t1 fully disconnects (channel.remove() -- has() now False). + channel._removed.add("t1") + + ends = agg.select(channel, "train") + assert ends == ["t2", "t3"] + assert channel.calls == 2 # re-queried the selector to backfill + + # Now cached again at agg_goal -- no further re-query. + assert agg.select(channel, "train") == ["t2", "t3"] + assert channel.calls == 2 + + def test_un_avl_end_pruned_and_backfilled(self): + agg = _FakeAggregator(reselect_each_iteration=False, agg_goal=2) + channel = _FakeChannel(selections=[["t1", "t2"], ["t3"]]) + + assert agg.select(channel, "train") == ["t1", "t2"] + assert channel.calls == 1 + + # t1 stays connected but reports UN_AVL (channel.update_state()). + channel._unavail.add("t1") + + ends = agg.select(channel, "train") + assert ends == ["t2", "t3"] + assert channel.calls == 2 + + assert agg.select(channel, "train") == ["t2", "t3"] + assert channel.calls == 2 + + def test_still_present_end_not_pruned(self): + """Control case: no departure means no pruning and no re-query.""" + agg = _FakeAggregator(reselect_each_iteration=False, agg_goal=2) + channel = _FakeChannel(selections=[["t1", "t2"]]) + + assert agg.select(channel, "train") == ["t1", "t2"] + assert agg.select(channel, "train") == ["t1", "t2"] + assert channel.calls == 1 + + +class TestStuckCachePruning: + """Regression tests for the round-cache scale gap found on a real n=100 + run (see examples/MIGRATING_TO_LAUNCHER.md §9): a cached end that's + still formally connected (not disconnected, not UN_AVL) but has gone + ROUND_CACHE_STUCK_TIMEOUT_S without a real accepted contribution -- + e.g. one that never finished receiving its initial weights -- must + also be pruned/backfilled, not just an explicitly departed one + (TestStaleCachePruning above).""" + + def test_stuck_end_pruned_and_backfilled(self): + agg = _FakeAggregator(reselect_each_iteration=False, agg_goal=2) + channel = _FakeChannel(selections=[["t1", "t2"], ["t3"]]) + + assert agg.select(channel, "train") == ["t1", "t2"] + assert channel.calls == 1 + + # t1 is still connected and AVL_TRAIN (neither departure check in + # TestStaleCachePruning would catch it), but has gone well past the + # stuck-timeout without a real accepted contribution. + agg._round_cache_activity_ts["t1"] = time.time() - (ROUND_CACHE_STUCK_TIMEOUT_S + 10) + + ends = agg.select(channel, "train") + assert ends == ["t2", "t3"] + assert channel.calls == 2 # re-queried the selector to backfill + assert "t1" not in agg._round_cache_activity_ts # cleaned up on prune + + assert agg.select(channel, "train") == ["t2", "t3"] + assert channel.calls == 2 + + def test_recently_active_end_not_pruned(self): + """An end within the timeout window (even if not the most recent to + contribute) must not be pruned -- only genuinely stuck members + should churn the cache.""" + agg = _FakeAggregator(reselect_each_iteration=False, agg_goal=2) + channel = _FakeChannel(selections=[["t1", "t2"]]) + + assert agg.select(channel, "train") == ["t1", "t2"] + agg._round_cache_activity_ts["t1"] = time.time() - (ROUND_CACHE_STUCK_TIMEOUT_S - 30) + + assert agg.select(channel, "train") == ["t1", "t2"] + assert channel.calls == 1 # no re-query -- nothing pruned + + def test_freshly_cached_end_not_immediately_pruned(self): + """Control: an end that just entered the cache (activity_ts == now, + set by the accumulate path itself) must not be immediately treated + as stuck on the very next call.""" + agg = _FakeAggregator(reselect_each_iteration=False, agg_goal=2) + channel = _FakeChannel(selections=[["t1", "t2"]]) + + assert agg.select(channel, "train") == ["t1", "t2"] + assert set(agg._round_cache_activity_ts.keys()) == {"t1", "t2"} + + assert agg.select(channel, "train") == ["t1", "t2"] + assert channel.calls == 1 diff --git a/lib/python/tests/mode/test_fwdllm_rounds_termination.py b/lib/python/tests/mode/test_fwdllm_rounds_termination.py new file mode 100644 index 000000000..88cd9b975 --- /dev/null +++ b/lib/python/tests/mode/test_fwdllm_rounds_termination.py @@ -0,0 +1,131 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""fwdllm's TopAggregator extends the asyncfl base (not syncfl's), which +has no rounds-based stop condition of its own. self._work_done was never +set anywhere in fwdllm_aggregator.py, so the composer loop +(Loop(loop_check_fn=lambda: self._work_done)) never exited regardless of +hyperparameters.rounds -- every fwdllm/fwdllm_plus/fluxtune run (sync +path) ran forever until manually killed or the launcher's watchdog +force-terminated it. _process_aggregation_goal_met must set +self._work_done once self._round exceeds hyperparameters.rounds, on the +same round-rollover branch that already advances self._round.""" + +from types import SimpleNamespace +from unittest.mock import patch + +from flame.mode.horizontal.syncfl.fwdllm_aggregator import TopAggregator + + +class _FakeChannel: + def __init__(self): + self.properties = {} + + def get_end_property(self, end, prop): + return None + + def set_property(self, name, value): + self.properties[name] = value + + def cleanup_recvd_ends(self): + pass + + +class _FakeAggregator: + """Minimal stand-in exposing only the state + `_process_aggregation_goal_met` touches, with the heavy model/aggregate + machinery stubbed out.""" + + def __init__(self, round_, rounds, total_data_bins=150, var_good_enough=True): + self._agg_goal = 2 + self._agg_goal_cnt = 2 + self._per_agg_trainer_list = [] + self._model_version_unique_trainers = set() + self._model_version_trainer_stats = { + "train_duration": [], + "partial_stat_utility": [], + } + self.grad_pool = [] + self.grad = [] + self.model = None + self._max_iter_per_data_id = None + self.iteration_per_data_id = 0 + self.var = 0.0 + self.var_threshold = 0.3 + self.var_good_enough = var_good_enough + self.data_id = total_data_bins - 1 + self.total_data_bins = total_data_bins + self._is_model_updated = False + self._model_version = 0 + self._round = round_ + self._updates_in_queue = 2 + self._updates_received = {} + self._n_aggs_completed = 0 + self._var_total_count = 0 + self._var_pass_count = 0 + self._dynamic_kc_controller = None + self.config = SimpleNamespace( + hyperparameters=SimpleNamespace( + inc_model_version_per_data_id=True, rounds=rounds + ) + ) + + def add_local_trained_result(self, *args, **kwargs): + pass + + def aggregate(self, round_id): + pass + + def eval_model(self): + return {"eval_loss": 0.0}, None, None + + def _log_and_reset_model_version_stats(self): + pass + + process = TopAggregator._process_aggregation_goal_met + + +@patch( + "flame.mode.horizontal.syncfl.fwdllm_aggregator.fc.make_functional_with_buffers", + return_value=(None, [], None), +) +class TestRoundsBasedTermination: + def test_work_done_set_once_rounds_exhausted(self, _mock_ffb): + agg = _FakeAggregator(round_=50, rounds=50) + channel = _FakeChannel() + + agg.process("tag", channel) + + assert agg._round == 51 + assert agg._work_done is True + + def test_work_done_not_set_while_rounds_remain(self, _mock_ffb): + agg = _FakeAggregator(round_=10, rounds=50) + channel = _FakeChannel() + + agg.process("tag", channel) + + assert agg._round == 11 + assert agg._work_done is False + + def test_work_done_not_touched_when_round_not_complete(self, _mock_ffb): + """data_id hasn't reached total_data_bins yet -- the round-rollover + branch (and therefore the rounds check) must not run at all.""" + agg = _FakeAggregator(round_=49, rounds=50, total_data_bins=150) + agg.data_id = 5 # not the last data bin + channel = _FakeChannel() + + agg.process("tag", channel) + + assert agg._round == 49 + assert not hasattr(agg, "_work_done") + + def test_work_done_not_touched_when_variance_check_fails(self, _mock_ffb): + """var_good_enough=False takes the retry branch, which never + reaches the round-rollover code at all.""" + agg = _FakeAggregator(round_=49, rounds=50, var_good_enough=False) + channel = _FakeChannel() + + agg.process("tag", channel) + + assert agg._round == 49 + assert not hasattr(agg, "_work_done") diff --git a/lib/python/tests/mode/test_fwdllm_trainer_eot_keyerror.py b/lib/python/tests/mode/test_fwdllm_trainer_eot_keyerror.py new file mode 100644 index 000000000..cf45146e0 --- /dev/null +++ b/lib/python/tests/mode/test_fwdllm_trainer_eot_keyerror.py @@ -0,0 +1,76 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Trainer._fetch_weights logged a debug line that indexed +msg[MessageType.DATA_ID]/msg[MessageType.ITERATION_PER_DATA_ID] +unconditionally, before the existing `if MessageType.DATA_ID in msg and ...` +guard a few lines below it. The aggregator's end-of-training broadcast +(inform_end_of_training in flame/mode/horizontal/syncfl/top_aggregator.py) +sends only {MessageType.EOT: self._work_done} -- no DATA_ID/ +ITERATION_PER_DATA_ID keys -- so any trainer still waiting in _fetch_weights +when the aggregator wraps up hit an uncaught KeyError and crashed instead of +setting self._work_done and exiting its loop cleanly. Confirmed via three +real n=100 overnight runs (2026-07-02): every idle/unselected trainer in +each run (82-90 per run) crashed with this exact KeyError at the run's stop +timestamp. Fixed by switching the log line to msg.get(...), matching the +guarded access pattern already used a few lines below (line 267) for the +identical MessageType.WEIGHTS log line. +""" + +from flame.mode.horizontal.syncfl.fwdllm_trainer import Trainer +from flame.mode.message import MessageType + + +class _FakeSelector: + def __init__(self): + self.ordered_updates_recv_ends = [] + + +class _FakeChannel: + def __init__(self, msg): + self._msg = msg + self._selector = _FakeSelector() + + def await_join(self): + pass + + def one_end(self, state): + return "end_1" + + def recv(self, end_id): + return self._msg, None + + def cleanup_recvd_ends(self): + pass + + +class _FakeChannelManager: + def __init__(self, channel): + self._channel = channel + + def get_by_tag(self, tag): + return self._channel + + +class _FakeTrainer: + _fetch_weights = Trainer._fetch_weights + + def __init__(self, channel): + self.cm = _FakeChannelManager(channel) + self.trainer_id = "trainer_1" + self.fetch_success = False + self._work_done = False + self.data_id = None + self.iteration_per_data_id = None + self._round = 1 + self._model_version = 0 + + +class TestFetchWeightsEndOfTrainingBroadcast: + def test_eot_only_message_does_not_raise(self): + channel = _FakeChannel({MessageType.EOT: True}) + trainer = _FakeTrainer(channel) + + trainer._fetch_weights("fetch") + + assert trainer._work_done is True + assert trainer.fetch_success is True diff --git a/lib/python/tests/mode/test_fwdllm_trainer_sim_duration.py b/lib/python/tests/mode/test_fwdllm_trainer_sim_duration.py new file mode 100644 index 000000000..9e5863e4f --- /dev/null +++ b/lib/python/tests/mode/test_fwdllm_trainer_sim_duration.py @@ -0,0 +1,67 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""fwdllm's trainer (FedSgdTrainer.py) reported only real_gpu_time_s, not +sim_round_duration_s -- unlike async_cifar10's trainer, which reports total +round wall time (gpu + modeled delay). fwdllm has no budget-vs-actual +contention model (its delay is a flat additive sleep, not a sleep-to-fill- +budget pattern), so only sim_round_duration_s is added here -- NOT +training_budget_s/overran/remaining_time_s, which would need a budget +concept fwdllm doesn't have (see ../../examples/MIGRATING_TO_LAUNCHER.md §9). + +This covers _emulate_training_delay()'s return-value change: it now returns +the seconds actually slept (0.0 if delay emulation is disabled), which the +caller adds to real_gpu_time_s to report sim_round_duration_s. +""" + +import os +import sys + +sys.path.insert( + 0, + os.path.join( + os.path.dirname(os.path.abspath(__file__)), "..", "..", "examples", "fwdllm", + "trainer", "forward_training", + ), +) + +from FedSgdTrainer import FedSGDTrainer # noqa: E402 + + +class _FakeTrainer: + """Minimal stand-in exposing only the state _emulate_training_delay + touches; binds the real method under test.""" + + _emulate_training_delay = FedSGDTrainer._emulate_training_delay + + def __init__(self, training_delay_enabled, training_delay_s=0.0, + training_delay_factor=1.0, speedup_factor=1.0): + self.training_delay_enabled = training_delay_enabled + self.training_delay_s = training_delay_s + self.training_delay_factor = training_delay_factor + self.speedup_factor = speedup_factor + self.trainer_id = "t1" + + +class TestEmulateTrainingDelayReturnsSleptSeconds: + def test_returns_zero_when_disabled(self): + t = _FakeTrainer(training_delay_enabled="False", training_delay_s=10.0) + assert t._emulate_training_delay() == 0.0 + + def test_returns_computed_delay_when_enabled(self): + t = _FakeTrainer( + training_delay_enabled="True", training_delay_s=3.0, + training_delay_factor=1.0, speedup_factor=1.0, + ) + assert t._emulate_training_delay() == 3.0 + + def test_speedup_factor_scales_the_returned_delay(self): + """The returned value must match what was actually slept (eval_delay + / speedup_factor), not the unscaled eval_delay -- otherwise + sim_round_duration_s would overstate the real wall time under a + speedup.""" + t = _FakeTrainer( + training_delay_enabled="True", training_delay_s=10.0, + training_delay_factor=2.0, speedup_factor=5.0, + ) + # eval_delay = 10.0 / 2.0 = 5.0; slept = 5.0 / 5.0 = 1.0 + assert t._emulate_training_delay() == 1.0 diff --git a/lib/python/tests/mode/test_join_barrier_reanchor.py b/lib/python/tests/mode/test_join_barrier_reanchor.py new file mode 100644 index 000000000..4138281c2 --- /dev/null +++ b/lib/python/tests/mode/test_join_barrier_reanchor.py @@ -0,0 +1,112 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Real-mode agg_start_time_ts re-anchor at the join barrier. + +`agg_start_time_ts` is stamped at aggregator __init__, before the trainer +cohort joins. In sim mode this is harmless (_avail_now() reads _vclock.now, +which only starts advancing at round-0 selection). In real mode _avail_now() +reads time.time() - agg_start_time_ts, so without a re-anchor the join wait +(real OS process spawn/connect — ~300s wall at n=300) is silently baked into +every subsequent availability-trace read: real ends up reading the trace +~300s ahead of where sim/ground-truth says it should be (root-caused via +feddance syn_50 A3 — see UNAVAILABILITY_DESIGN.md). + +`_mark_join_barrier_done` fixes this by re-anchoring agg_start_time_ts to +"now" (real mode only) at the moment the join barrier resolves, whatever +that wait actually took — self-correcting if the join wait duration changes. +""" + +import time +import types + +from flame.mode.horizontal.syncfl.top_aggregator import TopAggregator + + +class _ConcreteAgg(TopAggregator): + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + +def _make_agg(*, simulated: bool, min_trainers_to_start=None, n_joined=0): + agg = _ConcreteAgg.__new__(_ConcreteAgg) + agg.simulated = simulated + agg.config = types.SimpleNamespace( + hyperparameters=types.SimpleNamespace( + min_trainers_to_start=min_trainers_to_start, + min_trainers_join_timeout_s=5.0, + ) + ) + agg.agg_start_time_ts = time.time() + channel = types.SimpleNamespace(_ends={f"t{i}": None for i in range(n_joined)}) + return agg, channel + + +class TestMarkJoinBarrierDone: + def test_real_mode_reanchors_agg_start(self): + agg, _ = _make_agg(simulated=False) + original = agg.agg_start_time_ts + time.sleep(0.02) + agg._mark_join_barrier_done() + assert agg._join_barrier_done is True + assert agg.agg_start_time_ts > original + + def test_sim_mode_leaves_agg_start_untouched(self): + agg, _ = _make_agg(simulated=True) + original = agg.agg_start_time_ts + time.sleep(0.02) + agg._mark_join_barrier_done() + assert agg._join_barrier_done is True + assert agg.agg_start_time_ts == original + + +class TestAwaitMinTrainersReanchors: + def test_real_mode_barrier_disabled_still_reanchors(self): + # min_trainers_to_start unset → barrier is a no-op wait, but the join + # (channel.await_join(), called by the caller before this) still cost + # real wall-clock time, so agg_start_time_ts must still move. + agg, channel = _make_agg(simulated=False, min_trainers_to_start=None) + original = agg.agg_start_time_ts + time.sleep(0.02) + agg._await_min_trainers(channel) + assert agg.agg_start_time_ts > original + + def test_real_mode_barrier_satisfied_reanchors_after_wait(self): + agg, channel = _make_agg( + simulated=False, min_trainers_to_start=3, n_joined=3 + ) + original = agg.agg_start_time_ts + time.sleep(0.02) + agg._await_min_trainers(channel) + assert agg._join_barrier_done is True + assert agg.agg_start_time_ts > original + + def test_sim_mode_never_reanchors(self): + agg, channel = _make_agg( + simulated=True, min_trainers_to_start=3, n_joined=3 + ) + original = agg.agg_start_time_ts + time.sleep(0.02) + agg._await_min_trainers(channel) + assert agg.agg_start_time_ts == original + + def test_one_shot_does_not_reanchor_twice(self): + agg, channel = _make_agg( + simulated=False, min_trainers_to_start=3, n_joined=3 + ) + agg._await_min_trainers(channel) + anchored = agg.agg_start_time_ts + time.sleep(0.02) + agg._await_min_trainers(channel) # second call: already done, no-op + assert agg.agg_start_time_ts == anchored diff --git a/lib/python/tests/mode/test_proactive_evict_call_site.py b/lib/python/tests/mode/test_proactive_evict_call_site.py new file mode 100644 index 000000000..b4cc4e89f --- /dev/null +++ b/lib/python/tests/mode/test_proactive_evict_call_site.py @@ -0,0 +1,244 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Batch 4 finding 1: D.1 proactive in-flight eviction must run in real mode too. + +`_sim_evict_unavail_inflight` (D.1, felix-only via `proactive_inflight_evict`) +has no vclock/sim dependency -- it reads `_avail_now()` (mode-dispatching +already) and the selector's own `selected_ends`, both equally valid in real +mode. It used to be called only inside `if self.simulated:` alongside +`_sim_abandon_stalled` (which genuinely IS sim-only: real mode has its own +native wall-clock abandon in the selector, `SEND_TIMEOUT_WAIT_S`). That left +real-mode felix runs with no way to drop a stalled UN_AVL trainer out of +`selected_ends` (and therefore out of `channel.ends(VAL_CH_STATE_RECV)`, +since `async_oort`'s selector derives recv-state ends directly from +`selected_ends`) -- the aggregator looped on 30s `recv_fifo` timeouts forever +once enough trainers went quiet near a trace's tail, never reaching its own +`max_experiment_runtime_s` self-stop check (which only runs once recv_ends +goes empty). See UNAVAILABILITY_DESIGN.md, Batch 4 finding 1. + +Mirrors the harness pattern in test_agg_start_ts_broadcast.py. +""" + +from __future__ import annotations + +import types + +import pytest + + +class _DistChannel: + """Records every dispatched payload/property, no real transport.""" + + def __init__(self, ends): + self._ends = {e: None for e in ends} + self.properties = {} + self.props = {} + self.sent = {} + self._selector = types.SimpleNamespace(selected_ends=set()) + + def await_join(self): + pass + + def ends(self, state, task=None, **kw): + return list(self._ends.keys()) + + def dumps(self, msg): + return dict(msg) + + def send_payload(self, end, payload): + self.sent[end] = payload + + def set_end_property(self, end, key, value): + self.props.setdefault(end, {})[key] = value + + def set_curr_unavailable_trainers(self, trainer_unavail_list=None): + self.unavail = list(trainer_unavail_list or []) + + +def _stub_common(agg, channel, *, simulated, evict_spy, abandon_spy): + agg.simulated = simulated + agg.agg_start_time_ts = 1_700_000_000.0 + agg._round = 3 + agg.trainer_event_dict = None # gate off: skip the oracular unavailable-list path + agg.cm = types.SimpleNamespace(get_by_tag=lambda tag: channel) + agg._await_min_trainers = lambda ch: None + agg._update_weights = lambda: None + agg._inject_oracle_utilities = lambda ch, task: None + agg._avail_stamp_end_states = lambda ch: None + agg._avail_now = lambda: 0.0 + agg._sim_abandon_stalled = abandon_spy + agg._sim_evict_unavail_inflight = evict_spy + agg.datasampler = types.SimpleNamespace(get_metadata=lambda r, e: {}) + agg.weights = {} + + +def _spies(): + calls = {"evict": 0, "abandon": 0} + + def evict_spy(ch): + calls["evict"] += 1 + + def abandon_spy(ch): + calls["abandon"] += 1 + + return calls, evict_spy, abandon_spy + + +@pytest.fixture(autouse=True) +def _identity_weights(monkeypatch): + import flame.mode.horizontal.syncfl.top_aggregator as syncfl_mod + import flame.mode.horizontal.oort.top_aggregator as oort_mod + + monkeypatch.setattr(syncfl_mod, "weights_to_device", lambda w, d: w) + monkeypatch.setattr(oort_mod, "weights_to_device", lambda w, d: w) + + +def _make_syncfl_agg(channel, *, simulated, evict_spy, abandon_spy): + from flame.mode.horizontal.syncfl.top_aggregator import TopAggregator + + class _Concrete(TopAggregator): + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + agg = _Concrete.__new__(_Concrete) + _stub_common(agg, channel, simulated=simulated, evict_spy=evict_spy, abandon_spy=abandon_spy) + agg.config = types.SimpleNamespace( + hyperparameters=types.SimpleNamespace(aggregation_goal=1) + ) + return agg + + +def _make_oort_agg(channel, *, simulated, evict_spy, abandon_spy): + from flame.mode.horizontal.oort.top_aggregator import TopAggregator + + class _Concrete(TopAggregator): + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + agg = _Concrete.__new__(_Concrete) + _stub_common(agg, channel, simulated=simulated, evict_spy=evict_spy, abandon_spy=abandon_spy) + agg.config = types.SimpleNamespace( + selector=types.SimpleNamespace(kwargs={"aggr_num": 1}), + hyperparameters=types.SimpleNamespace(sim_inflight_residence=False), + ) + return agg + + +def _make_asyncfl_agg(channel, *, simulated, evict_spy, abandon_spy): + from flame.mode.horizontal.asyncfl.top_aggregator import TopAggregator + from flame.sim import VirtualClock + + class _Concrete(TopAggregator): + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + agg = _Concrete.__new__(_Concrete) + _stub_common(agg, channel, simulated=simulated, evict_spy=evict_spy, abandon_spy=abandon_spy) + agg._vclock = VirtualClock() + agg._sim_staggered_redispatch = False + agg._sim_inflight_residence = False + agg._sim_free_slot_ts = __import__("collections").deque(maxlen=128) + agg._sim_last_commit_sct = {} + agg._sim_inflight_expected = {} + agg._sim_trainer_budget = {} + agg._sim_budget_min = 12.0 + agg._sim_redispatch_gap_s = 0.0 + agg._sim_cooldown_until = {} + agg._real_distribute_settle_s = 0.0 + agg._track_trainer_version_duration_s = {} + agg.weights = {} + return agg + + +class TestProactiveEvictBothModes: + """D.1 eviction runs regardless of mode; the sim-only 90s re-clock doesn't.""" + + def test_syncfl_real_mode_still_evicts(self): + ch = _DistChannel(["e1", "e2"]) + calls, evict_spy, abandon_spy = _spies() + agg = _make_syncfl_agg(ch, simulated=False, evict_spy=evict_spy, abandon_spy=abandon_spy) + agg._distribute_weights("tag", "train") + assert calls["evict"] == 1 + assert calls["abandon"] == 0 + + def test_syncfl_sim_mode_evicts_and_abandons(self): + from flame.sim import VirtualClock + + ch = _DistChannel(["e1", "e2"]) + calls, evict_spy, abandon_spy = _spies() + agg = _make_syncfl_agg(ch, simulated=True, evict_spy=evict_spy, abandon_spy=abandon_spy) + agg._vclock = VirtualClock() + agg._distribute_weights("tag", "train") + assert calls["evict"] == 1 + assert calls["abandon"] == 1 + + def test_oort_real_mode_still_evicts(self): + ch = _DistChannel(["e1", "e2"]) + calls, evict_spy, abandon_spy = _spies() + agg = _make_oort_agg(ch, simulated=False, evict_spy=evict_spy, abandon_spy=abandon_spy) + agg._distribute_weights("tag", "train") + assert calls["evict"] == 1 + assert calls["abandon"] == 0 + + def test_oort_sim_mode_evicts_and_abandons(self): + from flame.sim import VirtualClock + + ch = _DistChannel(["e1", "e2"]) + calls, evict_spy, abandon_spy = _spies() + agg = _make_oort_agg(ch, simulated=True, evict_spy=evict_spy, abandon_spy=abandon_spy) + agg._vclock = VirtualClock() + agg._distribute_weights("tag", "train") + assert calls["evict"] == 1 + assert calls["abandon"] == 1 + + def test_asyncfl_real_mode_still_evicts(self): + ch = _DistChannel(["e1", "e2"]) + calls, evict_spy, abandon_spy = _spies() + agg = _make_asyncfl_agg(ch, simulated=False, evict_spy=evict_spy, abandon_spy=abandon_spy) + agg._distribute_weights("tag", "train") + assert calls["evict"] == 1 + assert calls["abandon"] == 0 + + def test_asyncfl_sim_mode_evicts_and_abandons(self): + ch = _DistChannel(["e1", "e2"]) + calls, evict_spy, abandon_spy = _spies() + agg = _make_asyncfl_agg(ch, simulated=True, evict_spy=evict_spy, abandon_spy=abandon_spy) + agg._distribute_weights("tag", "train") + assert calls["evict"] == 1 + assert calls["abandon"] == 1 diff --git a/lib/python/tests/mode/test_send_gate_wait.py b/lib/python/tests/mode/test_send_gate_wait.py new file mode 100644 index 000000000..c4c961ee0 --- /dev/null +++ b/lib/python/tests/mode/test_send_gate_wait.py @@ -0,0 +1,185 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Batch 3 T3.4: trainer-side [SEND_GATE] delay decomposition telemetry. + +`_send_weights`'s UN_AVL wait loop (syncfl/trainer.py) is the actual +enforcement point of the real-mode send-time gate (T3.1a/T3.1b landed the +mechanism; this task instruments it). Two new fields on the `task_send` +event -- not `trainer_round` (task/train() emits trainer_round BEFORE +put()/_send_weights runs, per the tasklet composition in `Trainer.compose`, +so `_phase_times` merged there can never see this loop's timing for the +same round; task_send already exists for exactly this ordering reason, see +`build_task_send`'s own docstring re: wall_send_ts): + - `send_gate_sct`: the trainer's own trace-time-basis clock (`_sim_now()`) + sampled right before the gate check, real mode only, regardless of + whether the gate actually engages. + - `send_gate_wait_s`: wall-time actually spent blocked in the loop (0.0 + when the gate never engaged), real mode only; always None in sim mode. +""" + +import types + +import pytest + +from flame.config import TrainerAvailState + + +class _FakeClock: + """Deterministic time.time()/time.sleep() so wait duration is exact.""" + + def __init__(self, start=1_000.0): + self.t = start + + def time(self): + return self.t + + def sleep(self, s): + self.t += s + + +def _make_trainer(): + from flame.mode.horizontal.syncfl.trainer import Trainer + + class _Concrete(Trainer): + def check_and_sleep(self): + pass + + def evaluate(self): + pass + + def initialize(self): + pass + + def load_data(self): + pass + + def train(self): + pass + + t = _Concrete.__new__(_Concrete) + t.trainer_id = "trainer-under-test" + t._round = 5 + t._phase_times = {} + t.task_to_perform = "eval" # skips the torch/cloudpickle weight-send path + t._stat_utility = 0.5 + t._local_accuracy = 0.0 + t._updates_returned_upto_round = 0 + t.wait_until_next_avl = "True" + return t + + +def _make_channel(): + return types.SimpleNamespace( + await_join=lambda: None, + one_end=lambda state: "agg-end", + send=lambda end, msg: None, + _selector=types.SimpleNamespace(_cleanup_send_ends=lambda: None), + ) + + +@pytest.fixture +def captured_events(monkeypatch): + """Capture every telemetry.emit() call made by syncfl/trainer.py.""" + import flame.mode.horizontal.syncfl.trainer as trainer_mod + + events: list = [] + monkeypatch.setattr(trainer_mod.telemetry, "is_enabled", lambda: True) + monkeypatch.setattr( + trainer_mod.telemetry, "emit", + lambda ev, **fields: events.append((ev, fields)), + ) + return events + + +def _task_send_fields(events): + for ev, fields in events: + if ev == "task_send": + return fields + raise AssertionError("no task_send event emitted") + + +class TestSendGateWaitRealMode: + def test_waits_and_stamps_observed_duration(self, monkeypatch, captured_events): + import flame.mode.horizontal.syncfl.trainer as trainer_mod + + t = _make_trainer() + t.simulated = False + t.avl_state = TrainerAvailState.UN_AVL + t._sim_now = lambda: 500.0 + t.cm = types.SimpleNamespace(get_by_tag=lambda tag: _make_channel()) + + clock = _FakeClock() + calls = {"n": 0} + + def _sleep(s): + clock.sleep(s) + calls["n"] += 1 + if calls["n"] >= 3: + t.avl_state = TrainerAvailState.AVL_TRAIN + + monkeypatch.setattr(trainer_mod.time, "time", clock.time) + monkeypatch.setattr(trainer_mod.time, "sleep", _sleep) + + t._send_weights("tag") + + fields = _task_send_fields(captured_events) + assert fields["send_gate_sct"] == 500.0 + assert fields["send_gate_wait_s"] == pytest.approx(3.0) + assert calls["n"] == 3 + + def test_no_wait_when_already_available(self, monkeypatch, captured_events): + import flame.mode.horizontal.syncfl.trainer as trainer_mod + + t = _make_trainer() + t.simulated = False + t.avl_state = TrainerAvailState.AVL_TRAIN + t._sim_now = lambda: 42.0 + t.cm = types.SimpleNamespace(get_by_tag=lambda tag: _make_channel()) + + def _sleep(_s): + raise AssertionError("sleep should never be called when already available") + + monkeypatch.setattr(trainer_mod.time, "sleep", _sleep) + + t._send_weights("tag") + + fields = _task_send_fields(captured_events) + assert fields["send_gate_sct"] == 42.0 + assert fields["send_gate_wait_s"] == 0.0 + + def test_missing_sim_now_leaves_sct_none(self, monkeypatch, captured_events): + """Defensive fallback: a base-class trainer with no _sim_now() override + (not every example wires one) must not raise -- sct is simply absent.""" + t = _make_trainer() + t.simulated = False + t.avl_state = TrainerAvailState.AVL_TRAIN + assert not hasattr(t, "_sim_now") + t.cm = types.SimpleNamespace(get_by_tag=lambda tag: _make_channel()) + + t._send_weights("tag") + + fields = _task_send_fields(captured_events) + assert fields["send_gate_sct"] is None + assert fields["send_gate_wait_s"] == 0.0 + + +class TestSendGateWaitSimMode: + def test_sim_mode_never_stamps_gate_fields(self, monkeypatch, captured_events): + import flame.mode.horizontal.syncfl.trainer as trainer_mod + + t = _make_trainer() + t.simulated = True + t.avl_state = TrainerAvailState.UN_AVL # would gate in real mode; sim ignores it + t._sim_now = lambda: 999.0 + t.cm = types.SimpleNamespace(get_by_tag=lambda tag: _make_channel()) + + def _sleep(_s): + raise AssertionError("sim mode must never enter the wall-sleep gate loop") + + monkeypatch.setattr(trainer_mod.time, "sleep", _sleep) + + t._send_weights("tag") + + fields = _task_send_fields(captured_events) + assert fields["send_gate_sct"] is None + assert fields["send_gate_wait_s"] is None diff --git a/lib/python/tests/mode/test_sim_barrier.py b/lib/python/tests/mode/test_sim_barrier.py index 7f309f57b..3020ed2d2 100644 --- a/lib/python/tests/mode/test_sim_barrier.py +++ b/lib/python/tests/mode/test_sim_barrier.py @@ -90,6 +90,12 @@ def _bare(cls): a = c.__new__(c) a._vclock = VirtualClock() a.simulated = True + # Gate-off availability state (production sets these in __init__ / + # _init_availability; __new__ bypasses both). The sim recv paths reference + # _sim_buffer directly; trainer_event_dict=None keeps the mixin helpers no-op. + a._sim_buffer = SimReorderBuffer() + a.trainer_event_dict = None + a.pending_withheld = {} return a diff --git a/lib/python/tests/mode/test_sync_sim_ordering.py b/lib/python/tests/mode/test_sync_sim_ordering.py index 295f00e7d..7b3583a8f 100644 --- a/lib/python/tests/mode/test_sync_sim_ordering.py +++ b/lib/python/tests/mode/test_sync_sim_ordering.py @@ -23,7 +23,7 @@ PROP_CLIENT_TASK_TRAIN_DURATION, PROP_STAT_UTILITY, ) -from flame.sim import VirtualClock +from flame.sim import VirtualClock, SimReorderBuffer class FakeSyncChannel: @@ -89,6 +89,14 @@ def _make_agg(): agg = _ConcreteSyncAgg.__new__(_ConcreteSyncAgg) agg._vclock = VirtualClock() agg.simulated = True + # Gate-off availability state. Production sets _sim_buffer in __init__ and the + # ledgers in _init_availability; __new__ bypasses both, so set them here. + # _sync_sim_recv_first_k references self._sim_buffer directly; trainer_event_dict + # =None + empty pending_withheld keep the ClientAvailability helpers no-op, so the + # sim-ordering logic is exercised in isolation (byte-identical to gate OFF). + agg._sim_buffer = SimReorderBuffer() + agg.trainer_event_dict = None + agg.pending_withheld = {} return agg @@ -483,8 +491,17 @@ def do(self, weights, cache, total=0): class _SelCfg: kwargs = {"aggr_num": 10} + class _HP: + # Real-recv timeout block reads these (getattr-with-default in prod); + # max_experiment_runtime_s=None ⇒ recv timeout falls back to the stall + # default, no budget cap. (Was missing → AttributeError after the + # oort/syncfl real-recv timeout landed.) + trainer_recv_wall_timeout_s = 90.0 + max_experiment_runtime_s = None + class _Config: selector = _SelCfg() + hyperparameters = _HP() class _ConcreteOortAgg(OortTopAggregator): def check_and_sleep(self): pass diff --git a/lib/python/tests/optimizer/test_fedbuff_lr.py b/lib/python/tests/optimizer/test_fedbuff_lr.py new file mode 100644 index 000000000..45d550dfe --- /dev/null +++ b/lib/python/tests/optimizer/test_fedbuff_lr.py @@ -0,0 +1,42 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Tests for FedBuff's explicit learning_rate kwarg -- when present it +overrides the dataset_name lookup table; when absent, the legacy table is +unchanged.""" + +import torch + +from flame.optimizer.fedbuff import FedBuff + + +def _make_fedbuff(**overrides): + kwargs = dict( + use_oort_lr="False", + dataset_name="unknown-dataset", + agg_rate_conf={"type": "old"}, + ) + kwargs.update(overrides) + return FedBuff(**kwargs) + + +def _scale_add(fedbuff): + base_weights = {"w": torch.zeros(3)} + agg_goal_weights = {"w": torch.ones(3)} + return fedbuff.scale_add_agg_weights(base_weights, agg_goal_weights, agg_goal=1) + + +class TestFedBuffLearningRate: + def test_explicit_learning_rate_overrides_dataset_table(self): + fedbuff = _make_fedbuff(learning_rate=0.5, dataset_name="cifar-10") + result = _scale_add(fedbuff) + assert torch.allclose(result["w"], torch.full((3,), 0.5)) + + def test_absent_learning_rate_uses_legacy_cifar10_value(self): + fedbuff = _make_fedbuff(dataset_name="cifar-10") + result = _scale_add(fedbuff) + assert torch.allclose(result["w"], torch.full((3,), 40.9)) + + def test_absent_learning_rate_unknown_dataset_falls_back_to_one(self): + fedbuff = _make_fedbuff(dataset_name="some-other-dataset") + result = _scale_add(fedbuff) + assert torch.allclose(result["w"], torch.ones(3)) diff --git a/lib/python/tests/selector/test_oort_selector.py b/lib/python/tests/selector/test_oort_selector.py index b659fa77f..5fe76243a 100644 --- a/lib/python/tests/selector/test_oort_selector.py +++ b/lib/python/tests/selector/test_oort_selector.py @@ -357,3 +357,50 @@ def test_cleanup_recvd_ends_clears_inflight(self, oort, make_ends): oort._cleanup_recvd_ends(make_ends(["a", "b", "c"])) assert oort.selected_ends == {"c"} assert oort.ordered_updates_recv_ends == [] + + +class TestChallenge13SendStateCleanup: + """The 'invalid prior selection' cleanup in _handle_send_state must key off + CONNECTED membership, not availability-eligibility (Challenge 13). An + in-flight trainer that merely went UN_AVL / wrong-task-type is absent from + the filtered eligible pool but still connected & computing — it must stay in + selected_ends. Only a genuinely disconnected end (gone from the channel) is + removed. Concurrency is sized so extra==0 and the method returns right after + cleanup, isolating the membership check.""" + + def test_unavailable_inflight_retained_when_connected_pool_passed( + self, async_oort, make_ends + ): + async_oort.requester = "agg" + async_oort.selected_ends = {"agg": {"t1", "t2"}} + connected = make_ends(["t1", "t2", "t3"]) # all still connected + eligible = {} # all currently unavailable + out = async_oort._handle_send_state( + ends=eligible, concurrency=2, channel_props={}, + connected_ends=connected, + ) + assert out == {} + # t1/t2 unavailable but connected → in-flight tracking preserved. + assert async_oort.selected_ends["agg"] == {"t1", "t2"} + + def test_disconnected_inflight_removed(self, async_oort, make_ends): + async_oort.requester = "agg" + async_oort.selected_ends = {"agg": {"t1", "t2"}} + connected = make_ends(["t1"]) # t2 genuinely gone + async_oort._handle_send_state( + ends={}, concurrency=1, channel_props={}, + connected_ends=connected, + ) + assert async_oort.selected_ends["agg"] == {"t1"} + + def test_fallback_to_eligible_when_no_connected_pool( + self, async_oort, make_ends + ): + # Backward-compat: with connected_ends omitted the check falls back to + # `ends` — the pre-fix behavior. Guards the default-arg contract. + async_oort.requester = "agg" + async_oort.selected_ends = {"agg": {"t1"}} + async_oort._handle_send_state( + ends=make_ends(["t1"]), concurrency=1, channel_props={}, + ) + assert async_oort.selected_ends["agg"] == {"t1"} diff --git a/lib/python/tests/selector/test_random_selection_telemetry.py b/lib/python/tests/selector/test_random_selection_telemetry.py new file mode 100644 index 000000000..c2d44f3a1 --- /dev/null +++ b/lib/python/tests/selector/test_random_selection_telemetry.py @@ -0,0 +1,203 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""RandomSelector (fwdllm's/fwdllm_plus's real aggregator-side FL selector) +never called emit_selection at all -- confirmed via audit: every "selection" +event that existed for those baselines came exclusively from the trainer's +own trivial 1-candidate channel selector (a channel-implementation artifact, +see ../../examples/MIGRATING_TO_LAUNCHER.md's telemetry gotchas), never from +the real selection decision made here. This covers the fix: select()'s SEND +branch now emits a real selection event once it actually picks candidates. +""" + +import json +from datetime import timedelta + +from flame import telemetry +from flame.channel import KEY_CH_SELECT_REQUESTER, KEY_CH_STATE, VAL_CH_STATE_SEND +from flame.selector.random import RandomSelector + + +def _make_selector(**overrides): + kwargs = {"is_async": False, "k": 5, "c": 3} + kwargs.update(overrides) + return RandomSelector(**kwargs) + + +class TestRandomSelectorEmitsSelectionTelemetry: + def test_emits_selection_event_on_new_pick(self, tmp_path, make_ends): + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + sel = _make_selector() + ends = make_ends( + count=5, stat_utility=1.0, round_duration=timedelta(seconds=2) + ) + channel_props = { + "round": 1, + KEY_CH_STATE: VAL_CH_STATE_SEND, + KEY_CH_SELECT_REQUESTER: "agg1", + } + + result = sel.select( + ends, channel_props, trainer_unavail_list=[], task_to_perform="train" + ) + + assert len(result) == 3 # min(len(ends), c) + events = [ + json.loads(l) + for l in (tmp_path / "aggregator.jsonl").read_text().splitlines() + ] + sels = [e for e in events if e["event"] == "selection"] + assert len(sels) == 1 + assert sels[0]["selector"] == "RandomSelector" + assert sels[0]["task"] == "train" + assert sels[0]["round"] == 1 + assert sorted(sels[0]["chosen"]) == sorted(result.keys()) + finally: + telemetry.shutdown() + + def test_eval_task_recorded_distinctly_from_train(self, tmp_path, make_ends): + """random.py's select() takes task_to_perform -- must not hardcode + "train" the way fedbuff.py's emit_selection call does.""" + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + sel = _make_selector() + ends = make_ends( + count=5, stat_utility=1.0, round_duration=timedelta(seconds=2) + ) + channel_props = { + "round": 1, + KEY_CH_STATE: VAL_CH_STATE_SEND, + KEY_CH_SELECT_REQUESTER: "agg1", + } + + sel.select( + ends, channel_props, trainer_unavail_list=[], task_to_perform="eval" + ) + + events = [ + json.loads(l) + for l in (tmp_path / "aggregator.jsonl").read_text().splitlines() + ] + sels = [e for e in events if e["event"] == "selection"] + assert len(sels) == 1 + assert sels[0]["task"] == "eval" + finally: + telemetry.shutdown() + + def test_no_event_when_selection_short_circuits(self, tmp_path, make_ends): + """When every candidate is unavailable, avl_candidates can't meet + concurrency and the method returns {} early -- no selection actually + happened, so no event should be emitted.""" + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + sel = _make_selector(c=2) + ends = make_ends(count=2, round_duration=timedelta(seconds=2)) + channel_props = { + "round": 1, + KEY_CH_STATE: VAL_CH_STATE_SEND, + KEY_CH_SELECT_REQUESTER: "agg1", + } + + result = sel.select( + ends, channel_props, trainer_unavail_list=list(ends.keys()), + task_to_perform="train", + ) + + assert result == {} + assert not (tmp_path / "aggregator.jsonl").exists() or not [ + json.loads(l) + for l in (tmp_path / "aggregator.jsonl").read_text().splitlines() + if json.loads(l)["event"] == "selection" + ] + finally: + telemetry.shutdown() + + def test_noop_when_telemetry_disabled(self, tmp_path, make_ends): + assert not telemetry.is_enabled() + sel = _make_selector() + ends = make_ends( + count=5, stat_utility=1.0, round_duration=timedelta(seconds=2) + ) + channel_props = { + "round": 1, + KEY_CH_STATE: VAL_CH_STATE_SEND, + KEY_CH_SELECT_REQUESTER: "agg1", + } + + # must not raise, and must not write anything + result = sel.select( + ends, channel_props, trainer_unavail_list=[], task_to_perform="train" + ) + + assert len(result) == 3 + assert not (tmp_path / "aggregator.jsonl").exists() + + +class TestRandomSelectorAggVersionStatePassthrough: + """fwdllm_aggregator.py threads (model_version, data_id, iteration_id) + through channel.ends(agg_version_state=...) -> select()'s **kwargs (see + ../../examples/MIGRATING_TO_LAUNCHER.md §9). Attaching data_id/ + iteration_per_data_id to the emitted selection event lets analyze_run.py's + progress_key() place it on the same fine-grained axis as trainer_round/ + agg_round/agg_eval, instead of collapsing onto fwdllm's coarse `round`. + """ + + def test_agg_version_state_attaches_data_id_and_iteration(self, tmp_path, make_ends): + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + sel = _make_selector() + ends = make_ends( + count=5, stat_utility=1.0, round_duration=timedelta(seconds=2) + ) + channel_props = { + "round": 1, + KEY_CH_STATE: VAL_CH_STATE_SEND, + KEY_CH_SELECT_REQUESTER: "agg1", + } + + sel.select( + ends, channel_props, trainer_unavail_list=[], task_to_perform="train", + agg_version_state=(7, 42, 3), # (model_version, data_id, iteration_id) + ) + + events = [ + json.loads(l) + for l in (tmp_path / "aggregator.jsonl").read_text().splitlines() + ] + sels = [e for e in events if e["event"] == "selection"] + assert len(sels) == 1 + assert sels[0]["data_id"] == 42 + assert sels[0]["iteration_per_data_id"] == 3 + finally: + telemetry.shutdown() + + def test_no_agg_version_state_omits_data_id(self, tmp_path, make_ends): + """async_cifar10's fedavg baseline also uses RandomSelector but never + passes agg_version_state -- must not crash, and must not fabricate + data_id/iteration_per_data_id fields.""" + telemetry.configure(role="aggregator", run_dir=str(tmp_path)) + try: + sel = _make_selector() + ends = make_ends( + count=5, stat_utility=1.0, round_duration=timedelta(seconds=2) + ) + channel_props = { + "round": 1, + KEY_CH_STATE: VAL_CH_STATE_SEND, + KEY_CH_SELECT_REQUESTER: "agg1", + } + + sel.select( + ends, channel_props, trainer_unavail_list=[], task_to_perform="train", + ) + + events = [ + json.loads(l) + for l in (tmp_path / "aggregator.jsonl").read_text().splitlines() + ] + sels = [e for e in events if e["event"] == "selection"] + assert len(sels) == 1 + assert "data_id" not in sels[0] + assert "iteration_per_data_id" not in sels[0] + finally: + telemetry.shutdown() diff --git a/lib/python/tests/selector/test_send_timeout_frees_selected_ends.py b/lib/python/tests/selector/test_send_timeout_frees_selected_ends.py new file mode 100644 index 000000000..e1d4b95c0 --- /dev/null +++ b/lib/python/tests/selector/test_send_timeout_frees_selected_ends.py @@ -0,0 +1,97 @@ +# Copyright 2026 Cisco Systems, Inc. and its affiliates +# SPDX-License-Identifier: Apache-2.0 +"""Regression: the 90s SEND_TIMEOUT_WAIT_S abandon in async_oort.py/fedbuff.py +must free the end from selected_ends, not just all_selected -- recv_ends +derives from selected_ends, so leaving it there hangs recv_fifo forever +(UNAVAILABILITY_DESIGN.md, Open A).""" + +import time + +import pytest + + +class _StopAfterAbandon(Exception): + """Raised from a stubbed pacer() to inspect state right after the abandon + block runs, without driving async_oort's heavier downstream selection + (same technique as TestCoolingHoldsConcurrency in test_async_sim_ordering.py).""" + + +def _boom(): + raise _StopAfterAbandon() + + +class TestAsyncOortSendTimeoutFreesSelectedEnds: + @staticmethod + def _stub_selector(): + from flame.selector.async_oort import AsyncOortSelector + + sel = AsyncOortSelector.__new__(AsyncOortSelector) + sel.requester = "agg" + sel.selected_ends = {"agg": {"stale"}} + sel.all_selected = {"stale": time.time() - 100} # past 90s SEND_TIMEOUT_WAIT_S + sel.ordered_updates_recv_ends = [] + sel.track_trainer_timeouts = {} + sel.pacer = _boom + return sel + + def test_stale_end_leaves_both_all_selected_and_selected_ends(self, make_ends): + sel = self._stub_selector() + ends = make_ends(["stale", "fresh"]) + + with pytest.raises(_StopAfterAbandon): + sel._handle_send_state( + ends=ends, + concurrency=2, + channel_props={"round": 1}, + trainer_unavail_list=[], + task_to_perform="train", + agg_version_state=(1, 0, 0), + trainer_version_states={}, + ) + + assert "stale" not in sel.all_selected + assert "stale" not in sel.selected_ends["agg"] + + def test_fresh_end_untouched(self, make_ends): + sel = self._stub_selector() + sel.all_selected["fresh"] = time.time() # well within the 90s window + sel.selected_ends["agg"].add("fresh") + ends = make_ends(["stale", "fresh", "third"]) + + with pytest.raises(_StopAfterAbandon): + sel._handle_send_state( + ends=ends, + concurrency=3, # 2 already selected -> extra=1, past the extra==0 short-circuit + channel_props={"round": 1}, + trainer_unavail_list=[], + task_to_perform="train", + agg_version_state=(1, 0, 0), + trainer_version_states={}, + ) + + assert "fresh" in sel.all_selected + assert "fresh" in sel.selected_ends["agg"] + + +class TestFedBuffSendTimeoutFreesSelectedEnds: + @staticmethod + def _stub_selector(): + from flame.selector.fedbuff import FedBuffSelector + + sel = FedBuffSelector(c=2, aggGoal=1) + sel.requester = "agg" + sel.selected_ends = {"agg": {"stale"}} + sel.all_selected = {"stale": time.time() - 100} # past 90s SEND_TIMEOUT_WAIT_S + return sel + + def test_stale_end_leaves_both_all_selected_and_selected_ends(self, make_ends): + sel = self._stub_selector() + ends = make_ends(["stale", "fresh"]) + + # concurrency=1 with 1 already selected -> extra=0, fixed before the + # abandon loop runs, so the freed slot can't be immediately re-filled + # by the candidate loop below (a separate, correct RNG-dependent path). + sel._handle_send_state(ends=ends, concurrency=1, connected_ends=ends) + + assert "stale" not in sel.all_selected + assert "stale" not in sel.selected_ends["agg"] diff --git a/scripts/analysis/README.md b/scripts/analysis/README.md new file mode 100644 index 000000000..43f587c99 --- /dev/null +++ b/scripts/analysis/README.md @@ -0,0 +1,138 @@ +# `analyze_run.py` — onboarding a new example + +`analyze_run.py` reads the JSONL telemetry a run writes under +`/telemetry/` and produces PDFs under `/plots/`, grouped into 8 +categories: + +| category | question it answers | needs | +|---|---|---| +| `performance/` | did it learn? (accuracy, loss) | `agg_eval` | +| `sanity/` | is the run healthy & as configured? | `trainer_round` | +| `selection/` | who was picked? | `selection` | +| `selection/why/` | why were they picked? | `selection` with per-trainer factor fields (`believed_I`/`system_util`/`temporal`/`speed_s`) | +| `insights/` | mis-selection & data-unlock audit | `util_disparity` + oracle-utility logs (oort-family selectors only) | +| `system/` | resources, timing, communication | `trainer_round`, `agg_round` | +| `availability/` | selection funnel & churn | `selection`, `avail_change` | +| `aggregation/` | commit cadence, staleness vs. speed | `agg_round` | + +It was originally written for `async_cifar10` and generalized only +informally, so two things it assumed were true for that example are **not** +true in general: + +1. **`round` is the only progress unit, and it's fine-grained** (advances + every aggregation). Not true for fwdllm-family examples, where `round` + only advances once every sub-unit (`data_id`, `total_data_bins=150` + of them) finishes — a run can sit at `round == 1` for hundreds of events. +2. **The model has one fixed, full-model size for comm-cost plots.** Not true + for gradient/perturbation-based schemes (e.g. FedFwd) that only ever put a + trainable subset on the wire. + +Both are handled by a per-example, **optional** manifest — an example with no +manifest gets exactly `async_cifar10`'s original behavior, unchanged. + +## The manifest: `examples//telemetry_manifest.yaml` + +`configure_from_manifest()` walks up from a run's `telemetry_dir` looking for +`examples//telemetry_manifest.yaml` and, if found, applies it. Three +fields, all optional: + +```yaml +model_param_count: 450340 # trainable params actually sent over the wire — + # not necessarily the full model (see fwdllm's + # manifest for the FedFwd rationale). Overridden + # by --model-params on the CLI, never the reverse. + +progress_hierarchy: # sub-round fields, ordered major->minor, each + - field: data_id # with a `bound` used as that level's mixed- + bound: 150 # radix multiplier (must exceed the field's max + - field: iteration_per_data_id # real value, or ordering breaks across + bound: 15 # round boundaries). Consumed by + # progress_key() — see its docstring for + # which call sites it's safe to use on + # (single-stream groupings only; never to + # join against an event type that doesn't + # carry the same fields, e.g. selection). + +event_categories: # declare what this example's telemetry actually + performance: populated # populates, and why (populated | partial | + ... # not_populated). write_summary() cross-checks + # this against which plots// dirs + # actually got files and flags drift: + # MISMATCH — declared populated, nothing written + # DRIFT — declared not_populated, something written + # See lib/python/examples/fwdllm/telemetry_manifest.yaml + # for a fully worked example with reasoning + # comments per category. +``` + +See `lib/python/tests/analysis/test_manifest.py` for the loader's exact +fallback behavior (absent manifest, malformed YAML, CLI-override guard). + +## Checklist: wiring telemetry for a new example + +Worked example throughout: fwdllm (`lib/python/examples/fwdllm/`), which went +through this exact process — see +`lib/python/examples/fwdllm/MIGRATION_TO_LAUNCHER_FWDLLM.md` Part 5 for the +full investigation, evidence, and fixes referenced below. + +1. **Aggregator must emit at least `agg_eval` and `agg_round` once per + aggregation cycle.** Without this, `plots/performance/` and + `plots/aggregation/` are structurally impossible no matter what the + analyzer does — this was fwdllm's biggest gap (`fwdllm_aggregator.py` + emitted zero telemetry of any kind before P5.2). Wrap every emit in + `if telemetry.is_enabled(): try: ... except Exception: logger.debug(...)` + — telemetry must never be able to break training. +2. **The real FL-selection algorithm must call `emit_selection(...)`.** + Check the actual selector class the aggregator's `selector.sort` config + uses (not just any selector in the codebase) — sibling selectors are not + a reliable reference. fwdllm/fwdllm_plus use `selector/random.py`, which + had never called `emit_selection` at all (P5.5); every `selection` event + that existed for those baselines came from the trainer's own trivial + 1-candidate channel selector, not the real "who got picked" decision. +3. **If progress isn't a plain, every-aggregation `round`, declare a + `progress_hierarchy`** in the manifest instead of hardcoding sub-round + fields into the analyzer (`progress_key()`'s `_DEFAULT_PROGRESS_HIERARCHY` + fallback is fwdllm's original shape, kept only for backward compatibility + with callers that pass no `telemetry_dir` context — new examples should + declare their own, not rely on it). +4. **If comm-cost plots should reflect less than the full model**, set + `model_param_count` to what's actually transmitted, measured from a real + run's log line (a trainable-param-count log, a `state_dict()` size dump, + etc.) — not guessed. +5. **Declare `event_categories`** honestly, including `not_populated` for + categories that structurally can't be populated (a streaming-only insight, + an oort-family-only mis-selection audit, etc.) — an undeclared category is + a silent gap someone has to rediscover; a declared `not_populated` is a + documented, expected outcome. +6. **Run `analyze_run.py` against a real (or synthetic, matching the + telemetry shape the instrumented code actually emits) smoke run** and read + `plots/summary.txt`'s `manifest event_categories check` section. Every + line should read `ok: ...` — a `MISMATCH` or `DRIFT` line means the + manifest and reality disagree; fix whichever one is wrong. +7. **Add regression tests exercising the real emission code path** (not + mocked out) — see `lib/python/tests/mode/test_fwdllm_agg_telemetry.py` and + `lib/python/tests/selector/test_random_selection_telemetry.py` for the + fwdllm pattern: minimal real objects (e.g. a real `torch.nn.Linear(1,1)` + model) plus fakes only for the parts genuinely external to what's being + tested. + +## Gotchas found while onboarding fwdllm + +- **A trainer-role `selection` event's `"selector"` field is a + channel-implementation artifact, not the real FL selector.** Every role + (aggregator *and* trainer) constructs its own local `Selector` for its + channel; a trainer's channel to its aggregator always has exactly 1 + candidate, so whatever selector class the example's `trainer_base.yaml` + hardcodes as a placeholder trivially "selects" that one peer regardless of + its kwargs. This is launcher-wide, not fwdllm-specific (checked + `async_cifar10` too — same pattern). Read which selector algorithm a run + really used from the **aggregator**'s config/telemetry, never the + trainer's. +- **A stale in-memory reselection cache can silently exclude a departed + trainer forever** if a per-round accumulation path doesn't call the real + selector every cycle (fwdllm's `_round_selected_ends` gap, fixed via + `_prune_departed_from_round_cache` — see the migration doc's Part 3). Not + an analysis-tooling gap, but the kind of thing that produces telemetry that + *looks* fine (events keep flowing) while the run itself has silently + stalled for one trainer's slot — worth an explicit check on any new + example with its own reselection/caching logic. diff --git a/scripts/analysis/analyze_run.py b/scripts/analysis/analyze_run.py index 47c97fb0b..6484d9e6e 100644 --- a/scripts/analysis/analyze_run.py +++ b/scripts/analysis/analyze_run.py @@ -33,6 +33,8 @@ from collections import Counter, defaultdict from typing import Optional +import yaml + sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) import plot_helpers as ph # noqa: E402 @@ -44,13 +46,16 @@ ), ) from flame.telemetry.events import ( # noqa: E402 + EVENT_AGG_BELIEF_CHANGE, EVENT_AGG_EVAL, EVENT_AGG_ROUND, EVENT_AVAIL_CHANGE, EVENT_SELECTION, + EVENT_TASK_SEND, EVENT_TRAINER_ROUND, EVENT_UTIL_DISPARITY, EVENT_UTILITY_BELIEF, + EVENT_WITHHELD_DELIVERY, ) except Exception: # pragma: no cover EVENT_SELECTION = "selection" @@ -60,6 +65,40 @@ EVENT_UTIL_DISPARITY = "util_disparity" EVENT_AVAIL_CHANGE = "avail_change" EVENT_UTILITY_BELIEF = "utility_belief" + EVENT_AGG_BELIEF_CHANGE = "agg_belief_change" + EVENT_TASK_SEND = "task_send" + EVENT_WITHHELD_DELIVERY = "withheld_delivery" + +# Batch 3 T3.2 (UNAVAILABILITY_DESIGN.md): the A6 trainer_trace_fidelity ground- +# truth lookups live under the async_cifar10 example's parity checker package +# (trace names / the trainer registry are example-specific), not in generic +# flame/. Optional: absent for examples without an availability trace store. +try: + sys.path.insert( + 0, + os.path.join( + os.path.dirname(os.path.abspath(__file__)), + "..", "..", "lib", "python", "examples", "async_cifar10", "scripts", + ), + ) + from parity.avail_state_series import ( # noqa: E402 + build_observed_timeline_from_agg_belief, + build_observed_timeline_from_avail_change, + build_trainer_state_series, + selection_run_span, + ) + from parity.checks import _fidelity_score # noqa: E402 + from parity.ground_truth import ( # noqa: E402 + by_short_id, + expected_send_gate_wait, + load_ground_truth, + resolve_trace_name, + transitions_in_range, + ) + from flame.availability.trace import state_at as _gt_state_at # noqa: E402 + _HAVE_GROUND_TRUTH = True +except Exception: # pragma: no cover + _HAVE_GROUND_TRUTH = False # Communication is reported in MEGABYTES. One model = MODEL_PARAM_COUNT fp32 @@ -72,6 +111,72 @@ BYTES_PER_PARAM = 4 MODEL_MB = MODEL_PARAM_COUNT * BYTES_PER_PARAM / 1e6 +# Default progress hierarchy (used when no per-example manifest is found, or +# for records/tests with no telemetry_dir context at all) -- preserves the +# exact fwdllm-shaped behavior progress_key() had before manifests existed +# (round-major, data_id-minor; iteration_per_data_id not folded in). +_DEFAULT_PROGRESS_HIERARCHY = [{"field": "data_id", "bound": 200}] + +# Mutated by _load_manifest_for()/main()'s --model-params; read by +# progress_key(). --model-params on the CLI always wins over a manifest (see +# main()). +_PROGRESS_HIERARCHY = list(_DEFAULT_PROGRESS_HIERARCHY) +_MODEL_PARAMS_CLI_OVERRIDDEN = False + + +def _find_manifest_path(telemetry_dir: str) -> Optional[str]: + """A run's telemetry_dir is normally + .../examples//experiments//telemetry -- walk up looking for + the `examples//` root and check for telemetry_manifest.yaml there. + Returns None (not an error) if no examples// ancestor is found or + it has no manifest -- manifests are optional (see + examples/MIGRATING_TO_LAUNCHER.md §5).""" + cur = os.path.abspath(telemetry_dir) + for _ in range(6): # bounded walk-up; a real path resolves in 2-3 hops + parent = os.path.dirname(cur) + name = os.path.basename(cur) + if os.path.basename(parent) == "examples" and name: + candidate = os.path.join(cur, "telemetry_manifest.yaml") + return candidate if os.path.isfile(candidate) else None + if parent == cur: # filesystem root + return None + cur = parent + return None + + +def load_manifest(telemetry_dir: str) -> Optional[dict]: + """Load the calling example's telemetry_manifest.yaml, if any. Returns + None (not an error) when absent -- callers must treat that as "use + async_cifar10-shaped defaults", not a failure.""" + path = _find_manifest_path(telemetry_dir) + if path is None: + return None + try: + with open(path) as f: + manifest = yaml.safe_load(f) or {} + return manifest + except Exception as e: # a malformed manifest must not crash analysis + print(f" (warning: failed to load manifest {path}: {e})") + return None + + +def configure_from_manifest(telemetry_dir: str) -> Optional[dict]: + """Apply a run's manifest (if any) to the module-level MODEL_MB / + progress-hierarchy globals. Returns the loaded manifest (or None) so + callers can also use its `event_categories` declaration (see + write_summary). --model-params on the CLI is never overridden here.""" + global MODEL_PARAM_COUNT, MODEL_MB, _PROGRESS_HIERARCHY + manifest = load_manifest(telemetry_dir) + if manifest is None: + _PROGRESS_HIERARCHY = list(_DEFAULT_PROGRESS_HIERARCHY) + return None + if not _MODEL_PARAMS_CLI_OVERRIDDEN and manifest.get("model_param_count"): + MODEL_PARAM_COUNT = int(manifest["model_param_count"]) + MODEL_MB = MODEL_PARAM_COUNT * BYTES_PER_PARAM / 1e6 + hierarchy = manifest.get("progress_hierarchy") + _PROGRESS_HIERARCHY = hierarchy if hierarchy else list(_DEFAULT_PROGRESS_HIERARCHY) + return manifest + def load_events(telemetry_dir: str) -> list[dict]: """Load all JSONL records from a telemetry directory.""" @@ -93,6 +198,57 @@ def by_event(records, event): return [r for r in records if r.get("event") == event] +def progress_key(r: dict) -> int: + """Ordinal progress axis for any record, generalized over the calling + example's declared `progress_hierarchy` (see the module-level + _PROGRESS_HIERARCHY global, set by configure_from_manifest() from a run's + telemetry_manifest.yaml -- P5.4). Defaults to fwdllm's original + round/data_id-only shape when no manifest was loaded (e.g. direct calls + with no telemetry_dir context, as in the unit tests). + + fwdllm-family runs can sit at `round == 1` for hundreds of trainer_round/ + agg_round/agg_eval events (a round only advances once all data bins + finish), which collapses any plot bucketing by plain `round` onto one + x-value. Folding in the declared sub-round fields (mixed-radix: each + level's `bound` is that level's multiplier) restores a meaningful + ordering without changing async_cifar10, which declares no hierarchy and + never sets any of these fields. + + Stops folding at the first hierarchy level missing from the record (a + record with `data_id` but no `iteration_per_data_id` still gets a + data_id-resolution key, not a crash or a silently-wrong one). + + Only safe for single-stream groupings, or for joining two streams that + BOTH carry the same hierarchy fields. EVENT_TRAINER_ROUND/EVENT_AGG_ROUND/ + EVENT_AGG_EVAL always do (P5.2). EVENT_SELECTION carries data_id/ + iteration_per_data_id only from the real aggregator-side selector when + the aggregator threads agg_version_state through channel.ends() + (fwdllm-family, selector/random.py -- P5.6); trainer-side placeholder- + selector events don't, and gracefully degrade to a plain-round key + instead (a channel-implementation artifact -- see + examples/MIGRATING_TO_LAUNCHER.md's telemetry gotchas) -- + still safe to fold since those keys can't collide with the far-larger + folded ones. EVENT_AVAIL_CHANGE never carries these fields; do not key a + join against it with progress_key() on only one side. + """ + key = int(r.get("round", 0)) + for level in _PROGRESS_HIERARCHY: + val = r.get(level["field"]) + if val is None: + break + key = key * int(level["bound"]) + int(val) + return key + + +# x-axis label for any plot bucketed by progress_key() rather than plain +# `round` -- makes it visually unambiguous (see +# examples/MIGRATING_TO_LAUNCHER.md §5) that fwdllm-family plots are NOT on +# a round-granularity axis, even +# though the label still reads "round" for async_cifar10 (progress_key is a +# no-op there). +PROGRESS_AXIS_LABEL = "progress (round, or round×data_id×iteration -- see progress_key())" + + def _sub(out_root, *cls): return os.path.join(out_root, *cls) @@ -110,28 +266,34 @@ def _visible_fraction(r): def accuracy_by_round(records): + """Keyed by progress_key(), not plain round -- fwdllm-family agg_eval + records carry data_id/iteration_per_data_id (P5.2), and round alone can + sit at 1 for an entire run (round only advances once total_data_bins + data_ids finish). async_cifar10 agg_eval has no data_id, so this is an + unchanged plain-round key there (progress_key no-ops).""" out = {} for r in by_event(records, EVENT_AGG_EVAL): a = r.get("test-accuracy") if a is not None: - out[int(r.get("round", 0))] = a + out[progress_key(r)] = a return out def loss_by_round(records): + """See accuracy_by_round -- same progress_key() rationale.""" out = {} for r in by_event(records, EVENT_AGG_EVAL): a = r.get("test-loss") if a is not None: - out[int(r.get("round", 0))] = a + out[progress_key(r)] = a return out def sim_time_by_round(records): - """round -> cumulative max sim_completion_ts (sim wall time).""" + """progress_key -> cumulative max sim_completion_ts (sim wall time).""" best = {} for r in by_event(records, EVENT_TRAINER_ROUND): - rd = int(r.get("round", 0)) + rd = progress_key(r) sc = r.get("sim_completion_ts") if sc is None: sc = r.get("sim_round_duration_s") @@ -151,7 +313,19 @@ def cumulative_comm_by_round(records): Round 0 is the pre-training selection warmup (the selector retries while trainers join — tens of thousands of selection events that are not real model dispatches), so it is excluded to avoid a spurious comm spike that - dwarfs every real round. + dwarfs every real round. The exclusion check uses the raw `round` field + (not progress_key) since it's about identifying the warmup phase, not + granularity. + + Keyed by progress_key(), not plain round: fwdllm-family selection events + from the real aggregator-side selector (selector/random.py, P5.6) carry + data_id/iteration_per_data_id when the aggregator threads + agg_version_state through channel.ends(); trainer-side placeholder- + selector events (a channel-implementation artifact -- see + examples/MIGRATING_TO_LAUNCHER.md's telemetry gotchas) + don't, and progress_key() gracefully degrades to plain round for those -- + both can coexist in the same dict without key collisions (the folded + keys are far larger than any plain round number in practice). """ per_round = defaultdict(float) for r in by_event(records, EVENT_SELECTION): @@ -160,7 +334,7 @@ def cumulative_comm_by_round(records): continue n = len(r.get("chosen") or []) eq = 2.0 * n if r.get("task", "train") == "train" else 1.0 * n - per_round[rd] += eq * MODEL_MB + per_round[progress_key(r)] += eq * MODEL_MB rounds = sorted(per_round) cum, run = [], 0.0 for rd in rounds: @@ -228,8 +402,12 @@ def time_to_target(records, target): a = r.get("test-accuracy") if a is not None and a >= target: rd = int(r.get("round", 0)) + # sim_map (sim_time_by_round) is keyed by progress_key, not plain + # round -- for fwdllm-family records (agg_eval now carries + # data_id) these differ, so look it up on the same axis. "round" + # in the returned dict stays the plain, human-readable value. wall = (r.get("ts") - start_ts) if (r.get("ts") and start_ts) else None - return {"round": rd, "wall_s": wall, "sim_s": sim_map.get(rd), + return {"round": rd, "wall_s": wall, "sim_s": sim_map.get(progress_key(r)), "accuracy": a, "reached": True} return {"round": None, "wall_s": None, "sim_s": None, "accuracy": None, "reached": False} @@ -447,7 +625,7 @@ def _floats(rows, key): def trainer_rounds_by_round(records): out = defaultdict(list) for r in by_event(records, EVENT_TRAINER_ROUND): - out[int(r.get("round", 0))].append(r) + out[progress_key(r)].append(r) return out @@ -464,7 +642,7 @@ def perf_plots(records, out, stamp, tdir): if acc: rs = sorted(acc) p = ph.line_plot({"test accuracy": (rs, [acc[r] for r in rs])}, - "round", "test accuracy", "Test accuracy over rounds", + PROGRESS_AXIS_LABEL, "test accuracy", "Test accuracy over rounds", d, "accuracy_over_rounds.pdf", stamp=stamp, target=0.6) if p: saved.append(p) # vs sim-time (fair axis for async vs sync) @@ -481,14 +659,14 @@ def perf_plots(records, out, stamp, tdir): gains = [acc[rs[i]] - acc[rs[i - 1]] for i in range(1, len(rs))] if gains: p = ph.signed_bar_line(rs[1:], gains, [acc[r] for r in rs[1:]], - "round", "Δ accuracy / eval", "test accuracy", + PROGRESS_AXIS_LABEL, "Δ accuracy / eval", "test accuracy", "Accuracy gain per eval (bars) + overall accuracy (line)", d, "accuracy_gain_per_eval.pdf", stamp=stamp) if p: saved.append(p) if loss: rs = sorted(loss) p = ph.line_plot({"test loss": (rs, [loss[r] for r in rs])}, - "round", "test loss", "Test loss over rounds", + PROGRESS_AXIS_LABEL, "test loss", "Test loss over rounds", d, "loss_over_rounds.pdf", stamp=stamp) if p: saved.append(p) # accuracy vs cumulative data unlocked @@ -772,7 +950,7 @@ def sanity_plots(records, out, stamp, tdir): except (TypeError, ValueError): continue lb.append(b); la.append(a); lgap.append(abs(b - a)) - lrounds.append((int(r.get("round", 0)), abs(b - a))) + lrounds.append((progress_key(r), abs(b - a))) if lb: p = ph.cdf_multi({"believed (at selection)": lb, "actual (at return)": la}, "client statistical utility", @@ -794,7 +972,7 @@ def sanity_plots(records, out, stamp, tdir): gap_by_round.setdefault(rd, []).append(g) gx = sorted(gap_by_round) gy = [sum(gap_by_round[r]) / len(gap_by_round[r]) for r in gx] - p = ph.line_plot({"mean |believed - actual|": (gx, gy)}, "round", + p = ph.line_plot({"mean |believed - actual|": (gx, gy)}, PROGRESS_AXIS_LABEL, "belief staleness error (utility)", "Belief staleness over the run (live)", d, "selected_utility_belief_gap_over_rounds.pdf", stamp=stamp) @@ -829,21 +1007,26 @@ def sanity_plots(records, out, stamp, tdir): "data_unlock_curve.pdf", stamp=stamp) if p: saved.append(p) - # selection-count consistency + # selection-count consistency. Keyed by progress_key() on BOTH sides so + # the union stays meaningful -- EVENT_AGG_ROUND always carries data_id/ + # iteration_per_data_id (P5.2); EVENT_SELECTION does only from the real + # aggregator-side selector (P5.6), gracefully degrading to plain round + # otherwise (see progress_key()'s docstring). sel = by_event(records, EVENT_SELECTION) sel_by_round = defaultdict(int) for s in sel: # Drop round 0 (pre-training selection warmup: tens of thousands of - # retry events that otherwise dominate the y-axis). + # retry events that otherwise dominate the y-axis). Checked on the + # raw round field, not progress_key -- this is about identifying the + # warmup phase, not granularity. if s.get("task", "train") == "train" and int(s.get("round", 0)) >= 1: - sel_by_round[int(s.get("round", 0))] += len(s.get("chosen") or []) + sel_by_round[progress_key(s)] += len(s.get("chosen") or []) # Sum across agg_round events per round: async emits one event per commit, # so a dict-comprehension would overwrite and show 1 instead of agg_goal. contrib = defaultdict(int) for r in ar: - rd = int(r.get("round", 0)) - if rd >= 1: - contrib[rd] += len(r.get("contributing_trainers") or []) + if int(r.get("round", 0)) >= 1: + contrib[progress_key(r)] += len(r.get("contributing_trainers") or []) if sel_by_round: rr = sorted(set(sel_by_round) | set(contrib)) # Binned (mean/bin) so the chosen-vs-contributing relationship is smooth @@ -851,7 +1034,7 @@ def sanity_plots(records, out, stamp, tdir): series = {"chosen (train)": (rr, [sel_by_round.get(r, 0) for r in rr])} if contrib: series["contributing"] = (rr, [contrib.get(r, 0) for r in rr]) - p = ph.binned_line(series, "round", "trainer count", + p = ph.binned_line(series, PROGRESS_AXIS_LABEL, "trainer count", "Selection/aggregation count consistency (round-0 warmup excluded)", d, "selection_count_consistency.pdf", stamp=stamp, nbins=200, reducer="mean") @@ -1010,13 +1193,15 @@ def selection_plots(records, out, stamp, tdir): # selector is visibly active; train is on a second binned line for context. et = defaultdict(lambda: {"train": 0, "eval": 0}) for s in sel: - et[int(s.get("round", 0))][s.get("task", "train")] += len(s.get("chosen") or []) + if int(s.get("round", 0)) < 1: # exclude pre-training warmup (raw round) + continue + et[progress_key(s)][s.get("task", "train")] += len(s.get("chosen") or []) if any(v["eval"] for v in et.values()): - rr = sorted(r for r in et if r >= 1) + rr = sorted(et) p = ph.binned_line( {"eval selections/round": (rr, [et[r]["eval"] for r in rr]), "train selections/round": (rr, [et[r]["train"] for r in rr])}, - "round", "selections", "Eval vs train selection rate (mean/bin)", + PROGRESS_AXIS_LABEL, "selections", "Eval vs train selection rate (mean/bin)", d, "eval_vs_train_selections.pdf", stamp=stamp, nbins=150, reducer="mean") if p: saved.append(p) @@ -1031,7 +1216,7 @@ def selection_plots(records, out, stamp, tdir): sp = [pt[c].get("speed_s") for c in chosen if c in pt and pt[c].get("speed_s") is not None] uu = [pt[c].get("believed_I", pt[c].get("utility")) for c in chosen if c in pt and pt[c].get("believed_I", pt[c].get("utility")) is not None] - rd = int(s.get("round", 0)) + rd = progress_key(s) if sp: spd[rd] = sum(sp) / len(sp) if uu: @@ -1051,7 +1236,7 @@ def _smooth(ys, w=15): if both: p = ph.dual_axis_line(both, _smooth([spd[r] for r in both]), _smooth([utl[r] for r in both]), - "round", "avg speed of picked (s, smoothed)", + PROGRESS_AXIS_LABEL, "avg speed of picked (s, smoothed)", "avg believed utility of picked (smoothed)", "Picked clients: avg speed & utility per round " "(rolling mean, w=15)", d, @@ -1068,7 +1253,7 @@ def _smooth(ys, w=15): elif utl: # e.g. FedDance has no speed factor rr = sorted(utl) p = ph.line_plot({"avg believed utility of picked": (rr, _smooth([utl[r] for r in rr]))}, - "round", "avg believed utility of picked (smoothed)", + PROGRESS_AXIS_LABEL, "avg believed utility of picked (smoothed)", "Picked clients: avg utility per round (rolling mean, w=15)", d, "selected_speed_utility_over_rounds.pdf", stamp=stamp) if p: saved.append(p) @@ -1177,45 +1362,45 @@ def _participation_heatmap(records, d, stamp): rounds = sorted(set(trained) | set(evalsel)) if not trainers or not rounds: return [] - # Per-trainer availability per round (forward-filled from avail_change), so - # idle cells can distinguish "available, not picked" from "unavailable". - unavail = defaultdict(dict) # trainer -> {round: True if UN_AVL} - ac = defaultdict(list) - for r in by_event(records, EVENT_AVAIL_CHANGE): - ac[str(r.get("end_id"))].append((int(r.get("round", 0)), - str(r.get("new_state", "")))) - for t, evs in ac.items(): - evs.sort() - cur = None - for rd, st in evs: - cur = st - unavail[t][rd] = ("UN_AVL" in cur) + # Per-trainer availability per round — the aggregator's own belief + # (C.6.1/C.6.2), populated even in pure-oracular mode where the trainer- + # side avail_change log is empty. Forward-filled across rounds so idle + # cells can distinguish "available, not picked" from "unavailable". + avl_by_round = _avl_state_by_round(records) idx = {t: i for i, t in enumerate(trainers)} ridx = {r: j for j, r in enumerate(rounds)} - # 0 not-selected, 1 eval, 2 train, 3 unavailable (not selected), - # 4 selected-but-unavailable. Availability forward-filled across rounds. + # 0 not-selected (AVL_TRAIN idle), 1 eval, 2 train, 3 unavailable (not + # selected), 4 selected-but-unavailable (stale dispatch), 5 idle during + # AVL_EVAL (3-state extension — was binary unavailable/available). m = np.zeros((len(trainers), len(rounds))) for t in trainers: - last_un = False + last_state = "AVL_TRAIN" + rs = avl_by_round.get(t, {}) for r in rounds: - if r in unavail.get(t, {}): - last_un = unavail[t][r] - sel = (t in evalsel.get(r, set())) or (t in trained.get(r, set())) + if r in rs: + last_state = rs[r] + is_unavail = "UN_AVL" in last_state + is_eval_idle = "AVL_EVAL" in last_state if t in trained.get(r, set()): - v = 4 if last_un else 2 + v = 4 if is_unavail else 2 elif t in evalsel.get(r, set()): - v = 4 if last_un else 1 + v = 4 if is_unavail else 1 + elif is_unavail: + v = 3 + elif is_eval_idle: + v = 5 else: - v = 3 if last_un else 0 + v = 0 m[idx[t], ridx[r]] = v yl = [t[-3:] for t in trainers] if len(trainers) <= 40 else None p = ph.heatmap(m, "round", "trainer", "Participation per trainer x round", d, "participation_heatmap.pdf", stamp=stamp, yticklabels=yl, - discrete=[(0, "not selected", "#ededed"), + discrete=[(0, "not selected (AVL_TRAIN idle)", "#ededed"), (1, "eval", "#3182bd"), (2, "train", "#31a354"), (3, "unavailable", "#fdae6b"), - (4, "selected but unavail", "#e6550d")]) + (4, "selected but unavail", "#e6550d"), + (5, "idle (AVL_EVAL)", "#9e9ac8")]) return [p] if p else [] @@ -1241,15 +1426,14 @@ def _state_fraction_plots(records, d, stamp): if s.get("task") == "eval": for c in (s.get("chosen") or []): evalsel[int(s.get("round", 0))].add(str(c)) - # availability forward-fill: track the full state string so idle can be split - # into idle_train (AVL_TRAIN) vs idle_eval (AVL_EVAL). UN_AVL = unavailable. - ac = defaultdict(list) - for r in by_event(records, EVENT_AVAIL_CHANGE): - ac[str(r.get("end_id"))].append((int(r.get("round", 0)), - str(r.get("new_state", "")))) + # availability — the aggregator's own belief (C.6.1/C.6.2), populated even + # in pure-oracular mode where the trainer-side avail_change log is empty. + # Forward-fill: track the full state string so idle can be split into + # idle_train (AVL_TRAIN) vs idle_eval (AVL_EVAL). UN_AVL = unavailable. + avl_by_round = _avl_state_by_round(records) trainers = sorted({t for s in trained.values() for t in s} | {t for s in evalsel.values() for t in s} - | set(ac)) + | set(avl_by_round)) rounds = sorted(set(trained) | set(evalsel)) rounds = [r for r in rounds if r >= 1] if not trainers or not rounds: @@ -1259,8 +1443,8 @@ def _state_fraction_plots(records, d, stamp): counts = {t: {c: 0 for c in cats} for t in trainers} avail_count = {t: 0 for t in trainers} for t in trainers: - evs = sorted(ac.get(t, [])) - ei, state = 0, "" + evs = sorted(avl_by_round.get(t, {}).items()) + ei, state = 0, "AVL_TRAIN" for r in rounds: while ei < len(evs) and evs[ei][0] <= r: state = evs[ei][1]; ei += 1 @@ -1772,7 +1956,7 @@ def _cum(vals): # default to 0 so older runs degrade gracefully. split_rd = defaultdict(lambda: defaultdict(list)) for r in by_event(records, EVENT_TRAINER_ROUND): - rd = int(r.get("round", 0)) + rd = progress_key(r) split_rd[rd]["pre (setup)"].append(r.get("pre_train_s") or 0.0) split_rd[rd]["gpu compute"].append(r.get("real_gpu_time_s") or 0.0) split_rd[rd]["post (cleanup)"].append(r.get("post_train_s") or 0.0) @@ -1782,7 +1966,7 @@ def _cum(vals): _comp_keys = ("pre (setup)", "gpu compute", "post (cleanup)", "sleep (budget)") _m = lambda xs: sum(xs) / len(xs) if xs else 0.0 series = {k: [_m(split_rd[r][k]) for r in rr] for k in _comp_keys} - p = ph.stacked_area(rr, series, "round", + p = ph.stacked_area(rr, series, PROGRESS_AXIS_LABEL, "mean seconds / round (across trainers)", "Trainer round-time split (mean across trainers)", d, "trainer_time_split_over_rounds.pdf", stamp=stamp) @@ -1837,12 +2021,12 @@ def _cum(vals): # queue depth: binned mean+P99 band over rounds (was a jagged per-round line) # plus a CDF (what fraction of rounds had queue >= k — reads the spike tail). - inflight = [(int(r.get("round", 0)), r.get("updates_in_queue")) for r in + inflight = [(progress_key(r), r.get("updates_in_queue")) for r in by_event(records, EVENT_AGG_ROUND) if r.get("updates_in_queue") is not None] if inflight: inflight.sort() qx = [r for r, _ in inflight]; qy = [v for _, v in inflight] - p = ph.binned_line({"updates in queue": (qx, qy)}, "round", + p = ph.binned_line({"updates in queue": (qx, qy)}, PROGRESS_AXIS_LABEL, "updates in queue", "Async queue depth over rounds (P50/bin + band)", d, "queue_depth_over_rounds.pdf", stamp=stamp, nbins=200, reducer="p50", band=True) @@ -1857,7 +2041,7 @@ def _cum(vals): for r in by_event(records, EVENT_AGG_ROUND): for s in (r.get("staleness") or []): if s is not None: - stale_by_round[int(r.get("round", 0))].append(float(s)) + stale_by_round[progress_key(r)].append(float(s)) all_stale.append(float(s)) if all_stale: p = ph.cdf_plot(all_stale, "staleness (rounds behind)", @@ -1868,7 +2052,7 @@ def _cum(vals): _m = lambda xs: sum(xs) / len(xs) if xs else 0.0 p = ph.line_plot( {"mean staleness": (rr, [_m(stale_by_round[r]) for r in rr])}, - "round", "staleness (rounds behind)", "Update staleness over rounds", + PROGRESS_AXIS_LABEL, "staleness (rounds behind)", "Update staleness over rounds", d, "staleness_over_rounds.pdf", stamp=stamp, clip_outliers=True) if p: saved.append(p) @@ -1991,64 +2175,127 @@ def _cum(vals): # ========================================================================== +def _avl_state_by_round(records) -> dict: + """{end_id: {round: avl_state}} — the AGGREGATOR's belief (C.6.1/C.6.2). + + Sourced from `per_trainer[end_id]["avl_state"]` on every `selection` event + (train AND eval), which `emit_selection` stamps for the FULL candidate pool + (not just eligible/chosen). Replaces the old EVENT_AVAIL_CHANGE source, + which is the TRAINER's self-reported transition log — empty in v1's + pure-oracular mode (`client_notify` OFF) where the trainer never emits it, + leaving every consumer below permanently blind. The aggregator's belief is + populated in every mode (oracular or not), so this is the one source that + actually lights up under the v1 availability gate. + """ + by_round: dict = defaultdict(dict) + for s in sorted(by_event(records, EVENT_SELECTION), + key=lambda e: (e.get("round", 0), e.get("ts", 0.0))): + rd = int(s.get("round", 0)) + for end_id, info in (s.get("per_trainer") or {}).items(): + state = info.get("avl_state") + if state and state != "UNKNOWN": + by_round[str(end_id)][rd] = state + return dict(by_round) + + def availability_plots(records, out, stamp, tdir): d = _sub(out, "availability"); saved = [] sel = by_event(records, EVENT_SELECTION) - ac = by_event(records, EVENT_AVAIL_CHANGE) - - # 1) candidates → eligible → chosen funnel (binned over rounds). Always - # meaningful: shows where the population is lost between availability and pick. - fx, cand, elig, chos = [], [], [], [] + avl_by_round = _avl_state_by_round(records) + + # 1) candidates → (AVL_TRAIN/AVL_EVAL/UN_AVL composition) → eligible → + # chosen funnel (binned over progress_key — data_id/iteration-level for + # fwdllm-family selection events that carry them, plain round otherwise; + # see progress_key()'s docstring. train+eval both included — avail_ + # composition is stamped on every selection event regardless of task, so + # this no longer silently drops the eval pool). + fx, cand, n_train, n_eval, n_unavail, elig, chos = [], [], [], [], [], [], [] for s in sel: - if s.get("task", "train") != "train": + if int(s.get("round", 0)) < 1: # exclude pre-training warmup (raw round) continue - rd = int(s.get("round", 0)) - if rd < 1: - continue - nc, ne, nch = s.get("num_candidates"), s.get("num_eligible"), s.get("num_chosen") + nc = s.get("num_candidates") if nc is None: continue - fx.append(rd); cand.append(nc) + comp = s.get("avail_composition") or {} + fx.append(progress_key(s)) + cand.append(nc) + n_train.append(comp.get("AVL_TRAIN", 0)) + n_eval.append(comp.get("AVL_EVAL", 0)) + n_unavail.append(comp.get("UN_AVL", 0)) + ne, nch = s.get("num_eligible"), s.get("num_chosen") elig.append(ne if ne is not None else 0) chos.append(nch if nch is not None else 0) if fx: p = ph.binned_line( - {"candidates": (fx, cand), "eligible": (fx, elig), "chosen": (fx, chos)}, - "round", "trainer count", - "Availability→selection funnel (candidates→eligible→chosen, mean/bin)", + {"candidates": (fx, cand), "AVL_TRAIN": (fx, n_train), + "AVL_EVAL": (fx, n_eval), "UN_AVL": (fx, n_unavail), + "eligible": (fx, elig), "chosen": (fx, chos)}, + PROGRESS_AXIS_LABEL, "trainer count", + "Availability→selection funnel (candidates→composition→eligible" + "→chosen, train+eval, mean/bin)", d, "selection_funnel_over_rounds.pdf", stamp=stamp, nbins=150, reducer="mean") if p: saved.append(p) - # Determine if availability is DYNAMIC. syn_0 emits one AVL_TRAIN per trainer - # at startup and never changes → duty-cycle / churn plots are degenerate. - by_trainer = defaultdict(list) - states_seen = set() - for r in ac: - by_trainer[str(r.get("end_id"))].append((int(r.get("round", 0)), - str(r.get("new_state", "")))) - states_seen.add(str(r.get("new_state", ""))) + # Determine if availability is DYNAMIC. syn_0 reports one state (AVL_TRAIN) + # for every trainer for the whole run → duty-cycle / churn plots are + # degenerate. (Distinct-state count, not sample count — avl_by_round + # samples every round densely, unlike the old transition-only log.) + states_seen = {s for rs in avl_by_round.values() for s in rs.values()} has_unavail = any("UN_AVL" in s for s in states_seen) - dynamic = has_unavail or any(len(v) > 1 for v in by_trainer.values()) + dynamic = has_unavail or any( + len(set(rs.values())) > 1 for rs in avl_by_round.values() + ) if not dynamic: p = ph.no_data_plot( "Availability is static (no UN_AVL transitions)", d, "availability_dynamics.pdf", stamp=stamp, - note=f"{len(by_trainer)} trainers, states={sorted(states_seen)} — " + note=f"{len(avl_by_round)} trainers, states={sorted(states_seen)} — " f"duty-cycle/churn need a dynamic trace (non-syn_0)") if p: saved.append(p) return saved - # 2) per-trainer duty cycle (fraction of the run available). Forward-fill the - # state across the round span; available = not UN_AVL. + by_trainer = {t: sorted(rs.items()) for t, rs in avl_by_round.items()} + + # 2) population 3-state fraction over rounds — the plot the dynamic branch + # previously never produced at all (only the static no_data_plot branch + # wrote this filename; the doc's "always missing in the dynamic case" bug). rounds = sorted({rd for evs in by_trainer.values() for rd, _ in evs}) rmax = max(rounds) if rounds else 0 + dyn_x, dyn_train, dyn_eval, dyn_unavail = [], [], [], [] + last_state = {t: "AVL_TRAIN" for t in by_trainer} + by_trainer_iter = {t: iter(evs) for t, evs in by_trainer.items()} + next_evt = {t: next(it, None) for t, it in by_trainer_iter.items()} + for r in rounds: + for t, it in by_trainer_iter.items(): + while next_evt[t] is not None and next_evt[t][0] <= r: + last_state[t] = next_evt[t][1] + next_evt[t] = next(it, None) + n = len(last_state) or 1 + dyn_x.append(r) + dyn_train.append(sum(1 for s in last_state.values() if s == "AVL_TRAIN") / n) + dyn_eval.append(sum(1 for s in last_state.values() if s == "AVL_EVAL") / n) + dyn_unavail.append(sum(1 for s in last_state.values() if "UN_AVL" in s) / n) + if dyn_x: + p = ph.binned_line( + {"AVL_TRAIN": (dyn_x, dyn_train), "AVL_EVAL": (dyn_x, dyn_eval), + "UN_AVL": (dyn_x, dyn_unavail)}, + "round", "fraction of population", + "Population 3-state availability over the run", d, + "availability_dynamics.pdf", stamp=stamp, nbins=150, reducer="mean") + if p: saved.append(p) + + # 3) per-trainer duty cycle (fraction of the run available). Forward-fill + # the state across the round span (telescoping sum — exact whether the + # input is sparse transitions or this dense per-round sampling); + # available = not UN_AVL. duty = [] churn_by_round = defaultdict(int) for t, evs in by_trainer.items(): - evs = sorted(evs) - for rd, _ in evs: - churn_by_round[rd] += 1 - # integrate availability over [0, rmax] + prev_state = None + for rd, st in evs: + if prev_state is not None and st != prev_state: + churn_by_round[rd] += 1 + prev_state = st avail_rounds, cur_r, cur_un = 0, 0, False for rd, st in evs: if not cur_un: @@ -2062,13 +2309,300 @@ def availability_plots(records, out, stamp, tdir): "duty_cycle_cdf.pdf", stamp=stamp) if p: saved.append(p) - # 3) availability churn rate over rounds (avail_change events / round-bin) + # 4) availability churn rate over rounds (actual state TRANSITIONS per + # round-bin, not raw sample density). cr = sorted(churn_by_round) - p = ph.binned_line({"avail_change events": (cr, [churn_by_round[r] for r in cr])}, - "round", "transitions", "Availability churn rate (events/bin)", + p = ph.binned_line({"avl_state transitions": (cr, [churn_by_round[r] for r in cr])}, + "round", "transitions", "Availability churn rate (transitions/bin)", d, "availability_churn_over_rounds.pdf", stamp=stamp, nbins=150, reducer="sum") if p: saved.append(p) + + # 5) Per-trainer state fraction sorted bar — the visual companion to A4dur. + # Sorted by UN_AVL fraction (most unavailable first); uses the same dense + # per-round `by_trainer` observations as the duty-cycle CDF above, not the + # old sparse EVENT_AVAIL_CHANGE transition log. + trainer_fracs = [] + for t, evs in by_trainer.items(): + states = [st for _, st in evs] + n = len(states) or 1 + tr_frac = sum(1 for s in states if s == "AVL_TRAIN") / n + ev_frac = sum(1 for s in states if s == "AVL_EVAL") / n + un_frac = sum(1 for s in states if "UN_AVL" in s) / n + trainer_fracs.append((t, tr_frac, ev_frac, un_frac)) + trainer_fracs.sort(key=lambda x: x[3], reverse=True) + if trainer_fracs: + cats = [str(i + 1) for i in range(len(trainer_fracs))] + segs = { + "UN_AVL": [x[3] for x in trainer_fracs], + "AVL_EVAL": [x[2] for x in trainer_fracs], + "AVL_TRAIN": [x[1] for x in trainer_fracs], + } + colors = {"AVL_TRAIN": "#2196F3", "AVL_EVAL": "#4CAF50", "UN_AVL": "#F44336"} + p = ph.stacked_bar( + cats, segs, "fraction of run", + f"Per-trainer state fractions sorted by UN_AVL (n={len(trainer_fracs)}; " + f"visual companion to A4dur)", + d, "trainer_state_fractions_sorted.pdf", + stamp=stamp, horizontal=True, colors=colors, + ) + if p: saved.append(p) + return saved + + +def _gt_segments(trace, t_end) -> list: + """[(t_start, t_end, state), ...] ground-truth segments over [0, t_end].""" + pts = [(0.0, _gt_state_at(trace, 0.0).value)] + pts.extend(transitions_in_range(trace, 0.0, t_end)) + segs = [(a, b, s) for (a, s), (b, _) in zip(pts, pts[1:])] + if pts: + segs.append((pts[-1][0], t_end, pts[-1][1])) + return segs + + +def _obs_segments(pts, t_end) -> list: + """[(t_start, t_end, state), ...] observed segments from a forward-fill series.""" + segs = [(a, b, s) for (a, s), (b, _) in zip(pts, pts[1:])] + if pts: + segs.append((pts[-1][0], t_end, pts[-1][1])) + return segs + + +def trace_fidelity_plots(records, out, stamp, tdir): + """A6 trainer_trace_fidelity deep-dive: each trainer's own OBSERVED + availability timeline (from its avail_change telemetry) plotted directly + against the raw ground-truth trace file -- absolute, single-mode, no + real-vs-sim compare (that's availability_plots()/A5 above). Would have + made the real-mode-trainers-never-saw-the-trace bug (T3.1a) visually + obvious: every real trainer's band would be a flat AVL_TRAIN bar under a + ground-truth band that clearly transitions. + """ + d = _sub(out, "availability") + if not _HAVE_GROUND_TRUTH: + return [] + run_dir = os.path.dirname(os.path.abspath(tdir)) + trace_name = resolve_trace_name(run_dir) + ground_truth = load_ground_truth(trace_name) + if not ground_truth: + return [] + gt_by_short = by_short_id(ground_truth) + + sel = by_event(records, EVENT_SELECTION) + mode = "sim" if any(s.get("vclock_now") is not None for s in sel) else "real" + span = selection_run_span(sel, mode) + if span <= 0: + return [] + + by_end: dict = defaultdict(list) + for r in by_event(records, EVENT_AVAIL_CHANGE): + end_id = r.get("end_id") + if end_id is not None: + by_end[str(end_id)].append(r) + + errs, gt_segs_by_short, obs_segs_by_short = {}, {}, {} + for end_id, evs in by_end.items(): + short_id = end_id[-4:] + gt = gt_by_short.get(short_id) + if gt is None: + continue + raw_obs = build_observed_timeline_from_avail_change(evs) + scored = _fidelity_score(raw_obs, gt, span, seed_state="AVL_TRAIN") + if scored is None: + continue + errs[short_id] = scored[0] + gt_segs_by_short[short_id] = _gt_segments(gt, span) + obs_segs_by_short[short_id] = _obs_segments(raw_obs, span) + + saved = [] + if not errs: + return saved + + # (b) fidelity-error distribution — outliers are exactly the trainers this + # rung exists to catch (item 20 would show as *every* real trainer here). + p = ph.cdf_plot( + list(errs.values()), "trace fidelity error (TVD, lower=better)", + f"A6 trainer_trace_fidelity error CDF ({mode}, n={len(errs)})", + d, f"trace_fidelity_error_cdf_{mode}.pdf", stamp=stamp) + if p: saved.append(p) + + # (a) per-trainer timeline overlay, worst-fidelity-first, capped so the + # figure stays legible — outlier trainers are the ones actually shown. + worst = sorted(errs.items(), key=lambda kv: -kv[1])[:12] + rows = [ + (f"{short_id} (err={err:.3f})", gt_segs_by_short[short_id], obs_segs_by_short[short_id]) + for short_id, err in worst + ] + p = ph.state_band_timeline( + rows, span, + f"A6 trainer_trace_fidelity: worst {len(rows)} trainers, " + f"ground-truth vs observed ({mode})", + d, f"trace_fidelity_timeline_{mode}.pdf", stamp=stamp) + if p: saved.append(p) + return saved + + +def agg_belief_fidelity_plots(records, out, stamp, tdir): + """A7 agg_belief_fidelity deep-dive (Batch 3 T3.3): the AGGREGATOR's own + belief about each trainer's availability plotted against the raw + ground-truth trace, independently per checkpoint -- + **selection** (reuses the existing per-candidate avl_state already + stamped every selection cycle) and **commit** (new agg_belief_change + telemetry, from _record_commit_belief). Companion to trace_fidelity_plots + (A6, the TRAINER's own self-report) -- this is the aggregator's side of + the same absolute (vs. ground truth, not real-vs-sim) question. + """ + d = _sub(out, "availability") + if not _HAVE_GROUND_TRUTH: + return [] + run_dir = os.path.dirname(os.path.abspath(tdir)) + trace_name = resolve_trace_name(run_dir) + ground_truth = load_ground_truth(trace_name) + if not ground_truth: + return [] + gt_by_short = by_short_id(ground_truth) + + sel = by_event(records, EVENT_SELECTION) + mode = "sim" if any(s.get("vclock_now") is not None for s in sel) else "real" + span = selection_run_span(sel, mode) + if span <= 0: + return [] + + def _score_all(series_by_end, seed_state): + errs, gt_segs, obs_segs = {}, {}, {} + for end_id, raw_obs in series_by_end.items(): + short_id = str(end_id)[-4:] + gt = gt_by_short.get(short_id) + if gt is None: + continue + scored = _fidelity_score(raw_obs, gt, span, seed_state=seed_state) + if scored is None: + continue + errs[short_id] = scored[0] + gt_segs[short_id] = _gt_segments(gt, span) + obs_segs[short_id] = _obs_segments(raw_obs, span) + return errs, gt_segs, obs_segs + + sel_series = build_trainer_state_series(sel, mode=mode) + sel_scores = _score_all(sel_series, seed_state="AVL_TRAIN") + + commit_by_end: dict = defaultdict(list) + for r in by_event(records, EVENT_AGG_BELIEF_CHANGE): + if r.get("checkpoint") != "commit": + continue + end_id = r.get("end_id") + if end_id is not None: + commit_by_end[str(end_id)].append(r) + commit_series = { + end_id: build_observed_timeline_from_agg_belief(evs) + for end_id, evs in commit_by_end.items() + } + commit_scores = _score_all(commit_series, seed_state=None) + + saved = [] + for checkpoint, (errs, gt_segs, obs_segs) in ( + ("selection", sel_scores), ("commit", commit_scores), + ): + if not errs: + continue + p = ph.cdf_plot( + list(errs.values()), "belief fidelity error (TVD, lower=better)", + f"A7 agg_belief_fidelity error CDF ({mode}, {checkpoint}, n={len(errs)})", + d, f"belief_fidelity_error_cdf_{mode}_{checkpoint}.pdf", stamp=stamp) + if p: saved.append(p) + + worst = sorted(errs.items(), key=lambda kv: -kv[1])[:12] + rows = [ + (f"{short_id} (err={err:.3f})", gt_segs[short_id], obs_segs[short_id]) + for short_id, err in worst + ] + p = ph.state_band_timeline( + rows, span, + f"A7 agg_belief_fidelity: worst {len(rows)} trainers, " + f"belief vs ground-truth ({mode}, {checkpoint})", + d, f"belief_fidelity_timeline_{mode}_{checkpoint}.pdf", stamp=stamp) + if p: saved.append(p) + return saved + + +def send_gate_wait_plots(records, out, stamp, tdir): + """A8 send_gate_wait_fidelity deep-dive (Batch 3 T3.4): real-mode + [SEND_GATE] wait duration vs. what the raw ground-truth trace says it + should have been. Reads task_send (not trainer_round) -- the wait loop + runs strictly after trainer_round is emitted for the same round (train() + then put()/_send_weights, per the tasklet composition), so task_send is + the event that can actually carry it, same reason wall_send_ts lives + there instead of trainer_round. + """ + d = _sub(out, "availability") + if not _HAVE_GROUND_TRUTH: + return [] + run_dir = os.path.dirname(os.path.abspath(tdir)) + trace_name = resolve_trace_name(run_dir) + ground_truth = load_ground_truth(trace_name) + if not ground_truth: + return [] + gt_by_short = by_short_id(ground_truth) + + observed, expected = [], [] + for r in by_event(records, EVENT_TASK_SEND): + obs = r.get("send_gate_wait_s") + sct = r.get("send_gate_sct") + end_id = r.get("end_id") + if obs is None or sct is None or end_id is None: + continue + gt = gt_by_short.get(str(end_id)[-4:]) + if gt is None: + continue + exp = expected_send_gate_wait(gt, float(sct)) + if exp is None: + continue + observed.append(float(obs)) + expected.append(exp) + + saved = [] + if not observed: + return saved + + p = ph.cdf_plot( + observed, "send_gate_wait_s (observed)", + f"A8 send_gate_wait_s distribution (real, n={len(observed)})", + d, "send_gate_wait_cdf.pdf", stamp=stamp) + if p: saved.append(p) + + p = ph.scatter_diag( + expected, observed, + "ground-truth-expected wait (s)", "observed send_gate_wait_s (s)", + f"A8 send_gate_wait_fidelity: observed vs expected (n={len(observed)})", + d, "send_gate_wait_scatter.pdf", stamp=stamp) + if p: saved.append(p) + return saved + + +def commit_promptness_plots(records, out, stamp, tdir): + """K11 commit_promptness deep-dive (Batch 3 T3.5): distribution of + "commit slack" (actual_commit_ts - delivery_ts) across every withheld- + then-delivered update. Should cluster near 0; a heavy right tail flags a + promptness/scheduling bug (e.g. coarse reinjection polling); any mass left + of the marked zero-line is a hard correctness bug (a commit landing + before it was legally available). Sim-only (real emits no + withheld_delivery telemetry at all — a different, trainer-side gate). + """ + d = _sub(out, "availability") + slacks = [] + for r in by_event(records, EVENT_WITHHELD_DELIVERY): + act, dts = r.get("actual_commit_ts"), r.get("delivery_ts") + if act is None or dts is None: + continue + slacks.append(float(act) - float(dts)) + + saved = [] + if not slacks: + return saved + p = ph.hist_plot( + slacks, "commit_slack_s (actual_commit_ts - delivery_ts)", + f"K11 commit_promptness: commit slack (sim, n={len(slacks)})", + d, "commit_slack_hist.pdf", stamp=stamp, vline=0.0) + if p: saved.append(p) return saved @@ -2172,13 +2706,13 @@ def aggregation_plots(records, out, stamp, tdir): # commit). Shows how fast updates are landing over the run. commits_by_round = defaultdict(int) for r in ar: - rd = int(r.get("round", 0)) + rd = progress_key(r) if rd >= 1: commits_by_round[rd] += 1 cr = sorted(commits_by_round) if cr: p = ph.binned_line({"commits/round": (cr, [commits_by_round[r] for r in cr])}, - "round", "commits", "Commit cadence (commits/round, mean/bin)", + PROGRESS_AXIS_LABEL, "commits", "Commit cadence (commits/round, mean/bin)", d, "commit_cadence_over_rounds.pdf", stamp=stamp, nbins=150, reducer="mean") if p: saved.append(p) @@ -2250,13 +2784,37 @@ def aggregation_plots(records, out, stamp, tdir): # ========================================================================== -def write_summary(records, out, tdir): +def write_summary(records, out, tdir, manifest=None, saved_paths=None): counts = Counter(r.get("event") for r in records) n_tr = len({r.get("end_id") for r in records if r.get("role") == "trainer"}) lines = [f"Telemetry summary: {tdir}", f"config: {ph.config_stamp(os.path.dirname(os.path.abspath(tdir)))}", f"total events: {len(records)}", f"trainers seen: {n_tr}", "event counts:"] for ev, c in counts.most_common(): lines.append(f" {ev:16} {c}") + + # P5.7 onboarding-contract check: cross-reference the manifest's declared + # event_categories against which plots// dirs this run actually + # populated, so drift (a category that's supposed to be populated but + # isn't, or vice versa) is surfaced automatically instead of requiring + # someone to notice an empty directory. + declared = (manifest or {}).get("event_categories") + if declared: + saved_paths = saved_paths or [] + lines.append("") + lines.append("manifest event_categories check:") + for category, expected in declared.items(): + cat_dir = os.path.abspath(os.path.join(out, *category.split("/"))) + populated = any( + os.path.commonpath([os.path.abspath(p), cat_dir]) == cat_dir + for p in saved_paths + ) + if expected == "populated" and not populated: + lines.append(f" MISMATCH: {category} declared 'populated' but no plots were written") + elif expected == "not_populated" and populated: + lines.append(f" DRIFT: {category} declared 'not_populated' but plots WERE written -- manifest is stale") + else: + lines.append(f" ok: {category} ({expected}, populated={populated})") + os.makedirs(out, exist_ok=True) path = os.path.join(out, "summary.txt") with open(path, "w", encoding="utf-8") as fh: @@ -2265,6 +2823,7 @@ def write_summary(records, out, tdir): def analyze(telemetry_dir, out_dir=None): + manifest = configure_from_manifest(telemetry_dir) records = load_events(telemetry_dir) run_dir = os.path.dirname(os.path.abspath(telemetry_dir)) if out_dir is None: @@ -2276,7 +2835,9 @@ def analyze(telemetry_dir, out_dir=None): saved = [] for fn in (perf_plots, sanity_plots, selection_plots, insights_plots, system_plots, sim_speedup_plots, mqtt_delivery_plots, - availability_plots, selection_why_plots, aggregation_plots): + availability_plots, trace_fidelity_plots, agg_belief_fidelity_plots, + send_gate_wait_plots, commit_promptness_plots, + selection_why_plots, aggregation_plots): try: saved.extend(fn(records, out_dir, stamp, telemetry_dir)) except Exception as e: @@ -2285,7 +2846,7 @@ def analyze(telemetry_dir, out_dir=None): saved.extend(resource_plots(out_dir, stamp, run_dir)) except Exception as e: print(" (resource_plots failed: %s)" % e) - saved.append(write_summary(records, out_dir, telemetry_dir)) + saved.append(write_summary(records, out_dir, telemetry_dir, manifest=manifest, saved_paths=saved)) print("wrote %d artifact(s) under %s" % (len(saved), out_dir)) for p in saved: print(" %s" % p) @@ -2383,9 +2944,10 @@ def main(): help="param count for MB comm conversion (default: async_cifar10 Net)") args = parser.parse_args() if args.model_params: - global MODEL_PARAM_COUNT, MODEL_MB + global MODEL_PARAM_COUNT, MODEL_MB, _MODEL_PARAMS_CLI_OVERRIDDEN MODEL_PARAM_COUNT = args.model_params MODEL_MB = MODEL_PARAM_COUNT * BYTES_PER_PARAM / 1e6 + _MODEL_PARAMS_CLI_OVERRIDDEN = True # a manifest's model_param_count must not clobber this if args.compare_streaming: compare_streaming(args.compare_streaming, args.labels, args.out or "compare_plots", args.target) return diff --git a/scripts/analysis/plot_helpers.py b/scripts/analysis/plot_helpers.py index 0f165d88a..b3bc9bdef 100644 --- a/scripts/analysis/plot_helpers.py +++ b/scripts/analysis/plot_helpers.py @@ -596,6 +596,42 @@ def stacked_bar(categories, segments, y_label, title, out_dir, file_name, stamp= return _save(fig, out_dir, file_name, stamp) +_TRACE_STATE_COLORS = {"AVL_TRAIN": "#2196F3", "AVL_EVAL": "#4CAF50", "UN_AVL": "#F44336"} + + +def state_band_timeline(rows, x_max, title, out_dir, file_name, stamp=None): + """Per-trainer ground-truth-vs-observed availability state overlay + (Batch 3 T3.2 / A6 trainer_trace_fidelity). + + ``rows``: [(trainer_label, gt_segments, obs_segments), ...], already + ordered/truncated by the caller (e.g. worst-fidelity-first, capped to a + legible row count). Each ``*_segments`` is [(t_start, t_end, state), ...]. + Two horizontal bands per trainer — ground truth above, observed below — + colored by state, so a fidelity gap is visible as a color mismatch between + the two bands at the same x position rather than a number in a table. + """ + if not rows: + return no_data_plot(title, out_dir, file_name, stamp) + fig, ax = plt.subplots(figsize=(7.5, max(1.5, 0.55 * len(rows) + 0.8))) + for i, (label, gt_segs, obs_segs) in enumerate(rows): + y0 = i * 1.1 + for segs, y in ((gt_segs, y0 + 0.5), (obs_segs, y0)): + bars = [(a, b - a) for a, b, _ in segs if b > a] + colors = [_TRACE_STATE_COLORS.get(s, "0.6") for a, b, s in segs if b > a] + if bars: + ax.broken_barh(bars, (y, 0.42), facecolors=colors) + ax.set_yticks([i * 1.1 + 0.5 for i in range(len(rows))]) + ax.set_yticklabels([lab for lab, _, _ in rows], fontsize=8) + ax.set_ylim(-0.15, len(rows) * 1.1) + ax.set_xlim(0, x_max) + ax.set_xlabel("trace time (s) — top band=ground truth, bottom band=observed") + ax.set_title(title) + handles = [plt.Rectangle((0, 0), 1, 1, color=c) for c in _TRACE_STATE_COLORS.values()] + ax.legend(handles, list(_TRACE_STATE_COLORS.keys()), loc="upper right", + fontsize=8, ncol=3) + return _save(fig, out_dir, file_name, stamp) + + def bar_plot(categories, values, y_label, title, out_dir, file_name, stamp=None): if len(categories) == 0: return None diff --git a/scripts/setup_env.sh b/scripts/setup_env.sh index 49364e528..1d8ded7bc 100755 --- a/scripts/setup_env.sh +++ b/scripts/setup_env.sh @@ -31,6 +31,13 @@ conda activate "$ENV_NAME" pip install --upgrade pip pip install -e "$REPO_ROOT/lib/python[examples,dev]" +# CUDA 12.6 wheels are required for driver >= 12.9 compatibility. +# The default PyPI torch wheel is built against an older CUDA runtime and will +# silently misdetect or error on CUDA driver 12.9+. Force-reinstall from the +# cu126 index to get the matching runtime wheel. +pip install --force-reinstall torch==2.12.0 torchvision==0.27.0 \ + --index-url https://download.pytorch.org/whl/cu126 + # Optional: warn if mosquitto broker isn't around. if ! command -v mosquitto &> /dev/null; then echo "warning: mosquitto MQTT broker not installed. examples will need one running on localhost:1883."