From d539c5778b072d1998e0e85fd23b8e3c4183450c Mon Sep 17 00:00:00 2001
From: Jayon02 <12012211@mail..sustech.edu.cn>
Date: Wed, 9 Jul 2025 10:47:17 -0700
Subject: [PATCH 01/10] refactor hf engine

---
 arealite/engine/hf_engine.py     | 459 ++++++++++++++++++-------------
 arealite/tests/test_hf_engine.py | 161 +++++++++++
 2 files changed, 429 insertions(+), 191 deletions(-)
 create mode 100644 arealite/tests/test_hf_engine.py

diff --git a/arealite/engine/hf_engine.py b/arealite/engine/hf_engine.py
index d2d5f469a..ed20cf395 100644
--- a/arealite/engine/hf_engine.py
+++ b/arealite/engine/hf_engine.py
@@ -1,91 +1,69 @@
-import asyncio
-import functools
-import math
+import gc
 import os
+import time
 from typing import Any, Callable, Dict, List, Optional
 
 import torch
 import torch.distributed as dist
 import transformers
-from transformers import AutoConfig, AutoModelForCausalLM
-
-from arealite.api.cli_args import (
-    EngineConfig,
+from tensordict import TensorDict
+from transformers import (
+    AutoConfig,
+    AutoModelForCausalLM,
+    get_constant_schedule_with_warmup,
+    get_linear_schedule_with_warmup,
+)
+from arealite.utils.fsdp import get_cosine_schedule_with_warmup
+from arealite.api.cli_args import TrainEngineConfig
+from arealite.api.engine_api import (
+    FinetuneSpec,
     MicroBatchSpec,
-    ParallelismConfig,
-    TrainingArgs,
+    SaveLoadMeta,
+    TrainEngine,
+    WeightUpdateMeta,
 )
-from arealite.api.engine_api import TrainEngine
-from arealite.api.io_struct import FinetuneSpec
-from arealite.api.llm_client_api import LLMClient
-from arealite.utils import (
-    get_state_dict_from_repo_id_or_path,
-    recorder_list,
-    split_dict_tensor_with_cu_seqlens,
+from arealite.utils.data import (
+    MicroBatchList,
+    amend_position_ids,
+    pack_tensor_dict,
+    pad_and_stack_tensors_along_first_dim,
+    pad_mb_list,
+    reorder_list,
+    split_packed_tensor_dict_into_mb_list,
     unpack_sequence,
+    unsqueeze_mb_list,
 )
-from realhf.base import constants
-
-
-def get_cosine_schedule_with_warmup(
-    optimizer: torch.optim.Optimizer,
-    num_warmup_steps: int,
-    num_training_steps: int,
-    min_lr_ratio: float = 0.0,
-    num_cycles: float = 0.5,
-    last_epoch: int = -1,
-):
-    """
-    Create a schedule with a learning rate that decreases following the values of the cosine function between the
-    initial lr set in the optimizer to 0, after a warmup period during which it increases linearly between 0 and the
-    initial lr set in the optimizer.
-    Args:
-        optimizer (:class:`~torch.optim.Optimizer`):
-            The optimizer for which to schedule the learning rate.
-        num_warmup_steps (:obj:`int`):
-            The number of steps for the warmup phase.
-        num_training_steps (:obj:`int`):
-            The total number of training steps.
-        min_lr_ratio (:obj:`float`, `optional`, defaults to 0.0):
-            The minimum lr ratio w.r.t the maximum.
-        num_cycles (:obj:`float`, `optional`, defaults to 0.5):
-            The number of waves in the cosine schedule (the defaults is to just decrease from the max value to 0
-            following a half-cosine).
-        last_epoch (:obj:`int`, `optional`, defaults to -1):
-            The index of the last epoch when resuming training.
-    Return:
-        :obj:`torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.
-    """
-    assert min_lr_ratio >= 0 and min_lr_ratio <= 1.0
-    coef = (1 - min_lr_ratio) * 0.5
-    intercept = (1 + min_lr_ratio) * 0.5
-
-    def lr_lambda(current_step):
-        if current_step < num_warmup_steps:
-            return float(current_step) / float(max(1, num_warmup_steps))
-        progress = float(current_step - num_warmup_steps) / float(
-            max(1, num_training_steps - num_warmup_steps)
-        )
-        x = math.cos(math.pi * float(num_cycles) * 2.0 * progress)
-        return max(0.0, x * coef + intercept)
-
-    return torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda, last_epoch)
+from arealite.utils.save_load import get_state_dict_from_repo_id_or_path
+from realhf.api.core.data_api import load_hf_tokenizer
+from realhf.base import logging, name_resolve, names
 
+logger = logging.getLogger("HFEngine")
 
 class HFEngine(TrainEngine):
-    """Simplified HF engine for transformer models."""
-
-    def __init__(self, args: TrainingArgs, engine_config: EngineConfig):
-        super().__init__(args, engine_config)
+    def __init__(self, config: TrainEngineConfig):
+        self.config = config
+        self.optimizer_config = config.optimizer
 
         self.model = None
         self.optimizer = None
+        self.tokenizer = None
+        # huggingface model config
         self.model_config = None
-
+        # initialization
+        self.initialized = False
         self.weight_update_group_initialized = False
+        self.world_size = int(os.environ.get("WORLD_SIZE", 1))
 
-    def init_distributed(self, config: ParallelismConfig, ft_spec: FinetuneSpec):
-        """Initialize model in single node."""
+    def train(self, mode: bool = True):
+        assert self.model is not None
+        self.model.train(mode=mode)
+        return self
+
+    def initialize(self, addr: str | None, ft_spec: FinetuneSpec | None):
+        # Initialize distributed enviroments and load model.
+        assert addr is None, "HFEngine does not support remote initialization."
+
+        """Initialize distributed communication and model."""
         if not dist.is_initialized():
             dist.init_process_group(backend="nccl")
         if dist.get_world_size() > 1:
@@ -93,36 +71,48 @@ def init_distributed(self, config: ParallelismConfig, ft_spec: FinetuneSpec):
                 "Distributed training is not supported in this engine. "
                 "Please use FSDP for distributed training."
             )
-        torch.cuda.set_device("cuda:0")
 
-        dtype = torch.bfloat16 if self.engine_config.bf16 else torch.float16
+        torch.cuda.set_device(int(os.environ.get("LOCAL_RANK", 0)))
+        self.device = torch.device(int(os.environ.get("LOCAL_RANK", 0)))
+
+        dtype = torch.bfloat16 if self.config.bf16 else torch.float16
         self.model_config = AutoConfig.from_pretrained(
-            pretrained_model_name_or_path=self.engine_config.path,
+            pretrained_model_name_or_path=self.config.path,
             trust_remote_code=True,
         )
+        self.tokenizer = load_hf_tokenizer(self.config.path)
         with torch.device("cuda"):
             # initialize scratch model from config
             model = AutoModelForCausalLM.from_config(
                 self.model_config,
                 torch_dtype=dtype,
-                attn_implementation="flash_attention_2",
+                attn_implementation=self.config.attn_impl,
             )
 
-        model = model.cuda()
-
-        self.model = model
+        self.model = model.to("cuda")
+
+        if not self.config.init_from_scratch:
+            # Load model from a initial checkpoint path,
+            # which should only be a huggingface checkpoint.
+            load_meta = SaveLoadMeta(
+                path=self.config.path,
+                weight_format="hf",
+                with_optim=False,
+                tokenizer=None,
+                base_model_path=self.config.path,
+            )
+            self.load(load_meta)
 
         # Set up optimizer
-        optimizer_config = self.engine_config.optimizer
-        if optimizer_config is not None:
+        if self.optimizer_config is not None:
             assert (
-                optimizer_config.type == "adam"
+                self.optimizer_config.type == "adam"
             ), "Only AdamW optimizer is supported in this engine."
-            lr = optimizer_config.lr
-            weight_decay = optimizer_config.weight_decay
-            beta1 = optimizer_config.beta1
-            beta2 = optimizer_config.beta2
-            eps = optimizer_config.eps
+            lr = self.optimizer_config.lr
+            weight_decay = self.optimizer_config.weight_decay
+            beta1 = self.optimizer_config.beta1
+            beta2 = self.optimizer_config.beta2
+            eps = self.optimizer_config.eps
 
             self.optimizer = torch.optim.AdamW(
                 self.model.parameters(),
@@ -133,82 +123,230 @@ def init_distributed(self, config: ParallelismConfig, ft_spec: FinetuneSpec):
             )
             total_train_steps = ft_spec.total_train_steps
             num_warmup_steps = int(
-                optimizer_config.warmup_steps_proportion * total_train_steps
+                self.optimizer_config.warmup_steps_proportion * total_train_steps
             )
 
-            self.lr_scheduler = get_cosine_schedule_with_warmup(
-                self.optimizer,
-                num_warmup_steps,
-                total_train_steps,
-                min_lr_ratio=optimizer_config.min_lr_ratio,
+            if self.optimizer_config.lr_scheduler_type == "cosine":
+                self.lr_scheduler = get_cosine_schedule_with_warmup(
+                    self.optimizer,
+                    num_warmup_steps,
+                    total_train_steps,
+                    min_lr_ratio=self.optimizer_config.min_lr_ratio,
+                )
+            elif self.optimizer_config.lr_scheduler_type == "linear":
+                self.lr_scheduler = get_linear_schedule_with_warmup(
+                    self.optimizer,
+                    num_warmup_steps,
+                    total_train_steps,
+                )
+            elif self.optimizer_config.lr_scheduler_type == "constant":
+                self.lr_scheduler = get_constant_schedule_with_warmup(
+                    self.optimizer,
+                    num_warmup_steps,
+                )
+            else:
+                raise ValueError(
+                    f"Unknown lr scheduler type {self.optimizer_config.lr_scheduler_type}"
+                )
+
+        self.initialized = True
+
+    def destroy(self):
+        """Destroy the engine and release GPU memory."""
+        self.model = None
+        self.optimizer = None
+        gc.collect()
+        torch.cuda.empty_cache()
+        gc.collect()
+        self.initialized = False
+
+    def save(self, meta: SaveLoadMeta):
+        if meta.weight_format == "hf":
+            self._save_model_to_hf(meta.path, meta.tokenizer)
+        elif meta.weight_format == "dcp":
+            # TODO: implement DCP save/load for HF
+            raise NotImplementedError("DCP format saving is not implemented yet. ")
+        else:
+            raise ValueError(f"Unknown weight format {meta.weight_format}. ")
+
+        if meta.with_optim:
+            self._save_optimizer_state(meta.path)
+
+    def load(self, meta: SaveLoadMeta):
+        if meta.weight_format == "hf":
+            self._load_model_from_hf(meta.path)
+        elif meta.weight_format == "dcp":
+            # TODO: implement DCP save/load for HF
+            raise NotImplementedError("DCP format loading is not implemented yet. ")
+        else:
+            raise ValueError(f"Unknown weight format {meta.weight_format}. ")
+
+        if meta.with_optim:
+            self._load_optimizer_state(meta.path)
+
+    def _save_optimizer_state(self, path: str):
+        assert self.optimizer is not None
+        os.makedirs(path, exist_ok=True)
+        torch.save(self.optimizer.state_dict(), os.path.join(path, "optim.pt"))
+
+    def _load_optimizer_state(self, path: str):
+        assert self.optimizer is not None
+        path = os.path.join(path, "optim.pt")
+        optimizer_state_dict = torch.load(path, weights_only=False)
+        self.optimizer.load_state_dict(optimizer_state_dict)
+
+    def _save_model_to_hf(
+        self, path: str, tokenizer: Optional[transformers.PreTrainedTokenizerFast]
+    ):
+        """Save model in HuggingFace format."""
+        if self.model is None:
+            raise RuntimeError("Model not initialized")
+        os.makedirs(path, exist_ok=True)
+
+        state_dict = {k: v.cpu() for k, v in self.model.state_dict().items()}
+        self.model.save_pretrained(path, state_dict=state_dict)
+        self.model_config.save_pretrained(path)
+        if tokenizer is not None:
+            tokenizer.save_pretrained(path)
+
+    def _load_model_from_hf(self, path: str):
+        """Load model from HuggingFace format."""
+        full_state = get_state_dict_from_repo_id_or_path(path)
+        self.model.load_state_dict(
+            full_state, strict=not self.model_config.tie_word_embeddings
+        )
+        if self.model_config.tie_word_embeddings:
+            self.model.tie_weights()
+
+    def upload_weights(self, meta: WeightUpdateMeta):
+        if meta.type == "nccl":
+            if not self.weight_update_group_initialized:
+                self._init_distributed_weight_update(meta)
+            self._update_weights_from_distributed()
+        elif meta.type == "disk":
+            self._save_model_to_hf(meta.path, self.tokenizer)
+            update_name = names.update_weights_from_disk(
+                self.config.experiment_name,
+                self.config.trial_name,
+                meta.model_version,
             )
+            name_resolve.add(update_name, str(time.time_ns()), keepalive_ttl=120)
+        else:
+            raise ValueError(f"Unknown weight update type {meta.type}")
+        
+    def _init_distributed_weight_update(self, meta: WeightUpdateMeta):
+        raise NotImplementedError(
+            "Distributed weight update is not implemented for HFEngine yet. "
+        )
 
-    def train(self, mode: bool = True):
-        """Set the module in training mode."""
-        return self.model.train(mode)
+    def _update_weights_from_distributed(self):
+        raise NotImplementedError(
+            "Distributed weight update is not implemented for HFEngine yet. "
+        )
+
+    def step_lr_scheduler(self):
+        assert self.lr_scheduler is not None
+        return self.lr_scheduler.step()
+
+    def _prepare_mb_list(
+        self, input_: TensorDict, mb_spec: MicroBatchSpec
+    ) -> MicroBatchList:
+        assert "attention_mask" in input_ and "input_ids" in input_
+        input_ = amend_position_ids(input_)
+        packed_input = pack_tensor_dict(input_)
+        mb_list = split_packed_tensor_dict_into_mb_list(
+            packed_input,
+            mb_spec,
+        )
+        mb_list = pad_mb_list(mb_list, pad_value=0.0)
+        # NOTE: We unsqueeze here because huggingface transformer models requires
+        # packed input to be of shape [1, total_seqlen].
+        mb_list = unsqueeze_mb_list(mb_list)
+        return mb_list
 
     def train_batch(
         self,
-        input_: Dict,
+        input_: TensorDict,
         mb_spec: MicroBatchSpec,
         loss_fn: Callable[[torch.Tensor, Dict], torch.Tensor],
         loss_weight_fn: Callable[[Dict], float],
-    ) -> Dict:
+    ) -> Dict[str, float]:
         """Train on a batch using gradient accumulation."""
+        input_ = input_.to(self.device)
         assert self.optimizer is not None
+        assert self.optimizer_config is not None
         assert self.lr_scheduler is not None
 
         self.optimizer.zero_grad()
-        mb_splits = split_dict_tensor_with_cu_seqlens(input_, mb_spec)
+        mb_list = self._prepare_mb_list(input_, mb_spec)
+
         total_loss_weight = torch.tensor(
-            sum([loss_weight_fn(mb) for mb in mb_splits.mbs]), dtype=torch.float32
+            sum([loss_weight_fn(mb) for mb in mb_list.mbs]), dtype=torch.float32
         )
         assert total_loss_weight != 0
 
-        for mb_input in mb_splits.mbs:
-            outputs = self.model(**mb_input)
-            loss = loss_fn(outputs.logits, mb_input)
+        # Process microbatches with gradient accumulation
+        for pad_length, padded_mb_input, mb_input in zip(
+            mb_list.padding_lengths, mb_list.padded_mbs, mb_list.mbs
+        ):
+            outputs = self.model(**padded_mb_input)
+
+            logits = outputs.logits.squeeze(0)
+            logits = logits[:-pad_length] if pad_length > 0 else logits
+            loss = loss_fn(logits, mb_input)
             loss_scale = loss_weight_fn(mb_input) / total_loss_weight
+
             loss *= loss_scale
             loss.backward()
 
         grad_norm = torch.nn.utils.clip_grad_norm_(
             self.model.parameters(),
-            self.engine_config.optimizer.gradient_clipping,
+            self.optimizer_config.gradient_clipping,
             norm_type=2.0,
             error_if_nonfinite=False,
             foreach=None,
         )
+        if not torch.isfinite(grad_norm):
+            self.optimizer.zero_grad()
+            update_successful = False
+        else:
+            self.optimizer.step()
+            update_successful = True
+
         current_lr = self.lr_scheduler.get_last_lr()[0]
         # Optimizer step
         self.optimizer.step()
-
-        return {
-            "grad_norm": grad_norm,
-            "lr": current_lr,
-        }
+        return dict(
+            update_successful=float(update_successful),
+            grad_norm=float(grad_norm) if grad_norm is not None else float("nan"),
+            lr=current_lr,
+        )
 
     @torch.no_grad()
     def eval_batch(
         self,
-        input_: Dict,
+        input_: TensorDict,
         mb_spec: MicroBatchSpec,
         loss_fn: Callable[[torch.Tensor, Dict], torch.Tensor],
         loss_weight_fn: Callable[[Dict], float],
     ) -> torch.Tensor | None:
         """Evaluate on a batch."""
-        mb_splits = split_dict_tensor_with_cu_seqlens(input_, mb_spec)
+        mb_list = self._prepare_mb_list(input_, mb_spec)
         total_loss_weight = torch.tensor(
-            sum([loss_weight_fn(mb) for mb in mb_splits.mbs]), dtype=torch.float32
+            sum([loss_weight_fn(mb) for mb in mb_list.mbs]), dtype=torch.float32
         )
         assert total_loss_weight != 0
 
         total_loss = 0.0
         total_weight = 0.0
 
-        for mb_input in mb_splits.mbs:
-            outputs = self.model(**mb_input)
-            loss = loss_fn(outputs.logits, mb_input)
+        for pad_length, padded_mb_input, mb_input in zip(
+            mb_list.padding_lengths, mb_list.padded_mbs, mb_list.mbs
+        ):
+            outputs = self.model(**padded_mb_input)
+            logits = outputs.logits.squeeze(0)
+            logits = logits[:-pad_length] if pad_length > 0 else logits
+            loss = loss_fn(logits, mb_input)
 
             # Simple weight calculation (could be improved)
             loss_scale = loss_weight_fn(mb_input) / total_loss_weight
@@ -220,96 +358,35 @@ def eval_batch(
     @torch.no_grad()
     def forward(
         self,
-        input_: Dict,
+        input_: TensorDict,
         mb_spec: MicroBatchSpec,
         output_seqlens: List[int] | None = None,
         post_hook: Callable[[torch.Tensor, Dict], Any] | None = None,
-        aggregate_fn: Callable[[List[Any]], Any] = functools.partial(torch.cat, dim=1),
+        aggregate_fn: Callable[[List[Any]], Any] = torch.cat,
     ) -> Any | None:
         """Forward pass with optional post-processing."""
-        mb_splits = split_dict_tensor_with_cu_seqlens(input_, mb_spec)
+        cu_seqlens = pack_tensor_dict(input_)["cu_seqlens"]
+        mb_list = self._prepare_mb_list(input_, mb_spec)
+
         if output_seqlens is None:
-            cu_seqlens = input_["cu_seqlens"]
             output_seqlens = (cu_seqlens[1:] - cu_seqlens[:-1]).cpu().numpy().tolist()
 
         results = []
-        for mb_input in mb_splits.mbs:
-            outputs = self.model(**mb_input)
+        for pad_length, padded_mb_input, mb_input in zip(
+            mb_list.padding_lengths, mb_list.padded_mbs, mb_list.mbs
+        ):
+            outputs = self.model(**padded_mb_input)
+            logits = outputs.logits.squeeze(0)
+            logits = logits[:-pad_length] if pad_length > 0 else logits
+
             if post_hook:
-                result = post_hook(outputs.logits, mb_input)
+                result = post_hook(logits, mb_input)
                 results.append(result)
             else:
-                results.append(outputs.logits)
+                results.append(logits)
 
         res = aggregate_fn(results)
-        output_seqlens = [output_seqlens[i] for i in mb_splits.forward_indices]
-        unpacked = unpack_sequence(res, lens=output_seqlens, dim=1)
-        return aggregate_fn(recorder_list(unpacked, mb_splits.backward_indices))
-
-    def step_lr_scheduler(self):
-        """Step the learning rate scheduler."""
-        return self.lr_scheduler.step()
-
-    def save_model_to_hf(
-        self,
-        path: str,
-        tokenizer: Optional[transformers.PreTrainedTokenizerFast] = None,
-        base_model_path: Optional[str] = None,
-    ):
-        """Save model in HuggingFace format."""
-        if self.model is None:
-            raise RuntimeError("Model not initialized")
-
-        os.makedirs(path, exist_ok=True)
-
-        state_dict = {k: v.cpu() for k, v in self.model.state_dict().items()}
-        self.model.save_pretrained(path, state_dict=state_dict)
-        self.model_config.save_pretrained(path)
-        if tokenizer is not None:
-            tokenizer.save_pretrained(path)
-
-    def load_model_from_hf(self, path: str):
-        """Load model from HuggingFace format."""
-        full_state = get_state_dict_from_repo_id_or_path(path)
-        self.model.load_state_dict(
-            full_state, strict=not self.model_config.tie_word_embeddings
-        )
-        if self.model_config.tie_word_embeddings:
-            self.model.tie_weights()
-
-    def save_optimizer_state(self, path: str):
-        """Save optimizer state."""
-        if self.optimizer is None:
-            raise RuntimeError("Optimizer not initialized")
-
-        os.makedirs(path, exist_ok=True)
-        torch.save(self.optimizer.state_dict(), os.path.join(path, "optimizer.pt"))
-
-    def load_optimizer_state(self, path: str):
-        """Load optimizer state."""
-        if self.optimizer is None:
-            raise RuntimeError("Optimizer not initialized")
-
-        optimizer_path = os.path.join(path, "optimizer.pt")
-        if os.path.exists(optimizer_path):
-            self.optimizer.load_state_dict(
-                torch.load(optimizer_path, map_location="cpu")
-            )
-        else:
-            raise RuntimeError(f"Optimizer state file not found: {optimizer_path}")
-
-    async def aupdate_weights_to(self, llm_client: LLMClient):
-        path = constants.get_param_realloc_path(self.args)
-        self.save_model_to_hf(path)
-        tasks = [
-            llm_client.aupdate_weights_from_disk(server_info=server_info, path=path)
-            for server_info in llm_client.get_healthy_servers()
-        ]
-        await asyncio.gather(*tasks)
-
-    def update_weights_to(self, llm_client: LLMClient):
-        loop = asyncio.new_event_loop()
-        try:
-            loop.run_until_complete(self.aupdate_weights_to(llm_client))
-        finally:
-            loop.close()
+        output_seqlens = [output_seqlens[i] for i in mb_list.forward_indices]
+        unpacked = unpack_sequence(res, lens=output_seqlens, dim=0)
+        reordered = reorder_list(unpacked, mb_list.backward_indices)
+        return pad_and_stack_tensors_along_first_dim(reordered)
diff --git a/arealite/tests/test_hf_engine.py b/arealite/tests/test_hf_engine.py
new file mode 100644
index 000000000..927b3e985
--- /dev/null
+++ b/arealite/tests/test_hf_engine.py
@@ -0,0 +1,161 @@
+# Copyright 2025 Ant Group Inc.
+# Licensed under the Apache License, Version 2.0
+
+"""Test script for HF Engine implementation."""
+
+import os
+from typing import Dict
+
+import pytest
+import torch
+from tensordict import TensorDict
+from transformers import AutoTokenizer
+
+from arealite.api.cli_args import MicroBatchSpec, OptimizerConfig, TrainEngineConfig
+from arealite.api.io_struct import FinetuneSpec, SaveLoadMeta
+from arealite.engine.hf_engine import HFEngine
+
+VOCAB_SIZE = 100
+MODEL_PATH = "/storage/testing/models/Qwen__Qwen3-1.7B/"
+if not os.path.exists(MODEL_PATH):
+    MODEL_PATH = "Qwen/Qwen2-0.5B"
+
+
+@pytest.fixture(scope="module")
+def mock_input(
+    batch_size=5,
+    min_seqlen=10,
+    max_seqlen=20,
+    device="cuda:0",
+) -> Dict:
+    """Create mock padded input data (same format for huggingface) for testing.
+    Returns a dict with input_ids, attention_mask, and position_ids.
+    """
+    pad_token_id = 0
+    seqlens = torch.randint(
+        min_seqlen, max_seqlen, (batch_size,), dtype=torch.int, device=device
+    )
+    max_seqlen = int(max(seqlens))
+    input_ids = torch.randint(
+        0, VOCAB_SIZE, (batch_size, max_seqlen), dtype=torch.long, device=device
+    )
+    attn_mask = torch.zeros((batch_size, max_seqlen), dtype=torch.bool, device=device)
+
+    attn_mask[
+        torch.arange(0, max_seqlen, device=device).unsqueeze(0) < seqlens.unsqueeze(1)
+    ] = 1
+    input_ids.masked_fill_(~attn_mask, pad_token_id)
+
+    return TensorDict(
+        input_ids=input_ids,
+        attention_mask=attn_mask,
+    )
+
+
+def mock_loss_fn(logits: torch.Tensor, input_data: Dict) -> torch.Tensor:
+    """Mock loss function for testing."""
+    return torch.mean(logits)
+
+
+@pytest.fixture(scope="module")
+def engine():
+    os.environ["WORLD_SIZE"] = "1"
+    os.environ["RANK"] = "0"
+    os.environ["LOCAL_RANK"] = "0"
+    os.environ["MASTER_ADDR"] = "localhost"
+    os.environ["MASTER_PORT"] = "7777"
+
+    engine_config = TrainEngineConfig(
+        experiment_name="test-hf-engine",
+        trial_name="test0",
+        path=MODEL_PATH,
+        optimizer=OptimizerConfig(),
+    )
+    engine = HFEngine(engine_config)
+    ft_spec = FinetuneSpec(total_train_epochs=1, dataset_size=100, train_batch_size=2)
+    engine.initialize(None, ft_spec)
+    print("✓ Engine created successfully")
+    yield engine
+
+
+@torch.no_grad()
+def test_forward_microbatch(engine, mock_input):
+    engine.eval()
+    x2 = (
+        engine.forward(
+            input_=mock_input,
+            mb_spec=MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100),
+        )
+        .squeeze(0)
+        .mean(-1)
+    )
+    x1 = (
+        engine.forward(
+            input_=mock_input,
+            mb_spec=MicroBatchSpec(n_mbs=1, max_tokens_per_mb=100),
+        )
+        .squeeze(0)
+        .mean(-1)
+    )
+    input_ids = mock_input["input_ids"]
+    assert x1.shape[:1] == input_ids.shape[:1]
+    assert x2.shape[:1] == input_ids.shape[:1]
+    assert torch.allclose(x1, x2, atol=1e-1, rtol=1e-2), (x1 - x2).abs().max().item()
+
+
+@torch.no_grad()
+def test_eval_batch(engine, mock_input):
+    engine.eval()
+    eval_result = engine.eval_batch(
+        input_=mock_input,
+        mb_spec=MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100),
+        loss_fn=mock_loss_fn,
+        loss_weight_fn=lambda x: x["cu_seqlens"][-1],
+    )
+    assert isinstance(eval_result, torch.Tensor), "Evaluation should return a tensor"
+    assert eval_result.is_cuda, "Evaluation tensor should be on CUDA device"
+    assert eval_result is not None, "Evaluation should return a loss value"
+    print(f"✓ Evaluation successful, loss: {eval_result.item()}")
+
+
+def test_train_batch(engine, mock_input):
+    engine.train()
+    train_result = engine.train_batch(
+        input_=mock_input,
+        mb_spec=MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100),
+        loss_fn=mock_loss_fn,
+        loss_weight_fn=lambda x: x["cu_seqlens"][-1],
+    )
+    assert isinstance(train_result, dict), "Training should return a dictionary"
+    assert train_result["grad_norm"] is not None
+    assert train_result["lr"] is not None
+    print("✓ Training successful")
+
+
+@torch.no_grad()
+def test_hf_save_load_weights(tmp_path_factory, engine, mock_input):
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+    path = tmp_path_factory.mktemp("hf_engine_test")
+    save_load_meta = SaveLoadMeta(
+        path=path,
+        weight_format="hf",
+        tokenizer=tokenizer,
+        with_optim=True,
+        base_model_path=None,
+    )
+
+    old = engine.forward(
+        input_=mock_input,
+        mb_spec=MicroBatchSpec(n_mbs=1, max_tokens_per_mb=100),
+    )
+    engine.save(save_load_meta)
+
+    for name, param in engine.model.named_parameters():
+        param.zero_()
+
+    engine.load(save_load_meta)
+    new = engine.forward(
+        input_=mock_input,
+        mb_spec=MicroBatchSpec(n_mbs=1, max_tokens_per_mb=100),
+    )
+    assert torch.allclose(old, new)

From 43b5b362f5dee6e050066fcc2e5a5640d4d89382 Mon Sep 17 00:00:00 2001
From: Jayon02 <12012211@mail..sustech.edu.cn>
Date: Wed, 9 Jul 2025 10:52:19 -0700
Subject: [PATCH 02/10] format file

---
 arealite/engine/hf_engine.py          | 6 ++++--
 examples/env/validate_installation.py | 1 +
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/arealite/engine/hf_engine.py b/arealite/engine/hf_engine.py
index ed20cf395..ea25709db 100644
--- a/arealite/engine/hf_engine.py
+++ b/arealite/engine/hf_engine.py
@@ -13,7 +13,7 @@
     get_constant_schedule_with_warmup,
     get_linear_schedule_with_warmup,
 )
-from arealite.utils.fsdp import get_cosine_schedule_with_warmup
+
 from arealite.api.cli_args import TrainEngineConfig
 from arealite.api.engine_api import (
     FinetuneSpec,
@@ -33,12 +33,14 @@
     unpack_sequence,
     unsqueeze_mb_list,
 )
+from arealite.utils.fsdp import get_cosine_schedule_with_warmup
 from arealite.utils.save_load import get_state_dict_from_repo_id_or_path
 from realhf.api.core.data_api import load_hf_tokenizer
 from realhf.base import logging, name_resolve, names
 
 logger = logging.getLogger("HFEngine")
 
+
 class HFEngine(TrainEngine):
     def __init__(self, config: TrainEngineConfig):
         self.config = config
@@ -233,7 +235,7 @@ def upload_weights(self, meta: WeightUpdateMeta):
             name_resolve.add(update_name, str(time.time_ns()), keepalive_ttl=120)
         else:
             raise ValueError(f"Unknown weight update type {meta.type}")
-        
+
     def _init_distributed_weight_update(self, meta: WeightUpdateMeta):
         raise NotImplementedError(
             "Distributed weight update is not implemented for HFEngine yet. "
diff --git a/examples/env/validate_installation.py b/examples/env/validate_installation.py
index 61ef6f7c5..6c69cd7e5 100644
--- a/examples/env/validate_installation.py
+++ b/examples/env/validate_installation.py
@@ -79,6 +79,7 @@ def test_sglang_functionality(self, sglang_module):
         """Test SGLang basic functionality."""
         # Basic import test is sufficient for CI
         import sgl_kernel
+
         from sglang import launch_server
         assert Version(get_version("sglang")) == Version("0.4.6.post4")
         print("  - SGLang imported successfully")

From 9e31934e5b3a63db933168266bea6867ea4e1ad6 Mon Sep 17 00:00:00 2001
From: Jayon02 <12012211@mail..sustech.edu.cn>
Date: Wed, 9 Jul 2025 23:34:41 -0700
Subject: [PATCH 03/10] revert file format

---
 examples/env/validate_installation.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/examples/env/validate_installation.py b/examples/env/validate_installation.py
index 6c69cd7e5..61ef6f7c5 100644
--- a/examples/env/validate_installation.py
+++ b/examples/env/validate_installation.py
@@ -79,7 +79,6 @@ def test_sglang_functionality(self, sglang_module):
         """Test SGLang basic functionality."""
         # Basic import test is sufficient for CI
         import sgl_kernel
-
         from sglang import launch_server
         assert Version(get_version("sglang")) == Version("0.4.6.post4")
         print("  - SGLang imported successfully")

From b14f45fad92d19e414ba0adc01368cc2b21036b1 Mon Sep 17 00:00:00 2001
From: Jayon02 <12012211@mail..sustech.edu.cn>
Date: Wed, 9 Jul 2025 23:40:29 -0700
Subject: [PATCH 04/10] Squashed commit of the following:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

commit 8d4b8dc90fceb144bf00f8125f938b57f696e166
Author: Wei Fu <36355462+garrett4wade@users.noreply.github.com>
Date:   Thu Jul 10 13:14:10 2025 +0800

    [Doc] Add an instruction about how to run the SFT example. (#164)

commit 3bf9c85e400a2fe1c6a1e488d27d458ede8cea45
Author: Wei Fu <36355462+garrett4wade@users.noreply.github.com>
Date:   Thu Jul 10 12:56:24 2025 +0800

    [Fix] Merge previous contributions from fw/refactor to lite (#163)

    * initial proposal

    * add arealite

    * .

    * change api

    * .

    * remove LOG_ROOT

    * remove MODEL_SAVE_PATH

    * remove PARAM_REALLOC_PATH, DATASET_CACHE

    * prepare for testing

    * prepare for testing

    * ready for run

    * local run

    * tests mainly pass

    * format

    * .

    * amend cluster.py

    * .

    * .

    * client test pass

    * pass rollout test

    * remove unused imports

    * add arealite readme

    * change api

    * .

    * .

    * .

    * .

    * .

    * .

    * .

    * .

    * format

    * .

    * implement iteraptable generation (#112)

    Co-authored-by: zhaochenyang <zhaochenyang20@gmail.com>

    * .

    * fix

    * .

    * .

    * .

    * pass controller generate batch test

    * .

    * refactor rollout controller into worker and controller

    * .

    * .

    * .

    * change to async rollout

    * pass rollout controller test

    * pass test

    * .

    * update readme

    * .

    * sft debug

    * .

    * add lisence

    * remove unused files

    * remove unsed args in ppo

    * add hf engine wrapper  (#116)

    * add hf engine

    * fix issues

    * fix ppo bugs and add test

    * add hf client interface and modify cli args

    * fix bugs

    * fix issues

    * Merge fw/refactor

    * Finish hf wrapper test

    * add test

    ---------

    Co-authored-by: Wei Fu <36355462+garrett4wade@users.noreply.github.com>

    * format

    * format

    * .

    * refine hf engine

    * .

    * fix

    * add fsdp engine and sft tests

    * .

    * .

    * .

    * pass ppo unittest

    * pass ppo and rollout controller tests

    * clear unused imports

    * rename ppo to grpo

    * change reward function organization

    * reorganize code

    * add dataset api

    * .

    * .

    * .

    * format

    * chmod fix

    * .

    * rename workflow to collector

    * refactor llm_client location

    * .

    * .

    * fix llm server api

    * refactor config structure

    * .

    * fix tests

    * .

    * .

    * .

    * Fix unresolved issue in SFTTrainer PR (#139)

    * .

    * .

    * efficient loading

    * format

    * .

    * .

    * .

    * .

    * .

    * .

    * Add CI for testing AReaLite (#150)

    * ci: add test-arealite

    * ci: add checkout before running test-arealite

    * ci: add USERNAME

    * ci: add test script

    * ci: add GitHub mirror

    * ci: fix typo

    * ci: clone one commit

    * ci: fix condition

    * ci: set command timeout to 60m

    * ci: enable pip cache

    * ci: optimize container lifecycle

    * ci: split into many stages

    * ci(test-arealite): fix typo

    * ci: fix wrong env

    * ci: fix pytest

    * ci: uninstall transformer-engine

    * ci: uninstall transformer-engine

    * ci: fix model paths

    * ci: show stdout/stderr

    * ci: fix not clean up

    * ci: backup sglang

    * ci: remove tmp repo dir when run

    * ci: fix docker run exit 1 condition

    * ci(test-arealite): limit the concurrency and extend command timeout

    * .

    * merge fw/refactor

    * revert some changes

    * fix

    ---------

    Co-authored-by: meizhiyu.mzy <meizhiyu.mzy@antgroup.com>
    Co-authored-by: Chayenne <zhaochen20@outlook.com>
    Co-authored-by: zhaochenyang <zhaochenyang20@gmail.com>
    Co-authored-by: Jayon02 <qiujiangc@outlook.com>
    Co-authored-by: root <meizhiyu.mzy>
    Co-authored-by: Zijian Zhang <futrime@outlook.com>

commit d48bf007cfb0821c35a18a673f3c2e8f51a8ee45
Merge: 42c717b b9dbd4a
Author: 博惟 <bowei.fw@antgroup.com>
Date:   Thu Jul 10 12:53:30 2025 +0800

    Merge branch 'main' of https://github.com/inclusionAI/AReaL into lite

commit 42c717b6e45b3b345f29cff5882ba5374b79faee
Merge: c38cffc a203c7c
Author: 博惟 <bowei.fw@antgroup.com>
Date:   Thu Jul 10 11:15:01 2025 +0800

    Merge branch 'lite' of https://github.com/inclusionAI/AReaL into lite

commit c38cffc02385acf382196ba6b720b2d8b91a5675
Author: 博惟 <bowei.fw@antgroup.com>
Date:   Thu Jul 10 11:10:10 2025 +0800

    PullRequest: 340 [lite] Refactor trainer API into utilities and remove mb_spec in engine methods

    Merge branch fw/lite-dev of git@code.alipay.com:inclusionAI/AReaL.git into lite
    https://code.alipay.com/inclusionAI/AReaL/pull_requests/340

    Reviewed-by: 晓雷 <meizhiyu.mzy@antgroup.com>

    * support fsdp engine and sglang remote engine
    * minor fix
    * .
    * refactor trainer
    * add close
    * rm mb_spec
    * fix

commit b9dbd4a2c18539648dca373c9c8c1347e4e9db68
Author: Wei Fu <36355462+garrett4wade@users.noreply.github.com>
Date:   Wed Jul 9 10:50:19 2025 +0800

    Update to persistent wechat QR code. (#159)

commit 17ea7fe94dc0bd9299082a069383d7372ed13ac9
Author: xssstory <33601810+xssstory@users.noreply.github.com>
Date:   Mon Jul 7 15:49:13 2025 +0800

    fix math reward verifier (#156)

    * PullRequest: 293 fix get_param_realloc_path

    Merge branch xss/debug of git@code.alipay.com:inclusionAI/AReaL.git into gh
    https://code.alipay.com/inclusionAI/AReaL/pull_requests/293

    Reviewed-by: 博惟 <bowei.fw@antgroup.com>

    * fix get_param_realloc_path

    * PullRequest: 297 bugfix: reward is always -5

    Merge branch xss/debug of git@code.alipay.com:inclusionAI/AReaL.git into gh
    https://code.alipay.com/inclusionAI/AReaL/pull_requests/297

    Reviewed-by: 博惟 <bowei.fw@antgroup.com>

    * bugfix: reward is always -5

    * PullRequest: 321 fix checkpoint save dir

    Merge branch xss/debug of git@code.alipay.com:inclusionAI/AReaL.git into gh
    https://code.alipay.com/inclusionAI/AReaL/pull_requests/321

    Reviewed-by: 博惟 <bowei.fw@antgroup.com>

    * fix checkpoint save dir

    * PullRequest: 328 [Doc] update installation

    Merge branch sxj/doc of git@code.alipay.com:inclusionAI/AReaL.git into gh
    https://code.alipay.com/inclusionAI/AReaL/pull_requests/328

    Reviewed-by: 博惟 <bowei.fw@antgroup.com>

    * [Doc] update installation

    * PullRequest: 329 bugfix: math verifier blocks the async training

    Merge branch xss/debug of git@code.alipay.com:inclusionAI/AReaL.git into gh
    https://code.alipay.com/inclusionAI/AReaL/pull_requests/329

    Reviewed-by: 博惟 <bowei.fw@antgroup.com>

    * bugfix: math verifier block the async training

    * format

    ---------

    Co-authored-by: 冰临 <shenxujie.sxj@antgroup.com>
    Co-authored-by: garrett4wade <fuwth17@gmail.com>
---
 arealite/README.md                            |  28 ++-
 arealite/api/cli_args.py                      | 209 +++++++-----------
 arealite/api/engine_api.py                    |   4 -
 arealite/api/trainer_api.py                   | 130 -----------
 arealite/engine/fsdp_engine.py                |  20 +-
 arealite/engine/sft/lm_engine.py              |  94 ++++++++
 arealite/tests/test_fsdp_engine.py            |  35 +--
 arealite/trainer/sft.py                       | 156 -------------
 arealite/utils/data.py                        |  23 +-
 arealite/utils/evaluator.py                   |  36 +++
 arealite/utils/fs.py                          |   9 +
 arealite/utils/logging.py                     |   9 -
 arealite/utils/saver.py                       |  68 ++++++
 arealite/utils/stats_logger.py                | 111 ++++++++++
 assets/wechat_qrcode.png                      | Bin 166550 -> 2772 bytes
 examples/arealite/configs/gsm8k_sft.yaml      |  58 +++--
 examples/arealite/gsm8k_sft.py                |  65 ++++--
 functioncall/code/local_verify.py             |   8 +-
 pyproject.toml                                |   2 +-
 realhf/api/core/data_api.py                   |   2 +
 realhf/base/stats_tracker.py                  |  14 ++
 realhf/impl/dataset/math_parser.py            |  11 +-
 .../environment/math_code_single_step_env.py  |   2 +
 requirements.txt                              |   4 +-
 24 files changed, 569 insertions(+), 529 deletions(-)
 delete mode 100644 arealite/api/trainer_api.py
 create mode 100644 arealite/engine/sft/lm_engine.py
 delete mode 100644 arealite/trainer/sft.py
 create mode 100644 arealite/utils/evaluator.py
 create mode 100644 arealite/utils/fs.py
 delete mode 100644 arealite/utils/logging.py
 create mode 100644 arealite/utils/saver.py
 create mode 100644 arealite/utils/stats_logger.py

diff --git a/arealite/README.md b/arealite/README.md
index d70b86ebc..f472c1bef 100644
--- a/arealite/README.md
+++ b/arealite/README.md
@@ -1,5 +1,18 @@
 # AReaL v1.0.0 Design Doc
 
+---
+
+Update 20250710
+
+SFT example:
+
+```bash
+torchrun --nnodes 1 --nproc-per-node 8 examples/arealite/gsm8k_sft.py --config examples/arealite/configs/gsm8k_sft.yaml
+```
+
+---
+
+
 We will provide both single-controller and SPMD user interfaces. The SPMD interface will be delivered with AReaLite, which is the paradigm most users are familiar with, just like using `torchrun` or `deepspeed`. However, this paradigm may lack some flexibility over global scheduling and control. To unlock the full potential with customized distributed execution, we will also provide a single-controller mode just like using Ray --- but our scheduler backend will not be restricted to Ray. Our code will be able to run with any scheduler in the cluster, such as native SLURM and K8S.
 
 However, we want the user code to stay the same for both modes. The following is a simple usage example:
@@ -187,7 +200,6 @@ class TrainEngine(abc.ABC):
     def train_batch(
         self,
         input_: Dict,
-        mb_spec: MicroBatchSpec,
         loss_fn: Callable[[torch.Tensor, Dict], torch.Tensor],
         loss_weight_fn: Callable[[Dict], float],
     ) -> Dict[str, float]:
@@ -197,7 +209,6 @@ class TrainEngine(abc.ABC):
     def eval_batch(
         self,
         input_: Dict,
-        mb_spec: MicroBatchSpec,
         loss_fn: Callable[[torch.Tensor, Dict], torch.Tensor],
         loss_weight_fn: Callable[[Dict], float],
     ) -> torch.Tensor | None:
@@ -207,7 +218,6 @@ class TrainEngine(abc.ABC):
     def forward(
         self,
         input_: Dict,
-        mb_spec: MicroBatchSpec,
         output_seqlens: List[List[int]] | None = None,
         post_hook: Callable[[torch.Tensor, Dict], Any] | None = None,
         aggregate_fn: Callable[[List[Any]], Any] = torch.cat,
@@ -323,7 +333,7 @@ Extended engines (such as Actor in PPO) provide convenient organization and call
 class Actor(Engine):
     
     @torch.no_grad()
-    def compute_logps(self, input_: Dict[str, Tensor], mb_spec: MicroBatchSpec) -> torch.Tensor:
+    def compute_logps(self, input_: Dict[str, Tensor]) -> torch.Tensor:
         ... # unpad
         logps = self.forward(xxx)
         ... # pad back
@@ -332,8 +342,7 @@ class Actor(Engine):
     def compute_advantages_and_returns(self, input_: Dict) -> Dict:
         pass
 
-    def ppo_update(self, input_: Dict, 
-                   mb_spec: MicroBatchSpec) -> List[Dict[str, float]]:
+    def ppo_update(self, input_: Dict) -> List[Dict[str, float]]:
         ...
         all_stats = []
         for _ in range(self.ppo_n_minibatches):
@@ -344,11 +353,10 @@ class Actor(Engine):
 class Critic(Engine):
     
     @torch.no_grad()
-    def compute_values(self, input_: Dict, mb_spec: MicroBatchSpec) -> torch.Tensor:
+    def compute_values(self, input_: Dict) -> torch.Tensor:
         pass
 
-    def ppo_update(self, input_: Dict, 
-                   mb_spec: MicroBatchSpec) -> List[Dict[str, float]]:
+    def ppo_update(self, input_: Dict) -> List[Dict[str, float]]:
         ...
         all_stats = []
         for _ in range(self.ppo_n_minibatches):
@@ -742,4 +750,4 @@ dataloader = StatefulDataLoader(
 )
 for data in dataloader:
     assert isinstance(data, list)
-```
\ No newline at end of file
+```
diff --git a/arealite/api/cli_args.py b/arealite/api/cli_args.py
index 786cbe6f7..ca4b78bd8 100644
--- a/arealite/api/cli_args.py
+++ b/arealite/api/cli_args.py
@@ -1,14 +1,17 @@
 import argparse
-import getpass
 import os
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
+import uvloop
+
+uvloop.install()
 from hydra import compose as hydra_compose
 from hydra import initialize as hydra_init
 from omegaconf import MISSING, OmegaConf
 
+from arealite.utils.fs import get_user_tmp
 from realhf.api.cli_args import OptimizerConfig
 
 
@@ -103,8 +106,8 @@ class FSDPEngineConfig:
 
 @dataclass
 class TrainEngineConfig:
-    experiment_name: str
-    trial_name: str
+    experiment_name: str = MISSING
+    trial_name: str = MISSING
     path: str = field(default="", metadata={"help": "Path to HuggingFace checkpoint"})
     attn_impl: str = field(
         default="flash_attention_2",
@@ -120,6 +123,8 @@ class TrainEngineConfig:
         default=False,
         metadata={"help": "Initialize critic/reward model from LM checkpoint"},
     )
+    # Runtime microbatch limit
+    mb_spec: MicroBatchSpec = field(default_factory=MicroBatchSpec)
 
     # Training Backend Configuration
     gradient_checkpointing: bool = field(
@@ -307,94 +312,40 @@ class SGLangEngineConfig:
 
 
 @dataclass
-class ExperimentSaveEvalControl:
-    """Controls the frequency of model saving and evaluation during training.
-
-    Manages independent counters for epochs, steps, and seconds. The model will be saved
-    or evaluated when any specified frequency condition is met.
-
-    Note:
-        - Epoch: Number of full passes through the training dataset
-        - Step: Number of individual training iterations
-        - Seconds: Wall-clock time duration
-    """
-
-    total_train_epochs: int = field(
-        default=1, metadata={"help": "Total number of epochs to train the model."}
-    )
-    # Save control
-    save_freq_epochs: Optional[int] = field(
-        default=None,
-        metadata={
-            "help": "Save frequency in epochs. None disables epoch-based saving."
-        },
-    )
-    save_freq_steps: Optional[int] = field(
-        default=None,
-        metadata={"help": "Save frequency in steps. None disables step-based saving."},
-    )
-    save_freq_secs: Optional[int] = field(
+class _Timer:
+    experiment_name: str = MISSING
+    trial_name: str = MISSING
+    fileroot: str = MISSING
+    freq_epochs: Optional[int] = field(
         default=None,
         metadata={
-            "help": "Save frequency in seconds. None disables time-based saving."
+            "help": "Trigger frequency in epochs. None disables epoch-based saving."
         },
     )
-    # Checkpointing control
-    ckpt_freq_epochs: Optional[int] = field(
+    freq_steps: Optional[int] = field(
         default=None,
         metadata={
-            "help": "Checkpoint frequency in epochs. None uses save_freq_epochs. "
-            "Checkpointing is used for recover. Previous checkpoint is overwritten to save space."
+            "help": "Trigger frequency in steps. None disables step-based saving."
         },
     )
-    ckpt_freq_steps: Optional[int] = field(
+    freq_secs: Optional[int] = field(
         default=None,
         metadata={
-            "help": "Checkpoint frequency in steps. None disables step-based checkpointing."
-        },
-    )
-    ckpt_freq_secs: Optional[int] = field(
-        default=None,
-        metadata={
-            "help": "Checkpoint frequency in seconds. None disables time-based checkpointing."
-        },
-    )
-    # Evaluation control
-    eval_freq_epochs: Optional[int] = field(
-        default=None,
-        metadata={
-            "help": "Evaluation frequency in epochs. None disables epoch-based evaluation."
-        },
-    )
-    eval_freq_steps: Optional[int] = field(
-        default=None,
-        metadata={
-            "help": "Evaluation frequency in steps. None disables step-based evaluation."
-        },
-    )
-    eval_freq_secs: Optional[int] = field(
-        default=None,
-        metadata={
-            "help": "Evaluation frequency in seconds. None disables time-based evaluation."
-        },
-    )
-    # Benchmark control
-    benchmark_steps: Optional[int] = field(
-        default=None,
-        metadata={
-            "help": "Terminate training after this number of steps. "
-            "For benchmarking purposes only. None indicates normal training."
-        },
-    )
-    benchmark_n_seqs: Optional[int] = field(
-        default=None,
-        metadata={
-            "help": "Terminate training after consuming this number of samples. "
-            "For benchmarking purposes only. None indicates normal training."
+            "help": "Trigger frequency in seconds. None disables time-based saving."
         },
     )
 
 
+@dataclass
+class EvaluatorConfig(_Timer):
+    pass
+
+
+@dataclass
+class SaverConfig(_Timer):
+    pass
+
+
 @dataclass
 class WandBConfig:
     mode: str = "disabled"
@@ -423,11 +374,23 @@ class TensorBoardConfig:
     path: Optional[str] = None
 
 
-def get_user_tmp():
-    user = getpass.getuser()
-    user_tmp = os.path.join("/home", user, ".cache", "realhf")
-    os.makedirs(user_tmp, exist_ok=True)
-    return user_tmp
+@dataclass
+class StatsLoggerConfig:
+    experiment_name: str = MISSING
+    trial_name: str = MISSING
+    fileroot: str = MISSING
+    wandb: WandBConfig = field(
+        default_factory=WandBConfig,
+        metadata={"help": "Weights & Biases configuration."},
+    )
+    swanlab: SwanlabConfig = field(
+        default_factory=SwanlabConfig,
+        metadata={"help": "SwanLab configuration."},
+    )
+    tensorboard: TensorBoardConfig = field(
+        default_factory=TensorBoardConfig,
+        metadata={"help": "TensorBoard configuration. Only 'path' field required."},
+    )
 
 
 @dataclass
@@ -498,7 +461,9 @@ class ClusterSpecConfig:
 
 @dataclass
 class DatasetConfig:
-    type: str = field(default="", metadata={"help": "Type of implemented dataset"})
+    type: Optional[str] = field(
+        default=None, metadata={"help": "Type of implemented dataset"}
+    )
     batch_size: int = field(
         default=1, metadata={"help": "Batch size of the dataloader"}
     )
@@ -517,51 +482,6 @@ class DatasetConfig:
     drop_last: bool = field(default=True)
 
 
-@dataclass
-class TrainerConfig:
-    experiment_name: str = field(
-        default=MISSING,
-        metadata={"help": "Name of the experiment (no '_' or '/'). Required."},
-    )
-    trial_name: str = field(
-        default=MISSING,
-        metadata={"help": "Name of the trial (no '-' or '/'). Required."},
-    )
-    fileroot: str = field(
-        default=get_user_tmp(),
-        metadata={
-            "help": "Root for logs and checkpoints. Should be available to all nodes."
-        },
-    )
-    wandb: WandBConfig = field(
-        default_factory=WandBConfig,
-        metadata={"help": "Weights & Biases configuration."},
-    )
-    swanlab: SwanlabConfig = field(
-        default_factory=SwanlabConfig,
-        metadata={"help": "SwanLab configuration."},
-    )
-    tensorboard: TensorBoardConfig = field(
-        default_factory=TensorBoardConfig,
-        metadata={"help": "TensorBoard configuration. Only 'path' field required."},
-    )
-    allocation_mode: str = field(
-        default="",
-        metadata={
-            "help": "GPU parallel strategy allocation mode. "
-            "Options: manual/heuristic or pattern-based."
-        },
-    )
-    seed: int = field(default=1, metadata={"help": "Random seed for reproducibility."})
-    exp_ctrl: ExperimentSaveEvalControl = field(
-        default_factory=ExperimentSaveEvalControl,
-        metadata={"help": "Experiment save/evaluation control configuration."},
-    )
-
-    tokenizer_path: str = field(default="")
-    mb_spec: MicroBatchSpec = field(default_factory=MicroBatchSpec)
-
-
 @dataclass
 class BaseExperimentConfig:
     # NOTE: we need this unified config class because different experiments
@@ -585,14 +505,45 @@ class BaseExperimentConfig:
     n_gpus_per_node: int = field(
         default=8, metadata={"help": "Number of GPUs per node for this experiment."}
     )
+    allocation_mode: str = field(
+        default="",
+        metadata={
+            "help": "GPU parallel strategy allocation mode. "
+            "Options: manual/heuristic or pattern-based."
+        },
+    )
+    seed: int = field(default=1, metadata={"help": "Random seed for reproducibility."})
+    total_train_epochs: int = field(
+        default=1, metadata={"help": "Total number of epochs to train the model."}
+    )
+    total_train_steps: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "Terminate training after this number of steps. "
+            "For benchmarking purposes only. None indicates normal training."
+        },
+    )
+    total_train_n_seqs: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": "Terminate training after consuming this number of samples. "
+            "For benchmarking purposes only. None indicates normal training."
+        },
+    )
+    tokenizer_path: str = field(default="")
+
     train_dataset: DatasetConfig = field(default_factory=DatasetConfig)
     valid_dataset: DatasetConfig = field(default_factory=DatasetConfig)
 
+    saver: SaverConfig = field(default_factory=SaverConfig)
+    checkpointer: SaverConfig = field(default_factory=SaverConfig)
+    evaluator: EvaluatorConfig = field(default_factory=EvaluatorConfig)
+    stats_logger: StatsLoggerConfig = field(default_factory=StatsLoggerConfig)
+
 
 @dataclass
 class SFTConfig(BaseExperimentConfig):
     model: TrainEngineConfig = field(default_factory=TrainEngineConfig)
-    trainer: TrainerConfig = field(default_factory=TrainerConfig)
 
 
 def load_expr_config(argv: List[str], config_cls) -> Tuple[BaseExperimentConfig, str]:
diff --git a/arealite/api/engine_api.py b/arealite/api/engine_api.py
index 919bc97e5..26e124aea 100644
--- a/arealite/api/engine_api.py
+++ b/arealite/api/engine_api.py
@@ -6,7 +6,6 @@
 import torch
 from tensordict import TensorDict
 
-from arealite.api.cli_args import MicroBatchSpec
 from arealite.api.io_struct import (
     FinetuneSpec,
     LLMRequest,
@@ -79,7 +78,6 @@ def step_lr_scheduler(self):
     def train_batch(
         self,
         input_: Dict,
-        mb_spec: MicroBatchSpec,
         loss_fn: Callable[[torch.Tensor, Dict], torch.Tensor],
         loss_weight_fn: Callable[[Dict], float],
     ) -> Dict[str, float]:
@@ -90,7 +88,6 @@ def train_batch(
     def eval_batch(
         self,
         input_: Dict,
-        mb_spec: MicroBatchSpec,
         loss_fn: Callable[[torch.Tensor, Dict], torch.Tensor],
         loss_weight_fn: Callable[[Dict], float],
     ) -> torch.Tensor | None:
@@ -101,7 +98,6 @@ def eval_batch(
     def forward(
         self,
         input_: Dict,
-        mb_spec: MicroBatchSpec,
         output_seqlens: List[List[int]] | None = None,
         post_hook: Callable[[torch.Tensor, Dict], Any] | None = None,
         aggregate_fn: Callable[[List[Any]], Any] = torch.cat,
diff --git a/arealite/api/trainer_api.py b/arealite/api/trainer_api.py
deleted file mode 100644
index 40bddaac6..000000000
--- a/arealite/api/trainer_api.py
+++ /dev/null
@@ -1,130 +0,0 @@
-import getpass
-import os
-from typing import Dict
-
-import torch.distributed as dist
-import wandb
-from tensorboardX import SummaryWriter
-from torchdata.stateful_dataloader import StatefulDataLoader
-
-from arealite.api.cli_args import TrainerConfig
-from arealite.api.engine_api import InferenceEngine, TrainEngine
-from realhf.api.core.data_api import load_hf_tokenizer
-from realhf.base import logging, timeutil
-
-
-class Trainer:
-    def __init__(
-        self,
-        config: TrainerConfig,
-        train_dataloader: StatefulDataLoader,
-        valid_dataloader: StatefulDataLoader,
-        engine: TrainEngine,
-        inf_engine: InferenceEngine | None = None,
-    ):
-        self.config = config
-
-        self.train_dataloader = train_dataloader
-        self.valid_dataloader = valid_dataloader
-
-        self.engine = engine
-        self.inf_engine = inf_engine
-
-        self.tokenizer = load_hf_tokenizer(config.tokenizer_path)
-
-        self.save_ctl = timeutil.EpochStepTimeFreqCtl(
-            freq_epoch=config.exp_ctrl.save_freq_epochs,
-            freq_step=config.exp_ctrl.save_freq_steps,
-            freq_sec=config.exp_ctrl.save_freq_secs,
-        )
-        self.eval_ctl = timeutil.EpochStepTimeFreqCtl(
-            freq_epoch=config.exp_ctrl.eval_freq_epochs,
-            freq_step=config.exp_ctrl.eval_freq_steps,
-            freq_sec=config.exp_ctrl.eval_freq_steps,
-        )
-        self.logger = logging.getLogger(self.__class__.__name__)
-        self.init_stats_logging()
-
-    def init_stats_logging(self):
-        """
-        Initialize wandb and/or tensorboard according to config.
-        If torch.distributed is initialized
-
-        Return:
-            tensorboard SummaryWriter if self.config.tensorboard.path is not None
-        """
-        if dist.is_initialized() and dist.get_rank() != 0:
-            return
-
-        # wandb init, connect to remote wandb host
-        if self.config.wandb.mode != "disabled":
-            wandb.login()
-        wandb.init(
-            mode=self.config.wandb.mode,
-            entity=self.config.wandb.entity,
-            project=self.config.wandb.project or self.config.experiment_name,
-            name=self.config.wandb.name or self.config.trial_name,
-            job_type=self.config.wandb.job_type,
-            group=self.config.wandb.group
-            or f"{self.config.experiment_name}_{self.config.trial_name}",
-            notes=self.config.wandb.notes,
-            tags=self.config.wandb.tags,
-            config=self.config.wandb.config,
-            dir=Trainer.get_log_path(self.config),
-            force=True,
-            id=f"{self.config.experiment_name}_{self.config.trial_name}_train",
-            resume="allow",
-            settings=wandb.Settings(start_method="fork"),
-        )
-        # tensorboard logging
-        self.summary_writer = None
-        if self.config.tensorboard.path is not None:
-            self.summary_writer = SummaryWriter(log_dir=self.config.tensorboard.path)
-
-    def log_wandb_tensorboard(self, step: int, data: Dict):
-        if dist.is_initialized() and dist.get_rank() != 0:
-            return
-
-        wandb.log(data, step=step)
-        if self.summary_writer is not None:
-            for key, val in data.items():
-                self.summary_writer.add_scalar(f"{key}", val, step)
-
-    def close_wandb_tensorboard(self):
-        if dist.is_initialized() and dist.get_rank() != 0:
-            return
-
-        wandb.finish()
-        if self.summary_writer is not None:
-            self.summary_writer.close()
-
-    @staticmethod
-    def get_save_checkpoint_path(
-        config: TrainerConfig,
-        epoch: int,
-        step: int,
-        globalstep: int,
-        name: str = "default",
-    ):
-        path = os.path.join(
-            f"{config.fileroot}/checkpoints/{getpass.getuser()}/{config.experiment_name}/{config.trial_name}",
-            name,
-            f"epoch{epoch}epochstep{step}globalstep{globalstep}",
-        )
-        os.makedirs(path, exist_ok=True)
-        return path
-
-    @staticmethod
-    def get_log_path(config: TrainerConfig):
-        path = f"{config.fileroot}/logs/{getpass.getuser()}/{config.experiment_name}/{config.trial_name}"
-        os.makedirs(path, exist_ok=True)
-        return path
-
-    def log(self, msg: str, level="info"):
-        if dist.is_initialized() and dist.get_rank() > 0:
-            return
-        log_fn = getattr(self.logger, level, "info")
-        return log_fn(msg)
-
-    def train(self):
-        raise NotImplementedError()
diff --git a/arealite/engine/fsdp_engine.py b/arealite/engine/fsdp_engine.py
index e45a871f3..8537e02b5 100644
--- a/arealite/engine/fsdp_engine.py
+++ b/arealite/engine/fsdp_engine.py
@@ -21,7 +21,6 @@
 from arealite.api.cli_args import TrainEngineConfig
 from arealite.api.engine_api import (
     FinetuneSpec,
-    MicroBatchSpec,
     SaveLoadMeta,
     TrainEngine,
     WeightUpdateMeta,
@@ -319,15 +318,15 @@ def step_lr_scheduler(self):
         assert self.lr_scheduler is not None
         self.lr_scheduler.step()
 
-    def _prepare_mb_list(
-        self, input_: TensorDict, mb_spec: MicroBatchSpec
-    ) -> MicroBatchList:
+    def _prepare_mb_list(self, input_: TensorDict) -> MicroBatchList:
         assert "attention_mask" in input_ and "input_ids" in input_
+        if isinstance(input_, dict):
+            input_ = TensorDict(input_, batch_size=[input_["input_ids"].shape[0]])
         input_ = amend_position_ids(input_)
         packed_input = pack_tensor_dict(input_)
         mb_list = split_packed_tensor_dict_into_mb_list(
             packed_input,
-            mb_spec,
+            self.config.mb_spec,
         )
         mb_list = pad_mb_list(mb_list, pad_value=0.0)
         # NOTE: We unsqueeze here because huggingface transformer models requires
@@ -338,7 +337,6 @@ def _prepare_mb_list(
     def train_batch(
         self,
         input_: TensorDict,
-        mb_spec: MicroBatchSpec,
         loss_fn: Callable[[torch.Tensor, Dict], torch.Tensor],
         loss_weight_fn: Callable[[Dict], float],
     ) -> Dict[str, float]:
@@ -349,7 +347,7 @@ def train_batch(
         assert self.lr_scheduler is not None
 
         self.optimizer.zero_grad()
-        mb_list = self._prepare_mb_list(input_, mb_spec)
+        mb_list = self._prepare_mb_list(input_)
 
         total_loss_weight = torch.tensor(
             sum([loss_weight_fn(mb) for mb in mb_list.mbs]), dtype=torch.float32
@@ -398,12 +396,12 @@ def train_batch(
     def eval_batch(
         self,
         input_: TensorDict,
-        mb_spec: MicroBatchSpec,
         loss_fn: Callable[[torch.Tensor, Dict], torch.Tensor],
         loss_weight_fn: Callable[[Dict], float],
     ) -> torch.Tensor | None:
         """Evaluate on a batch."""
-        mb_list = self._prepare_mb_list(input_, mb_spec)
+        input_ = input_.to(self.device)
+        mb_list = self._prepare_mb_list(input_)
         total_loss_weight = torch.tensor(
             sum([loss_weight_fn(mb) for mb in mb_list.mbs]), dtype=torch.float32
         )
@@ -431,14 +429,14 @@ def eval_batch(
     def forward(
         self,
         input_: TensorDict,
-        mb_spec: MicroBatchSpec,
         output_seqlens: List[int] | None = None,
         post_hook: Callable[[torch.Tensor, Dict], Any] | None = None,
         aggregate_fn: Callable[[List[Any]], Any] = torch.cat,
     ) -> Any | None:
         """Forward pass with optional post-processing."""
+        input_ = input_.to(self.device)
         cu_seqlens = pack_tensor_dict(input_)["cu_seqlens"]
-        mb_list = self._prepare_mb_list(input_, mb_spec)
+        mb_list = self._prepare_mb_list(input_)
 
         if output_seqlens is None:
             output_seqlens = (cu_seqlens[1:] - cu_seqlens[:-1]).cpu().numpy().tolist()
diff --git a/arealite/engine/sft/lm_engine.py b/arealite/engine/sft/lm_engine.py
new file mode 100644
index 000000000..1b1715da2
--- /dev/null
+++ b/arealite/engine/sft/lm_engine.py
@@ -0,0 +1,94 @@
+from typing import Dict
+
+import torch
+import torch.utils.data
+from tensordict import TensorDict
+
+from arealite.api.cli_args import TrainEngineConfig
+from arealite.api.engine_api import TrainEngine
+from arealite.engine.fsdp_engine import FSDPEngine
+from arealite.utils.functional import gather_logprobs
+from realhf.base import stats_tracker
+
+
+class LMEngine:
+    def __init__(self, engine: TrainEngine):
+        self.engine = engine
+
+    def train_lm(self, data: TensorDict):
+        self.engine.train()
+        return self.engine.train_batch(
+            input_=data,
+            loss_fn=compute_packed_sft_loss,
+            loss_weight_fn=lambda x: x["prompt_mask"].logical_not().count_nonzero(),
+        )
+
+    def evaluate_lm(self, data):
+        self.engine.eval()
+        self.engine.eval_batch(
+            input_=data,
+            loss_fn=compute_packed_sft_loss,
+            loss_weight_fn=lambda x: x["prompt_mask"].logical_not().count_nonzero(),
+        )
+
+
+class FSDPLMEngine(FSDPEngine):
+    def __init__(self, config: TrainEngineConfig):
+        super().__init__(config)
+        self.lm_engine = LMEngine(self)
+
+    def train_lm(self, data):
+        return self.lm_engine.train_lm(data)
+
+    def evaluate_lm(self, data):
+        return self.lm_engine.evaluate_lm(data)
+
+
+def compute_packed_sft_loss(
+    logits: torch.Tensor, input_: Dict[str, torch.Tensor]
+) -> torch.Tensor:
+    packed_input_ids: torch.Tensor = input_["input_ids"]
+    cu_seqlens: torch.Tensor = input_["cu_seqlens"]
+    prompt_mask = input_["prompt_mask"].bool()
+
+    logprobs = gather_logprobs(logits, torch.roll(packed_input_ids, shifts=-1, dims=-1))
+    prompt_mask = torch.roll(prompt_mask, shifts=-1, dims=-1)
+    logprobs = torch.where(prompt_mask, 0, logprobs)
+
+    loss = -logprobs.sum() / prompt_mask.logical_not().count_nonzero()
+
+    with torch.no_grad():
+        seqlogp = torch.zeros(
+            cu_seqlens.shape[0] - 1, device=logits.device, dtype=torch.float64
+        )
+        for i in range(cu_seqlens.shape[0] - 1):
+            m = prompt_mask[cu_seqlens[i] - i : cu_seqlens[i + 1] - i - 1]
+            logp = logprobs[cu_seqlens[i] - i : cu_seqlens[i + 1] - i - 1]
+            assert cu_seqlens[i + 1] - i - 1 <= logprobs.shape[0], (
+                cu_seqlens,
+                logprobs.shape,
+            )
+            seqlogp[i] = torch.where(m, 0.0, logp.detach()).sum() / (
+                m.numel() - m.count_nonzero()
+            )
+
+    ## Loggin stats
+    stats_tracker.denominator(
+        n_seqs=torch.ones(
+            cu_seqlens.shape[0] - 1, dtype=torch.bool, device=logprobs.device
+        ),
+        n_tokens=torch.ones(logits.shape[0], dtype=torch.bool, device=logits.device),
+        n_valid_tokens=prompt_mask.logical_not(),
+        prompt_tokens=prompt_mask,
+    )
+    stats_tracker.stat(ppl=(-seqlogp).exp().float(), denominator="n_seqs")
+    stats_tracker.stat(loss=-logprobs.detach(), denominator="n_valid_tokens")
+    vocab_min_logits = logits.detach().min(-1).values.float()
+    vocab_max_logits = logits.detach().max(-1).values.float()
+    stats_tracker.stat(
+        vocab_min_logits=vocab_min_logits,
+        vocab_max_logits=vocab_max_logits,
+        denominator="n_tokens",
+    )
+
+    return loss
diff --git a/arealite/tests/test_fsdp_engine.py b/arealite/tests/test_fsdp_engine.py
index 4237be76e..d295408d3 100644
--- a/arealite/tests/test_fsdp_engine.py
+++ b/arealite/tests/test_fsdp_engine.py
@@ -81,22 +81,10 @@ def engine():
 @torch.no_grad()
 def test_forward_microbatch(engine, mock_input):
     engine.eval()
-    x2 = (
-        engine.forward(
-            input_=mock_input,
-            mb_spec=MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100),
-        )
-        .squeeze(0)
-        .mean(-1)
-    )
-    x1 = (
-        engine.forward(
-            input_=mock_input,
-            mb_spec=MicroBatchSpec(n_mbs=1, max_tokens_per_mb=100),
-        )
-        .squeeze(0)
-        .mean(-1)
-    )
+    engine.config.mb_spec = MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100)
+    x2 = engine.forward(input_=mock_input).squeeze(0).mean(-1)
+    engine.config.mb_spec = MicroBatchSpec(n_mbs=1, max_tokens_per_mb=100)
+    x1 = engine.forward(input_=mock_input).squeeze(0).mean(-1)
     input_ids = mock_input["input_ids"]
     assert x1.shape[:1] == input_ids.shape[:1]
     assert x2.shape[:1] == input_ids.shape[:1]
@@ -106,9 +94,9 @@ def test_forward_microbatch(engine, mock_input):
 @torch.no_grad()
 def test_eval_batch(engine, mock_input):
     engine.eval()
+    engine.config.mb_spec = MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100)
     eval_result = engine.eval_batch(
         input_=mock_input,
-        mb_spec=MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100),
         loss_fn=mock_loss_fn,
         loss_weight_fn=lambda x: x["cu_seqlens"][-1],
     )
@@ -120,9 +108,9 @@ def test_eval_batch(engine, mock_input):
 
 def test_train_batch(engine, mock_input):
     engine.train()
+    engine.config.mb_spec = MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100)
     train_result = engine.train_batch(
         input_=mock_input,
-        mb_spec=MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100),
         loss_fn=mock_loss_fn,
         loss_weight_fn=lambda x: x["cu_seqlens"][-1],
     )
@@ -144,18 +132,13 @@ def test_hf_save_load_weights(tmp_path_factory, engine, mock_input):
         base_model_path=None,
     )
 
-    old = engine.forward(
-        input_=mock_input,
-        mb_spec=MicroBatchSpec(n_mbs=1, max_tokens_per_mb=100),
-    )
+    engine.config.mb_spec = MicroBatchSpec(n_mbs=1, max_tokens_per_mb=100)
+    old = engine.forward(input_=mock_input)
     engine.save(save_load_meta)
 
     for name, param in engine.model.named_parameters():
         param.zero_()
 
     engine.load(save_load_meta)
-    new = engine.forward(
-        input_=mock_input,
-        mb_spec=MicroBatchSpec(n_mbs=1, max_tokens_per_mb=100),
-    )
+    new = engine.forward(input_=mock_input)
     assert torch.allclose(old, new)
diff --git a/arealite/trainer/sft.py b/arealite/trainer/sft.py
deleted file mode 100644
index 4ae7cc70d..000000000
--- a/arealite/trainer/sft.py
+++ /dev/null
@@ -1,156 +0,0 @@
-import time
-from typing import Dict
-
-import torch
-import torch.distributed as dist
-import torch.utils.data
-
-from arealite.api.io_struct import SaveLoadMeta
-from arealite.api.trainer_api import Trainer
-from arealite.utils.functional import gather_logprobs
-from arealite.utils.logging import record_timing
-from realhf.api.core.data_api import tabulate_stats
-from realhf.base import logging, stats_tracker
-
-
-def compute_packed_sft_loss(
-    logits: torch.Tensor,
-    input_: Dict[str, torch.Tensor],
-) -> torch.Tensor:
-    packed_input_ids: torch.Tensor = input_["input_ids"]
-    cu_seqlens: torch.Tensor = input_["cu_seqlens"]
-    prompt_mask = input_["prompt_mask"].bool()
-    logits = logits.float()
-
-    logprobs = gather_logprobs(logits, torch.roll(packed_input_ids, shifts=-1, dims=-1))
-    prompt_mask = torch.roll(prompt_mask, shifts=-1, dims=-1)
-    logprobs = torch.where(prompt_mask, 0, logprobs)
-
-    loss = -logprobs.sum() / prompt_mask.logical_not().count_nonzero()
-
-    with torch.no_grad():
-        seqlogp = torch.zeros(
-            cu_seqlens.shape[0] - 1, device=logits.device, dtype=torch.float64
-        )
-        for i in range(cu_seqlens.shape[0] - 1):
-            m = prompt_mask[cu_seqlens[i] - i : cu_seqlens[i + 1] - i - 1]
-            logp = logprobs[cu_seqlens[i] - i : cu_seqlens[i + 1] - i - 1]
-            assert cu_seqlens[i + 1] - i - 1 <= logprobs.shape[0], (
-                cu_seqlens,
-                logprobs.shape,
-            )
-            seqlogp[i] = torch.where(m, 0.0, logp.detach()).sum() / (
-                m.numel() - m.count_nonzero()
-            )
-
-    ## Loggin stats
-    stats_tracker.denominator(
-        n_seqs=torch.ones(
-            cu_seqlens.shape[0] - 1, dtype=torch.bool, device=logprobs.device
-        ),
-        n_tokens=torch.ones(logits.shape[0], dtype=torch.bool, device=logits.device),
-        n_valid_tokens=prompt_mask.logical_not(),
-        prompt_tokens=prompt_mask,
-    )
-    stats_tracker.stat(ppl=(-seqlogp).exp().float(), denominator="n_seqs")
-    stats_tracker.stat(loss=-logprobs.detach(), denominator="n_valid_tokens")
-    vocab_min_logits = logits.detach().min(-1).values.float()
-    vocab_max_logits = logits.detach().max(-1).values.float()
-    stats_tracker.stat(
-        vocab_min_logits=vocab_min_logits,
-        vocab_max_logits=vocab_max_logits,
-        denominator="n_tokens",
-    )
-
-    return loss
-
-
-class SFTTrainer(Trainer):
-
-    def train(self):
-        total_epochs = self.config.exp_ctrl.total_train_epochs
-        steps_per_epoch = len(self.train_dataloader)
-
-        self.log(f"total_epochs={total_epochs} step_per_epoch={steps_per_epoch}")
-        global_step = 0
-        start_time = time.monotonic()
-        for epoch in range(total_epochs):
-            for step, data in enumerate(self.train_dataloader):
-                self.engine.train()
-                timing_stats = {}
-                with record_timing("timeperf/train_step", timing_stats):
-                    with stats_tracker.scope("sft"):
-                        stats = self.engine.train_batch(
-                            input_=data,
-                            loss_fn=compute_packed_sft_loss,
-                            loss_weight_fn=lambda x: x["prompt_mask"]
-                            .logical_not()
-                            .count_nonzero(),
-                            mb_spec=self.config.mb_spec,
-                        )
-                        self.engine.step_lr_scheduler()
-                        stats_tracker.scalar(**stats)
-
-                if self.save_ctl.check(
-                    epochs=int(step == steps_per_epoch - 1), steps=1
-                ):
-                    self.log("Saving model ...")
-
-                    with record_timing("timeperf/save", timing_stats):
-                        save_path = self.get_save_checkpoint_path(
-                            self.config, epoch, step, global_step
-                        )
-                        meta = SaveLoadMeta(
-                            path=save_path,
-                            weight_format="hf",
-                            with_optim=False,
-                            tokenizer=self.tokenizer,
-                            base_model_path=self.config.tokenizer_path,
-                        )
-                        self.engine.save(meta)
-
-                if self.eval_ctl.check(
-                    epochs=int(step == steps_per_epoch - 1), steps=1
-                ):
-                    if dist.get_rank() == 0:
-                        self.log("Running evaluation ...")
-                    with record_timing("timeperf/eval", timing_stats):
-                        self.evaluate()
-
-                stats = stats_tracker.export()
-                stats.update(timing_stats)
-                self.log_wandb_tensorboard(global_step, stats)
-
-                self.log(
-                    f"Epoch {epoch+1}/{total_epochs} "
-                    f"Step {step+1}/{steps_per_epoch} "
-                    f"Train step {global_step + 1}/{total_epochs * steps_per_epoch} done."
-                )
-                self.log(
-                    f"Detailed time stats: \n{tabulate_stats(timing_stats, floatfmt='.2f')}"
-                )
-                self.log(f"SFT training stats:\n{tabulate_stats(stats)}")
-                global_step += 1
-
-        self.log(
-            f"Training completes! Total time elapsed {time.monotonic() - start_time:.2f}."
-        )
-
-        self.close_wandb_tensorboard()
-
-    def evaluate(self):
-        if self.valid_dataloader is None:
-            return
-        self.engine.eval()
-        for data in self.valid_dataloader:
-            with stats_tracker.scope("sft-eval"):
-                # No need to log anything. Logging will be handled outside
-                # via stats_tracker.export().
-                self.engine.eval_batch(
-                    input_=data,
-                    loss_fn=compute_packed_sft_loss,
-                    loss_weight_fn=lambda x: x["prompt_mask"]
-                    .logical_not()
-                    .count_nonzero(),
-                    mb_spec=self.config.mb_spec,
-                )
diff --git a/arealite/utils/data.py b/arealite/utils/data.py
index d6c073606..0b322ad4b 100644
--- a/arealite/utils/data.py
+++ b/arealite/utils/data.py
@@ -277,7 +277,7 @@ def pad_and_stack_tensors_along_first_dim(tensor_list: List[torch.Tensor]):
 
 @dataclass
 class MicroBatchList:
-    data: Dict[str, Any]
+    data: TensorDict
     mb_spec: MicroBatchSpec
     mbs: List[TensorDict]
     forward_indices: List[int]
@@ -379,7 +379,7 @@ def pad_packed_tensor_dict(
     data: TensorDict,
     pad_to_length: int,
     pad_value: float = 0.0,
-) -> Tuple[Dict[str, Any], int]:
+) -> Tuple[TensorDict, int]:
     """Pad a packed tensor dict to a specified length.
     This function assumes that the input data contains "cu_seqlens" and "max_seqlen" key,
     and all other tensors of shape [total_length, ] will be padded to `pad_to_length`.
@@ -391,7 +391,7 @@ def pad_packed_tensor_dict(
         pad_to_length (int): The length to pad the tensors to. All tensors
 
     Returns:
-        Dict[str, torch.Tensor]: Dictionary with padded tensors and modified "cu_seqlens" and
+        TensorDict: Dictionary with padded tensors and modified "cu_seqlens" and
             "max_seqlen".
         int: The pad length.
     """
@@ -420,7 +420,7 @@ def pad_packed_tensor_dict(
             padded_data[key] = padded_tensor
         else:
             padded_data[key] = value
-    return padded_data, pad_length
+    return TensorDict(padded_data, batch_size=data.batch_size), pad_length
 
 
 def pad_mb_list(
@@ -453,13 +453,17 @@ def unsqueeze_packed_tensor_dict(data: TensorDict) -> TensorDict:
     assert "max_seqlen" in data, "Input data must contain 'max_seqlen' key."
 
     total_length = data["cu_seqlens"][-1].item()
+    new_data = {}
     for key, value in data.items():
-        if key == "cu_seqlens" or key == "max_seqlen":
-            continue
+        if (
+            key not in ["cu_seqlens", "max_seqlen"]
+            and torch.is_tensor(value)
+            and value.numel() == total_length
+        ):
+            new_data[key] = value.unsqueeze(dim=0)
         else:
-            if torch.is_tensor(value) and value.numel() == total_length:
-                data[key] = value.unsqueeze(dim=0)
-    return data
+            new_data[key] = value
+    return TensorDict(new_data, batch_size=data.batch_size)
 
 
 def unsqueeze_mb_list(
@@ -472,7 +476,6 @@ def unsqueeze_mb_list(
         new_mbs.append(unsqueeze_packed_tensor_dict(mb))
         if mb_list.padded_mbs is not None:
             new_padded_mbs.append(unsqueeze_packed_tensor_dict(mb_list.padded_mbs[i]))
-    mb_list.mbs = new_mbs
     mb_list.padded_mbs = new_padded_mbs if mb_list.padded_mbs is not None else None
     return mb_list
 
diff --git a/arealite/utils/evaluator.py b/arealite/utils/evaluator.py
new file mode 100644
index 000000000..9d559ea63
--- /dev/null
+++ b/arealite/utils/evaluator.py
@@ -0,0 +1,36 @@
+from typing import TYPE_CHECKING, Any, Callable
+
+from arealite.api.cli_args import EvaluatorConfig
+from arealite.api.io_struct import FinetuneSpec
+from realhf.base import timeutil
+
+if TYPE_CHECKING:
+    from tensordict import TensorDict
+    from torchdata.stateful_dataloader import StatefulDataLoader
+
+
+class Evaluator:
+
+    def __init__(self, config: EvaluatorConfig, ft_spec: FinetuneSpec):
+        self.config = config
+        self.ft_sepc = ft_spec
+        self.freq_ctl = timeutil.EpochStepTimeFreqCtl(
+            freq_epoch=config.freq_epochs,
+            freq_step=config.freq_steps,
+            freq_sec=config.freq_secs,
+        )
+
+    def evaluate(
+        self,
+        valid_dataloader: "StatefulDataLoader",
+        evaluate_fn: Callable[["TensorDict"], Any],
+        epoch: int,
+        step: int,
+        global_step: int,
+    ):
+        if not self.freq_ctl.check(
+            epochs=int(step == self.ft_sepc.steps_per_epoch - 1), steps=1
+        ):
+            return
+        for data in valid_dataloader:
+            evaluate_fn(data)
diff --git a/arealite/utils/fs.py b/arealite/utils/fs.py
new file mode 100644
index 000000000..f79040035
--- /dev/null
+++ b/arealite/utils/fs.py
@@ -0,0 +1,9 @@
+import getpass
+import os
+
+
+def get_user_tmp():
+    user = getpass.getuser()
+    user_tmp = os.path.join("/home", user, ".cache", "realhf")
+    os.makedirs(user_tmp, exist_ok=True)
+    return user_tmp
diff --git a/arealite/utils/logging.py b/arealite/utils/logging.py
deleted file mode 100644
index 6bbc08b83..000000000
--- a/arealite/utils/logging.py
+++ /dev/null
@@ -1,9 +0,0 @@
-import time
-from contextlib import contextmanager
-
-
-@contextmanager
-def record_timing(name, timing_stats):
-    start_time = time.perf_counter()
-    yield
-    timing_stats[name] = time.perf_counter() - start_time
diff --git a/arealite/utils/saver.py b/arealite/utils/saver.py
new file mode 100644
index 000000000..2692f0df8
--- /dev/null
+++ b/arealite/utils/saver.py
@@ -0,0 +1,68 @@
+import getpass
+import os
+
+from transformers import PreTrainedTokenizerFast
+
+from arealite.api.cli_args import SaverConfig
+from arealite.api.engine_api import TrainEngine
+from arealite.api.io_struct import FinetuneSpec, SaveLoadMeta
+from realhf.base import timeutil
+
+
+class Saver:
+
+    def __init__(self, config: SaverConfig, ft_spec: FinetuneSpec, for_recover: bool):
+        self.config = config
+        self.ft_sepc = ft_spec
+        self.for_recover = for_recover
+        self.freq_ctl = timeutil.EpochStepTimeFreqCtl(
+            freq_epoch=config.freq_epochs,
+            freq_step=config.freq_steps,
+            freq_sec=config.freq_secs,
+        )
+
+    @staticmethod
+    def get_save_checkpoint_path(
+        config: SaverConfig,
+        epoch: int,
+        step: int,
+        globalstep: int,
+        name: str = "default",
+    ):
+        path = os.path.join(
+            f"{config.fileroot}/checkpoints/{getpass.getuser()}/{config.experiment_name}/{config.trial_name}",
+            name,
+            f"epoch{epoch}epochstep{step}globalstep{globalstep}",
+        )
+        os.makedirs(path, exist_ok=True)
+        return path
+
+    def save(
+        self,
+        engine: TrainEngine,
+        epoch: int,
+        step: int,
+        global_step: int,
+        name: str = "default",
+        tokenizer: PreTrainedTokenizerFast | None = None,
+        base_model_path: str | None = None,
+    ):
+        if not self.freq_ctl.check(
+            epochs=int(step == self.ft_sepc.steps_per_epoch - 1), steps=1
+        ):
+            return
+        path = self.get_save_checkpoint_path(epoch, step, global_step, name)
+        weight_format = "hf"
+        with_optim = False
+        if self.for_recover:
+            weight_format = "dcp"
+            with_optim = True
+
+        meta = SaveLoadMeta(
+            path=path,
+            weight_format=weight_format,
+            with_optim=with_optim,
+            tokenizer=tokenizer,
+            base_model_path=base_model_path,
+        )
+        engine.save(meta)
diff --git a/arealite/utils/stats_logger.py b/arealite/utils/stats_logger.py
new file mode 100644
index 000000000..62cc0ba9e
--- /dev/null
+++ b/arealite/utils/stats_logger.py
@@ -0,0 +1,111 @@
+import getpass
+import os
+import time
+from typing import Dict
+
+import torch.distributed as dist
+import wandb
+from tensorboardX import SummaryWriter
+
+from arealite.api.cli_args import StatsLoggerConfig
+from arealite.api.io_struct import FinetuneSpec
+from realhf.api.core.data_api import tabulate_stats
+from realhf.base import logging
+
+
+class StatsLogger:
+
+    def __init__(self, config: StatsLoggerConfig, ft_spec: FinetuneSpec):
+        self.logger = logging.getLogger("StatsLogger", "system")
+        self.config = config
+        self.ft_spec = ft_spec
+        self.init()
+
+    def init(self):
+        if dist.is_initialized() and dist.get_rank() != 0:
+            return
+
+        self.start_time = time.perf_counter()
+        # wandb init, connect to remote wandb host
+        if self.config.wandb.mode != "disabled":
+            wandb.login()
+        wandb.init(
+            mode=self.config.wandb.mode,
+            entity=self.config.wandb.entity,
+            project=self.config.wandb.project or self.config.experiment_name,
+            name=self.config.wandb.name or self.config.trial_name,
+            job_type=self.config.wandb.job_type,
+            group=self.config.wandb.group
+            or f"{self.config.experiment_name}_{self.config.trial_name}",
+            notes=self.config.wandb.notes,
+            tags=self.config.wandb.tags,
+            config=self.config.wandb.config,
+            dir=self.get_log_path(self.config),
+            force=True,
+            id=f"{self.config.experiment_name}_{self.config.trial_name}_train",
+            resume="allow",
+            settings=wandb.Settings(start_method="fork"),
+        )
+        # tensorboard logging
+        self.summary_writer = None
+        if self.config.tensorboard.path is not None:
+            self.summary_writer = SummaryWriter(log_dir=self.config.tensorboard.path)
+
+    def close(self):
+        if dist.is_initialized() and dist.get_rank() != 0:
+            return
+        self.info(
+            f"Training completes! Total time elapsed {time.monotonic() - self.start_time:.2f}."
+        )
+        wandb.finish()
+        if self.summary_writer is not None:
+            self.summary_writer.close()
+
+    def commit(self, epoch: int, step: int, global_step: int, data: Dict):
+        if dist.is_initialized() and dist.get_rank() != 0:
+            return
+        self.info(
+            f"Epoch {epoch+1}/{self.ft_spec.total_train_epochs} "
+            f"Step {step+1}/{self.ft_spec.steps_per_epoch} "
+            f"Train step {global_step + 1}/{self.ft_spec.total_train_steps} done."
+        )
+        self.info("Stats:")
+        self.print_stats(data)
+        wandb.log(data, step=global_step)
+        if self.summary_writer is not None:
+            for key, val in data.items():
+                self.summary_writer.add_scalar(f"{key}", val, global_step)
+
+    def print_stats(self, stats: Dict[str, float]):
+        self.info("\n" + tabulate_stats(stats))
+
+    @staticmethod
+    def get_log_path(config: StatsLoggerConfig):
+        path = f"{config.fileroot}/logs/{getpass.getuser()}/{config.experiment_name}/{config.trial_name}"
+        os.makedirs(path, exist_ok=True)
+        return path
+
+    def info(self, msg: str, *args, **kwargs):
+        if dist.is_initialized() and dist.get_rank() > 0:
+            return
+        self.logger.info(msg, *args, **kwargs)
+
+    def debug(self, msg: str, *args, **kwargs):
+        if dist.is_initialized() and dist.get_rank() > 0:
+            return
+        self.logger.debug(msg, *args, **kwargs)
+
+    def critical(self, msg: str, *args, **kwargs):
+        if dist.is_initialized() and dist.get_rank() > 0:
+            return
+        self.logger.critical(msg, *args, **kwargs)
+
+    def warning(self, msg: str, *args, **kwargs):
+        if dist.is_initialized() and dist.get_rank() > 0:
+            return
+        self.logger.warning(msg, *args, **kwargs)
+
+    def error(self, msg: str, *args, **kwargs):
+        if dist.is_initialized() and dist.get_rank() > 0:
+            return
+        self.logger.error(msg, *args, **kwargs)
diff --git a/assets/wechat_qrcode.png b/assets/wechat_qrcode.png
index bde130ade779d00e37c2ce18869a01ff72cd6d2b..1f867badc73046805479fe1a2b44c03d619f4fe7 100644
GIT binary patch
literal 2772
zcmb_edr(qo6u(rPt`%raT85bAwo{p`p-G`&ji!uSwzaEkIbyS$ni_(dJcS-pjG1EY
z^q|LL>-N};(j6315gJO`vM?)40}T*$#}Y6LOu2Vqru}38@-nl3d~;^*eD};b=l3{Y
z`Ht<03w#27003A(PKw_N0Eh|q@t)=S5-&~CyTX^Wr1W9{K;Cm7#ObxjWdPuFoE*RT
zd*;P=y1P}Tt-fE}Jrw~#k4zT|^JR@!B-v|>VLL(-zGAX(i^XCrup8_nB7mWCLR__c
z_MHDablDw#l-n;I5zBZy9+JdjqO>Ud7>J9B1m#uGL;I8}8Dp>FpNM80T2A-!UO00&
zAB-fFK)*k~BeDH4m2=KtYqeskgqfEp;|@v|eU8MYurxRVtV2lO&@o`M5mt~k`>?3_
zsglTTjO)@}=R`>vB}`O+<s^Q3ULoux6Nd~9C~1_S1XKvrWD|j6%E43V4R1kxG#Cm$
zjl1g9kV0uwuIuj=^!%qZ+k6!29IM5_=+_~R+zVQsG;<h1sP~pu@yuLS-Y6y<EVYw1
z2y*b?+QMx&6l$k(e1&KA<kweU+22AJL=STpY7s%!GB5Pk$dzq(;PRzwl$+oUp6b0G
z7!3+`x8aP|T=>1X+ijPnyix9(>#fmR!DON=Dvrs^L29kD6VV!rL4F^HhOpxI@F7Pn
zLB0+w=sWMr)}#sf7Kgr_-}ko57^9O*5UsZ4%r-#<{N~)UiOpI(4k}brS{gU~J*a=U
zu7V>9#$T03;aCs_d~|^jR|8L6ist6S9mCcB*SJLM{MZdjZCF5|`7tcaKht7_Gg_fJ
zJJ^9@wg=#ezsjP1U_wjBr~LV?oj>8g6qe@CtMJ9fUN?3isOY#7QiM+mgJ?R!sw>ES
z;gjIq_3FI<+HYpHeik%awPx@PN|zDiE{7K)!nHv)T9IgaaeX!1G_@89HoOvDiH!^5
z71=P^Lk3JEa4>hYakXB(&|^9ee;W#d_I}bFxq12tI&<78tog1*P?0kNf7Y3Me%Wcq
zf;wepWPAUI!=#5sM2^z#*GzrlBrq(F(+b$~a5L!f?Je2dH*EvXvu$__18Vvi({O)Y
zFI#nU%Pd;_%z}4=kNF0DrZ;VqvRYDkqdV)Fp-Bgo==sM@{?KXx##YBHhUKrH5&MK8
z8J(Q{rbXrUU@KUD&xS)Q&(Oiu{7z%%pmFXsk2utaZs99(xf6M#hblVw=3YygKoV>Q
zlf#|6nlW#&F7(LojM{CE1E$1`jLn3|_D}{yHTU=q$-8~CI~+%2!Plod;<YT;ZPrd2
z8f@verUGg^u&j@q0ox0ED}U{Q(Zr?vf-wjy6dP88Y|ngZC@ln))`f|vFU_5<aj^kc
znR2k7WMt;r8vlxEw4?U&T;(Of*mABbwJ(jg7AT9LtuLJKX(BHUx9&zsJ;^FAdg8JZ
z_`BM@fn}wAV+`W-2BM$rLtPlsm-;TXpRY>Tv#4A|dJY-kbACvmMpmXwh6Pgm0teDI
zO%F~UI~i=9UG^qc_vxjO^h)?+u?IHn!u;ROE8Vk^>KeS*PLM?z@x(YhPt{E|U%o$V
zz32hcRJ2!KE&RGXUC+o12SR&5|E}{GH`dUYJ_x@>*MfbpX0UR7YuRu>%|^9tfU0vy
zKoy5crDu1;pL}c<z94^R-czIW+2tulJMt3cfn(P5o+ce1rBSl!eFYH|&#2Xt8ltfq
zh&%T87jlc~A30iO%S7GDWlDjaGTw94>0T0Kcs`M7S#lGRbr$|y;qmpq@3&ed0)67|
WRpj4FEUsrNKu*{me``zDk$(Wyk#Fk&

literal 166550
zcmeFZXIN8P*EYHkkPd<rsZoj`RRp9HMd<>f(wm5g7>Y=*p@UQb0i^{5M5KxI-g~c+
z-g`@^0YY-te)e<D`=0ZiAE*9!zH2X-To+l3u*RBWj&YBB+%xz;_yypay0V%wKtKQh
z1mG8dp9UTQq{LTAt`d`yTqPkRB_*T0PDx2YL3x9gj`}*=4R&_c8>}o4E<qm1E&f|9
zthdE^`GrM9?}>8o+?Tn3S4Qxz=-t2Ggn*QcjFOy^iIS4(?oHO4cmHo6_$Gjsl(>hm
zgOGp|xI#-nNK1fk10dji5)=IE0RDXtTp=U^Z<v&foC3U{{2FkDfROMC5g{=#5fON`
z4|pCRq9vxgCHnB{bsY;5PDlEC{;`>)T#6;l49|v9++wdj1dx$4GTmTi;knJrcZXkG
z;=ZJmw9KQ&O3Es#YU<Bl=<4Yk7#dl=wt8dz*5;j)vx}>nyN73BP;f|S*vIg=_|FN6
zNngGuf6L0w`JVeD@8|E*vhs?`s_L4S*0%PJ&aUpBk<qd73FM#2sl}z`mDRQNjm<6e
z!Qs*I$tmXS{4cu*0K&h`0)PH(*#E&UTF|a5L_~x{B!AgOaK#NAgtSD&w?wbfJ=7tw
zaJ<fW&!3cDF*dWLnT$*98H(Z6hhcI?Zt+DP^k1g^%d-D#h6VgTvh05|?7!@q0w@Uy
zz{w+|1)u;robQ_-`9I^IXYh{?{Nn@v_`p9t@Q)At;{*Sb`vC9gPLT`ihV71pO%d<=
zu!x!D(|Ka=JHtnBEfL0166}w$o$h_27yRio<Bfno;$?bSSZ>{z#K-uxO5FfDFUD@C
z<0irlO;4I|dpe|Ed7Po1RGYO2FJb+YoY%K^ikxGor(3E5=)+veGiXM#b+Oxn)|k-6
zTHZ<F??w87r9$U^?=)yWaxm5S<mVOG;Q>whAJ{Giww=zYhEDJKodX+{r=H2ZziR>x
zZV8oji(7x%T8J6=jeTn<-fsIFyL>iQQ&$_!;F0!qjQUb$1p2UR+f3&&S19qT`}VEb
zQxfTwr97K{aYmg$ft9HKs`T9W^NFKI_oA>u<H?@R-#)4*SqL5MR$_=#=43pw`w335
z`rhlahBw%)<dQm{Rj1nKqsu#DyXX2ulu=mg!(0!#N^BW4&FapNG}_GDZeI0`>XKf*
z3GF_?<Io92k<CY1&3ReLC77fsm&4EQ9XHm0U$DN<R^VB=_U<%P@A3GzUdR$o<U~_y
z{Fzt+nTnpP@xQO?@m3d17HVke#eI@tgH!0IXo}Atj^ly-EaN|G_MJ8MCzpJ);LU{E
zlxX_6S1h>^H+S~Ipn7%j+9^FAh(608&6RkJOZE}J=!ZY&BntC6x5e<lR`J*GXo0qi
z*Po(&odq8e92HV2oO{jBdF-z)%Uy3e&3PZ^ICGl6dtH6(TBlF0;S3=jkiVsedsUaa
z1Z{CIEaVxlyBjT6QUeoeuVPo{sB?Rca8Pfr7)yg(dYySMyk1Ek--1(cCu&obKIt=<
zf%1-0Jj-#C5I~3xn`*ZUu?W$0oSvL)a0NW${ivcudGEmq)hGG<#C$=%Z{fgy?g)Iq
zfxb{s!2|RO+jzk9EEM-B2Kx>gJq<5?HNVD>PD^F8mw@h^;Q>z5{mUQ-9#CpG=8y}Y
z(g-77u@Pid)_Y2REFWd1J0;1Y@2cP)(R%m}+0FRT!SNn#ud3+zQPDV#?(9CNeys)P
zZ3FAb<w}Ol<X6**nRYj$rT$pC{?LiZ$nUh#a^3AjI~S?xznhS~rN|qGl^!eKrc!j+
z>HRV_cb_#gt%J?W{-oFf=|a>v#98$`^_L(aVYJc*mY7!g`&(;<1$*h!@TWf=yU)j?
zcpt~L%wKSfEcAc%7j8S2Iv&h<k;|NwoWsNH#GKU4jTD{Er)8FnSvBG!&otO0%*?4S
zg&9xksS#58(Jb5vBzfQY$m}}{TdbU%uGYJ-V@(>|16T9oX6UD)M{SiAGW0@1vpv|R
z&kx6t=9%y=>RwzGFD^h}6+w?l+%~TFC}OK30VFMU_{yi{jqHb1e!Ojv9~H5$iwF?9
zWQ&X$m8gU*)pMF^$?_FZ#zBGI<>O+&?-Pd2tJr*?#+;0hBbRErWcsRh-hk*OjQmK1
z^}EYRoA}P4_XQr{HF{ssbe34<jx~LsMzg^W$7t=%uY91v62XJLvA@PshK?tM8D*BQ
zz}*<`C*3erzI`-!Akiin1;J!p65G0~v{U_nC7v{>$B4Pf!JU&Qg854jb=G?I(k&fH
z?aU0~d=z+qp$QKR8P$y}L#!zUhI~cvK-ZN~Ttg?$Z@kIfTHEIXPC)ZQpQyn{tlg_v
z$*Fa9%~c$G>-+4Cd8-p0ZtXVlEat|R<MTfzZwHsR^Mq-wUPi3EH*`vx^*?hdis-nq
z{bZ=WBFeV6TI-D7zx=_v+_^s0!bb4;apR|-mBWnOr?I3f*LMTpEbWTA!pKKI?+1Sy
zsO)5v(Vd9*F1Dcga`PUELB#<HTcmyr#`pMT`N7z)wp`C;%m?`S_+CvJT~UOyRjk{M
zFO(=5OT<83@ncga<<a72$Hc4Sz1ORFdm-{M<|E&Or6nAfK8rhA!BV;&$Ew(sS5e}D
z=QxHP2-$a=y1N$_CaO@SVyY0iCx@1y#W0LCxCBxW$H%+}MqAD!QaWpRpp4uOU0(|K
z>;MB)OcylAqu*11mjn-Rr6pYkF5`jWIArn|3o*UUga6oZHJp!d4i8ulp3&{YcW&Z=
zb7B5rOnh$p&#>JbyW04Dw;Q$-ZabiBa@x)R9Uqj86{Ox6Zx}LR2=G8>l%?^aaB^L=
zlOoE~&_t*$snp~*O|0Pn&^b1-R&D3xlB1d^b|&_6N4_*%LsNNVfvU7)#BNnGGC)dB
zcM%VGN50noGCQcN+_mi7ytH{NVH3%C(jDY2%2P6*Q53p^2PQ}QUHYQRDjWwKBiE<O
zMlTbl8pbA1K0Aon&#+G({fwyFvD8a;v`cl~Gwqh|h9V?Lmmz6tl9ayRzc~e;lb=g@
zlXU9hZf$uoVf}U*w`ZY8ENABC;Ubk?!@{$<3B^CfA!kf~pP)4p%f$$2k8?6Ph^Hb_
zUs_6h_T~DcHLUVg<?3>|LT$;A-f2jyio;DD`@9!2$601R*m9&&HGEz~YI=;i{OjvY
zZfQ2Rb3NTvJ1U#}EiIED-Qpj#)Yj7c@PH)hB%9P}q^kPsxP|U-4~a2vspa+)C<=N>
zke_5FFjeCavZ@kk>uY<72QCTnjupMw9Xj4jF81o-f!uO%$#T@i_3ET|I9FGE$qtjg
zRg!$PAM>otjG<)mG#L#)A}OZ3c=ElTDE_1WrW%^3sBE)Pr0`%M*t<<?OVrGRCd@&+
z{;}!i;A&MD5#>vGysq4)&V4@x`|qXeuU^ZoGa!S4Jj}o3+&+~-qO}T_IPt)gz9#p(
ztG8wpFC9m+5<XkcSh8<lR}{F+B#o`e`t{65%=9$6PSP&xEu-7S?{1Ow?es4|p7@qJ
z{pE-yvzlpYoBb6(R)$@~RR}zA<)kM5Ovs(Inqoeq*abr)nYPdgH?D+Ww)DBDyr?@V
zE*^q$Xx$1Ayu{#vBir(|@=bUdFE%>S{DdY34=DGV*%;8%>nH*L$-`^@U#Zq^{W6Ff
zj2}9>cp$9O4(1-&*lZ7hpyYIECJ%9sryDOwp}6qyayg%GTSkS$b_&x2I`-FZjlJF<
zkd{bzG2?tc%ic$eWnS6T9#UyDdiK0Fu1ot-`uOd-n#5o``ZqhjKGDs@B;DB8my=v9
zrr*?$xHW3>ct&!ciwh4Z=GB>IU=X@hj{`L<D19W=IJ9x{X7Eyk<!qFJ^!KUTD8xtJ
zu{Y5J7A!sV-s@3+u<r&k^EB>?-XX6)Ic<Nn(LjTi2wwj(<&+_>ox&`K2b%I-up$L`
zfGQt855q}J2Y>rq%+=bTFMjs6zVEAgvfo5Es^d3&wF?i-+u+3KF-qmdX9v*JDR`9U
zmX1najV^1gidP0W|Bc}Mn{DEO3}mlNOt^&fDvz}&AJpXqK}<(O-iXjjs8U7c=U1u=
zx)vL*%gmc*v^iLwiDf6AleAi1sq41|5>Kql8Qi})5W`Ag$vo|8(_ALT0bO1R`<FH+
zGP=LXrk?5Qp8C}{cUI;V_7gTuRixwzbmpAtbdlEzevG{4WuKoM6D*MwRhM$r=QkUT
zsIq>gqt5d=@rc!-wdWV|xAB1Lp=+gY8kD@mDZ7)OOng#j>@dKi@cBa8hu7v}+5{z+
zM@^US7*P6Q-)4H>HLXXgHZGgs`jB4+%xMw=)b_Z~-fQ>n@b9;_`MGy=snl}yT{Oik
zI2etFwsLS8l<;J&59d5bOcY@>T3PB59}A0xcTOI0><%!y_rwmd<Y@m$?eO+Gs}r)s
z1LhHU;M-iC4((_AX)`>4wp1A_Ph%NizdbbD%RZE_OqsR%XBjHW-c@`b4+PP)%kr3G
zRD3V&A@vc_RS>USiD9PKZ=Rye1E<>+54|I<v;f4@K*<19P~XiOrLP!$&EAE~>Jzmx
z3b^E750!)b%=szTRpTAmH+bdOvVY|A&E@p9vX~H;?Ag+%%KA5KYn{&Zt`~~$vXfYL
zHE_8L$%+2xNTePyQqQuCqo$FD<hUj~-&u+Yp`GsAUQ_(C9Y9_}c*KyoWPTMUDWlWV
z4i|hP_oLN&+UZX!^?Lo&VQ;Y|tH`PD?-G$W<jV3Yp@G-WpSvY%Cf|--KA8S88|eHz
z&}<(?fqU#BiU*)^@QphrA-N0Y*Up^UIRd!t7K0)LA8^#)YdTCmLWIc3uSG0&RE`O;
zjJ&Dx@c!20x*~F_#-0z`cylV(coKvMVh4J0&BJ(LV-nV{ZFE#TbseW7D{?{7i3hT*
ziY4S>cmLCAclrGjZ_v*B`?wYw&~?5Q1$LOpjbLxNFf?QluN3lo1a>P~M8*ync<Rev
zD1fUm#SITwfOuzEM_=MX5q!b56;}^Gan0_DUiZnwstzC53Phx6c#TC99y%zI99im)
zE`1NXXdK>e-2c3b2d)%LV9Y_}fGa#MAogjL?4K{R?%TICGh46RM9>}iXr1m%oSbe=
zb}Z$`T$1Oad1J~NsXJo4h^O<94u-XHeF9zH{M#0A`+ni^*xx(rY-l5MhCQz83crr#
z&m8y5+4_=*1`US2O)U#-hRuy1y)V&7b<jztmW8})IA8q@@0FH?lkQ`X=~xil#VU8=
zi19!s%O;!k0i-AS$54H;%%4>n@-9i+n-cHw0II?pIwjDG2MEm3MFWGlheO4e_aHqD
zCb+>Q5DY$!U*-J-4JkhsOZevH>1}|zkmY~mQOgYFN1sm=1uh$FIxlOMG^C`y2iIl0
zekjJc`8*^O4s-=DM~~J@Q_LI{XE<LJLRw_x^cd|}J=6(pn*?VE8SbU(q-JMUzq)vu
zJR)+>^d6Y~s=`%4WR;(sv}6{``Z;du=&oHZUp;*PXP_=7@PldM1SH|y-qM7ln0spM
z%wSnfrecm{`MLVH_>$0yhRzIl%fK)MXK1#E2OQy;pY>Vp+v?-Te71I3RcdRqm3`zS
z<Z2t*7G{qwBU}+}QPX*NfP6!aIM+;R*-plg!8>z}GEWY-nP2jQCrel?-nx|9rrAl8
z?b%+t6U@ni^oOv$MY-l^Ux`Tdw}Ta9<GO<PKPeFJi9PHSvP`@m)gYdZ7p(^L8^6AG
zOU{45W5MO9VC%&yKmYnqBa?^jDTP*Q@~RTBoxNF6GqEKIjmCl+=XjZ&va6peqpE4x
z`O$H)A!_c2gdNKW%JN>un@-F5<AN;R-dC%vOby+)aJO{2SvwXO8GMXacVFyFf7Xjl
zsVV^d`a%)jwQ2od@FBPGe+26j*}?zGU>&@7j^qDYnPkwT7rOnvLyZUQzwkh@`DI%E
z_e%tHMY9$U{0amkSyg`WWhQh*)&fkbjTf@dtW=x?7DKUqF50L0skI-$yjOt-qMY#n
z1qoKQoCkLpvua3(ae9`H^@+QBp|G?1OZH+yZ8Gh?j5Y=46>{fcxg~#>`KfQpdypAH
z?<G5*tvt5ju6)KKY2iP3wch&S$M(;B{Z)^Gc$s&1&1}%m_V!NBUcGglYI}d5W?h$P
zXHP>G5o&&L$G`_98Wbf)5h$E)A69m`h4H1&KH^{omV@KM!1*IgRJ3jI0LNX#`5UR@
zr8?J^6N-q$C}zvbIVR}yelPZ1tcMD20jGQLJ$~tq9W!o!o(AFAuW3-pPRYHSx5sid
zRrt7yV~Dxnx!V`j4r-d?td0!h-U^Ou??o}=G=y`Sm*qgzU_8GVLc0dul8dfun~Ci-
zIxu#V^DK=|h&D6+8nU0(n5OdjP|Y{k!sg2{!3Rgob72`@iLd!)^X}fAF4qqF>I5ur
zhR-3yJc&8pOz*fPPvl!VPzu1VQ-nZdMfbFyScaD`7*F0tYsP71l8IE3NT0D(QN7zK
zOiH=)%5W?Zt7M10JNB&xee#t>(s~ej)Sv&8HtkfNobGec<i2>PEx8wm%(#s)!z_D0
z_XqfOi9cnHlr#BKbWb9~8tPu+0U7JoP3N^?!P@~J6coP<Jdj$Kb6F2RY>ad}P|N4Z
zf63eD>DsS@u_&B;dpO{t(QUUR)j~8wL-GfC`?lntxrmDO@7M=1+VQP!HeT?`{#!{N
zKq{>t!6`#MYE00VwuJmcCMn7E?K*)ag>qOC4CeT~o9l5{{^60l*GrD$Ej)15CAbmQ
zVpK}VlgF?BC+^{oEUhjV?&8eNmk004k>~p@Igbv;^r3JR!%&i7ft6De^eyy^U9fQn
z0>MQk)=kt4oPb^$I|Ali5b|a56iXEP{pT`mf3t+A#s32EgMR_|i11%H=)=b6W$`1^
z4mbsv)8Fa$^zZb$R4^aC(eFeEcb$Q6you+RO+9T<?nwCIu(wppcQbj%11$R%{Y}hU
z=@W%G-OgP5RxWX^oVA4<=D%hHah}Wm6{V{aYa^f9hg~B0Cip7XF<}<n#|42_AI$_X
zZMjl*+o?#CbWX9kAmf1Hyx!PR_O0)YMK-5U&d8Du6QpU9aHmXCy`_LsvMg)RuVBTN
z7oW|a9Kek>oDO{n&-8iZQ1V!j*S?!m#z+w28*P2U<|7_r^J6y#zL&{NYhw;#aMdxZ
z<`UYLmK5E!+TrrKh%fQy*Ui-p!Q2%I-4i(|76@#4v-+g+)s#S3jrgNgsBY7h--QZ~
z<L{RD6_dLMAl1fqr(Sk5eSUD!xh5NIhNdp2I_^%OrXOQ!Ai8)Yds#<J1o`w{^h_W6
za|7f7T6a*hAMZY#TM2L)tbbq5EKe<i@v%3ots)J1;AY26E;~UJ=HirZFva$*la{PB
z^=R9O#k-@&L28h3b;tNU)c<?P@NQ1HP1zzPk_ZU0e@gRA9?HL)L!TJ(nQzlBHby*4
z?_<WBsgjNXZTS$#bG^>y9}AFcWxp6T7p<md8^`6}wk}Fd#!T905+r<Hh*RT&<k)#j
zp%QROOT8K&MYxi0oURC~t=@o(=`!d4*<5*AAM^SXvCfMk)u);!AIK5!a-0IP=4zI!
zg9g)ad|R~hm?9^p*~l9)3z|-ej$}o8(3*N&!Zh{?s=VmSU|zG>RS)UN!#Hh|c#|6g
z*qHBLNN$99ijY?g(=kldw(G#;cZJL{9zdEFHw!5h)+wJ9%=5HaIZj7HHqGEfbfz;Z
z4zxUJ0secMUc7<6YzhfZR(TRQo-IpS)Kwbxcdw3r?K(|-lU7&5;oy_>e`tC&B*B8z
zwMKl68$~lkgHzG?FZ^4q{#Pn-`VFQQXZZPjqeG*T|5<XW2Z(b2l}nA6lg`WVKoKDx
zcqCzc;`0|+KE$=q!8d;7=cDz51iiKVMOM@A=Ku0|Lc%=w-X^otsZ)W;xZCNw$*m-Z
zgxjzWKK=L3`pXRx@W3|GVR1fGMmf+<@P6r>YAG8+Vhk}vUI`5->yGJ{=-J(n1ew?C
z>UUg(ZP!I0+QW5H6BF<H>kq3@(l@E8oLCzE+&nbDH2MT_dzgHrj}rc}9VjtJV%Gyd
zF|ylly%avw^15SPOS&D<jD((3IZNLzuwbxu@~@!viJLKk_o~n&oG(|7)JpxnW?jT|
zrk5DA&@ZX}D|~>=+9ig+XjQ{yFylBM5By=AKb(N~!Gj&ug-Uat)PoR;11uQ9^;;yY
z%4--4`B2J1ax5{^3Q3~tfCd3j@?sAw;<1z*rK2-1J*jYxVJ`7w>0XPKnwS|$^9Hf=
zH^1aG7GdnJdR|fCGu}PGCRhm|i~e9d$LHNr?&1M|8dSCdYuQ}kx>l{v4S4Ve6^dsf
z4?Y)Xt|ZM<?k*_U74GR?J>b#C)xSTFn;oQgI}~+4JyVrlX7dx+lr5&7nlaWO)VOPS
zb)-4O@l1~hgfGt0Wo@JV?OPpDweMfgP>Uk%q3XN2WbN->*v7EJNw(j9)1l8Xu<yxt
zI@dQv6)R5^)ahD@AM_+P)=>w?NGlUo7JAM$L^u#v1&H0!y+O1L?TLb_RF=8KG2gZo
z1#4)`5q-5)zw47Iva74|?}B?im4AEKJn)YBCUsr%wz3_EHX7taM-xeyV`pqTD+C6i
zzno5mnZHD*NaI}gjrIe?ci*VaZ7r>O*DWab$SnUk*M&hsWi<2mLY7eXj{3skITqcu
zLbd5`3l7BGo~fSES$CpkpVv~?s!840J}!P;F)iH9^aXveRJvcsYwa6bINm?)VI87p
z68nb($}&+>8a+U|5Ik*b@YJ}N;qLc+$7;j3CZV~WhT7^+cK21awkF!rN&Z#B{fl7(
zqv_G>zZf?2G7)UFtN97_Uksau8BC8riT>$-@*t`A9Yh@5o`e4Z=|m77Z=L(peaI3k
z_NJ~E=z&_#pIvu=Z-WFYcxt;w|2zwKdX!Bx|FRMfq{H*FFNhnlhmf!N&?rb0p!e_J
zvUV8pz+s>7n}X%JNUtGchhNipVDQ#ivO+5f_5i$E{OMJyrfD(%juF^^c$A8M?dWp)
za+@Ywq$E8V(`JIi#wlWZ?Y!Lm3CmH1Al=j?PpH(h=h9fm7hLrnWt-J<>TVWQwC#AH
z?Zw-gsfTO5OKM!(jRK@igBJ-sF)VX2vl5?g{qo&$Z#wrkX^g;{`{XIs*s62JaCtll
zv9GfZ)RetmJ!|S-U|icF_h#-@bh?Qx*%2PlH)hcpFBcF`r@7(r6-Xs@=Y}I?&JIpG
z&LD1+Y4T$IF!$%}ZoZIuUGHwfPb~L0NPf_t#Zwz{O*=eqV?=dzFNM5$s>=FmB?d!m
zI%KSe8}%1Ho-gkVFk&PnlakuVKp*F76FF_{d$6oNv7PacZ5K{hh1(f>Xt3-)il5(0
z9?)ui;?P!acA-36xIVgmSA(Z1DwPi^JR#M3MOOc_304KI{iRt#S(lA)RRuI3nT@qN
zlaqk$IyasZ>IYTZ^;fQ~B#&e7d}KGmDxuAL=BL(i*uNgsc$l2aa!UHk`l=*c^;8y|
z`$q!{=BYd4S?pda1<W+(@-UU)Ouxo((^c<%*sfh>Fv;mtLQJg5$X6t}T<1s4Wo`CW
zT*caf#IctI80;VXu*5_xWyhb^<nQiLf@~6+VQ*yep(I@^eZ)o=>lu;+t<sW6^2lpj
zLn@;xEWo>@k}LONyNpv^9KXA-LB)r8RJwZ<9$4d>hHnSKv6`Oxt@T=``Y4b>cezuy
z8MG?7Kz&zqh+wWxW<qm_>pT)!>J9S0v0%2{Ud01(NFUXFHVUWy#<%8YY&-uQAP0k2
z{Y6Zn|0bqjpT_<tK**;c#XWzH2jG_s44!)lIFLH7zZB?d{6Alw#OHTvf6P9h{#GIk
z64z7JYAzb4y<=oA5bJtnmrhT{MNcTUJqAyoJ<wi#z#{(qZ3d;l;PIi4QC(#Vi{?&^
zW<&4SM5tuKoI9Iy@v}ORH<cXEU+*=)J~zozWsobXa{Dq+?f}}7;z~PxhEky%HZd{b
zjwXdjWABNXd_^4~XpOe6_ww|KX1<a+j3aq&Qqj0XkutgRiv7m&sZ|Ul*uh%@S<I?y
zZ2Vn8<5tHG$}zd+!>Q)moPi=2x2ZXVjO15V&dvkx9%|UYULofgR_*POO7J1!eHGn7
zqkXKlb7F<m+eY^h`+)&jq`(gttMHVn?O06|LWC8n-jT59iga}REw4EL!mw=9R_|I>
zSf1`tbH0)D6`E_UAstQ!@Fsz7A*_be6^}w@`+2x@XCYY7(|BvR{B-|0!umy*Ap+Z6
zV?p!Kl&N~nFe@7~c<BCa8rKjCc6%3p?It<mc;v!QwIksNBF1p!2<T>1CeYS;mbRjD
zM@RY(YPTYRh4)pmC77ieqsu9NM4KCwy3BkBL2;H?^bHofW)%%IEg$q7SD?i-d?$vr
zVNRTguR3Ad)44_+6V7QLL`daxBAb^*tuv|oq?iYx32(fGP~&^OdHXC&bN3J0UasD2
ziqoR`uJpkOm-{UxP#)SR@Xkv9bDTgR+P+St%&Y5}0faDtB)w667%eeSm6$Y<sGdaI
zmO?obLgXJiUs5bLRwv678WeP@_;!ysUT8ZKfh(7BJpJ@@aOMqFo!N^!9J@0F>Ek;H
zGAUFk2t|7F08cS%1!c+i17rU<&*T&HAjE+H^wPWW!04D?;GtM|L|u%;WhVS@wCnvh
z+64(=CXf(@UXXyH>MugL==#fV;e5b<?x0Zz{(H3=9$xRJfd`(=8y(P0ZZ<B()|)RG
zuR&8C@j$TWNdhi2wEiah&#h}VuFvL7t5ma?xs%cJjP4U6*P4b?k}CWuUP-W3X3FW?
zp#zwCP@kg_F6;&eux8149Qy{LktX9x>ss66d?XO?!868;pF8H+i2bv-Bkpt8tFDPf
zI>qnmiBqsY*NroVDK5TXU-hz{M~0u!P`SI#tB*`j1mEjhILkqGl2l5h{#0U7PO*Z7
z!fClDin2yscpgfV*ak)})!!0m5pu2=#tAmtk?%$!`ZTjJ>U40UQ<n|?Ea6uyZ(IJo
z_?w+y;QrKC1}yg-xZQV*CRsH*_P{kb<m-RIFsU<6{C;Ogv)77k)CwAn{}orA07sqo
z9O~Ez^SDH%J$w>ltN$>|oltAE=w@A{xUWu&e|(kmir!lMTM3~ja;crn-RuONoMm-7
z`S%0K`#23Vx%r;nQ*zQ$9$PLPfOni*m7_%;<g<P3mX_w?!0M+NzI{I3?P$B$7RQz-
zkgn{hpVeL9Q!n?2Q;p$;*d9B{MD^fxCC_~7A3>yVT4-K*oR77r)>M{s!Z_H+oj1}A
zGGW1N`&zEiSjzF3;G)~;lk~p3`u$zd<L>;D(Oj`<Vqq<1^2%KJNQt*(Zcb?1<vk6n
z%dsWRMjh6}bG@$B`hm)22sUD3{`d%bbhTJ`bpOrhp5D^cR)PST5RwvX{+KVA5W8ya
z5NGEQFfGTef=vM$GbVYp;%5kv(y{J}^w3}KvTfaY21IqV)6$<>GFAlGsHOLunu<Od
zi`#^)@TE7ssVb(zXc@<lm>O)!W>h6V=eDBZcRcu{0&<2+5PEmh_J;D;Q^DWR>yI;j
zN2mHJ!}$-ka(rlvKBvUgxpj8^IqCT=nLIB^WG#Qjus(l%|7NtRbFXD}($$BlyUS9A
z^4d%6H8yJ+FvG>KNg)Y$2{yOQ9Nb(_E9p$MZ`oMMeu+0)Ty%3{Q&O^j@mRj0d<Q~`
z2Uhgp=V$Ph^5qRBFOnARGX?~%!Te0fZOkn=MgdB@Hvcbd3_qdKzGN2iDD;Hx65ift
znHD*<wS-`>q36g{ecE3-O7y^g@F3VWFP$i%m#m475!i(V8!izY3w&DM4xkxgIqer*
zy1I^O%<;C&oinjH{WWK(K4j9=Jfb8QATU?Qgf>?l-^~g&OqRcgp@e?<6Y^+_Y{7?S
z?JeOj*5X~#9Hh4Ly~0b;<9_$`;5vHr=7H(E`zv+N?kn%aWuRj$&59l1Hm<dWMRsc>
zbss_oSKf8F!H<6$vA9ZW(sT_Sp@qJG!2_FIj<gFE5BB3^-V~Xen?CZnD)hP!bMc#v
zx0<=#;gi%-c=yPYVcoYY1xK3>3Y^pPvyVBA4ZOek7zDH)No=ZbZwZhmNqmcnoUYn#
zc$2iYrRj8k0;H18Um2-gj8T;N)jJ{C1+tC@JxL*6n4j526pucYSL1prUE{s(*j~w4
zCy7~qfmN?ePAg!HWsIF!eaKB66p6@jd*CK-qhi!PT%G;yL#jk!!HMUqX-!y3q=g!}
zG*>a_*Ssvv1=`g->yRhu(8(f{pJ(_TezvSMGb_t3Zv`{MAi?M=xmDHWMv1Y_saI-C
z#uOu&jMMH9BVCk9&X6#rci&!ntaqAA;%FnFw@f3<L}mvZOD+Z4aD!frZV8UHND|J5
zVxsr}0>Weg*ybx+_n6=Y9vF)=%;D#hiP_^ivisgW&_b8cB?W&srv1WwhR&x$9133~
zHeTr6`~LNJKKEZ8ljZsA!qrTFj#8wt2`?{_<=A4h$~(`P;D<f%F620-yOSQlf4N-o
zQ(>!wF6sVyPpnT3*Z|j+=J+B3ww6dtdKd2v6y)xTBv?fEn#$wKzZ-B#;Id%$Svb$W
zd~CmmN?S|>tu{<JVKMZ>?<;Y02?Cw({SF5eJ5k5^Yt@WW#o?Y~GV4+Mdv;&s>s~)(
zjSjlm%=M>2^`uBIzEDWDC7dtg%0J_uXYh{?{Qu+w+YKBTuLnqlSv){Sop*^?IrG)t
zUykV;*qwK0TPDmcbfZD#w+Otd>@S=Z%6b_Q=tvs5vf%xv)7%q4Cksrt6o;g<R-)=p
z3Ujt9_3i8^YGgF8cc`*cGaar~?+4vC;>cMd6OyQX=qMP=SU%Hfzq;yg78Khxn3+M%
z5x(i*eMh1)h9p#)QzPNA@7jH7Dhy%#k;IVqyU`;}{__r`T1m*nn(CC=l%Rj);??2K
zr(SRT<hH^$ya~T;o}V-bO28`1gWB3;YBGgM0V{vD^&C(6{T4Xcq}_#mxr;-itXyx{
zbE)mf9|K|!I7E~@Ps0?L++pg&!VY+#T(~odu<o|uHwvyD!Ji5`smmGC5-P0-((Jbr
zhiyrlcJ^6)qHU9Q^}g0}A`Rf*n=5%T7B3D`ZR5m$4`aF9Z|X-D3|y;I*Ht6d`q1V-
zXn(eC3_)eTo|{KM<xPsFnbcA{cfgeqtd!~Qx@p=$3~EQy9|{<$4>J)mcY5ox{99C>
zT^V5fbvc0Oo`wLC61(BYCP*5fqU7vZ>@TO0ZF695z8S?{XE29zwu?-qrjH*x*Ovy>
zrWj6-HPu(F>B{6;WAWiz@I^yRBhGIf2PzN1@24cZN-lONWc$`VXICsQs7DAdkT-uk
zc4VU`|E$I9*}QXC(A9H}P?R`<;{R@O-9bG*?EBOvDHqA0lE+IA^awbaqI~N!3?u5z
znhOgj+bpnc4qpNs{j^`gsQ<m~rdSiCIa;_1HWH1(Ca|$?bls&pwH4MCZjrbb1Zyw!
zi{LHMcpxtfz5w=oZL@InZkJCU;lWMPz=ajy!OpOaKxM^TQvR<mK~PzZTdyD(5<D=?
zN7%KIC(L=xq?d7b&NyLqJ1~3{<r{NZzXW3!Ongxlzizd4jj}=>MFqUpF*R>1rrN|Y
zAh|}5wj;ha2dU#+$rROq*93p8b6m{WhMdEEX-(gqrz41v93}@U+<|K(vh>zP_xK2V
zeiRm8g};KgJOmws4DzKydL80iX*U<K9kXic)&>uSOqQ@)w@xB7xxCtP9Y1Qz`r~*m
zRjO71kNUs#1Po*FmO8ZcCBYj!&=8M><zSo^*p(r)9_d`eDu04R5K>%x_M#oy;(tAl
zOw4){OI!M#20MyJ)46Hs+6g84d%`=EF-!d)k_Uq&`l*NQ%QY2@-3{9;J`yqBOnvV|
zkU{Aw@Ll@~%x=*fqbirc*u?awlg{HMyr468d!E7H(#px_z0i)`YSmYNPN`3&Y%U8=
ziRkqPv7BaHpqB1x4j%9u#4!j}279Z}qkHB!#<&e;=wj?{-yj@Xu)gYd_igc8^m>5c
zF@$8=e1k>I(5$sWuR>KdHld{YhKryKj)Wc72VbN`LoR`G5iBtrl|gAF0K?HjXhB&j
z#WPR=s1IsLdh5%oN~&S7E}qIXV3zHNZW0&Q&5Nf*;`-mbrBT+QSe;B$p^i+>t@);p
z&6R{%c2I8)T$+>|QnC;uW;h~&Ir{kW@J*Fn#a>|$;&R0OJaEKM`dk2Hhk|XEKxHza
zBuLzX&KyzvV7QL>q%rjLzD)E-;^;EkIOzsuH;Y3qdyu(zK9C(E`8aH9jTI2N0Ux>v
zY7RFVF+aP|Bq8N+YH@*rDW5NcRk;I&sh09&$MggVO3uE7!_H9-ddc%<W7G)SPf3Q}
zD={L~4@`b>W%9DS7e5YN)DFu14Xbjg{VMdF=eyw|pD0q0i4d%7J4nR!e>bCwTl5np
zuW#1O&Q5;RGNSmB_K;9Y>Jhk)2*;+BZR-AeV$>{fAi(MO-9E*S+A{+(k?5G`57@>T
zCa`L#&J*6q?9$(%*UVlSzt&x*bS(2>y-D*#Ukz>fXb3C2Sjay&)kB+?s{H2Zi(g7-
zlYR?vsw?5Z!4_YJO9q+kZgyR@hC7pU^m}5@q+o>`?M~#~Zsiw=@q6n-)W?0^qGi!`
zdLF5-+x%$S@W65YG-ti)H-n+Y7ca>-a%f!FCDgVpX>bho@pwQB4`8VIz^84TjR!^>
zafIO;3iJCa)0f-!&xM^3|NR7XQEwA^v=92#QVq>6?Y7EE-1+dUBB$TpLL;u;2x~B-
zn24SuNtQ)I<2J2UOHB(ScLsDjFL)>Fy)HE7@?h6<W>dH#mt&8!m*1~zyz!oTNJ8}C
zj(~Psi6G1Ij;iQK8c+vi)K?@~J&^_i!R))={@-&gghO&Ps9Cw^nNdo|dgYc}Dy3cX
zscsi7_252#BU20q4VBQ@M@~|(+btklk$O23-Drd^CUh6x?ts`{u#esKiGQ;%&f&J#
zA&T4e1cftotWJgQ)|$i4(^Z)obScTY(7TWMWvnOs1UD5ZVzf}2$PnDz2u09mpRC>{
zR<P>m-aIanY^_uvLgg9TsU?)B$*dV9JJP3o)PI>98LiLeWE`=$Stp9h)f*MI4!0q?
z-en|l^Mj0&nbU$pXep-gN%D!%Lm?uu8?JIzrNLCG0rGDNCkjY{zJc<eppH2n+Fe)4
zqTk|Qx|J7yPY$SPk5m<NU;>*wClGK)+d0=_!3RnLkNBi-5dHuhO$&>IxI-5wQKe>g
zoLG6M$Q|QW8}@wA6Lt9=^Hl4oim1z++c^w9XAz9;VR_Ai^4dAT2N`W_upN9GYyxj6
z*5@vr29?9<26HuXl-SZ0ySV3Xn!GNOxfEzGi#a1Vf+JnP;1KM^)B&g4Iwv}Rx5-p&
zx0W4=(UrbgBopHa<fFgM?s`*YP7eU?R?+u6pM-@;KsyXy*NkE%h>CEgearp2wpSND
z{g0)Nekk12I#nPZ%1x-$;OgXJuj;+=k(Y4pJEk0$)$$b&ApEg$e%zt0M&=<n-i@c5
z*S;jeJSLkz%r~hxsePN#2782!dJ%*1y%*AFl4*6^KKYg=Any+5^Yh~>@HRCq-kKkn
z9y^>bz>i2b2>Wrj;9dKLaO5Z`vuQ5e4>LcI-8Mf4n<@kK8jGzMB{^cq6dowmt&p51
zx^PSE9@ty4%-!q<+<h1%_G3@-qB1NT)+7^Zi)PU0FT??TM-)s6H;#68yC-b%>$&vN
z{4fcU7aIKjcn?k{Xn{KQ+mnbGpF$E8nWQ%uU7`04iYWwK?A$DtbP6{f2TUv&_u~P=
zCjknnF+YlvMRs|9HB^;Vnf{*c8kRaGxmt?|n&XOtLi!w7dG&=M>2e*ipK%_9ms<*w
z8_QZ~#rck^h^LW_?2<)<zA4(v57^AWD0(Xea=s721qp0GKH|9QQN^KI4WmJtTr&l{
z{m+!|mu!%(`<p9lAP#PnfGu(Kzoxu$`SY{hg$+i&?AV5>P_PR$$(sW>-a*H-{lo)u
zMqVPB!J!A9M-G%*=hkfwlqNjK$$5hbj%4eWmLbn$+Bh<hez(8+Z~=*u!kyp3z93f3
z7Ew;E$aIcj;UWoxsVR+4y@Qmf9~ldXCoAZ)A(HUzbC?aw_+IL6b>W-0rCS6GIIiRf
ztx*RTX>6Lzh*zHHZZO3)d2sumntA*DHC_!yz<f60;~!^}Wk(J_N@Rh1pwS5K2F7z@
z^hp_=i3Z{hS;v8Bjf%Xs!^&L}fJ5GEk>=W;rcu+kr?G8WJlNk4I53--2_DbfP~5$_
z`x&v@iF&>7_5*pUtll>7hwyS8i0?=FUN0|?7P+?R7<64qBPh~4Ct4NWnOohwoeUg&
zR(8|X?5|qjKTs>&kYiXfT&7d`HfP5L6}Qq}aWvI$Db#QAg;b<Gov<I5P<~Ys=)iTR
z3a!yqB}!dc&s~0Qj<p##JC2G@d6Srd4Y2E5@%q&Clq7A7#bxiSWc-gQO_<0jk7D+v
z*hJblkd=GWiL31dHLc{Q`8EX&JQ(J5m{qhgwV&i|=1|4l1L&hbGqNlZtX6@_r5rCV
zh>vip0gP^4U+usy$S^pgbo#;iHCRyp5PNSL*O&z^1ny$;zl)6m6}Sf-zml5_C+g?#
zPbAyV-qv_+P1S!#TrY5N;csKFxg+223Blem)y4%>z)yRhUOf%n<AoAhf9~f^7TQy=
zTX&oHy@Yi%mKDR-57u$GN(^$y(=BMd9OK3tVz$R6{;L;~PQTlm$Q50`9RMa5p*;AI
z5fX=a2aIEg9p&3t2B&U&sFwi_uN*(&%2%gCa(pf`9dTcw=SVz|7`5fIJ*&X%es8%&
zbUtT%M*sFkhe{&pbfufgB`mrYBle@;MKDXZ?CD<Ly{I8@YU);24zzFAi!E?`;YB)>
z-(MB7p#6adYzB|W;WEouo5hdVJNdT}PLAxYbpm(Yn+b_xqkR)pG$+b6g(Wp5b!y7=
zSA*z&U-8kR0z45BIA&PGEi}X0cZVGvYm3!<v6Y(u@V;t8;5)L8%gqUOGTmzAjOygJ
zVd>`f3%1K<<O0$S-qcMmcH}I{!`mnH4z@ibD~1p<3lgKBbi8QOgBE-xrm*Uz=!(pI
z#RevgF9ok+l0r5)=T;6sna}|M<;4(*0En{8jX_A4n1%;@)c)$3nl3s}ySF|Vws-D2
zrn<i*NwTwh$LYjrp3s5o4;s;?54j9PYva7$nPWt?al-jqM)0=!do8f(>3VemcYUYE
zlkilUj1O>ipdDQqD1zlZ(H|2QTD#EkN!N0pj$FS9_xxqMvoGu>kye0YB^^v)_J(+q
zC%u?(kvCA5kiAG56u2d~sj)L47MYG=7{btWI$;zjsuoK$ipyn689#l$OS&V!LFj;E
zB#CKU?`}j9<Y!}CmKy1|aGV$SE8jgscDc=;=*3WqM#ETfOuF-z1g}6i8TglJ&lejR
z+>6_U<CGSw?Ce-^#)D$~vAC`dW7Lh)3`#gFrm=$s9$r*X=EWE{A$B7y;(ole5-*X<
zO7irOcs;C5##x_3o^jiOK43{eBEn{dpjB-*z}I|mq`XddnH|!CCd@MtOnPk3h;ric
zWj<4>hNiuz^R}&eb6cKT!mPPS4VpgufWep7Jzf`08Tw>Ie0pqT$zILBxr!^3i%ld0
ztNl_6PO**TV41KSD|{8L_Kh-=dtm;{HBZ`YGk-AUR2<^`-s6D<P>Mi)NGi16P-|dk
z;qm<|Dz+o%>&G1+g9fa6g2#)%bqCeLf&eSLs8|OL{g)#5d%a`MW*#$h;`KT;IyT~0
zlAh^lDjb+B5DDltu=~Mq0`7VSB+0klT$K`?jZt=ZAVo5^d;`jOTnN(-n0jvMXq8bG
z+I6T8(`xcLHOu14kpJ!LM-BeF;Uf5uOzQz0$6s?{eho9R-I7;iY*S-f+i_g+U`;vZ
zqLnHDKDmuSn^E?u6{}z@e_&FSMiDxtzmjx@f`T+j9lokE3;P{*dcXHN_ai|>p8t83
ztM!Y>Gau}m>$YN&43f-{!V<DyM(zlcC#oKnSv**lmd_vec3J49xv{CS1SJ=DaN_ic
zE{P<&{2&WGl;iLyW{wl1FNnLNtoV@leUA?nU}v~#c5~ziBd2LY+{f612Wo4~7rCa3
zXr9Cdj#Sn?L_=SUXN(fPe`qKFIlwg@*#G?c^%bcbyO#p6#p1S?u}YclpE`L`Xl@I9
zlqQ$4h3oFdk2bPP!^6(aVzS-y7DjRp3r`)A8NfgysLjXP2uXVMfWseE+vdxMzMm;H
zk>kj+nfUWjWgL@NY)b%%ePdGLOHA!jL;hv8oEb+t-wvlN?Ic5Fwu^1-P<r|}NGZ2y
zEKmpmZ%ekw*dtWR+JPiN8k66VE2rzpO)~o}+t;WnKG}cud1*a(iM4pZ@_vg$qz?7O
z^CY%#dVYqjo9DL?FU711v!HCG({zP*aoZgKc-<4bfkK%+yFj8g3&&LJj1z`UBe!-0
z&E$-dP43$$D=Y2{Sz^_;m+0D8fvIlmIgX8twq;)0bY(R>WA`FHy-vSTqj<KX!gk!W
z;k3m^Fi+!6+8|s}mv(%+^g{NhWzT$S<ob_dgHdlLM#Mry3{~NURH|A^jKGZ<cx~-D
zGR$3|l}SNxoaa|rRru`4bpi401;3uE<;$&;l)<YrlC5ENqSkKYT~|WC1eRehrf;mr
zKVX!jS!hFjPw{wH*@3p7=BX=8Q801t?st?i1rZv=%_RpDr(4rlS!KwT+I&-%(((7@
z$b;7Fb2Wok+!fYaWNzmW&yKlKDZJ)*dJ|w`-|qG%UdWR(I}H#RE5G2(lO3wqovtU{
z3<pj$MZI~Jc;VNLS}L_|Zrxtfxh0xFP^EW7MC*T41Z%_bV|<F*xslPr_7jZJOfZiS
zYO)&()Zc5guVNInsWGokl@n1<klI`yb?!2G5^rcrb$B9^F-eQM1HqXyTQNV|?@jYL
z-3SW!@L(I^2^{v27~N4Z0(Ki1Ax9~V7@Ff^jd?RmRNK<pK92AbHtcqR^x@r0WzerP
zI;1Hy9<f~;+s`TwN|^0!JbmFJk<>U>Poh{B(aJ(ui3~g)s9ib616IV+g9$cOc`f_T
zjkrg5_c%wh0>o}cxZWoW-i(9Ap{ELr3dmT3Ika5;{gG2?3;B~0G}ldLpEz-Uiqp2}
zYT_7YYIB<|1cM8>`)h21emvLGrnX}Z_;em_TYSLrj)1qEt3gG5M_QX5?S_p^YTS=m
z5#T;9goARXu2v5m3a9v6pf{;)P#HoFZf%OS`2RrqMPiK#?>Kylwxu8%Rk9&qV&X7P
zAQG9O+D=?1sep~ixh-76+B_pAS$yjz?xQ<b&nW8krMqoIRuCB*0-rHHOFod+IqG2B
zCLgoCU5iA?Ev=oa$A7M&_haWJcsuhiYK`l8?Ch<BjilAc?wA}jg!o-Iz&I_D%0XRE
z6@;p)qGvfC*>^l*{qam&ufxk33mYgX@P5Qz1rxB-w1}sq6zw8hd9QqxTE+8dKLqJC
z>n(z&Fd5|Dq3XJ-BKY7yKN?1&f~ob%*>p{$wMpEo7|MPa8A(Q-@fzf^keleO)`gO&
z5!5@g$EnwFZs%*e$UR)biklt>cQPZBUQIqo4$&zI@OAns3(V|b%?0rQHGGi|rgS|l
zE%MgD(Bohgd9OEh=cmg&m*bx&*3~Pn7)+AUNiyHapphTx#A@0>w`<^FX@v)tNTNAW
zpC=qOa?97JbO+CyQXFF}Q`hQ@n;IZBXr?fW%F;yAWSXPUdnFM5UjuikwdDn-<vbRJ
zMB1KDnr<ft8X6l3TzT~K>Hv+PJG(p|Ap+A-3iD+hVjQ?{<4~j%Cp5GA>5~}dxG1Sz
zfsW&*551<l(86dA^@8w|&{cpEbx+02H$i`iqtIdz<iw`?i8KVmb(~M1a+5Y$89U0~
zl?jYbUaX^l7rW1Q=$*2pjs2edBRR#+wEEG&XNcZ0?a%fAK?ZfN@n?9;4C=^dq{kH+
z=6ET<qzIN>`}uGrA&6pBG$WpCYA^RG-ZPU`T`8y9E2(zq{>V^w8<iNfH2d7RZfu0=
zNj&AS#$74a7pqUHW`X0A3>r2JD2n20C<igDHg@|;S)IlY;ru0bMV!PPhQ3`+0hcLl
z=2I}IwwRM=Okl;RbKHKYQMLClMP0iRF6LibeJsW4C)X(cqSAFA<|0UECqy5`%>UsY
zwbYLvS0<t?Zx{YFGB6H!T@`D|F)1}T<WihnK2KGYx2QZMWFHmD!xbhK<M^j)nVH=&
z{Giz16FM#T(DA3bU#A5l{mI-J;eiS6RR(6bsMlj@zr=Wuv-M?w9M>nwbOW&D!aOC>
zutM3`I^3)dY@;K)8T(rAf^X5k3kNlt!*qU&dfr^B_3>)~n+dOF+56VbvUrTXe@ZRl
zY+v&71UB73u@z{D3hqepoO7CzRc?+}i)!YAVo>Mg02+ixkM5fv&p|Iq^@r1?(TW%i
z)rhBFVy@h27Js-WBl9_`ptHq<RU<3Ia<I#<eB9G!KSSh^@2B9jfoA3Cbx@IIevXR)
zwQzBMG-O!aQsi-$bNA8VYkMgbo7NEDOvf^p-TihQ%<2!AE2HbM(UX!*x0mgAbX$|Q
z%Tq40oe7zn2N{-iG<oV<Gzo3vB&j210;nG{9PxZkY^23OKBxYObH`Sb<AGjgWaE0^
zkyHkaAV&PBH~h7E*|Xn1u8_^-qsB1arq1Vn?)3(<f;T%W2Rm9iFH&6w>)qEPJe(FG
zjLnXYtRBhUtGtme7CpZpPc=RFW9md8(MMkL+KSb|xlv@1iDy=ix}SMn^Ymm3+#&F<
zUBCmUAYcajmK_C{i;f0{F)Xc1wvB$y3I$y=ZHSIvQSSb|b87ID3d9znANTA7%$lhp
zrO(#lbbT5hWXGSs043UT0*l4uh7XB@kk7W_ueqw-y!F)O6~L}dh%i?Nv_rvt&(m#*
z&?(QHR-?_8PXTfcNo;gv3xN9omA%?`Z@$r)PA7N!@b~JyV(aM0S2fy%H@qLB3dJwf
z^zQif^JE86TYexNT>j)6QisGb=tn3_ulPhmM5GQIhEhbgk#3uacfbkcN@FNOk)$PD
zue0AauyG%as2_ZyKQN_@4cYliL<l{)Wv=ATq+U97MEl)vCZe(;A#q7(sOP<bFEioU
zVe%OgtQJ1aA}+miaUpz!leqt(4ji7p?k(Z96hot8kz03%-=tvjYj{+qfh$QmtgmrV
z3zLNN+H5>MYs4f2hg$+AXr@*>ht~7Q=V?b3nnbK_q&cr<ewh*IY@4_MYIfokhuK5w
z!)mNoih}a*us5?)z5NR!6~l*|bU=7t4ej{7oq?hWd4q<A-KzLA|N3K4(mmG~gHO)W
z0}po}aO8sP`9cjNYbTymc?I|O<`qjWkCd;0w5jV-;D;xHsF_T-5f4192envN5Lnod
zg6y_qS)vg`Ddhw2&44448xJv8I?)WP;sm?qS6nnM6{##Qluy?7dqiyyzgtg#I_psD
zcrVcBfYm6BQe1p)IMz7PKr*#*tZ=+xUb=st2D{vVe@<96LSTc6pxYp_6?;HcUtimh
z)K_1dyk=rYB_2FLVjJhamXT95zi1th(&iaDT~7Mdxz?Ka0E(2t5$tZCxh)WuV=Qu-
z7a_zZm<U}~?ka65Jm9XZuodIVt8m7Uv#hCaR*l-Ns9&f(7@|Mq2~vz!hr7SN9y=6+
zDw17>f}e!3>J9zgRcL2>mX?&&CBr-9c6$B{OJ9$slq@7JOqtm@sN84987$fF6nG+Z
z*?nq;uIeSBNji<nv3mEJmS7*F8Hfwazn-}hR_~f3+oP<?%n93bW@icqvb^(IyZ!E6
zrKkW)OO!&xIMVPf%bNrjH+c5uuTGEm)VTY5@{aRwd5cJ@``saJ+8EV0$n0vgL_y++
zs%wW#=Pzeni)O+<$18^q*!o?;Mc~bo?VcdQGhTj22-oqV?oRoKP)sG;=?yu@PC4Xt
zCBTPdVOOjPwMA#-?qOFfyo>ZwcM{+mxW~5QawHL7fHkcgDTnpTZ5(vj-FA2T*fd)f
zn`(Db<aGiE`H4`l$xsYJoy_p*iH4gPqh7=MvTD>mLZWV;wR`2U+b{0x@q@e*etg|%
zxVoFL_g&_cL?Qk-?aM>s24eJOOqk2Ch0Qk#W|sSK2~%yYd1sdbD8|s227JdC@cA&9
zThrV<6t23+CqiSWKdSZd4iBwz9d(w#AlS1pXXH}F-FydQAu^wR$=3v_)@rG~<b7H_
z;&MZzfaf6B|1=+dSLMA5k*B^2+6|}9Sa=Kug~vG`uK3AlGrJ@8&`+{<qgISEdyJJk
zUm>1fF7Lr9^|Rft8<wE=gL(cJ_TDops&4HTECeY)B!lEaf*?_n<Rp?rl9Dr$Daomb
zMGz1qNK_FClCzR?k)!0KWC|pQDq@l9?d^Ncxwr56bw`hLyZamC`{55aHLCVld#$zS
zn$Mi`K`k{7ue*gd)c@E)_{ayT(B1f_qb(3el}lTo$|tCMUBkgaPnKU~8i_a{@6YJd
ze*6p6)LM<5rQLJDl_iZ#pNG|KO+I}=EwywAX+AnW4?UInP!ZHvF@*GKbX;}4tGFsd
zwU?$E);9UW-FE<ce4O<<6WP3h=8qB0+Vh#_OS`I(Y8)-_cL8ExB+e??(4$>^K1(}m
zI@Mol->$zpfCGUc2Z$a_@RJaULp;p94k|X8Bim?y^W{eyPKQ9ZH70@^73MdVJNK%0
z#HyFf>OV>EnJv=}$aa2(%{_j|DkPa9^sNK`lRTwy2geVzi2{Qf@9^)hl|G!enn~Zb
z5!9pNT2m5tG^9TO!N?MLIB9r31GIR)J5Glka->Wu-5Mo78tcD7?#s|Wc_eo~dCy(9
zjnzqvnGd~Y?AZPzv7e7GWJ^^}@RDX!HU(#V_whI5K;mlIr|KeK*$|eC$7;=$<|#ua
z>aG~=W34lXmc!5IpYabdm_GAX?&aRboQXi5Tv#yvRaqgVr;2?}_>}Xcs2sk&TmU##
z;M+<drPVtoM!|QXVt1V>Roj9Yvw0uo(#k*w<=NL~D`1>h)q=*qK(3HWP{lJj@Vq)|
zPK)xU!0>=IB_}E@R=Pcxi9q@?9rOdGndMi4NgL_yHTo*lk2gx0%F5z#!S*v4R_TU5
zkMwpW=c{r|@0d)xW%Qng*-D1cQbn_iX;gGmj#yeD2LtVD>doce)O|tCX1Ady=WQ@A
z!8s3}Xwr(kj6=fI)iRg-_}0^H?T#`kbvYTCQ*el`1<`_aNu21o_PZhX?><yMT|6dT
zhYpp!7Oh#hv~A1QiDrIHaAkrQpIa$Wsfi&B^7VaC#eY!HK*Z9XIs`C;Mw9HbG649C
zJ`ZM?e5oF#RsZRJB5H4)vhn8$1UL)H(yEkjhMX!POs1QKHGW5jN6Sq=SZv&^eC}Jx
zk=EBkscfA#Z<xqXQseO+ev4-TphGWO6juX=%{RvHLmk;I9-6*i)iEjF&OkO;V9e5^
zZf@}*4%f87AHH#`TDHd%$SCAd^Zh_LG^P2N6{y&;O>&At{6V`|h78jM;3Wbt_h-iP
zjL0%G{`0@S&AV+0o$h*=_}uoHL<{J6^sGlWafpB7MAP9tho<-%tH>pXSM^$-!YPxM
zLn;NoPr1}wJg<8xB4o`F33z*RfY*vX-~>^iLujFjzla4a6b(MEji2ufzSlfnOUKXu
zAar_->z2I)JLH*bT#J-@@xq<0&3KWpTSOV_YnjujE3V{=8pWETL8`P*jVwgNV%NR4
zpQD%GR@~E$XL@|i;2VA(#!5?}RXI`h%=EXpbm0T~#N}}9$bx6fJV87~o6^-ioRT-d
zkUPNd8+qp<tpV^ck2vo;qW)s;)%L(waaBQy>cxK~k*+?cs;A7bx~k;e+X40!5UmGv
zQQ96&`DB85T%XGuE+RPGlGxN2>%BXBX%GU~&R4R?Tck>0T6%B&{B1^w$5n7iPosub
z;&K_26FOVuSCU|PUqfVE`V1!xR^I)r%W<gBe44wrVS6mRDTr(5IhmQdo}wd9<F)wY
zP`&X=Im?ry>?cnf&D>8JzXG!*t$>F~M}97h$4x4{aN+dGSZy$HY@6|d9ui_amiNca
zcwcm#y)Dmw$(^0Bv6jKS5MOI;hTaHYbtc|sCX8dYH@(;*nPLyx;QZkFd%1w8Z!4Pw
zv1+zQ(<W2hJjMStOj^CoD33@;rzt65S}WS%kr`%9uc0RM;i?}c#nbte>lksiaMML9
zkby!TY`&XbIpxwhGJD)4W1oR4W%OK)j(T)lo~Zl#Xz)qaGp_8r!{A=}^Qdy>d6iZZ
z*y43B^Yhp0mc;ADGT?HXCDWk*PnqFKI?hbxBo(>t?)6NW9eOStPh)@Z+gewWA>Jm@
z<zJb$L>EeK@)BDLWldbTiu$vncMWv0lWiI5FrqBsA-$_saS(1ozS-=xZ6zjb{Pigm
zh$Az}%XF~d7P$yvVJrgYh(;)ZsH=h5LcJTz6z_0ivQcmJ)}Hx=IJ=j)r8`DnlnTew
za9TjL{E7PhGuw2eDZaPfb9B5sZmkKR*oYCWB&EDbhVwO1CPRqdT<%NIo%cdnV?cWq
zZCsctBwx6Wq4J~W+S#1PU`QlSQbQ*4$UgnRKGQ(Lk)7jXR`JHyuOT8Le7-NoT;fI&
zeL0#lB72FxL6%;=hm)HCtB5ktzz_U>?qjr}<wt8>U@G6jWkazxa&zIrpQ0<@)=0@!
zZ5u}=-;sD<94U5@@G=eWtW3NB=0c&nnphvcrO;oXBhTb}&3j1ejs5u-XutuENtau-
z$8=$VV!;I;@aCp8jibUD+clR&GuIamSQR_51{k?-sH`hDb`VSGfs3d|fwU-r3(-9|
z>I=rYGngt2a%aADQG+&lNWwWG{(1Q_bNC5uCBxT{2Q4j`mj?mOzvxY(e^xg$CTTnY
zB2{ICSLzV?4v9{Px!Lc=7rhW(wX7_L<5+(igD(~hNteFndU>x%*R%lzh<{o&`Uyb`
zhkXIeV}8$9NS@|JuG75F{UEg+Qp+HJKW8eOE%;qFl+m}Q7PMH30N(;rJ!y)q3=n$4
zOrlI*+oFyR(#N%5g;G)!&DB$K(L(lE*0!?-The1dKPRsZDz-06cl75n{sK9rY$)3;
zu%EG@R0<27PRdD<2cL@O-^tPZ<OVYstIqz2ZY%OoS#4_Zi2>*;PR=(o2jeYViT6^8
ztEEYvfnYi{H<Ra8;(d&srg|K}T_JD<_G)f?wS%4<+|h$-Qx_y^Q#QCKDR~*!zYAvi
zqPe;6FJ$(->YHEEj0E+(^tac?$s+-?vA~wl3~ZOaU0Rp-qOhPotZ4bF7B!4WL-#I!
zFBAWY^3O~|>o?X7i|MFAF5DtavFGjO1W}27&KM-k(b)iH<jc43nN^seoLy=KvW-yY
z#*KG`?7!HQub$b5sCBF`x1x<|w80H=@YT(*HS7HH)}FzH3m;~$C@g+==mnO#7gmaF
zt1c}yafIHazJ_ry2z@&b7R2D3R^Z2gUZ_+2&{P=FdTBNq5zGxu=jOe)j25Y5#1Ve=
zlzDXEx}$<726QgoVzDB3Po>&4hRfC})?BG3e4qOSg1T=mfmAGDa@oBikzkwba(*L4
z!%iZcJVI(7pdUnqvtw)#SK~~&T59M}&g!(+Y{c{^uy>b*jU`0VGZSCw1?FWL%>GF&
zV(Qe6O*h1j_qdVNq3=9;<q9Bvc49!YXcvS#(#*qId7WzcsE5XbO<`Q+Shny%(=MEH
zYZn!)fd^<Ox`(UZ1{NMZK5UH*TJoR$0*rPJYN-1X&z!Oab@<l)O31YO_h%N#22hB+
zxU_E}Y`0sMp$a90vG2NP;dGaUS6Nkwv>~aRIO*pKJOY?~Ae@-<8)%;~bM)#izE8NG
z-Oor`J7vLD$;9LY&D0etZEy<=iiAfV22Y;7O;-I?&uk|bka0<}gsolmRq^hQMfke2
z9T#n7lbT?R${g$DNJXJ0!%rsWeA7I>s|%GjJj$khp&%h`kT@|8$kTw8D-cqk+m<He
z=SBd8GsXG#l=i<qu&HiTLyE&jlzfftV_sLV-I2PW@Vz^BbJzPtQBt+Uj>6K`wwO-y
zQWc`!>+s?_3VTHbciCP(z5?Hz@dSHW4-T6xow)S*4`LT55t~QL*vo(X{Q`V*!tK(W
zkec3HTqQPO6lFRI)EpsKTlx<gkwriFNHXWYG#m@IU;3vrPEdr~3s?46LB*aIvIWcW
zbEmSLN~aqi&o?*DQ`-WTo`<pj)g5;KegFTJ6MO&r-v4|4{{LhS6e?0B|M=d)pw5=T
zoz0%S1uD;3K>#(=vF~N@6}+r#4UpBi2?7;?sl-Oa0SFHSc$$#_(f3B62Y$i}g<x<v
z0hA_BtE+!_eLolwFXUJQEO<Mi+#e)&2W@e4hrSOB`Xgf)!>6VO@C1QH44_IeoRLG_
z(!xGSz&yDIbfr&v0Rd771spAc6QKl<6rJ~wh)WvLgliC>S&YublKtB)>6k44+buy^
z&qj7SSIZCg3u?c}o_H$jeApo&$R_yzZlYB>ravw%y=TU$(SoqK>YM|AaGeDqL%23#
zXMmxS{hveiH|Qn&*HEedJybLf!+(Z>@?XR7;UB}0^*^2r;?I+@`_Fxq4)BoQ{Evss
z0X$?U9t0sKX=HJ;33XPACm1)%p60<_bjlt}1nT<_C^i4(s>R(&h+xL8MrDROi=4IZ
zoD;A&q(&MMLfqj^AaU^>&)Jy62o~CsrivWr{O#jqi)SqL^@{BA{@n2=I4&_q#j-LO
zJ*E_+oe7X8lT`w-jIxDXzA%;^+=)0|ErTxuOd6&MbQ;4m07NZi2LhumOW${M0aQWW
z<^G@j)TXraDwA+8y>y*_EYF7X&2YOm^MgHw-Plv6yJn~*L?Pz0+PfDMoI>+z@5LVK
z<9XvTN7goLgS##x^5%k0dr~L%Gv|~e`p%6s39fq-Oxl3B#>BO5$QgM95Z4%I=!J8_
z*+m+GrJN2VFLaWu$e8stcx!9#muJ@Up6a&cBf--O*EK}Q353`&JqR1&G!rM%3yys@
zQua6vyulvcD~YTKl*SBy-C`#HKH;r?XHv9CFtT3P)_X+ZcPKbBtK9P13X@uhL3R!f
zsaH2ea&ZWYd|*(d>Cgu0v(ZY7z==S|^!r$13{(?s5ZjaaEsn43@u5VtVdX~!Z5*}?
z&rAZ*u9FJHszJ;e%J&_mc0+C24&8kRc2%trTrv-wm5lgLR5*ve5O52rG;wt9N4k_y
zR?|VFpkBk+8->cW10<Q*Fh$)egHSkN3b^FoT`P#9uBlSYh4Sv?eH|d;PM+swTnSj2
z9r303w3+lmuyx3K$5Wo%U}EVGMr-A&l4#q&;1X(Xx-hRIoirdFqb?byOcffM;Z>Oq
zUB14L&Q+^Mjbzyd<vA4~C#dSJohh1_vbk8&z}W+|$PfvE1X<$oz=z&>Lpdg&9S&)<
z(XRH|FI@<D)i!;l&no#V6*0qW&8`gQhIj5Tlp4N%q3I%T;1kq%p}>MuW1Z<~dhh1}
zVspv$YGn)@gc9iVH;8Fb@MEsWT~Kg#VK)p<CGK8JdIURTOFtd<T)h`IuiSj~ILX=e
z$gpgD^r0<_4cQ$sIJvnXDxr6#jbN6a-<!ecfUn}!(ehx27t1;sA?VT@kc;&7Wswf$
zFDh9T?2x*%zb<;9t2;ou9?1z&kf#bJz7|K#w607|dpF~^G-Mipq$|Q66@ox{-aDS@
zQET>Hh`Shgr+SHlkMamo>P>7YPgBF|Q(~>>?y-7uZ?dRG{sIwWEUq9rlL8x$kJ8lm
z$W0$vXDYCP<xHn6?qN9%VTE0Z+mgYb0&x7^RC3I5TMB4oQ)X;te#|Dl|FuBfBuaY#
zFP`)XS>kip@3^xXTa&SPI5)`FKdasKwnH1w2fc<_=eccXJoh}4UsN9!)TC4;7+{->
zv!8C#HnBkfKZ~$yUJgf)m9^aA&!@?U%5;n6kYFAe83~7m$#*RHjXHr&mYD*%P!U<-
zrzWjZ8c_AmCXW0Rx($i(I_lQM-Ii-i+)<sQk>=FEG6DF5xd8J;vq&F54)6I$7A_+B
zKBkM3U?I$6&d$=kDX&E_%_-S&Kiv6n$**4{Y1va>!N3I)MY8nQ=969m1jde%k*P()
ze3{y6PBA+xN$p3<q%snhV|WlcEHezQP&<C$1-1V!W>5;{E{k0$z2zI&{a#td-8>xJ
zafqu#<z5%JQN?w8328Qb;MQ()MRaud&Vq{fT7%}3YoTMk8{e0SC1JCoC+jx1an#l_
zHK7f4n9ZC4JXijNa<DC4$&=WY_&#5@<y#>V2^jq)$RDZKO+=OJ-stz6`n@H`-AOzD
z{li(H!bKU#jFSE?$shZQHxH~H?fX#XAFGNFLbb2blZynpG9-Nec>6<g;-)k9OwwMi
zE33D;G%G%x-Djf3_;Hnu9>>%7UyEh;8-Nuy1|F#&y91qni^HzO!@^k%LS`59Z;IXX
z)HHDY%qA-%<f$`;W86kH`E~kQqrkDAc$<20O1sfK$0$U6)PJxP%QUSSjl3(TOYYY@
zf|NM3XQ=xoKI)Q!bArJrt>}c_yeVWF{;_;*=2ssX%;Z3MZ8}?{US#)K^INoCJmo_=
zUb5AXR&N<Fo6^J^O((#JP`~hU_RLZx`wO&px`}1N<U<|NiUw%vkx%Yt&YFUxAIR_W
zTHT5eU!m~v5bpKQ@W9!gLv)hfZcFvxJE^PvF!-uk#r>g;cs~mb3zoHEISfuJEsBH?
zJ}xZ(S-XB@+C=<gtK=Tjt;AXBP0{MoYmae6HNR3pT<NFS*OVjC<U%ky%k@x<0UIhA
z*_OHrA(2fi`MKDrmae*9N7Np<L-0y4)@Q^47rF+x&4{;{Nt_LotDrm|ZIv$Ud<}@*
z6o|Dnb7?DyDlIVOXs8<6K4K&}-*Aadoy9(BojZca;}I@n#^oCI+6kye=Veg*KbArp
zAWAi8x4?H;;%%I^oy~?8?agqgDpoxdXl74kS$AH`@HCHFbA5v)tw+U|dRi5Tei<$=
zOYY(Ir4S^JQKhwG1Jg<yq+K(jZ?ZyNyg8<vIWzB!Lq_rMls?#VQ^jNIL(o<%_aGQW
z_|&`7<03y7T6}&t<XivJt*8k1;R`i=&JYiLiEKhF<+Tv1u5#twT`hyjxc%X!b34Z`
zPeOh_3CVLm+RVsEHbgK5;;bGLJNQVZML9UL2V_;Zywdl!?C+BkWGAn$FV{jLkV~Jl
zVNYgN+a_x1Y^wQ7Im(=N+P}MaD3fRk4%-CUW0Gx=H>{%?-zHt1lODE>9hns=zR#C8
zrA$0#%oqcw8rY)3yL_0r&}H<&MNIqpoS$;_=Qo`D230p1k7McApv4$lWKjzPvPe|@
zvwcHIt`c`|`=h&4u_)C(#n{U+@R-mw1SQ<v-z1iz$|7VslzLA0O4veRXC~UJWXUM^
zo{8UjEag<hE1VmiExKSin1gaJlbF7J-(W>z5$D38I5S4{`1GV|rzv83;_3Wm;s$p}
zo!Dde^Re5;+-fZ8EX3a>Ne%GelJOxTErLL=1x$kaWCfw&AwM$oS1?N7EiWM$x}Aqn
zSh37zA~eA*Zu|@YX-MVA7P+FoK-Rl;^yz&YpQYX&5ZkN;&)khY+cw8$)qo=gZ(RnL
z6*iFfssa&=Teu&_+8ANMuCc}=QPM9p3JmA@ez=L`*?f!L=Y8ZRh8}^@$w1qtf=OWy
zOb93V9+qe1%!~L^(8R74Ep!LJYC$Ms3Y}fiS})MNO}1UePLJNfxmoFT^@ymyk0pPz
zv5!3!-)xw|N;(W#Nz{yc`+T<g`QXp=XZR@5x9)(uDaoyxon{$Ww1}Ry<b<TMj}4LQ
z@VYYlyWrU$XXER<=z~f}w~2Fj$xIU#s4?{R*eEMwcZumi&i?RrIR4fW4`Lc(7IE;Z
zO10bVkUOvOb&_s)?~=r!x$~J+*2URpEJk!OkPbavA9l)v4zhOlzI((n{O$In9a8p%
zJj;Q^W(?@mmG=4p%8Qw1nxEIJ8tQ(#CRv4B>pu5jen=O^BlqyWXBP!+A!z&FFAt7^
zS)HGmP|7>|NSernRac>bOznR3nvCFZARvliQt5)+5qNiP=2|e?Vw~+*LBvQ-f4W(x
zhKsH&^IDXgRIiF3(yEJJT6%P=k3ItTPaLmI@G#^^)&l-h5(to>4&sm}$c-`nE$zN`
zL)if(n6}AOD;$U?AQL7dAzTjuPt5|4_znQ;mycIV0nge$v8g}LAbb^$F~NpjBL0O;
z?*UsoVhi$r`;^oF!%qP|FF;GR>Ux2i1{yg1fM1(|{9CCv(m8ua?>JqiJiafmw`50@
zWcoBmj535!pWS{c)*ycj91%Pgj8|3r-Gb7QrWCid%(s}V^F7R<eT8vVt3su*lBBW(
zD+y5cyfcXXC~S&~1^0g}Qx3ck5i+6*@~wcZed_DHu>>qRfS@Edw_@eJkY_B(Y3DT{
zMMyFMJcIM3H;gGbN8hDiI_&WvFbb$62;=f%?ahz6v&YXqUuTQ;|Ih?+7J`n$<r!~N
zpHyCRX#rH_=twzG_ay|*S-{s4QFh85AD6;cp1{#mILCVbo1fZ2(8|&nVWiZ<b;m0T
zlYZrst1<4~xuw7o39>JIZjh=C23{GQ*U{+-H*Xk#hD$2uwdQJ9Lh%02!0P^~fH=|h
z-hCA!D~dk9PGAQ7i{Ik<u(3{E<)aXIKN?ATMF0fG_LfQhZ6M|W5}WK*SwAD`9Ie!d
zAHR@(-6h4~5u2bGrW~|8%wy8o#yTa<SN5PVub;yEMTCvn;EsP7AP3z0^h)h3EI-bS
zk=oX_pDhQ_E_7dpl~|Z^$KFm1VGbAFs)sO1TZm977Z*Mm$$y$SU$@@BBh+obbJtUr
z8YT9&#hQ9}DdBas3gy0^?R(bhOgF-vfUM^U#-I(JJveB-%XOvvu4SCH*0;`iT}zv6
z_8T?!EdPtF?q%X@oz*XVr+k_tf>4IrJ~4VhpH?Wq3Yo&Y=ATvqM&A*xnu!D58f@xb
z-9PhfMZUa;TE}O!rd=!G!hMNcOs!caZ^5^zi<k>2R1;&7ni8?WKgH$5U6?Hm5e&6>
zbgerr?Q4sa;RYUIrxed;oejg!rnI4WG;GOf{d9OIeYB-)YqRenae(F*yX$gtm>ZBM
zf|ey_9%){ehR)Nu7@Q}wwCOF=1Q)Z<vZXgyIL)SSlzJ9B3Ddb$n0VF+j>?0WK#ZhL
zx$+RL;8C}yStQQCRTJ6M{hr6>-bVeTlR=3W$vO1Df`iJcp2ngV`@Z-8_RLs0t7JsE
z0uD@an4-F~)bqy^b2R*=o^){D%w|=qzQC7(P_%Hjtl%W_`_yoa{ub6s9X5E#R-pC@
z21p)DM2c8zC;6=E;#gzEQ}uK$apF5$CVPB*4$;7l(Q5*m|52Mb?}6KzYCES@Ov`xI
zUNXmY*o%{Ev^QB(Z^7YHJOApHU@wZ+GvW2+v8mYGgW&s+7-Q=t`QpkV9a}~g+LkI3
z_fhU(=k832ZF$IZXKFMe!766Hw`q^;s}c~wS;8I54cY|Zj1istv|tA6u?kHz?!N%#
z!`N<5O(g-Wu-E^f;QgF*JxX=h|2UC(fG%Ev6W3j0?I++`u`mdv3KI{eci7-c5@r={
z8;|P?AkKOj!qag&8o|sr?$sRk?5LN`^>y=a!Dkiyxy9|9xWy-ovrtsqF4771Y|)E>
zPj>D3(z1O(SLA%A&vh41#+uBrJk!1XJI;7bu2Ji0v`dP`c_uOI`z%R~C*q6-B~POn
zo!-X0%?5#b!IrlJSJD2vNMgjVEL4g~hpP+wFyd#UqS)(<<Yp%DEYogFbql8NOkB*d
zNto$fGLO|Lq#HLh%ao)Bgs=pJrjgMCXNI0PpEeJE%FP4;1)4+a*we}vi8Ky#5;{hP
zWV*3oq}ob>^+*UMW~d860f?ZS-$ThmB4s|k>58Y8moC2ClsPuOC&$!c!OI`b{E6I~
zMN)qLed3gDfB!jti1eYJZo<pvxF=uPM}XNy3@e%1=5RF2^K8vX>ON&Z6`2F^1gxI6
z7?_KXtv1B5$Eag;#y@bkH}tcdQis3%Wv*rAd-r!nB+qAGBi8ruJGk%RlAtR$>ukXB
zYmkCb9+{Svg%$O=(tj+^_2Le3wljQ3zNM+D6_~#AVQuu?EM53BSNQ!uY{-Te;;lK$
z<h7AEQuTl}=?q0KIru4FY3)vk0?5)D3>4<4=UQ~k91Yw|dy|yd`OD%Pi66mO+c?>A
zZlDvQ0`anZt>4q9__JK>UPKz+x7;Dc3o{G}LK`wuWBibE)IVF75*-;#*j^uVyl1gH
zxF_Sj6e3~1G-Y6b9E~#PK;?%mJIy%peX6?`BfqM)-OMCxEa}>DNN4d=$(tsNo_&Yu
zX?4jrrmDik6A>JPmBkic2&I>51)JK-A3j`bY^-7|E0<&h=auD>1_Sz72DIxNY0pCA
zd1Knsubt{<ZzKmgz~CHH8^#m5;Q-G0U?KRJ0H8>21HuR-K`6xAZ#~Xy!#-Trs$bQ&
z!%AX7V$2}wQ3Inwj7pE}BQ$d{g>g$$tWfn*%?~p62w;ZCCTHN>O#ajxc3l;FR};h!
zR8e~=Z&!VI-y_s~n@JNa&ZL!{P3nnZ!qdJMo-h|rq_<*g#J&CbhgI@n2zb@>a9@<z
zd6iGdCr<h|f;?LAnET_xd(xcyo+p)$P#<~{C}0LE8vN~ZTF!J2I2vNV$5JNY5Q~p!
z$=0g(LC8gy=}qS6oi_05>phS>UfgAv-nAq(77Fmx7?@Kbx77gySDcboD(NZMCS!OP
z-9!>XvYy<II};+jyG8mdX$gW+sWrN;IUXKUe6aknNQnhVL(rn$Ji4Yq*SI&|gn{RT
z-!wka`bJlZ0Oz4kzwYQ`DXJq4$=e&$$7?AxKhm)r_UUZT)`9?&FO2Q;YFm|U9Aqfk
z%r|!5vJ1~(5NQ2G>C(ojwtDBy?CTngSEsJ2Xck|+w9A0F>6$q6mugelP*iD8(?Kdp
zuB|owyrx*U?I-Q3v)9aS0oveu8bE^*=DRc35YZ-R+AdiGUia4O^!F(nUq<&sL!c6i
zsMZx6T2ueU9><jP-Cmi6;!V>nm7ET?Z3{(<4(i1el&NyEBJb;pc%d?aEv3Mqm1SzD
zOtNW2jh9dCGu_?+?gKTdGpqOhAuzT?v&bBDSI@b=$9!nv{6&eua3l>$+e#V>q%%Z@
z?aVEb14UKMu2Ys|E^e<gWXUfSuqNtz78c5marS0U%vGcM_VH)MGl~@o(%0cJXb9f*
zb2K=-%&ux;xTbDG4KdUZTh}X1@kn7a_H<hdozO!{hN)Mlcga69EU%C9u76wkQAMNs
z`wFugkX<l|We#I7yVc19o8U@YdQ_4PlGT}{-VBzls`;=c7XG|$OfW^&hBxH!C!y)(
z%E?LP;|c6zOtt1@`QGf_Jytvdz>L5zznw%&k~#fFE>7AAIZE&7JJVyK7g1-_bIXeA
zd?mSKlRYzY3g<MEXP}MR$hZqF+^50R;{MS^$GQ{eci4mr?ieHS+C*6p5Ds^PD?)m;
z3%H#t#V`S$XhLcGa@jZ+j;V~~qCOZXAy`w)<B?~E<t6Z*3PS%7)LL0|v{OpF9Xnjx
ztNet5bVVu9Ma9(8pcOWFj2yxkUt1V%CmMe=8HLK)lK%yw!LjZY&J>QF4I2X&V*$i0
zvjl*k$NzxL7LWg2`GcYVc|jf`ik(<K(&htB_e>CMY*I^AtJYZ>0Qo{)fz}^ee{zje
zf2V+S%uiQFL+519qj(R!=Z7Y}y(xz4z`BNA#G(BXE2rfMjCL^a<5}e<SfIHY@Ky%C
zSjXZS@G=cYC0yS)EuY`WVPfP~6)-B;;9A!!Y}U0BC~#W7GH-cBEaLIw`7b(#;bC@)
z;k$9QtFjWPHH<;ey>#hhLVYj;`<592abCQen_o7u=+)Y;g$L&%M8SfDv`x15oIYs$
zgbJrC&>OgAqjER^Qn}*WbpKD{<<`;&%;8@k_IjX{QYUvQ!PB&FD$obN;AleJd<V$l
z0eQ&7_}W8A)#0^26nL}E{{?!;)6r*qp76^TD<cZ%=lA~trKI5OpZw{)M$ZKZVj(r~
z>*OBbjPnz5a<4L-XB$2zhgCxY*_wM6mv?4|sc=p#_5e<u)g>2*R>%L-Kxno+=1A*T
zGWO}B3byku(0wSk(u4{JU73JbhoQkYZ(QU~to4~(U{_d`1Ty$f<uxFWTGVO`M~PbY
zi_`4v*-YX${f1OleHolrAgmY8ZN4BJ@ZL?{o+5v(zfJps4%w}M6*Aa0v=7UQv4qL>
z+@qIVxG844!>X!GGD8PSu*e5_{;K?nurp9x8CHI@W9AL!@a)GIN2%^-06l)Zb<9gq
z(AB+6u1NuJ#R~K7#6GcKokoqy9#n$7L9$i}y&*CtYq4*$h`rs}N<NTtABZmmP66k9
z{Ca6Hx5mnsyNRhE_Gs3)f6<W_u^m^kVv13n8VsG3JH<#ob!`)60|!^eruT;YDmk~K
zR@0B9G+gzn-wjkxRr0OU%`?8NDjGG%p~BgN)H1MXtez0Jy(;^i!YuzlnnH$z^tU<N
zOS8pA^FiCzMnHUS9XMk4eLFc>dkjZ?saYVxoIr~aDn?U(FAjRU#vJ;w*Q~J}SDFMm
z?(G_4?A`XkTQsd2=E4^Jg+|xxO=t!q@gIRbiTn%Lt_qX8GU=j>LPsuB5$^u5<kJsY
z^+}vYY!1_@Q|ph~*9|^lz8X%hoxeGMhTzKpWJP#o4d8`!>zSN!SrRpxWTzxdy-`HB
z<;VRz9*X1vB2uT-Kqb^f06fOu{7w4QB-|l8!)!QN2#?r=vpFyd3?R#Av#HlinRL>Q
zYm<ycSi9U-xAp_Gqazs=w)8|SsqkN*A8SbFj~jsrL!!rL`PAo;feLVYs2{JvV^6i$
z$MSoh>*`2I!C)$!Q{Qg8rzq05^eVbwtuG#ZxEutyXm+9zi~zS>mj)FNk8^a#oM-rk
z81>QbneQd$?Ut=mhc2w_6iExh#cYLm$X57jROhy+1)<4~D^f#C>&lvrhCz(0L^$E|
zbi*#-G2E7OP(x}6bZs4!^y$T+G-b6(w8m`gTA!22vxJdKP#@d(!a>8U0X%n~?tW;>
z@aT8$Z+<nBLBpU`2xgl-ImTQolq=p+BB_Mavk;ZkliZ4L2f?Ut=CR`>m1y#_Z@g)V
zY?dd|84$%Vp5YR;yfmaD?}T)<6w{9%>J<J-TE_7qM8+psZxF=U=-w>9pnxKEC^5wa
z!TS)yI$R3C$}EWWtVENp^khZ02zZxnU)FYyLL*_DN?l>?mgHkVMhyCrt8@<k(}UXb
zUyg45-_`si<>?xU3`3I>049p9N93e32fTNc>t<m*MSFfhnKjW61YXrfVB$((cAGDF
zTnjiqPO=6b@!aMHZIS*E{^QvZ?g<jTl4ug^Y7b5Q#Q(b=EWT|>U)athDI<$iXR<>r
z<k{vPk3XXTE3b)P>fh@)jCui!>N?(ut61KS=Is@Y85pFjFZNunWX_5M`GfcG2nlor
zys^_B_9WBR;`OypFqfz}R)+na;LVGedFnt``mo=s#^Wxqq5%|sv}I0bW(W({nR>CL
z!=U7MKM;R~N+#a_63ci3M48EPZ`DBs-g&<@>@9mS^WuB4^r}js9B?A7UVHe}A|6Y2
zm;3HFRRX?P3U(qn%E_5l^EOAcMVI4#+XF{QR_MzGxD(5JGgI6ASQe?OfcKQ~U!q$5
zB`~ro*CUxM*DhSQAa5qS1iDEfREdVIJ3_0~sdxER&*&gud@`kNwD6$AY}^TZ7rlln
zHaQ?b)=iA@MlA(t^)%fi@4oyA@OA@dzG;)(N8jym!QU=O;6yvuuBaq+SE3y;K}@b*
z^W!m*4TeVb-c@`g!D;*2QiwF63h-*Gh&lZW6lH;5cCE1rb+*=-eh^XduEz0}z+leX
z^~710ld{ow7I*fqDf8!?9!tKd7u1q_zbh1?7n6oZ-utLLt20D;qLtyy?-Lv59Yr&j
zfHQZIT`vrbyVSDrg}ACiNF6VZ>a8MAF-w>vnTkK?D*V9U!!=&!Lu<53DzAsjbe@}D
z=!F&t{c~mIyfTY@_Vkm^*JM3}!%wn)7gONa14PzlU(=!PV7>w`ZXNo?rO%9-EVsr|
ze8q`<A(|QfHxi&TfmjdLK+&1-riv{+<+a!^yFI2DyKT;{eZ20~DZ?j?;0A4i%kUmQ
zcsC;AumJY#P}_pS$pB%^^Dy%0#a5RT?8F5or(-S!v{X%dbfIsYx>#dUUG?zSJ=q34
zZE#KS6o2Hhe5~XLQi=IYw<n%4sHTa@udQgYx4dO80_<tXBZvJolPLT7#t=GAPEh(e
z-c9C-x!A5`WWc^IWFka1D7W0-JQ0;=5vVrRA|RVzx6~;oQ}FcS7r~2c+;%yj9??+I
z`4{Lccv64xrFGfjo%eZt8(&iv=f&yzCPJhsVoo6u7KHmP_Blf(%R9m*h3QsttnykQ
z8eV`8d-fS=-^rjw2y;A*lX{WvP8?I!BZSi+2%=_dkZnb1lRnsje#1zyJE8@i@(-47
zej5;nxQ9TZk&Q&ND7#238(JnZnQF-8{Dt$e>PS1zEBU`?hwMltH^xX>0Dx}I9Ln}h
zaVZZ+<Q;L?X7OUOuv7pqkTcp1!H}EdlpCAFUUtvc>7OU@^~6?!v+hvwg~!IjF15ik
z!D5N5D3_X%!FOkLz{Dl)okoAnC}P=+uk}APo~~Fu;;)q&SbOafZxUrIzHUPqlOxYu
zdL;tyzX$^0)-Sme8@-d%!1+H{&IA7E6;R;pl{$PtzWyKGVuYR@4W7!)nP8vYM%;u0
zm|#4~AWa)QCrbfTtqoKFAi*VfVmwo8gHgvSnL)5Ez`1oCYCQFKvaZ1(Kz+m4i=5yG
z3IJ|MYAdQt#mWNgqSn-3poMUNKjQ$osh{`Fw5@41$%eHtTKpHqS(n?c*Lm5bu7C6s
z+2ab?q>pZZp<2%rxCsU}zwFk)aSL_q_+OwSt$SF+D}Z@1Z*#~d{rVTkPV0iw8*)V;
zhK-4DeQl5w`~&EKu_Jdz=6XZT<o`39G%gT$T5Nr9<@VUz0kV|-+pcHd@{u$w9NQ@d
zxfCn~qWl`ansLN`xAqe{h+jfV7?L#T<E<T4=3pr?kS+t}TN8%@UQqR+&mVsP#d3w8
zU%K726#Ab12Am3VL=MLM2?fjB#$JzwWjdnMZWEL>t9#_OsaRlZLH@dORDo3E09EZe
zAJ@+K$WmoC=Hhsbq|piqVKTFDd`Y(-#{T5FrG!qHN}zqd`}EQ^$ym)kycb|Kr^{zH
zXr1%ESi3eEQZvS{Wv1YC7}Q?hMpuMp!#u7uXDTOp?V5!v(@ADu#I%rSDwxBGP6>gE
zpE7cB6;86fQ+5Bv0D(RoZ9m)lpxyP-pA&Z)6FuK9z7GcA1AvI{$+BRqbx_PXg^uZY
zz8}N_C`8^;#)`kvRKdM-F*{1NbD7W~i-RhKsi>v}k&JAp?X!Mb&ty5++o4_0@@(Ii
zhwzP?S6?Y&>{Z72PaIDIXv@+MB+_&vd~#nutl8fp9r4`l@e>94Yqi5Ew`Cd7)Y~%^
z!9&!;h_s|s4n=%0m`RA|r}t=#IZ1+Av%_hTz5AVr7?z%e#1IgR!Qhm4HeUZ#m$>w?
za=;iuY{gw!>JRy1(4&PvRA?f+tKGgK`rx4=_+`8T?XEc-sl|-(hsQSISKeOzto1D-
zJI(8ft}r2fkSaqj?6em;AyOF?OcAb8_YO;bMd<Ss(UL}X(8rk6mjvx@liiZEh`Kg%
zNSFC)tmN&)4qNLt>xfw=2@jFf2G_$o$5941#54%ZImTe9jeqL?bc<f8(_`C~ccqPX
z@7y}(eyH|e(hrJg<5(yKKEOn;21&IyxnvdXd^cV+j*NMlLgv}<UKyvqqw)(dW9=~)
zYZ|!S^!!<cTlL5zn}#bz5htIL2&*tn33h<b-!+Jxy0m%dUNqNn-??h=t<NO|PGz|>
zmKmc=%N89dRq!qLHu2d`_u5pZ8c?h2_ex#7emz!mNQyz4n6WOHn5f;-_${!gFEIkP
z>U*{dgdPQhFq87AvnY7su5s9}ALp|EpK#^|bqvCU`?+C%IyEVvp~!m?wF0-CB!fSf
zD*1VPk+a3KsI7KU_V+%jjlPnFsVmNi@Tq7|pKJ*fnq=J%JY6cup>6=TX&G-}`7vx=
zKAE5?*D?{PlvJs9k_tzQ6^U<XcziA%$^m!dat0Ndi=T*W<<x0jTsL0q5&5jFIc=$V
zJLuku00?8$LY=GiINIJ@v?t@`052MBZ?E0Gem1b;L){;!k5Y-+zqVSv6Tm0K$2!d)
zS3Bhv7}HM&26@RzY;Mal#~`SrsfMyJs?LId#o|xUjKv+yRTt{|70^!29cDRsN}x~6
z>3!cYTOoOiq$^%VIObFiV}K<GUJ#xdfEv$MZlYzVGm`+dhoEawDi|tM;fsq^7a>zS
zX03^NgYsW<Z<moH0v&j}#<blHf8OXdlilD>=^W3ZF3|@f_O9SufyW0*eTB)KEL!NO
zOMN_Gey&QwWJ1dZ+RXQzLv&RVYUG>t+=N?`yn3xhtiYrxem{z3mK4R-kqMcWrkRT@
z%%5Lc(D2wYUd7$l+X5Gw2LUP&``%?{jH?04#4%kzpXv9HV>TQzarr{_@8Uh)mjXQk
z_-)B{qvahgOV99Qv^&N^W65KFW5qE%U30FX%Q_P$r6xS3e(!k{Xyp|d$>eurWaK3G
zYAk>i5T#ljyY-looG6)nEXs%7Lrq2l<Tv^*FlcqVjUVHyTi+_|IOnB7b^MhgyTK}P
zA+*6hp#VC80GubB*hmJ8>ws&X5x_YBCn@X|AlXJaZd1oyYp{>09OY7zD1)|0#xuMt
zwEztyZl~M{zas)ej98UtHbQmvVVS<8E8kVP9tID&mMlc?=YLYYttiKYQgu^VGxLqZ
za$qzq2zJiSnpzBAE*Ps5yFbmV7JjHRMIz)8RGNk{TY-}<!sdI<X8i+weJ*VWJDjPO
z#r60ec#yt4BBnHpN|44~)md3IHx!XlcPuaG$ds^*Wh-T+VT@n!kct6yVHDBeE_&Ax
zuN$cs(`?mEH3AHICCVPZs~$<vT481&eWUbS^Z?X+EpkJD<7#V?BlWRku7o^_eJ$&A
zLT{5+_!0qXakJ}2_VO=~N?mhf^D=vqsWQ6+i7rlNIFWc6&@rylm^p5BSWaicYbby&
z?q?`=lvc^h#%`U2@U}APOo+5(TJpBpXom)+*6g+C?SfKJLtXs6&x5W_KN@;f+((~*
zR(F53;b0~eP-h86KcT*zg9aIzajaj;n&sPNbD88WPj@M<rBQFbOKYqSi}QpPz9!1E
zAB$JGG#HrsUFKt4dzy#yM%#3NVl!=yHZ&b{ei#EMm*y#gk-qpgS!-CyUorhEUObdj
zDs-T~9hdqzpUeCqP*v(Q7~3}In()5!rISIuzaZIiV6K98#eaqVGB!{XWrCAHHt)H^
zaLx03l<;Rq2`pD_@}T39*^&}*s3xJlTOk--S;~e2ze#2QHmCRE7v<B4FCahHs5Tau
zzg!&s(s$8c?=;)$Okfp8B#VP=bTaKyBqYE(JYiBqeh9bxo~bm;lA20rh$J5AV*>RV
zue3<5#NlAYpiS04*_(n=s}>Yr{{<4UT2R&k7cq>0U1WI1Yazf~Zu*vqKgP?tOvh}a
z{l<H($WrJo$nUUylnLXjh)S9BsVpl0^21l)!7ts_)Q}E5-0fjQ%s3ji%O4T;VA8An
znbc5ev~_1U2^kMQM>H;OY><;&NG8dcs1|sr*r`dcb-%k_fDZbG<W|KakTgl5sQnr|
ztVN;#L*uOSe8Rb`!nq&;YLczd@$n%sSSK9F>l^(fJ3SsKKErzgVRV$t{JNJmbCk@+
zH2^9$y}{qha@yp|CM^dF&h{7{Y~&rSKWk}2j&aB5ax_-d`C0#WU{?9P;(hcixuegi
z`)ddd5Kc_0dy_7=9?%LP$=6wzLfn_n+MNIWN{B4<CLgh$Z2~Zdl5#h69Daa^Y@ZM4
z^KxtXA3ePXc!s!e_aTJv{!#!_&89#u`Jl#CfgAuwRgnM$=xD>YYRjGeQBnO3Pe2^K
zJe4~KO0VN;7P|igpoKgC1fU_}9Di6n_rkwfJ%MG2@l~Ac77)U*+V;N|y$z<}Oz`zI
zsKr^=U!Z4fm8t)+ZZWtA=F^?mzJDs+0JNHi+%Tpt`cyEirHf?UIgNN~&+@dJYxI^b
zJCIs)l<ET~4rVdMP--{A_HQrd|J32-ILip{!VMoGgv7b0XoK6}U5az?u~sqcZPGug
zYli^9)CI`v+H-&!>TKw^Jo5!$?<aKxq}V6R7^=V3+d2DkTjrmEH%=6w@HPi4f&9gK
zNMl~Y<~r}nGT>U-Q(laeKR8QlZ{GxggrFnEz=O<{`!}GP9Q>nyV5ND(#+Ed=M~$}s
zXbm#aYWKfU_&!^X%%Z4umg;<*?!`<p<?T>5^t7HP=C`4}xcCz>&r#Xb(Q8|DZ!S``
zjMr6K&iiX0C0*wt4<WmFud=S2Y*hMLLU`7ZhL_x*xX;IBqzUA?2}Fmnvfi+c!A+J^
zp!XY$*qj2*m{^wRK%d*kLK4fn&Jy0wvX&3M7N7Md#m9_4NO+ch^gDb`&Gvhm{s0(c
zeLoa8jAz#t1Ol})f%E;GlPa%8%+3d!5mgE!QrJCvIZduxJj?IW7h5wX;GJzVR)W35
zZC-BgLZ{ml`YKsl@Q0pHiw+bxi)l2sB}?VejMaSh2-pWRPoEXw^3&cT)rJlMnAlrq
zHO};XBX%a$18kYNq75GPj}I?%bmyH*OAfN9WGXqQIi%$rqX8L|Vl39G9O?113e6q(
zMC#tNGus&8=%p%;x#_N~5FgL9Le@NZ0tIJ$V^?3X{k$l);2Hx1Vjm<f?Chv-XtF1R
z#%Wc%?cB~oI5|Y{D3;iNhV=SA7FaMjzJ|cmcnAp7Yf(ecz$asRkqWKv5-?<y-`r%1
za93xQ<CRrj#O6in)3PKuJ=<#&;rxJ>GS;2PekW!0jwY;l9Kyd1sNYLU>pm4MndjMn
zp)h9oHzy-w?#jhqcbW|2YGocD_1N?)y1R@YuvG}*yIZJYM@zt6>W^{pMjr=ZJ-8ur
zEUp-@J{R}|vJWdGPuB$LDR*&Zo*oSqHK`gGI4n>7;o&oQ9hK0110BTjVoDBsWI5F;
zYl=nEY9n6J9Ivb5a8&)mtq77dnAQhz#5H9T-QohdfvJzr_r)8~E@|#FeOd4&Q6QiE
zPrf(skF>TSz~p0L0>f8t_rzX>{^5W;NDW_G4<*dsF4<wRYTbEpna(_Q<zyA8N_RtO
z)Yc#rL#1l3`E<YbG0Gp@2S3l;%u+Dj2b^|=fM{tXcePpS=J8Nhefrc3Rerf~>UX`}
zAYUsjFfNnC>3$<x3aMOL3{zgyXha3)<n_RY7);H1ZsSU{4+89+`6pyO+)h+yl}QaH
z<k}Bz>~=KM>UCpSO>69Rr+{3)t-;v{ron8a3q+NPG`Es1$Yk(<lIS`k^%!*5z!^B1
z{xje>ERPmaj?5uFKQle8G*^AIhcVu?|98rlZtH{;H<^n{alinJhC2j2_goza1&-+7
z|7-@7IoAfCH82syn9Lwipode!AdI@78>IbF`uHdoJu1U9;-1chy8s;aiFo2<Va_7=
z;{C`<L_Xl8P%eaIXB8;fT(e+8i?_@npVg~Ttp~MKo^(&stfDo#zWjV4<v!68)Asr1
zi-Bv`w{FYN1D=NyA>vx^vdB&~JiDOzrWpMz<w!q8k^0cc{ft#1&`5A?PJZwhxk90d
zLO@PSavw!r0#mylJF(3zLb{WI3dC7>0+z3QcIZoWr%L^B%tbh0cwM@WDSceH1~gMS
zyL3`vPH!`H6HenTBY6D{P$2d(2FwCQkh|pez-9*o>-@djp`HoKGv}h#kdO1Nkc%Fd
z%Uwr1<z-@X9AQ5MVg0WZXu-c3`X!h%X7$$KG3h@5tuWu`4&%&>58AcOri;06*GL|D
z9>u%CHp}&I(#C{gZ}&|Le?<ntXMlX#Q(X+F8J-Q?et{9<Fc%^nu<F|V<>fO}EWKI%
zo7%hjJYqI#d#N$+HTM`F(%nu7{)nuS6^0#ZqnRS&zXYrf4bzCEEa3Xkip1jR)N_mD
z#QUFZFVD&na#=)53M$=6Ny+luXtlzQ6OcyL2=$l2YroR5Nxu#R>KW4Xq=c9l7=?*5
zu3p+h{B^IY_ocXFVfX~1`KT-7sX&G`@j~oC`o@;s;@)7@pszQu$02Yn%<h(mx9gZ&
zi8#O=-X?q)J(H07zRYgF8xL%6S??q#Ow?E~LFEPAc8jdy3Vknpyee;*XlQjCM@-Ea
z2lcE^2y3y<b&poN53JaPCR;e-m|LLkQ(K{xr}Y3AOG|EnI1_kP9wM`2O!7Uyy?V!3
z?=*wgCz_vcNp!S8wHGScR*UKWjHTNRKx`&uT?aweOF)geP85!kt!cSLr33bonlX!n
z`ouWbrCVN@>avgHQC-7s2im^~Fme|pEo|-FkUn#WzV@IugPX!SWQi{*buL8KVGPUa
z^zB-I%DZRGrZMwIqx9!fhGF>}dED3oX2VhD7NP_1gm>w`+dg=5V@UODAJW~N4vNRf
z`CNb@Z!f12cL5frO97Vq+u{QJRE2T<tp{|{g-WI-W<@BKB}`lz*r(+PWLcbyN#42V
z8)NLw4Wl`Z-=xKK_ceGh5UIFG`WCnG1wNe?t-O1ef48%~NyI>?*wIz-?!4v-B{#n3
zY$f$Pb|l=jt5dZ@tZH*Pq7)7plj~An{vc)d=0?_y3wM)8?hf>PX4}&?XXoX7zfe^V
zl#Pe<6%KyUvf<+PEdIPsP5OizF6~BaF7c5#3;mUxqLKzpH<w;dOCU-3Z|c?MnoEJR
zk(gzHVOJJT1ThzGZ&5CgenJHl{rn5}#sU6l@$e?x27p9~1`~S6uK#{X7w6dG-ys(d
zz|c89g<~}L8H<VLyeyf!qaku5Ema{h37rro6P2-YuYGlufB|P~!z71|U#+0_er`YN
z>VK`j-+frT1nh$r3c#$5z&N~<yS&FQhhhheVDPS|MgRfU=niQ0*noLci3e;}+W;FC
zU{+`!We2WviIjt+wLp9PPiLcB6ue8#i;VaoQYuQ?kEnt`x2lSULEJa!)5?a)gM{qL
zsGPXGPvq2}K8EBdt8r#ipA-GRU!*Nzn1@yD=hZhvKZw-h+FHAxa*Ah=9(W(~xd2Mf
zQIT3|)(0(_XYIhgUsY<yB^q2D0ka%una&m-KDYM(<f6Jbodc+V4vJ<ehu`WHn)9D@
zNwe>UssVfev>kCm2sq_#0f-J++I&oTH2`D>>$J+XWSvig+_F#wEq4Hg>nAxBw=0%A
z0rS%QHo!JM&%#iP0nrkG;Tn4cU)FWiI^?`Lm1pF<epm^x3}X+pu89En7X$S3m<@$*
zQF3B$17t#vf$u-QmtpenU(p5={`(yi0g_YE6^lze;4VU6!qIw*hkt*y@;`nD=cW3@
zUQGbOo>#NOzVp|s#NGznnM#tB;q9AsK&Mk0iwQ;FQ$=NF$@0Hynij0%5zi3D-!r+&
z_Lj&dO~3wMcuwPQJL;eE8yeF5mIIT%`*Jo@COJuh&JH8}<+^`Kb3pkcDhz))Rv2Z+
zY!NcJ_$MTOBOJjGLJxZ`)9wX&7Xol=0aK|TcEq%9(pvgjb-{Bm!rXmq4PE&PBkb$!
zj#^eB8;Q4i+sE=UDVBB}GSYB3=W#H9MXFwNY<;EBD0E>Gx&N79F`<$QXEX8I3f<zC
zXKjGTh3jde43Jl;1G1-(Z~<v+WY$}V%lIkVO)ZNfGxEtTZa0$Oy^rJZ$4Fgx-U4mc
zGx_)T+wMbZpC^jUcqlQi#T^(C;G*zDWJtBg+5}otmeDV_lY;jn`>hG~`;=U{EHnGq
zm}`+s^ytdyK=xTdhx3gEjR$sdi8c&Tfsa@qFC=GYg%=f^UD?km+1;P!FD`zgR(YY7
zAE*<oS7~qKnlku<))#LKtb(+7oB0sU5%p8l`T3C354v2#q(|Lei#5dY7-_pEQqpTG
zG)-;Z+|EPqLgW0YSB7h!mV>(nlWSGiJ!e{$+Bz^ne$L)2<rM0ENqQ!<+EtI`ZRN{k
zv%|P>Hxg(ua;6yHQbRRAX{+^{)7Ig#D2Dg3Yb<2SDlVt_fD-z1pT!BS)-@h*zKE`<
zKFeteQy;#yB%xCfZSTl-H%-1*CNKV1M;~BF36V@7hIyJ|5|Io!cRMw_Rz}@DJ=SmU
z33o_m0vRe+X0pX7fgT!q@1D7Z?OA0if!|7O2W}GL3)%L}r=Dl_O_2~Pr$<BF?8(MB
z^xr#P(NZRul0cWF6#`tLIm=q!(r!=Q%WgBZ;{rGS8$ui?j~0m7ryo_GO21<V7anw&
zkS}ax2<;6(CigJQpao+1SnFm^IWw0YFR>a<i1O_`3C-{seYSB)3{*oZlFLCs<k?#m
z_dYzW)<rXacKOP2ODcszHT;|1(Y$m(R=J-+Pctc{5iFaO)+~R2vYY;)wbk#G?V}=G
z7ZQ(05}R$%9kU0QGshZr4Ydt14mQ!x`eTU_6O4f)+F5FIeOAwzV2_X*`(rB`J(g6C
zUm>zlc=Vv7m>p@{6&aI0%7ucoGgN*_ID0*bp2F*u!0e0+=AXz$|1+RHMdZ<K$<wlA
z)&=$T7Wd>xZ?g*)UtG51Y!ZuZ`0Z=89ET7786W(Ert}j(*~HU9f;-ONE@Zn&?3%k<
zSX@7AuB$=eH=PTsP_)L5KeWT;@7I$*XGgZl_kd&xGLd@mf{hDrbau2r2E~df(jE#$
zhT4M<3_@W#dGAw!#F{5UGVwgaBA@h`UQ8Iwl~m{O`r|a%%+A#v_eew8g>rj$=!_Wd
zhi(CNk+^HK)n*`kWH)Ks_~Y9jF|=w7E(R~h;xYdhYwsNmXWzYxj}V;^UDO02YV>Z1
zXb~Zz*CYrcqBD9Y>L@`FJxHQV^xiwsTZ}%V3ue^O<~ets_j}g*o!|NMylcgp#hT18
z_q{*++IwI7x-NqqAGCtcLL2Lwuo1%ZZ#Df(?U5-CqjO9H(g&jaqu=nS6)7A7WtwW+
za=Y$+qNn!@)%fspU@SP$0I?XX_MC`uvku2={||_|0R8D08f9A5I%VzYP*|fIM+g->
z5>j*R(~*`&)&;%wYXC<{$XO}SuYI_lqF39Gpu&ee3+4Zgo%ePIcWawG$P{;&;fxal
zS=4{;IPc&==Yc={=*zWs{cg4JdtQyZp)u)AGzq>tO|U5R$7$oL+-HGnr~JjGp~Oy#
zKRTR^T?J7D$pN=P-tFi-`DZRcH8rXI&Z0WF`z@#*Q;Dsp+N^SZJp*8Q1+n&Ad4PZ_
zfS4oZO4&vYFD#Dj0-k~sv*`50@R+8}>Zd_O#h0Tv`S0?RUr{ONQA)OYui`Q=gec{l
zAhLI}b$1=Lg430x?fQS|zklyF_UsA?VDQwNY@t`qpe$Eerh=x#fsBh3Y0mq>(y-V|
zqaL{+a6cqQ!p}nGxn|^g4c@KFHLdv424Bxk_&qp~W9-d_?c3P2ow+b&Q)7(LWd383
z1gqX1@C;rcZ$#BNj!`+%BMiU9a?cDqDLp5`|GQVtH3w`WbVHz7xKLlCn`<CjeXOur
zy;-CWx^rT3P-JXPEiJG`N)kWq7NB{nts2N-!$7yG|I)A)2?6a%{WLabX8!%V)0N2}
zN%Q3*OIX+!_Th4?*+5=sx9QZ|sY6fmg;B{N&PeH4Vb?}|7T>rd=`#37Dcxo0idjQl
z>Vr_NK~^r6)YlEGVaA{E0NhVnlN(I~HGJr=P;T;j2gdoCvsrgNZZ-9S`Q193sLWu$
zL=q-l2eXu#lk1LLGF-+@jqu;8>*CXji|^n&Qj(UI-b%8BqeYLFts*ncU+6Hmu-UkM
z`(W)Xl0f{&MfuwC%S~~`{#b<g!VB@YYw#xpf{UN-Gzh|!p8iGVlPgHTUM4@}p0*WV
zFt3AP!COw&LGzSDU92gfW2(rHxi-ptTQE`~se|CU_kzlE2*vDr&B1bM#9$eVzO}o&
zfaD_FwD~wpkksFR@?&|e-k1m0Y#PT2XK5;7)IP0nzEWp2l=lKs#U)Fe?;K$BBa9Ia
z7Z&E6swENJ@F8wUP&L7O<)TSWyp(f#I$f<otHYJdcmLtrx6&ZW^-H5ZMUJEg7{WsF
z=WGv!Y;A3~mEDxD?eX1vtnReDL<&lr>>Is&TkCZjrJ<*Q-6k<0fPF}<U4w_Q0kjx1
z3q845GL4EvEovRkLtY=l3;mF!G4r`>n#{|+wScACx$YbCg)x=_Iq3qY`0NT`yX=Gm
zSTa<UL`ycVk~KdRwu@-l6u#a2H7e>c*oByrV~btI2!-uOr7E>A@Vdw$dUSAM7A5=2
zp7`qd3tR(Jh0pdGITA}=5y0F4Dix~|>sI%mzb#USRmU%H*G$6X#n*<$hSxuN@Hfq=
z)LcLyR2*J{f|NP%acO<ED1^p7&wgfiZaBc1+V4`nQ31Xt4seXU$r5@M)>r>xj8E-&
zzQ(nbg~4gaMd3LfBqD(9`|^T`@uK<CqAIzF+OH$IU|Q>BZIFM`nhqN@rK@fdv7H$b
zNy6+Ck22AhdKTP)Qo!h7Ah2s~q@P69?5UVSQ{6uxK~CdN&f@*QDQW}{(9XnP3jiYr
z#^0;ff2`TFmoIuqHyO>XkE0sdsCRZxNZnjv6bI0n2{e=t6OXhU;Zhk$qn0mk?E=yU
z*y@uVT;ilZ^22^b3*@yz%Z|9yhj7tH9B8~7D4YVg5z9B{PQKmCkxC=;K7R51scne)
zjVj28!lMlztyqro8~!L>NZ|NBzbMW7o)OnR%Pmc5g=QlO%ZaN;OAFoK9Mg`T#fndK
zP4taKx)hz?*^7(2vBxJe$8sYr*fpD`E%%-`ni>BpXAxDrDNI(=_h31NOY})goJl2A
zl<)g9mutGpyK<U53$6x9iBc8r0uc^ix&OQED~%?Kwn68{2uj#b6vdNh782b?$v?V0
zXG6BZ(JRq4L3a>j+4phGpE&4sQNDhnr-Z>A81?WI9ooLcy)+V!%A+_<L-W(_hXnYG
zMi3yztpQ|A9P}R?TXF6d<P#(-1wT&*5*`>w+Yg{xV2AWSC|LdaA?z>e1t{|WqU7e0
zy_=2e?dA4mtI=R-2=*o0U(BomSUu>kTpO^Xi{<}9Y5=-)d<U$@4*z}CLf?Ntz&n6e
zf&TY1C<878{2u_U4<PXW^XcAye~JJ7bkvD+#4^={Co#NCJc5DhOX0A1vJ<f3&Gd2L
zwAbr?%70!p0l7(L&*m6i5W~d;i1L@7{`KXt`aiqR{J$0DuAfxRy@^#G-#XssOw@9f
z%}qAM-!M?<*wuN4nrsRDA4|W2|H>mc6P7g#>jMrnFz}c)3(y)aTJ3><1^?e4I5_<O
zTwYtPR#&<eIQvW`HcLtu&GA?Of<uC|vCyL*z0n+7a+L`pF-L$ic*qLX2|MYw5#mF$
zK-!=42b(hVk}jR8%8a@$YAdtBLf1N2m3(MW=eciRk}I?tLHnj!+S5~jHUZRmQJwn^
zBb-$oSbGSe!#%{>nW0q=QVSP{Jzc$Cs2`Zzy8UXNI~aE$a%f2^lSiRL=Acypg*~5K
ze*4kVoa=#7BOgg;ZvYW+2XS`(13I3132dV8{q2s8;izV;C*)ri@7CXGsYEPtm3=?|
zNR)XA!7-?ZT<rpN+N!``Z4Uo^R6K>h7;;HnEz&TP-vnf0{5mF;=!-XArExQ?!Z8R*
zS?`S0VR|Q9p4rsxwwmX9>_kdSv-8D{wKOLWbPRlydHC%6hCt5Tzr{|A?dn%+%s@tN
zWcif{*6LQ`D~vAM)xI)PN6%T-qQ~NEmP~If%3s-0zh4g?82;kj_XioQFpQ&xghRIK
z0IVG}_qT-3X;Ci;dV>vnF*$1`Zel)2cx~-9%PGA-*_H~FY!j=_m!w)JR|0_Qi~l?_
zUR44{z3cmhccS0NQ((J%Mn!~!eKc6C@$~Dp0|Y#oP8duXV81o}B20|}M4P938=&jw
z5-Kt~1d2=^!cYBT6Yu2?BuF!I41kiKQ~ILl8ZkU;lu>Jd1dQc7ghelM%$~09*V@dd
zpXMHndtYYlIu1XYGKAOo?NNA{2(}Ev6u69szYj%ll9CWOjg?5WVziJYkrHFKmv=H%
zd+NOz{B*$&6L}X&-WY?QxdI}-s~$ijLkP9&;9Y+nFBt>k{~btmEi}<$uvRit>lpj<
zP)seUW9`=Mem&(uKm?Z!?uZq}@OQV}MHf2wPERgqv-CZ=|G?ApeUJysodkC!I-H<C
z-$aYpnsw=p6vG>hB30-Ci}b60d`5f%_Hqw|PDeZWU=gBqe>7kGkh&%=Ib5&DX4OfW
zJ^qdV8^C8`g$k=$Q%>(wQIcb0{W*jFQHlHkzRb1=z(&}uagJxB#0}Iiq$e*tzyE?u
zn;`B*a3_-ia4ITbq`H<Q`;nHhYkP9@v;F!i4;>zjhN#ek(3D<i*FL|wyr8a+=-lgb
zp!ITi2{^Jy^a4tGmeJmrmyhS(_xASX7WY}FX*X**lam-o%YQhG1M1l)zy%&#4FWDO
zAhc5j{3mg|W4jpfq<n1Diz#};41ohn(4R-f5BpqAYD)pQqu|_w$oYP&O2ylqYalN0
z6&cM~t1Y0`=Pw4t95$-+%(t!7-Dk^!!PeOPenBK3kxEVm@C<)T?CY;kqvumXC$U*c
zXR)<4p4nkHs~WFdWSw?aBmfICWO`(c)ol|8+1_7u^^&&JNCubH%2&#|L9KD@PlvF>
z7<MJhgRCNiy_=TD?0KmtXN?mho_>7$BZ8D>bT7yg?SC6x(0Nx|v5+f7$&30&r1Uz<
zp)Y{HuZ<6CxX{_gFY6S3r2S$1D<)cLF*sQyX)bB*R_iD@UXe7Jcs*S=jmU<eZ}x~f
zJRv+-ovp7$9l&8R0>B2vS=$s@mi_)Dfe+!-0}}3F`H-<dd;Iuez}CB_22^`!NrV+!
z+c)aU^u&F44-oAAL*ml+kdBs+2}I5o*6xcoy=3UfWsraPdW}_RSg$c>a(8k`a2+<_
zP4sG^fr_}ZFTf{{QVXfmwJ)YJ*CJ>8b!kb!w|Ag6WwiVA=sI%<;~02qq1-!cRVrKq
zuW0&n0)VqEgD?nGAkVed_$llT^zEU#*pf=&QtWrL*FYyml=TNQ5k%PBI`ae&GwIlJ
zzJ9i$=f`XU&|UiN@qe8_BAT4WdM%8)y%|!nC=}UiZhfYH^eRF>N2w3@T&7<+bH5fG
z!p7)F5>Yf;NPeZL?qe`bCC%*>2YVm0?!g|75MXDh4WcqH!|Y^+-=F86PtLjp>Q$GP
zll5fUY+h198HL@i%-)CFHGR6bK)s+*lpxJy3knp+>i~LM76sV)ZoS>iU*~=;XA#s4
z#I(FjTSPKrb$rgT>?9`uf#tcjm0CkHweo%buLoR|Wsfl(odjF0kk$I0TuMO7bIQSY
zadP2lIt8C>&uA4Pelea5<CcUq>aWEm1vad++Cf&}*g{7>sqz86s;VJHN(1>8V@Dns
zOn|JrzLQ@P?Qc}FeKho1tI?}EB$@VBKO2^@?Ad003x0+2+8E<bW;sGW(M&7jR=|GI
z(_|ulJAnD@0|W`h8u()GJJ4<eD7i?-U^GwHzLW_dX6n)U_`th%;_DrFYJ?A9LYFf7
zh#@J#ajJdI1ImsIP5z&Q-)F9SB|4KW9R)Zdn&##@JCtc{c0X9!kWAxv#3T>QG^{as
zl(D_J1lLm5YvpRkI*sjGS&rU0Vq7tMpY(qBP0TUwSt)u-!waviFkxK`mW<QoHG6{<
z2Ok8#MoOnKn5XHrq=7(UDOS=s&s}3c+HKP|3CI}H0AA1_?vx3#Tqy3YM5uHA4fu{_
zVg&T}Cp=fv?&{(on}0yQak+;tMp(x2Qf_u3H0r=p{|>(Xn_uh}P~mQ0F2y^Ow;UwZ
zJ-_PFLk*(eDrs`XeMvEA|9kE13z6z!Z!9Dc((q!B#(0KzLqA^Hzmh%(Y^89wWXJA&
zcQ6&q4sTMZ9X9Q&B=PUcN>yXvz#kPc4&=gSlwosweI-jAZE3}JDk#1ZlQ(}!%Jmur
zbzIAA1}mlmoSYyv0H&!%;qZB|MrlxR_g&#@!FGC;n~ZlD6Q95*AF`4KQG&J4)gjMi
z$w`5%7`}iMzM)yU&Z1jKKzdr;yK^LGJpGy(bC4H97N!j%`~2rh2gEz0?khR=_$${&
zYvq(d<nLSuzs}#j5|95Bq900|sEp4MDrTPB5s$B)vUXFue(Ch}oM!N0n&unIesZJl
zEH1L7NQp6+Y);|VB@^Ys1=B%S8r98<qO)6%o=*}!mo+pBRur<rLY~~!n0nP3!kYQO
zn^#w4kSGjz%W;Uk6OCpqTAv{e;aT3=<82?y<r;p^SW<mBZVSKM_d)hrJn7^pGgRE~
z4z25tidTlx_>G)An9VjXY!n8-4}DGgci*Q`8F#W2I7rHPy~QUR#0S{`o1EfStp2K5
zS~cl7Dp;*^yiWF(k6)kS+0>MRs}h~R`dTYpo5D7IY%wC%F;>M@{NAIuUG7c}*K4xA
zN3J8j8R&!PYWCk}1nieyI%xQpYa<k##>8K%Zq8F%NI~&RN14SdK~%ngQd!}+vF-Jg
z;><W?pX}TF3wg-9wu}brv72Kh<{%<}sX`bHcEn1%KFLWKv5d#};ZE`Sg_`@##F!<2
z88&sTl@<#&O>{7{M<X=FKP3LBYWmLS22yYw2&BU{_qy!){z3@FNn}VcNEx|?ZA7^B
z98io0ppMS>C!3r<T8d(R<xsUnUI8F(zOK3?RiQs?b6;&0Eo)b-qf^0)-}S8k016X|
zpq(_+T$tCcWaVN%MOkvekQA?r{w;NtP6fxi!jXaE$y`bD5cfJ&a#4M@0A&tXU&dO1
zvk~BOx7pw)Snm=UibSkh^SNk@eFzSPyij6)sSR9}O_KZRYEuXq{X)DCVH`NR&0Jva
z5p|MLBWSr9pos99(}m(|QMpzAc&IC7$5MHDUdEh@Ak%a7p{AfjJbap%@K%5}sk4tT
zFr&hHZL3#My|b=9t)P#2`$Lfwvq=nHVld-6exec!ut-^PZI8w!<Wfq=eLER8E~yid
z*Hb4g<Y%JO9AFEd`_;-n>F<t#>0+#+iYNLqZhw*@Z*z|ldK%V%mnbqoB=Kv<3JmZ)
zja36mw$nuyhD4KXm0Z8reBeL^bD-(6+wxIP^rL6onaju{@np&EA!8e(*%dU*J`DGo
zo(NECz2;y4URHZ}3mQ7KdD;8t&}r$zJ(D@U-|}pf!~>^rVCgP0svUAHi~vqat-mUN
z<*V%!_IsGzUdjIFb&n8gaDw+)$)amyR3!;pJBU^qD|BCkd%=pTB<z)L7iuF!A1%!h
zk{Hknl?rKbLi)i!8eR6K6g?>M`F`(s|AiN?F5p)7{uOyn`%8<hXn9u*sRAKp9j)^_
zv8%I$`l3xQhs=r91%fw?QKE0dv%mYS4HR=0Ad4`|iY}ra6nH&|=mFpmJ|gcX??g}t
zjL*H_mg{)CM~XN4-&kV_i?d-N-DtamE$NfAWKA1WL9d*R#L-Y!9Uh&DY@{nN&rRFy
zya4!^MzOW5got4a^!!9wj#HmD&hB%EixefpcYw_vk_UF0Y!S{kb(lRvZ=Y%1Rm*#O
z+j^>zGsO~orRv}%>l|BVrc)F7d(58e(~}UDM{mtn{qQXM!ce&%-FE2Rg1V?bggt4<
z9X)E9NMLr@Ng6vsw)7*N0A%m~62&X%sm)Y&7%Cunra>k`loWPt!gVCg3J{9PfGS?n
z{?hB~<x=m>Ck8#0_5M2<_~C}jW}tQVTAw|0scXJNW`G>z2@H*Z@^`+}Y<0OE89=5#
z?c_m0QTvkbdt*J%>$vY6)cwVxYGA9bV1;U=ROE>vTBvSi-YaH&UQ1N=@wcJvh)<y)
z1y#Fi7W8J^3T4grjVVFyOiu^yWDSG)1y?36m=b?F<{wa8i>GjSEwOV8o5zAC^3jL~
z_pukJe@Vy`2TGw@AIAW#2Nci1^|h1Nyq=D7UiQd_l?~S~Nn^{MJV__}N_TVFt`)wj
z*yW88<~k81zkB#$gqlE@`PNgw?HfWlvr`FmeiA{=HF1JY3jU$^>kA&%DAfNo#wyl1
zsA_GlM);5M>-7CQ;L{wNu(*Sr4v6<k&P);e{_XE&BGDeqCM>**NH5*~X>yhTUi>WV
zVX^TJn_{M*;w-=YM#ux3c$el;H>GW{gqf|=DQv9K42~1qvZ!LicJ%6g%<`fgu`Ky{
zKUc~nX)<c9BrY#{Gl1}qz&rCq{V#aiB!8R4+BaD>3PR`Ih}8Y1h}zyU#4oeWI2rxl
zWuQ@|4cOBioEX$kT_@^pd5@{>*Oz8L{u9a01_K<FJu%1ZVT#-sLzq*5Z5}k}>dj(9
znogEo8g}8l$vq)wo^{U-nI7BX=)Fd=FX2r356I^CqDHhtf5s-}O9bj*J!J6GI}faZ
z^;v7BhTw0<iDyYVl;vm4uNl4lH%FgJ^!Zz$XJh0YRzIVroRC_3-Oesa4>|>2qgF#;
zhitybx=^CNKzUe~tcRo}ST?mr<YRv0v48n?J0IG2mE5k?Er_<o8aXJhUTEQXS9+p&
zN(Ui$-}#G}4Rvo5n?AW$e=8_}R9>!t7tbR=-Z~$UM2YaR3vZDq4C+E-6zb2M>gV_K
z0ac!qhs;&|4H5G04L4$a{Oq{93@>oPVAJ}W7OB6g@Cor46@#f3=OE<Uy828fWiM?a
zzI+g#l7gCKg5UX`61)049K(1;P3bqDNdZ%-=rE@c{gXdR1CXbyL3T@Inz<dh?;5Ad
z?HV#Sl@5XUCkrN$>0sJ7uPee_={Nrbj*GhpgoAFukgagFyqyESL>T%CS(m@sdhcZ5
z4@Yb8kgfLUi^QBl4i?yk5?eavN@?;Qnmj$xp>BM!Q{Im&=23(<i_|llJBa20vhKUA
zbuc?xS%r_PA-4`fj86_UfWhD~&`w~Fm5qw?cu|zC$jt1OC||@SG?t+6Mo8#$j`K4$
z>R);~{Jg%dVPgNlHu{!$n}aqMC8yMpNAVAc5o)IjfYtf6SnCoq!PaS^<DTeR)=x5e
z`mWcUdkKy+?Q854LEGThK(#lBqdT?*-ps<UM-ehvJIu_RwmTCpnf9^heCyt)bFKr$
z&-;6paA4X3@3Fe%=?CV>A$jDma2)f5S$~_P+EiYWz=v6Wk0kFhd(&sZltE4WwV1=m
z6HR}Ha+)HO?=eFT2FY}WhWY|usYGSyR+s4joCY=P0o+Vn?Z_v0lj)lxI$`faq8SfF
z8sZG+KH_9{Wk;iZiq*d^m<Cilh$uSNN{oBtLX6KvEe7yoN<kh4^)))Tp(#D|PTpS~
z#1;{ybjJ+%T%LUzBSv%Af)!Bb!Mn>@3dv)+yn~^P356U<fPdCtK~r;3WR7S<j7-6}
zP>e?Yr|i7dxCD}cYsZ|Kn&GAUI5XDg2raX3&)K9HIptv;XX1EztqW()<0r%WVEwkX
zpY@Fm4EL#~I8sPyS;*HZb>5*f4-{Fhwc5}Mtur-}y2}fTk5a5FAIHbpP=OiuaT-Lm
z{;$vn35u-mruvKK`vr)r`Y>JJ20DZP#_G&i<TCR_dPk-})YEDoo|+g3)-@xcKlz`N
zm3OtF=kbAJyKKDZ)4qfz+ty_BRZWh>Mm|axJbadr5uG*X_@=b5JW~ff2gA9?lOoib
zo3z|Sq{N^&U<f%*2;b)}bZGMTl^BWtL|^r5vTu`sq)|yvlu*`YF4o8n!+<2rM_rUr
zYw?yB)GcyG-nYnDV3OH&4+ix<QDlIQ2djm+hKdby;A-&314l0n627Cz+V_EueK`Gl
zOtjjD;c}t$Hk7B_Z?<U7iEy_Ixs1}N5*cJBB)j#Ull9|vK(GG_diJU(kPcJ5u;VM9
z-W0~UFlK{tbYeLQiXy<z$<6jnXhy+4COSyz0SouwGwn(dv5RHrPa?zbSzYHYFiPyQ
zAt_pBmh9-XcBHgTy2@lpa{@Kpyvq-g{bVJco#%7ctVm(XPS(-dA{{%jx*4xd^Gh3=
zu+uzp*<D3?W5li%m4}}e*3i#~Tdp9e>9=0DVj+j?a-+4WBFn6hKcoWju1@*c8Eli+
zHC6sq*eO8_=!yn+XCG+F-VOS<I2eRb36y&rGCLZ2QI*k;TMSh8wbB9>tZ<-15*gVJ
zupk2$fKUKhxHOjP<+~|+rmf3GUPfchsYL;W_*`2dO0*94<@-dPft+)H0_O@H#Foq=
zAGT_cHF$z5nXY;931j9k;0VtZiZa3SoobV^dEznPW}PR9yD}`Q@77_mFe^iEGpI@F
zZa<$909OK_GFaIE&eWe%osV9+@8~BM`zi<d`Z<OU47jLeS=dc4UtdcV$cnbbmsI`a
zfK>xd<?v563MwXmIVQHELO?!iLGMZ0ahx--Lc=-DMttKqUUZW$!O2X3zNu<t=V$sI
z9MCtBI~pt%NDOsX^Mlj0G&$Am6BcpTX!AKQQ1OsT*&Xlt&1nJqvc3<oL8Svt76qEl
zc$qv2bZY9X#2omRJgZhQrX>+V5)6*g@HySjivw{B#3}MWIoQC(iaD1#!q}PbP?%EF
zWV%*;m09i4dg4>_KL;QVP{20+@ODL*Dw-!oqM4v|^297Q)^5NA4<soUmy~p<e|ku<
zXUX0exnMF?T$2`PZO8;3eMCIKvrrDQov?TxL@w`e-`NVh^q%8Ravn~#ia)chs&VS@
zZFO5jUPDNXCUYE}IG$x&#7*{zHs4;SHv=%kt~nQmVluenWDxlp_%a>qb7P*n|9}Wv
zw2`f1n$6W{0E!3Iz3*9m?X+y!&zaPmze*_wG%r@J-OvYdxs>oj&dL2Z4Yl?;OmE^i
z?}--VsEMU=y~1FTZ4Pj2Y%Ow(X&Gw#dykC~*I(I~`lQ<VSn5@z!N8gi2%wHz$|#Zi
z7ra*S{(TK^z++UA9vEb5H%`;Mh#6XD^3QwrR?Qnk)4>V4rC96U-%bSg=UKb(Or3e%
zmO%eP^g>PaM-MNjfcqdmE#78SktaK8`+9*r<n*j|cs43Z{HoQ+qOx+T=;*`21O3Ry
z8(xx78J0LtWU%54Jh=_%P!2wugX{rq!fi53fW$+3-k*E&q9W)JD5H?2TZeQG^$4kt
zhbK3tR*FX?8fg~2EnPlKDTAZ#KpQp#_?>UfEk61O^ur1uUX>P9W6om*$_wi2=HS*b
zbfhs{Yx*vrJj#_bfLxR`_Z(pTy8&-B$Ums<VXBY@#}M_=pQS8kz$-=-CtTLo4BT{9
z^Hxbuq5zgmoqrBzNGmOZN(_Liy0-zW>W-85JiOciANii-M&};sv?v2Bsu%4i_?8Ul
z>P|(T#yN@703Hij&YiI{vy3;~=hAN^gNX_JziwSS7Gc9yAxtW3%om3(c0%P2w|u5d
z2Z|qUx8!)Upen#tf9u0Nqpp7E=$e!rAAsi6-|O8*iWT-lI)lx2k9N`Xf&+rImYRuw
z#`N4CLFEmdVQqA~Y<JSN?<{u*HidUBi_#49-`ghULI=15HQ^aNz1<#i@h}~7ddPqa
zvrKV9pZ7aBQA_p6eV*5S_=4t<xfi)H4NOl4F42Vbu6VaX15ES2y^B_udf1qGW+>Pu
zKrXqsB_C2R?~4K~8i)AjD}wBX*F)9n=ho76zZOVT>W(DfIrTH0cEXv{#AwTDZcey0
z&S^o2EB;RQBkpahGjKgX@6)onJA06Ua;Diabg(ON^iG?dxWyT5vxX-FObxWoiXc)^
zf$5N|r!5M8hLMfs?|e7LbB)?^j%=A#hORzZHn62;E3x%ni3AM{mjbI61;FKd)4F8@
zxKFBX-MFLx_F580TU|QfJ=ybUuDkT#5c+8t=j08s#FF@YWv0PX>BAj>->eh0ER*u2
z^(Cq_7XA9o?4L-9Po8{cu6^ojzcEV8fEdmBb&8zM<)IWV@?HBr6QFOh(Y|*ee3RJ#
z3Ad!c80N2?PkX@Vv<gjhM9660S^2Qgb8>)nUS8-2G0L+e<N1~9rzPODTIC2;$!?Y(
z)<^SE1muancYw~968mG5p#Cz*f$$Mr5@U3ozCsc-_i5#ld?q)~Uk>w2Ry8xI%UdDm
zcRKwJ^V3Rlm;CxTRLL`6S4%sLlm><<{Mwovky9;rin_1k?9Uk0A<Ys*Nvr?{z^$33
z1v(6;9`q4%Mho1Zn{a9Xr^TY!FBt)Zb+}=(bN8&gU}@0v>#h`i$`El9%Aa9N9@uf5
z%>_o0>rViol&})u5;>W)69%nkYzLhJ@pocvG$LCc@2_2IqL5QmzO=ZYDD`C0zYK3o
zv1Ww5Px0P_AVqOXnFYcuO>jf~0WHlOJ|NiSye|jrzC@-2`Yd?BR`qflwA@L@Z1!5)
z)0yr2w=o|MrzC;>t~69ax59{TYWtsa=y-l^k0fS5pW(%O<A?nmtlbcET|)LhTVp+s
zUH<_I0jXR9Ud+F7Bepi%Tzvfuru1`qa(0&&H=h1YqbF#Y?8{c&B2Id<_5S(V7L2<p
z!w5<DD=R5jg@)sOLPVJBX+JF<<j?77G(70HrPa-C{vee4b&8-fuCW9cXNoxtSERs5
zerrnYgCTjw*Fv4E2PQ)I1;Uag!{R``SD58m950lo_so(e=Ufltf#}VyE**5f{|RJ=
z7sVw4$V|@$EBLJ)UVpS?1I`rBc3iCK(IFz`Mm;L99=Mrdx3FY=)zFtZ4YioB2#XdB
zNq%jD7{?Rm&+ZMLMAG}_I(=3YjtGkVa0IRaG2R%T#<ajuJSio#_yzo#WeX6U&7IJ+
zQ15QPy#z&>CU+rr`Sl|?#jAcUg?u5$i~Ewas7oZG>i3}V3i6JAmS)7MqSIB}-sHaI
z27c0l7Ya7i_&4K_z~$`<6^kXL-{(;?q6j%TWmq-WU%B^R3=m~cSjJ<>*0|5ZJRtj4
z`_j(kGhI*R;esg;kGPZ^U<mxhX9VPxdmFO;%{~g3`4n<QHaBa4frZr!@7wiU21KSn
z=A9pW@_FgZzmZ5Hm^22W>Gj*X=09W&now;52ADj+q$3YZiOmMKriiQnzW+tg38(pz
zFF3r7@m&rthON59{2kSTX0e9e?i=#v#ma3_lB=)lne!N_j?yJ&mFDU4({Ij-!^}^|
zv)tKUsF_iu41jWg52n<g2G~=wDhO)i!NvRb-sF#6zs%(Q2lTB4a!HW7nkg0AqMDBg
zNY|VdDu2Cb-Uo|V^!=hQyA>^w4ejwPf4X@!G?rG?W}vwj0@x=b6oT$vl$<4^kSu{`
zB0<|a=3m*V<jn{)X%#u9>7}Rn@P%B6K<>uAsi(^&0o<E~?t(MFzSLCJZ7MWng5dv?
zb_ox=m;F80aKNZb<nNhRYGpImt?@L~R?b*bnN^J+pfLeqN!zz_2Uzr+dI~xR17+1<
zC$tdPi3!?%WK^VsE6}lp47I()Iuz~U1Tmkg9Wq;Hjefvf6)<jNVV$T_n?#Y!Q$f46
zm4xC+p%fg=V8yvw_n(9KyF(&FX^XBqlfmNcc5I5Q9{+&S=Yx`G;IM0dQ2<z0`~(in
zUbr|`W(`dH?ox0B2Sb{8$f;+&{XO0Oc}RxK1}`qb4@YN>oC}jTD#kiVP?+^nI~wXf
zYqQb2l||;CA3R8u0(+5L4uakQ{d*EsK>%g8;CrK*7aE)@P&JVw21TjUmBV)Sq{O2x
zei$W|_y8lc7*5kG{scG<)D?W9J}MGeImmJ!6cX0no-%zr#TefRbNe>@y2__R;m24P
z{5G~;7hUFkX%)+^Ufr0A;JvSR0ooT(Tg4mTWSh^U>^_SFvbXv(AkxaLF7fBSQHHiT
zV|&-YG&{0hx!z^i_|xIH4M#M;Zj<Xh8t6(^9(XzS-pIM+S`M@5MWwb3X{fhRWz%~y
z%Gq(1A4`5|M~l~mo6H4dzuNb@g#YgMIT{u2<$_z312FRTcOy$#mo^Y&u)3k1%|~Ev
z-*qPrp&%A_3zppKnXOM(@~UK#BnFb<xBP4lq_2V9u5Sg!t+i==M}Att1hYrt&uP~Q
zUxtlM>x<)^fxFo+co0N4(BA9PWb6#UdM64A`XiKk$>KTcFOTMl+eBx_kEF*HPnLgp
zIT|x7AxfaO&T;?(4%LgzMyt3SCJbeW`)kjNy|J>gAJ&nEw@nyXlInR_l?NaLx<pfb
zZARF0Ai^Lofh+A2wEea0bK5;^FBLC_G7rS~a&xN)(wW0Fjk^!cf!@8M5v`pW>6!QH
zQ{rJYP6otTHXL_!=9_U(NP_loRyVg~*8v|8yJ74;ck+})j87_w2I6;~`|l6SuBU)g
zx5D2Ws7YbtARcKVu4OI!$?%btUr0*o06r+e4-i}P_X6V5pzL3zTy|Ffa?5UvRi~w3
zCA#_DU3g5<?4Nyerh7@x{G_OUbbPqi$l+(VXDRpZJm`PhbNs(N;;*#ZIaAr6SyH!D
zwoN;gR~TZ7=f(3y%Rb@}tg`8!?3l4LUuzcVp!amE>t_Uc8XE1>c-Jy)-WaM{cgVYx
zr1bhvse&Fj=3)JUoQt6gYOQUbRGcU##jDt2#HLZTe!1aocc70^-KI_>XF2CaVhieG
zLvz#*1$LPW5<yHADoAj*1(7ypCDLR6k&dHX>Cl@@iBEM)MLv4&qs(pg_zUf855|MG
zWr~AV&4aED{J&!$FKTD}1Inx%Cd<yM#;zKT3SU1?R;ZFahv!4qw4pS(;1Qsa3nW5}
z!Ep(!#>^QE?bn|y%T%kY&wA$*B^Zj=set*SOL&{M_8^xC#{_k>LVK9DRokDZONkE1
zWK8Jt(}8YtR)~!Ov1`HYXVte7rO1k2i71#pk<)Z~%Roj0mdQ4k)RBwkh;xnen{&2C
z+jWYVK1tcBS{$MxN<FZ>Ju1UR2(tUFOBChLGX1^={;|nmxlrD#Zr3Jm=$bDrKGn^S
zJZW&%8(xytd-qnw;r^1?%8d{N1J4SSz`lG2(5v!mCz6o$jddp1#co|<jp?8-U;G=_
zb80(*b?TL{W!{OGy=<Zmwfuh2L-@!@^Rp|0=++D7%A2)b&s-Y$mw7Ne#}^fFYk?Gm
zCb<Lc?w`@2$H91GrboFUY(x|C#!W@D&18$^-!&#hIPWLVb4L@f#JP@mwL!2tYs_Gx
z-Sj5g@U(Qpx<h$4fg=c?SSVvs*!X!K1uUG6dxBwYGnKrl{EL`Uq>Od4t(xKD^G6yA
z#1%oP^cZo?tnL>J?+nku&fmGG3y7%qqkU82aQLl&e)ss>a{JlnZ|}~$+>+^$&^2z~
z;9q!vjNBQmB_H}ENg!!2)0&^6<K~A*V$j{AJqWFREavFw`06RRsuea*4Qv%Oi~4`9
zILL;{^g%~FU9OqYPwamnREG3H76+Td){WgLNCZ@>H<xlAYSou+`t}p6U?|s*1n>8Y
zVl`}EDd&Ot<Comt9M({xG;L>{JAFl247^bMacXUUPyb=TlS!T>yEovvcia~3VxBmC
zn#_MUk^kBgokHe;y0->Sy-V`lQrY1w>s4jVD4lU6L41E4YI?5Du}u)YUlHvm-ZT@U
zAA;2i_mW`*@g-}Hy|yGmL%Qx7#ri9Iv(?g!+%9VWeBXqW@Qv#rqvG|OR%>&t%xe3e
z*!HTONz-5V-fHS0)%cVKq~9n5N{6~wFjAX-p~Kb0;$2$Z`6C^k43^0<n-6a~;&RmF
zVxrDMF!b@>s~`WAoywV&Mt?|3ljb&|q-9A7bs<!>y=KPRuED9GiV9|CwP{C4q#^UO
zQNUV+5l>^(_xOeXJFNTK7zOr)gaYNLmS&n~^rvSB70e3WG;!8-3fuTICvXO+*WR<*
zOa*71-<XHY6?Duco;;k}s!*%_J7o@+^|1nd*`9QW1ykY;`&>T8Y8D$8--O6kh$dEI
zb>O7gvtg>J;gg!w(46RZ_k`#8APC<Pdwd)9<n=wImc6(>wEROJjnA`<E>=LsMp}9d
z;MFMp72PSMHEO>Wz*?<oTX)jmO)IzMUK;sr_g1XwcK4l{+nfo2HfOj)iaKGDqd>`f
z*I#k_ajS%cZC$awmTWm($qMezZ9U0J8kG}$U9_Pk{lZa~;E0-7R(0jN<oWf6BOBN+
z2f9u@<qIHqtt({U_wZSA+?Cj_<&E-#x~`?H5MG-Lf7oq~&jSxfM!gPpuqR_oBfjsK
z`Ozm-Ey;UL_WFAL3>wdgEXAytD#xA!ii{^j9XizZvzLMOPM+Tu%${C`jh4!NJXh-g
zsk!E;bACHCYiGRHF3>`szpRTgtjhEYPEu!i$)D!5>wC)&f9&Z+EU=9_3jqT`+a4-z
zfSapSiyURN(G;R%V%6op#TeEJOeJfI8;jq$ZF?a+|1h{ML@(=bcZXB_6w*NPI3Qcz
z*2?n~_m*MPpH1;36($^Q^0KBJf_~v~t^khLaNV06iFk-6MjJg1zgK&uny(QzdPj?p
zTn*K+diOLOxL7Yj5pp7|Bh!GrhyN*t=W#81CH_=_uiK}t-c#gIhC`GeAjdWXVt<5i
zfQbV(-SO5NEH`#ac);V-CFb!bFInej1$dR{V~wK@0kd4|^U2vw=I>-&Q+zCv#GG6<
zEMD*&VDY>Fr+|g2HKF-`o9?F7Gf2@C53D6>XuM2*KIsBFg@3u!n^0mk>WaNm;78KK
z0>1s?sEbhpa|X;TG4qb)4YHiUzXz@Hj6=5NfLx##6z~69736o`1*6$^M6KM_eo*90
zZW=K({Qjstt*W3VgX0Sr$>Lct)xXR?&WX0HBCNLN)U*}Xs2r{M^(R6f1pW?Baa9Eo
z#XLPf3<ow{T7=865Bl|I1-`a4H7);oHX5SzCSS>r#lLYY$B`2SxUYbr-rAD~CmLK;
z4u^)bs>dcXsi_HvpOc9f78307`yM*(Y6Mb1AMn0l*Yp8;1xXb}w_)GA@pAKSH88c^
z-DXEO7LFUr%xU>S>KOf}zJ#icEO}w}asyBBP~t|@NB%5m`J^hL1WYm|>xZJDlttT*
zfGBkXI2=N8LgBKP?C3J=TW2)pK+0r7$bgO3BjHKF=7AXs+Cs3|==LszdZ;Ib&eO`|
z$<2u;F<ss+fv-pt|EN*=xm!Wr29xrucbj^cwtqYsk@dDoIN0T7N@otOzRl%#Y^7Dw
z*?udW)Z^`YZz*?xfr6UGTMw!pg_rCo3OCE9E=m^oNya=#t^4k@>)M>RdiOkAy?2?l
z=4XyiZ7XD0V?N7iNMz?XesVyBe<wz+`z(hMQ&;$Pr<`X#pLZfkhSQDT8c4Xla}o<B
ztWiav0Fo=ky-S7M(6?1B)8$SToK0RfnaWIf0Jl#5M1gOv--_D48hgu+*+Oq}b92+U
z$F*CuQO;O|hhP;Xn|aYgPWtpe3K4VdZ*Sb6O*)@`_T=C5(-g7}@7<DCTF^SUfH5&g
zF#&rJ+E}{PR`%ZW%fh|yTo{wDe)oW*SIF#N2a87l_^QD!^airSx=b5zh@VMctJ5Sj
z4(R4H62IXoa~(P6VmXo8l;9{|r|iB`J7@RzwkFn@ubCf;im-^Rze-T2V~@pAVHH=p
zF0*?hv$@NATWeCdzRSlc8}Kl`Q6^$bg`u<7f+9}G2uyYny;;i^7EB}$jFg%!5<#@E
zgRLB&JfL4?FMP*-&XRdb@cpTrV@BI@3SFr3gF6NxJRe+#DO(*UovuyR_C8yu2|DX6
z+>bP0Ecn8%`&<=z-Uo}aWJ7O8m#l2-YT9uwl~<Q!j#e-kZ*B4rIPLFQOtTZV+#wg~
ze~`}g>l?nD`4H2`1Ep7DCm>xS;cwVdl@!!LHnb_bu{Ngv5B!mTNv8j=haYl#WJbl7
zTc7ICZr|aQ+w*-BOd`_^yLQ}!$1O8XUGpF@wuPMBHM2V|oL&Of+@GmP)?w-L$0M#F
zZ*e@o9w`xvJw*IS`w01*+b}!hP&yY2o38;W5c}V8jMx%oMS=;W)0;jS!Tn?=YLgiz
z3pHX6z)LwESgc6^jyK6miQ?=aXK!(5fhuBiX#)<tWKkIo%$M2o?v)5dns&5TdeHaZ
zgFfEgw?-$$4;p}^4tS_RWKn^#Sav{Z#n*N;j3BLReUQ1w*3RnFEx-nBOnNT{Si3rD
zpWic@I)U9?tSj-RD_As<7pW<))pAzr<O%7@soi`72&&H;1q!40v#ZA>8%um#zrS5@
zi*r!`$v`4}`v06GS=pw#7!1>!;>*j2Eal@_CW%L94f<b>sZ6%{7X&MQ!mc3$sGXyX
z&I}Rd*}WrEPbyW(fBfmSRfl+dA%D1zSt$3P*VIxX{BL<3y75C6<FnYp#2MGES|YrC
z<BTRC)dns2o$2ZPq$KOD9uAUg8ISLQa-XHZ%HLo6)Q1K|nr4lVYM{mSp8OJh(K2lg
zm{X{ulvw5>aMDoU?(SK7-}r=l*4`QtvX4oul;gBiTKMC3C3Hj3Eo62=HA)A(i|`EJ
zoKj01jQ-3yq-h>U9&!#{-)yO9f<&gFm!RiQLXosNJk3f2C_Xhm!20jN8dV=LrbY1z
zsBM~pFrKS{VzW`v{s!OPVLD!4nKviPA8>#`V{JqdXU2^EAiR!VA4vC-;*fBhrN~kF
zz4-F$cAj^58;48*Z5f9#po>Y3BCCwl(90ytestkqQztlSf8nl|)UUH6856-IbJ=G4
zb$Uil=|jsY<Q`PWU-(D2JGB<G>C>kT1JZiF0X`LwRf^UYD@sA`P&!SXw3qx5oo*E!
zHs>9Td0+^(9iy&=v5R^==~2o&ZSC^FM~Lnvo-znTGU~n`^GEzJp^ZIxh`w>E_DQb&
za?<09;48_sBrH%t+Fu!GbtIaLzq3s^lhBmB9%7VKQV8i7n`{*tT4vT_6x=UJV6;|!
z@`TX<1a#HGX@Nr6KJZ;^CVw-TNnR+KXZ;IF{Q6&JT;w6c)=Uz8pKaNXfD(q&N(Gvt
zQyqk$>2BUHaF*=d@Xx!*ezIVEbzMmG+o(*IXf2)pP>Eginh_gOg5|t=x?)h<m_}Bf
zz*Ud;S#<r?_kIGl#{J1=FpIy#xI_@?JJ}Bzc7byYi8Y{KF){g(WHuu5zSfxl+k>f_
zu0GDQ+0Q;rnzOy(Ni-pyzD5T~j@(d96(sZG>s8D`K;*l=Y(SDLyL|p*v$E(@T1>Me
zKCGYaRH`!;>V#w7#yxW_)Vh<bUC8{oa!|1(p|(G8n*L`tk!I6T$|wT`Lk29%;j!1&
z6sL3^*$(EgtDHJR;8fpD@zu|K&^gnxn576txTg;H2oup)Zby*V$)QnTBJ-B?5ea_2
z;uq9xqYEJZWoKspL6IZHmE7&K6IYtTaCQO{==EW!PaarC<f&{=H(I<$EvTVvMLF}z
z*FJfZi6cim`5|p-A$cTGC^1~<CR?z)0FA2_*S-JL^Wl9#Sk{{YI`hk0&xu+={_7J>
zHyiw?j71ttZM)S0w*#~>L&P5x@4l<jCY4j(khhI|TA5_TIlh{NojnY8TB}2=h5vj~
z$#2|!&w!CR17GA?^FgqpoDE-~t?lKcQ7vwoenQ<dZ#3!tFyAPQgIz4*2u*Sr_a(rw
zmlwYY3qff?ZtvAg-HoX288`3VNO2AwQeGt1Q<CYEjXBwOMx{q>ObShoY0upCj!q?*
z5O7Eq877q8+cD4mGe#f^E!0cXNLr7aW?YQ>Gz@a_vvIXNhcB2d+k1~&sIZ`0DDO&{
zmr|5`%L9{PwJ>HH=>CYlq#wr1)t&sJn(t%Qx>=6M$f*Jwi~X&zMPIS-?iV|zwyC=x
zvTc*KKIxM(<beQ-zy-SHz%j2%b@VPtVFa~i$)|x%7b{Ao!NZV_Z$b9MP%bp-2-nj|
z6^~FE;)@iHEuuPCCEA)Xm?Fzvr-t^b>B0u%u7M=Ag#6&nZh8V(hf$ipB__2bzD3#D
zyF^)B68)INN{%@T@Jg_ud@h@bEUm^0J5#Lmw6gJkPBRYExMH#SVEpBKe<dgeglhQ?
z*~-GHWmviXB%li1fhWj&J5#{pYkv!(H1cC`HX7rv_@X#KL`uB)l&$q^?R~7^Zrq*f
zNr0ZTkvZi?6hSvLUHQs~ljw_eZaFlY8|0hbCmii-7w@saDyLD~lpy`~cs*_PwhTf^
zH!s(GOJd{G?tg%Wetho12b>2oAvb^-!wAm{daGrx9w{N0M18UEYb|QM$#;hs&^h6u
zoA!4KWrjsI)g<>Mpnu4}A0km(F62aW=@Jcj=C8HByrQw1I@RGBy<+Wg|1&D(#DS7W
z73l(EqhHfebKzJ(Lv=>|rV0l5p2Ep72Q4}Ln85rpvxSz2Zo^fQ8+AV-nEKrqcqV`H
z&j!8yb}zjb5nlZS&LtV%({oEdU036Ti$#~{le}KZ$cE&K-oqEHxLvUT28pxcYA1^2
zRPWorH06cKh!T_=jjbEt3P3ch!8!<`YpQ9E-{t%9)B8Y!e^1%k)Vaf3?FPMM<nUv@
zdW8;nF~r`_o*U~UF!=-~Aa#dvG2x|PSlB|$K@BrhP~4GM@V>_D1OnoZkMdr509x{f
zlrFxP`nh%~SHK_QpLxmLcj@$Hg|+43mZ>sF4v~YD8s(YphL$f1pIzCqw#F||9}m4t
z_<>d|;NjCpR}+bCdsa`b?@j$F$K8W&_d1ZjMPS~9|G?Y$?%>8S?jp^Wy6CS`AG+6p
z*fsB|D)>FZVaUXsN``+*fUm@+jUGeMN3R_co7!I%Wn<E&n@T%kIzLsu|B@7z66bze
z)*hQn>(Nf{a2b%6<lsh+*#D4SL1&aoa2seHx(<%`XyVJ0=IZFD=+<e{ii*cDvb*u(
zZ)X9b)hy6^VmnPWZla-`_tbO)64sIqdtKld!`?Q2cr>mP^4q%pioUCRWMNP^A!G2W
z@!E0w<C_Fx>qy!=y^N&aVuL}eAR=WeaoqUq_=5lA2g|e{haFj}oXkJGF{W260Z>_?
zHs-i%kgP`1x3Gboug3Ko&v^D0d#WotDej>Ijyd49gtp>FGHwS>SFYst^;D09g|Z(2
zCkg?0SE7gxaY4g%wOo6t$D-JaIszi5%P)Y9vA+hkxo~fpvURd%38HIq2!ct8{NSrl
zq3LGHkqxXx^2V*WnzV&UoI3Y?ya)J(RJ@Jm5>cyqu$Eok08-CiKQ?M(Sm<^{Up=Nr
z_fsX0K4j$R+qAv?`6}5x6Lg`aJk6{!S99~M%jWM5ec^O;fB?2An~cW!f%84bG_7U^
z81z<%<lf}`gg9K;du>bI7iS=!>@(*bd{GmU`$lKWl1Yh`s0Vz9CszKoU+Ka^%N=vk
zaFyZLx*R-<z`A~!FrUHIM8jpwsqlOig5=u4him*R>~@O$vu<w2rV8~oKshad>>Hxn
zr$ooeom89r+Y6NEVwuQz3<&!<^C@p05tnHFuOEx&w=yqOLLYU{woRgETIic@htp%Y
zM9Q09Q@tYpHb%E)MJ2w+)Fz6R)^;F|MEw#?Q}X^qP#oa804(5?qzYdj1zoMr1)=Tw
zy(~$mo%;$MT;&-C!aN(u2L>BZ4)S5`b1|1mN-shzHPOXgeeBUW(jthicqdtP%4z%|
zLkFqbC!>U}J4$pdMi}_xCiG^$ops4OCxvM+>BWS=JE>cZTp|j`Q<;NU3yiZS`aE2)
z#_6R_yQrzye)1CC%*^My=Ng^E)+}@7*aPAZ^33I`@(%@q-elBOg^E%o`W#Ta@+YYa
zU0KUX7kE@4zb`hl`l^w-DKy|Yh&=-2liPb3eQ6g{Q_2d_s%lZDm|Ps>?h4;f##18L
zl513`v?y=yccyH))7qC^$`zMa)lVuLw$1D^aNbdjo0$Enx#lFgsiFI;DbAHd<e0$5
zZ8-O_zKx&JH?vN<GLqX(0<L}eFQ{JYQwHM!3f?cU<;Vef2joiq{KBv^xo&yO8}kpZ
z$XF6Z@rFGHD>S+vtrt4|1M-*~zpTi%12zr*3fvVcAMf<7UWa86ea6oXBvOFF4U@&w
z9wa<5G-NiulL$C|KvW%|ImG)dsy|dn2@>Q6Q*}L5DV6YllaAzpz0u%43kEH8ac=Rh
zY+%vWd=JNiWp0mGg`gv4q6NCaYkO>133kF`&q;K0m$pXeU=GAj|DOCd6KZ2Gx2v^z
z&7ejy7wjQXA1U23te<pNAtk~j5HR8fVg6GtB(J$z*H9m-qFC_rsRf=e+sTE_kL!Mz
zFX#d_n2z%qSP3b9?{wv|a&QiBFfgFK&uj1kh;*Y*&>)>ED+IIUf&=kU8Np6CyFlFi
zMbvn9KhGktM7_xa0KEQdf=NEHfSI?KLXP{xrS?Mmw)IWX4?+zda(xhG($Q7*f&E!?
zx&`IiT)VF<kUq(;3H$ux$Ew}94bU+?4v9xyZ4WokxN2Ixxc03Lb&fRsa;(CVY*r&k
zQ?-$pk>mz`AF6x?Pus?`2l|))jk4p^D$KhLQa^ckADx!#;9U}}>|E#nttwHh=0NW`
zXkf4(Fo|NPs|81kV)ZoqRf~-g4zT;th+iLgzI=1e_}N@J#<Kdh2|k}cj-|)oM|w`%
zaCw9J*&s>f@Px8hbiX0x5E<j+P}hcw0oM!iaiXCaN3Ch0n(U_tT$c_Xa=s_2Zv6M_
zsW5{GAa{SmULo6*t0sw0kN$QnQghLVJ&MxP{*K>v71<-@_V#*3EuudWKZP}?B-OJL
zg11I|X8eTzbnIr1R<ms^&SDb92JsT0XCojdY^grB#$PV5-d8PyqA?<T(zI^J0P^vh
zke^*8s>r84Opy;8)+Gx$vk3Qki6~8rGk@~SdW`E<ncVTH;|`qmrw+w#+^-+)Ht7QW
zApgiVA?w^CkXN7-HVY0Nejd~Pl0L~y4fom%I&|>fMN>eB1;w~G^8WX=C&sD#>mzwt
z+s^pM7uAoiR+fIQ+HK$V`CJezJAC*Ncdr!_&>p>POno`?#Pz=FRqb<SbL!`m&)wX|
z2wW}XuKh4?$FL`p29?vwJnUI>X)lzhS1fb_{1i5(i%lw6i;~6+y<~VW5Aur&05bSm
zaS`URFo~IZzJqVTXl7PKOL{K<{+RM{g_=812gY<_dtFh(6D4NYiY{h*6WILZzz0ok
zc{gS2W}pgGo^4HEJub_o@Ob={<*{<-DCJohIHBsR6*?w^D;_k1a&HOg*!B4X^kzS)
zpzZpOp1^LhNDp+qT7SKcs$?oFmp$)+kYAf`4bsn@?doY1F(*HfmR>z72_=Ta2Y3<7
zhXM)$F&9Cot5W}`&7?ybp;R3#tNYvbxAw>SbLq7Sl8Wjw$eL0qlN2`;3x(rgE~=1K
zTp<d(FL4`Po?5$6`i#xFc9kPB;pvwOK*Mryf3l^nE#@ZUtIBHWDG|3PA(vgAh<X^T
zW1L6^^HL9+$`ip2>yb4`E&hBE>Ro*SGY?*od+lwVBhxYB-URN0(b_ku)@9L}2K0Ch
z+*i+`7yRjxm-<SYZ3d8~VEL+wwJ0NUY3@<7YdqHd2gKpH!3Wy$cSku{_0@YFzuR1*
zp3#Wp_q<0Vz39WWzUsYiJ_9s)l~>yt-?foXueVJ;Q(b?Y%r)4^>KnHjHkTC2Upn0;
z^S@YotEed7Fx-2{0qO3Lp`^Q0q(o9WRYXd<VQ2~I5ReAx9BJt;5s=mafng971ZKz)
z2LAhXuf4vb{q42(TKj+#4j9(VGtYa+b^Wg3*8f0;CCkG#Hh-s#W=KW*aSl`Gw0w^2
zT{S_0o1~bU9SR~>{p#PpU6q?p(M?}oPe_DrH;_xt12EY69nW5*u#B?mQ#~DzEJN|E
zO|IVe{?ptg$}K0hcC<Jf-+(yvrlUp+%HJ+6pUc1MDL@=MO^edY>){cxJ6mAPnL$Tq
zo49*Eg=a&86%IbTU(BZ|J|)s~Sp6S1_RrsUocvwh0WlyDHuqVmnUE{`W+bvNHS+5&
znA`jDZ1jaZay5$ex@JPT^c45&bznr~xd-&5X*yD-E%f@MPsCZTtrv@>ZgwxEWj4Iy
zjt)IJ#%l!)fk}LHQivPIXN^%B-HZ}*DO>peoNjDh(RW;jCB!j1WP*Q|Yzz=zWce+@
z6S8ELtlKzibdlqLkyCpomD*0=NT}&(5Ax+k=}99}9<J*+;T=4@^XV}^UhBdD9cIvK
zaT{2{t=uS&oTPurr)(|3ydbCWGM;@E96QW@A9YvZ`n=w?Igg>wCUGj`@%M=ph`hYu
zq{DlQ<x&bJhoJ!u{^7M7m5rCIrw~y35Zcyj{I8=STQD9pX~4d0{8ViuFFE^YxQs&B
zA!bt+qWb+~<hE%f(h^SIyF(E_z|#$cvN~vyGSFWUcUuN94TAxh=Gi$67CkkkWB~|=
zSgcrf0^5G}d?KUdmI*n{pu(_|f!q&NS+O=Dj?z7&H8xD9wYiL?p*JZl9953Nd^_=j
z+egypw=#;lM>8iRK2(Y<14Pf)wp3OofB`xzHR1s#c7pkZD?F+_W?3xA#^pP7M8T6M
z9S_C`GeBL|p@V<rhDmvdn4adn%+v2QxAnFqCL~u*7?eKy5#CbKqg!d!_qw?Wm-4eO
z5gdR-4JNX4qC0bty~0n&sKy=ZthqWq#^EHmPRZ@=vS#?|9!=6k-Z5MyNAAz-016ff
zVAA7vS?Hv~x40}O)S18;_;)sh02Hb{GV45PVb8U4q9jhL5I4TcGjOAW%Qco&S=3Cf
zI|Qx{-T@{RZjp59anc0K{;4vX3m*i%FBAM@AXg~a67gkZb*P!wch{xJM5B+Jn%!pe
z+!T^Z5nTO_lYicBhX)joQ2e=x&hnW~{ivz{`kOcEKn74y?4+g1M278GrcJYS&6Rh(
zbx74AO3tedn9^Z(2rAinw*LEjbLVxEu^G-yc|1;3SXAiR0tY^m4I(YIBPXdc`Xdlt
z)IE$nq_|A<ccA$7JYOTy{n0nRkJ{7M<dSMs-wsL{RmO=Gc(W#F9132o-$&NrJ|VmS
zvOi%0==gl3C@lv2&7C<|VL7S(<3t(PnEcf1(szDm)FCGY*RYe?@sO0o@qeVfdw=VC
zZ&*`aItS`buCXGQ3P7iCfo%d@E`Oqs=7<U2MU@pEH7{MfJ;>pHhks+&S(Kq<GT_wJ
zotTkDPVtaPIURtW_&CsEQdh7VbrKS-9m`{szC<D+gi#9f^g!Ru@wVLx@LDu_G#!ia
z+$g<fT4p_(cAN;8uY<~?v&XK<lRc_6*y6@y>Z$oY#U<C1C+9p91LLKvm6&`5TOlc!
z54R{q8=v>5;V#I`gt=Qzkshldxw8!MU<m7El+7fm<ZU6*f1s{fz|Pn`kJD3==1&-C
zX14r{yJZNZ)0ge=5(o)U5P`w4GUz9FPaY7KQ;O+(c^Brq+ujB|04YRDXn2qNf1tDh
zp`P~KO*#MdSDBChwmiI9`r$hk@od#%Qr1d^-<?o~6r3eN;d2jH70*@}<bOwt0w-cE
zT!mMYU+~26QRQW6rqCY~8p@p*q5&ZoO|bo#{Q*2;#&?}GbE=hqZw()L;J!ZSOb<r<
zH5$qc6Hz;mv+h9uUAm)dI%pHwE1<+tHbD8Pu|KVbdZX=2pA(cN8+M->Y4MaWY!3O)
zt>V>mIN1gx$L)pDC3&^h^~EM&Vkd(3NUrSVXC>;#y1#!3CUHDI9H5Y>8Ji`m^iJNF
z*e&ukj^Zc<g2lGrk&J+_2(Jt<FVEkt+bdQEpN!p6p|$D)5#;4TyrN}2=|4q?4`^eE
zxRGGGi}$}BIG{!Wk%`u4ysHkK(^K+nE_ff-RHQLAmW#(y`>_U{dX?fz8Dqo1)`jeg
zHY6=)5CxRfJ5TIsl0?Z}b7c#xr*^=7e|7eS81`(N|D4UsGr^c)^(q7kgCn<`kO$xQ
z9}Le?6zzkT0Iu5SJ8=i7TJFd&)T(CP+Uo6<_N8dPwUOLLkPJET5K`%)dCOo$Mf^62
z+Fzen<7e}eqfU)U6Z|N=!=Y=_|3K}IWvG(e#)Ha(OiGF}U5SWT>E8##lZ?NCjGI}D
zt}RNIot5_1?`3HAuPth{Au1N~pnVoG0|URcqO}ipZl#RaxA%U93KZ9nvBZr2BK^dN
zs#^Y;e#b2O*q962^Hh)&NC=cbUkn4z)-s9=e^qdB;e_nfqUCp`HqHC8qJl(Gz9IOX
zDzEn;9ad;SLqvy(e3EUl?Emvd$l;J(KKEhS6(_aNL6}7gmNZx1867wc@qqWG$z=Fe
z7IBmx*~yM4m}2~3o=$eFjf4i91|V9T?K@`7_>KdGOXsyy9{^pGIc()E;T56vw{5_Q
zKA&~Q6z(v*RdTBP?ZqFjm@ID!*K}p#=ob<j<<9yJ!YK-~VC(F_(jJtEef|F3%)+RP
zJ39)L<EvXn5t{H6GxFleFKa=z3Z6=wo*-QNj@`8qF|=2_3fI;_PYk!hq}Yarki-3l
zgexG99*_x<(l%?s^(RU#^(pDouE{`cOmRK!v(eX_fL@k4M)fghp%-(qv!3jFU#ER0
z$X|dviD9$*xVI?fR=t4(3>)Aat^A>lP*z#JGCaF_b@J0_7rJinbDnYD)@Mojr`dVl
zpN-E@9Eo^>-0O#GN2fd>pDlXnf7QIz2Q+WKvvXBn@_t9@d~b%S_{KMus7V8FNqC>{
zKpp1zV34H4=|x$0ln64VRGu8XO$<Q#-9Xm-|2u+BRT=)jE&u<;58lcE8C10&&7K)j
zuf9Xl&!wsebVkHv_l?LcW90tED_k{EB$bk$_<Ipg*U#*vYMANiQnt%FC60>OroTTW
z=7@JY8RB4aVU~?+Za;D`iJ$NZT!Iy?o2_JOgS!a~v==)fBrzwW1qo4J?MJd^UHv^h
z!C6vW9^b~2#=6QzfPO0hF&Hfa&y95q3u*eCZTBeqT@t0425EGbZ?I~yUxYZu=$bF7
z-Hv_!DUEicxX#Z^Z$}7AtNhe1ReDW-=zgpUSFqk4l`;?Sny~QCq*b}fH0RSFR;IW_
zs*jN>+`)&VYaEn)d_m3;UFLApCgCq%n}2G)_%wWy;+(#(#t?}pX+OE9_z}6S0Bp;A
z*-0?YVLr$s8=Z8U+|e6O=$cG<t~S|~&pd0u{(4Er5r9W(>Erkhq(PT(3s{;X!07#i
za!kce@=f7_mvil(8>KUmWkor8<+f$#b0s5!6B;bfvc>4t+<?@I=NIpMrNSCV*20L_
zvR}gGb_OC~^?gs#EF&7D1&Il^?Vp0WGO76;{1oYcVe9IEc^NK%!6Dni3--a9?Ig3Y
z%dc)75hUx3Dw>(LJqwcKC=LT-C0C2n^BlT=tjiqUN&nm;?r0DOPr^OR>!x?%6ZW#u
zm%Qgr_&2zb0@um|To`%NK`eJ@$mDZT)f^DCwCVRrrQ213e{-v@tK!g?eqwV0oy(ni
z^U|b~=POFa^;_%UQ<3An66H~_yZrOa!&obS9N;Y=i(uF~D4}X!wiqu+d!H9qMSuDF
zb4Afh?C74{e$qIm0R>o1v_CDfUHrXp=$aGyx=Fv0G6@0mr8^wjos6V&1izRc3U$i4
zYw>aoaI2Pw<aZXu^FfyVRzCvv&%;r8EG9(iNL@5yIwH@Hk#M`Vzir9qkE)W78jJZB
zQ2^1=2MuJC$KzVY)NlMqM!X>0J``5;Q$ME42hosfSA`1+;X%eMDipD+D|HLc87SUZ
zbZMd?!>x~+l{8<J$9pe6ORrUmJ+k+3M#3mylY&iFCprGVg;l1yxS@p;n|`-j?^6B)
z8Mxq%&;L1d;q>#`AxW33Bi>V!IX)_4-RXP0ZnW(0o}W8$y|en{j~{+x;m6P-s)Fmz
z{T++g^5{Jk&ejaAs>?~<JvpW!ye#+K-ZiV{{Tv0Ql+j<nU!A?{sCRQ|IZ(*?x#1Rs
zUl8a`QHx)2u|<Nt7yA@-5qEpsCFN%~l>O&_eG%08@SQjNOa?xnRL2~MVQ-`on*$nb
ztjgMx7?PafpFfuyvgZTOE?{1YRbj{P`Dh87-DRl%sn@(}ZX%f>Ir&8#vqoXxa-)u^
z&_<JOrqd^f=Ebb=N=#FICL0&SIgWT*I?`7XMGYLbe+Q1D{9N@7^E+nEdfC(t_du%H
zpEim_871Bo-bfV3<I}CAJElHV<l7x9X{!rj5l5SM-S0}Jbrd5UOUhvQ?C)U_ivX(P
zAyTjN{b8qfZmJ*ad`AYdf_$RyDRL{(e~>D;dR3qKw<n^bol2?hiiBQx_$2Dzw$uyD
zqjKNlGyJmpb7*>}?w#~IgMZ|#e!n3Of^D>Dyl_C+><c}|fbJ~052Uy;7FmY2vG&>y
z+E563KVGPhp!(aE+vR1DO!S8=`MIUyu^4473Tx1rSJEIU&Cqpt)kSleC!*vjNkY0i
z;qWsp38Epdv!%HPz?API%IFfhmr!Hra-Cw))-+!-LDOygu=O-tSBc^jYVto>VahBB
zi&1>^Twze8Uu~gIS>cqK&XxExJn9feMhNy|6@4|Fs3eIfEPgR>k+ls!5@l_Pn-T&8
zYeKGeRbU*)=%T<LSNj`2P(hb6AFy9jeA@89%wG9azByrMKdnzPY@6-z$f$W2ppYSE
z^%+{93ySAPmJKO=1xH)C_Y9PRx>{Gfj>?$4L|F1P!Gi!<*pdejwD+kyI{AeQt;uHd
z^yvFRRDR4xX9MiU9P3SrW#RKuy59^}DUayaeDrx2vO6qkqBjBLy$aO<j_PjsT2JJ>
zIUYcPhe<Eo(a+XHwO6q6LG>OsbZ5KWL{>jZX<^{OImzt9)&BWAdevB<xOxsqw+D0f
z2I$di2}?-PL}^{GTo#sJxr`#*j1Q-3iTOS%k`o_}gA`3}OOLjf_OoW}i{=uo=q=SA
zs?8CDIm6auQN0K$d&#fdE6o=c?N0?YS$(t^(aTvn7f1G!jaWStl-ce}>3V1O4)4gr
zo9}N~LExvhszasBm>^x0-|y?{8iLd@3z1!ebqzsBeD-sk8LU1=n<Eyhd<%1~SB7hI
zRc6jGn&7eGR?=)WyMO!|LFH!rYc;ITy&j%T-4eg5Ma3I3k~*3eE+Cr5E{EEy+pbw^
z?>AvN%->Im>r%Xoljpt;3%v{Y_N$Z{${~~UYQEW8ZS!#~?R?8}^c3e6P`7L`^zr#1
z45>!)n2X@0@EvNQrI*u_Gx6L-NLIhaPbKb)cPhbodT55XjqBRoHnmM2fw}_W8@YU-
zt0ASef&x&<#Px|`>HNo@l2u!eEz&p^_WY+sW`(ms7K71ECjmBxi7W&axxarHMyPX}
z2hidKPFgOX|N3GbSP|mPQat{=ID=-1`vL1xP5*L0L#@f(-OjQ8Fy+RRIU2rB-JyCq
z>31^(8`NDtQdi~_kbw5@!|OYW17j-<1}vY#7al5$*CN9Vc#OuqQHmA>e4{o11JFkN
zm&1A%6Y0a7qdzut-&8pUGuKq^R{o%%x+o}0o9pn>_{3=ZWwyJBmbdz^@P;{F^i{$j
zB1EG;yxX9t)4@?zE#l-0chUY$A5s-)u(rA}s<nDv+}e}YO9@(b=@8o2X>UAtE#`Vs
z8>}2`t)^oxPuri&e9e(Vt|wj3IlNUNPvgt%(|9(F^P0Q-?KRF8e86b+*yPNzzb82;
zPw7;rH$hIw@S^OVfBU<3ka=rx#TaqNQ`_Z!5JMJV&Pg}dr^WdOl|lKJsGzx5^JJTF
zEA@S(zV!b1i<fdC|2)gEDO9HXM#Wm&Stz&Qd;($mj`|TDG22@(rv(R!Va(bgLCMNb
zro&(Od3T44xj6@?$LB5aql_9f%xigo2cxh#0??7Vn)ry`{PmI9_f)_EhRvT>nXAjI
z^HtkKj~l<d7v6oca5DMi2%_w=ES>t)B=xEBa`W*B>xX$sxu-{2KBm`U|AHg@y`s$5
ztnE6+_qqiPh4dhe;<!<nMYsm~e(c;B3*K~OKZ|<X3SM>1mmtz!YvH~wygFnGz<Lb>
z;*hw5wd}~p2D)55cks>AoWC8Y4dZk8*z%?Jg&@912nIVEbq-klIY;g6?C|_x+$3TI
zv|&a5S4u`;ZNSBt3{2C?uk3(ta4NttU&{|xL^vJ}2&|qb_ZvS?*9y<lyXWa@nZ*D?
z;{D{_1*)Mi7*;3}9Qk$fIY7|U49Oc+WeX17+M!4~5fxosT{q2t*_r#iMaMk5?kHpE
z4EqaLlm-g!T9P8UxzYD@b?)d28PTJ>H%zEACC^H(d^qKQ>u9#*=<-@xu=kN)cNWuk
z9F<C3c~}+J6-_aciqN;`mu_&+uWHZbM@C<@N!A&skDdK?5GI(kZ^wx^G+LH+{h<Hw
zdhh70gY-<QP$KMQk;UNe|3KgiMxnAd7^GG53xPjz-?+B@@q!E=|6To_!<Slk+<+UY
za1CDr9?bhO@(GDTNNRrXR+UA`Z)pIA*8Bv~aUMx8d``IbGDHNz@Bwpt7L&3+xJ6(<
z9!}8_3Uoz8(oFaLRTS44TXROI#tpO|%KA4)8Ugp;I<hLhiS4?xn5^_W^DbUnnAg7Q
z50(Vr^q+SFpOk`>vlo>mWmyX@Kt=+n6FE+WMySh%5D(XI<#v?L<?-cWs~7y6QVO+%
z;-dXwXmdFz!DvPF_yag%x|wYaGC(}xD!pENLFQ-F|3)lnZ_g_Gf5s5b50Dv^QT&s|
zGfK~seFN0wUovJw7~gBtD#i%<;>fciVSlBQ(O`rwYNGCg^*6UyyKYO#FD0uN(=18R
zB`VKP>?=^~lXvt9!^~zKdo3Q$ejc75^=OYeV);R(HT}LoY$P_I%-(%~F59r5p{{zf
z>Bs0g_H$i#Fu2_79birTioL%KiKE0^*%FwF(0${dEc-D8Q*6W7$dsdHjZiC_u$<1s
zAJcvx+on?6(<snR6Tac0Yh9CQj^RaK;I7eW#LX-%u%)_SYnYV+j#PMrtlM>C*9=?S
z><9R`H<HK>I-vVUMI-jSjD*3V?MKb`N|}P)iSUFO>W8?wlT4GUIex(BqQdqAlc3eR
zT!v;l&Pr9yY@JTZgX3@)rJwj<)?k~^$Edib_Uz)&MF(M$*KfNdpZS9Vr1$>=;b7en
zN05;<>xhOr4JYrebTJyX@|+yC;gc%^7d+XWno*luhLNm;)8LZ-KxS#PIVB{kj!|D|
z1gH18o!19pDZmhm2@4=ZG=_qDJPYeb!vcaA>V<nf*E=;|7?zEcP7DN<5&U2DVE^ZS
zt?4)1zPzrjxzG`KneC5Vah2;O`EYUpeGSbOsTC_}VVUCv;vx6sz!aKaBsjC6aMA6P
zgc87e`Nrb0YrCFa{>zRui(LQBKVQnz`8LqMZ7s$CD`3R>4#%56M?&<AYi2nWJ@JI_
zX4+;kMQU<#)lzAO_yI*5*B-Le)V*Y>HtUg$yrgGzBdPyz5@3~!S<K{4W5HFjzy6D*
zCzO*FgZZo`Dtqs;h^LWwQH0?A#VF;iJG!;l!C$sZgC|q4_YsiaGCh20(jKyg8f=Z!
zJJNiL>NqW>>Lr3304UbeP4%4faO>)55L1BSU~mV*w8!$U$56t3c_#Fy@exl*aps}q
z;kW#Fy#MOcf%cCWcOWa0@&4U#YvBu=Jw5h4PlfD52cESBYv=J>gK&vWEtD2aQOZ4^
zQ%k&M(oE41+y#_@gX!#SOG=7>daXUosUv=G<(11awthW7!gyU#8)@%nS2J!%V~3d>
z&zu&?ktyY-;%PT;#dX@v{TnZtWfPtDz7dQXOr(-kiLN`J=3RUOcuJvP!BuzjDl`iL
z7c0jdg^VZG6v7ZIEda)(yM8#d*E^U9D7yQE8DaqZrZO{pHO$=^NGw!KVbaoubajL<
zj6^2ZZOaTM?Hjt!gbgJS-B>-|CGW<k)c4<%z#zPuFo5?-uWg|!#^#$f9(Nm|srhyh
z&h(_=DL-B_=IOR7seLfRlfHq4qZ1Jkq{Ix*$cem=7GWs4VBT$+5=Xg9sCj;Pr7PO%
z@zQ&?=YP%eT!9WQbL~G+lL=G`Qyf_x{BX%2eIzuuI@jrg)t`kVsv>0hu5*cd31$X4
zGf%7j{JBbOKqa?<^Z2*>yWEswM6BfDA;7#Te?e1alen2zNBDVGND%^(LjOu7id-M0
zt?6cnC=MlJ4{6tbESDK1+20s#N?w^IhuiuK1gpi;q0WG7UYOVQ95|Ny?P;z&#j<UZ
z{EpK{*^?d6Zu^Vv`J|qADvV1<ld&CoKRe?*#>eZ$wTWb6RG!X(m4Ju;e;`^V62u{}
zBG6j>JnbQTVFf37U#@7DV<nH*GD@j)33~$g8iTgc>6jX+vvf->_c4|GSnYuUbVMBV
zn)KS;1-4(wP?)nTG*q-pDmn#1uJ$wB(H~a;RWN<;f1rQJi^MVtN=$yGwTr#NO8XB5
z2wgihEVpvsg}*7ij4$17uOV{mI=&n!%CP02Q8RPd&`nIAQK86bww{8M<=uxqT&%MT
z4zg{FZWcNBc(_Ts+t)c)uTq)DkGCE{gy9>7m&Q0QcPLA+tT()^Bxol5L+}EG*L8ud
z7fstFMcrj?V>;LbpTtb;D873#Bol8A=1jYlYczaQN-f$hO2#I@LAvGk+Y6$g`>OHV
zhOfpmcE2Tf1t74bz8X`&XSTg#8Cay&?OVKZ8yZ+x@U2)Y09}OhAqL+(TRJLNAS)W@
zGI^OV+so=}SyJ71GtN$cI*(+QB9mZKez9~?=DHUn`9`SWK8Sqi4-+0trK6!7>#)4H
z*i;#b@3uzjXynwHn&OovQR9k4t6J|UX`{KW_jls+n<Ag<dhr%~z;7w^&KZp%58lS^
zvxWwgQ2-}6&TsqVnnCJ6(9J0Uv}I>jg-mo@p|jY9sH>x|fU%3UxPF(k1bgpl4bxjI
zAQ?GA025g#aeStFeh)?RT@?Fthh!ay+I-d1o2!=_59bZ<E#w2e+@?`u$~li5alpa6
zxETudxVX&p3i0!2x8nX}x38EuG_M}L*oS+gzVb&Hd-Fr!8csRH#Mj|(WN4s++wYFZ
z8#~f?jLI3v=ZFg+GZvcB>Y|UzfyfX4HH4_<^5f1=isJubwkt{Ysr<cQIqd`O%=(Mx
z^75G>q*_Z(`qx*eEDCBgNr}2h7ILFyNax-T;J#3~K&sN;-QPT{tAfuU4x1i$I5Wf^
z)elz+4h?boOwXS;mr%f|XQmBh)w<8b@ctAB9-pM70Iq7N`&X$Gav<4PpNpbxefpmM
zPrTCx)?LvuWX*XqeUD+{fRGncaIU^3{5FTwoz`dH=bnP6^7Oph-mia84jgxz5oUkp
zuB7u+l|S?`d&m4Q?|BEdfxIJfGA-JLAM3N&v@RozA>Ze+>&4|>R8o?wyu-PO#0tW|
zfNQK5DD5KRLQ3PH#E5-h(McxZPFFHAL03W&LT)5kPfc`8cor4v^V^O)l0h1rY8gyo
zzZ;mEem7(9T!A$yeS*nuz$BeK{=5at<oV<aqckcHx%f-ys~ies)&nyjvOW%<s*MRL
z79EmDV@eNz4r&<RU;5NXe%o8{hqNjjchQ{~(f+kYcT>jHmDeOHb2&;vGuRBo6aM@I
zRt}Y-V3sA5;3{uvl+UYwJeH=*R|k71_)DK;=dy}7_0{Zlllia29O&UoM;c^G9XuGh
z{1r@wJ{b+QNa)jhC6)ZBJ?UT#nyEeFNov6vxb0`}=H7|v-{~!-3r><3Y42_yY<<XO
z={%KPS|~)sI2U}`%>5PI7%^|puz*$fX*6uIoDB9br+dr8q`5W7$2R{N7^GANA0kfT
zo(^C4p<Hrv&(^K=luU-%C(Jd4<k?!~=>QYYJ(c^gsAI1$t7IW$JG^Er?hsy|7+>)-
z);qdym>Oi$Koer-R%PZ<?gKB*V3HXzf%5nz;B?|6H=~qHFFvHT8{upwEhmhI{y|lK
zbm>WHnUaN6HO5&6az@7pD(o>e)wp;*59ZZ~Ptz3m98RQ^1bW6;C6(iDxCHBX@FX;#
zczm6IMu<u(PP>_w8Pt$;?S}xUtR(u|P3(IonjO6*$BXj2Kt(W~ufcBU8EP@7koLCz
z_g4U*C3CvSwT_>y_N%hwJ16<dkqR!Rrq(*xWMTmdsdK|!6!+w7*Ww@60;5WN)=E)j
zq>*rjkx;&b_)NbK-zHzK@tWpvA&BfM*#-v1VVu_%AF$5oj<uxY*TT*IicR-D=r)AE
z-rwjX^!AyYnPl^`jR}4__M|*defd4rFukwewGp8{Tm6`f?9<KLw9QRd&n~)Ca|s7X
z?GV${xNQ$=v)h%#FrdOsY$R5cJGZ$$b~y{6*1p70Z4Xi$vQrcquS$LM@_gA7d?vO*
zXG)6mdwGAg5$c69Opw~b)35y<YD+I`-a6T_ZPyzsX2P=U_xDbE0xN=nam1X<`!~!A
z!yuAOSvo)Og@7p4!CzlgV{*`;qVyP#^DyNHP3Eq2m04DJtPiH{fes8|ZlH^Fa;z-s
zodR1__`NyA7ou72-~I11vvgJVJ~^-g=+zdiIchwvKWY8@!F~7+QK6g6kj~Ii(K95h
zWv{(Y9_{xud-O6At?Aa~<Vf{*wRVDUeL@``uB`84FNMj8lpQ1Ev(9@IM!&H3v%P1d
zRnF(kbK8*<Jvpchw2`U^JB;dGT)*Po?Y%Q#7fyh>m`v}pau0fuXMSxvL)Y%d_PIQH
zKW&!)^a=)~p8|c-IS4>748;Kl6oF+!+ntNjyBEx^=JKUm`UquC+&mWJZYG}7{xVwn
zFV+4kC4vp33+1ctQ($XqZ?T>h@>T0)vZDPs41^I_A1?OyjzzK^b*NG}e6w<CofO`n
zAOdC+rebgd(ELN66MNN~Up>`TRCxwVq9RChxHS>G8b!GPg%pnY3Vya$D%Jo8&=-1m
zpw@>kFVSNI9IY8#1f;*a(-gBpcn3`SmpX*GTx^U!cDMNkahA~Qe^YLihn2mK5OaI_
zefR-Nr0qeL*o2O8fef-%F_e872gumPDpv=4O(eTltT(mOz`6H$ZtBP1vsHZjt4+6m
zv5GZDYfdI%EwAzdDXQD4gg-?OZ$?o^yiV(O{N|J1<m>-06Q%9sjlZ&={_@F1GSNwu
zZWgW8z)Q3BEVT<h09#-WFeH*xa8MnCKm=#6Ff)8{XO%_@cvo1wk0y-|1ZPxep?ZdR
z)|=LLu6w5>3DkHjM^3LD2h<sx{sS>%U&lJ2W{-26E2i=6YI0BY_@C8>qCk65N`dWA
zNhkW69bu7?{h;iC5K_^P+eglz?dvmL$FhU#H|*i@d0_$MkN;+@_cm)AXOJoU2%sQy
zm$3-SrCGPN(PLZov7MOib${vYGYkQYgpZ-}s89lR#5!&nPHr;ytuCx+K;&1aHAQ-d
zAejIaSu4?xr}Fpga5%$Wp2G~&FXKMKWib)^%2UO_9Hne63o~ldjUG%s4qyr6qyCXY
zW%ICF3tms_f8Z@SR7UPsa&ZjwP*4WMt@B6_b1tlUG|bntfc1+kfteWuuk2=`&uxFS
z;HaHKc`mhfl+-;hMA*&@Tqn0}5rpd6=?NCpDAns(+(fhcDd@76d+UH=GyjOIvCU6J
z;s$%^qsWe{YFq;^Edo<nAVa-=J(>?0gBZQ$27+N$m{fF<C|&Riq*mMF%XWq*C9hjQ
zGsc;d;zlWCRb;Q9pZ@=?#r}7zvj6k%RMKt>sld_48(hb-$5k!UxN>Ohp*ylw5Gt~g
zERg$@<bhyu&768BhGVr4w*50NeSh(UW5hbOs`%|Y!W-u=sl0@Nsg3HxOma-fW<kB3
z&Qi31DDl)C*YY3F^YI+~X{Xc7Iohtz-FDxQCEmbBT-uIr<eUOcp>ARJ%yTK8iOs#B
zuF;F{V_*F7oa_DW=&?+l1Oi51GEn$n^e@5P(i9v=OinWw*N4A|&ghK~S&=leF6pT%
zvK(jBz?>Gx5%`i%q2}ZJ)X|VJ2174_8Gk?J*_D}$SY^p5LuC-&DQ=X!o8V$cWDNU*
zC8_n~C7EL1&R;LZM<q`<eSLE9YLwk&haK)=)pu?=ZVbl%93AB+m3L>pn@+0))uf>3
z`0)~8T}PRYZ>i|a=pNSMfk;CwJ_EWur)G?-VbXt~r(yCy%_!909@i-&fkTS34`!VI
zvDavceTJ@TYBZm&s}Ooj$@EO?1sG3AE0RWy9k#<??geKUee|Ii4o&f`$R&}XSbk<v
z7wy1ihglz!E#XNRdwM`|Tjdo^TLz+v?4k8(-`#Zt^C`QB+(}`+5AN|%AY6gP9E}?5
zej3CQ>(M+(X==JGf*bV-6p}hb_twriwvVP6tJdFN@L5MU<)mcizyv3V`vR0TnZ1N=
zill}zqeWsXY~8YFYc@t-_wMTOyg+C_jW-fgyegyc!6?-alKI<}tBKLeF@i-l)>v)~
z06oSVFP+z<$(^7pj{EbcFhM{nxkZNw(n~j33IKI3P#bf{Ie2~Krb)T1w--WJ_wSr=
zy62Vn+U!=kBqb3acoPy|N#V?|Ro~4KHKB2?>f3}<-cT#BO-U%raa+7ESVSH7)&&Qd
z=xghAyNA8QcLv2!7^!ck0}*Q<%&eF!aVhYr9H`winB#_6Da8K+<u@-zrbNgT5OXOM
zxpA9RHnqErrj-HY;Dhw&J2v-CxvuX1CF@nW7m>o%-S47KQZmFUvvBbDSEJ<b-S7<o
z?PxK{i+TW-Ik15elW;U~-xp<o@}L>w{9UEp*IGYyzKzQMb1E(#<4sJU?F(i)G&}c7
zx)WPyUk@Wu*4OXv`IDk|ult??*%&)m{TJ|XcEGgI8lqW-2o{LlC&@B1)LhWm+0fF(
z0gYa?c2b}7PPmMApKAwyrD-dbM~c?Z_<PY&<UZL)^N%kF{|u%$oQt`rUY-00>M+8O
zAWf3OAd%FyNt;iC0a$+GH1_&tt>Tcs_19IMKto;h=mXn$7DHnPferUNAyj1Qg<u`b
zUfD%n@57DV%Q>Pc)d!5jtlr`&X8qbb`zaSBOij+qE0Fxh;z{^g!{^T=RPTW<y}ti_
zhy}*LL?rVMUVyoeCk%fY-7V-)jBbhN1PO0g%I$gsvE=uc2DoMsU3sI-sl_Gl7fXfg
zp+g@LNvVx$^Y;0wsoLmR157Mo9R7gN^6L|SgbY#Z--j(651x1Eo}_)k*5dtQVO$j?
z@qbH4<!Dq72EFK88~4%L;^^bImKMI$waHwLD+C{?K0XbjNWPP7ZI6eu8C%P}<H~=g
z{W@@lD*Hk@wKjNbO!khuYi)noszdNK(Mz*?5WJ5@;<4G8X}$n#?Zvj=5KIW8OzVSL
znnXY}#SiWqMG-Ri_W_BEGm!wZfB!DV8=z5hM`HD#1&2-C-A5f)ghW=miHL}Xe3FRf
z%xNngV~z1OR1T5CxnLNRvQh%?5M*jl{P~N4K)58-u@usUC_751)Iz7n9v>e`N~w4^
z3}<!V0jAe_i4Ukmc>q!1QO=7vN0I&sH8A@?Mbfbf15ky~IH6K|U6_kgs|&1Bd+edJ
zUCI`_uSxe~v;q2>43MV!X`$~ywIZiTSFeU+2B}Ae$|t(B`HoPp2^&#1`1&{16w#yR
zKUbMl9Yd)vCnB8SHGz_8eZYQn4p?BWqH5wVDCiE2e}|fAIcLy|LOe{3SKgluUE;3=
z$qqTtkJC)$DVUC%X1rBAj(q+OPt}9~6cRx9Em#oI+>a#a%{IJ|?laF~EYZsokWH(X
ziSY$@3Y;WIP+^isu7wIZc2^l>&=P+Koip<@Xi~={(j=oNffXGAutTAs;zsX9Wz`0_
zW7N%=@V(d?@RPbe@SMX}-i50BKo`rp#5-5dh*<yyB`~FHC1S;i68tx1Pt3%ctj3g?
z{h%6R+#PvSI(F**jYbbM-V(VJS$=-Pp?WRQM>BzPr@s?gu0XToON;ZJe3Q|j#=&>Q
zJVvs|;^9V#|I?uh9;I^eBtLF5)zq}46sR4-bAi1*{Iql@f|;B6%pw;c<sbd<K`wsK
z(C=J;k6%V!cv+;$&cFDcf5xh)$Tz~zUeo%HA1%_fQ><ox7^JmhW|W8<XX@a@h_}27
zq~u!YZhPS!+{yHOO3=Ac5U!8Uwfa`y?APv1JUxtUC__^W|I_tK&sA}EGKgE3=OANV
z3Ag*|5U6eYtwt#w*DU2lRJk?cnCIhwZxKfKjI3qxJy~y$x4(inI0;xxDG5P%9nhs4
zZLPOxVkR@Qg3mJCA`-qxzP0G2a)t?2=FxkPr1`%aKa5#jXk!iHPBZNHjo@69=Ad%(
zsy$>7_VM4w9Rq>bKzLC=M7zvD?CtxNNCeXgtH;J#6iu2Akr?siG_2IU3<XP-J|TKL
zkr4P?FNQR;Rj>|HKFk(A4hrW(=hF=^9fp{__!!g8G`!j2g=i(h;vp_Hi3Xp&$zWjO
z!Qn$It<3^5iu@fIm8-97Pi~pYjHm>+Q9b=hj25{hyq{x8!FgN@Rh;Y^I#BHX3?1K@
zh9b;#RDvn8{G3!XG<*#Dfte-s4elMXsnFW0iwhrB%!Ar;xLp{4hPLnht=Wl7AERAs
zmtKRt=<UuNu~g2y_rYT{dIZsGk)<rZ(@!Nem}0|l$5+6hewAHxb9WHMf~c)<fRl{<
zbX4ygkzvG(F=s7>@k#&ga?7%L+*%vJKUBv=Dn7+E;Puu2B$02Y3M;dgSa9v>Ubpw`
z#W%HK2v|Vf79@v^PE&01)5Q$lW(JaXRDCAZf7fZ0B{zBBazZSUN{vJD{BUhC=}#XO
zYSJEEQpj^xaG9}Q@z<vLrC@&oAC75>+?>x^Qr<-Ay*_mW8|3DxQP$_MX9&Bd-B<jE
zpbS%=5;@@1E0=Rs$33g9ukS=hfq)bGOK^114PSG$-Q0`?zNtT(rb8;8eN?cC8puKW
z2S*Iq94gp~{S|BxS%W4GjxfHFmz(rEne}#{#3~|-4JUG$BNKU&uCLJ#;Zh>_irSk)
zL+fcZoDsmntJv7S4k&^s#_gKVfx6bC5^ypE?Dgc922>p|&@-SzEMyiLEA@vE3E&!9
z9P@#C3}a#`$$3nDy~C_<+=O8flJ69j(@>9E8}p(Kb~mJFHbdz-y_m|<YJJU@-Nm_0
zGpFo=2ak05hV&x(oi<gqX8P6w(xN?u^|3FiuP-+XjFQ7EgJl3{dKeX^L-^>T5GkR_
z`wN*$FW!eDz9$c9Q5J+t9q}O<E}{5`1rNnjBdms88PZZ7y`;a8SGE3^qUOqDjK*cF
zr7Jaj`xcK$ahFM@4<tBqIEc20!#XuXHJMeqxGk*5M+kL;qA9W@&qP2YDeU4!`zfoH
zgE&g&iN_-6c>*;=ZMwOaOltB#rSbEfX_xt_^~SW9!n-V9r%c0FVEhQe4`mdv2nK<g
z(I5C+0(j0$Lu^yis&DuD&MwQ0Z;Q*Pqd)2M&&fkb#?3Kd)lid2A}g89de_ySu;#<y
z6BTF68^_((qGfzFuPvkjlNEZoCpX(;C%IOd@RN%E2RJ1}f*Qy6d4#7nxBsLR&R)R5
zV4I0x@ZLp|Al=fBR&9+vEuh+w8pD8hIyD`GsvgL3OD(<(^L}H&vmYFbs7bC#dN43u
zyZ%asAFncLh-!Gd4j}w4l>`4YU#e3|MQwoRy^p~8=Ey#gU6bC}z&=Me{b<ZksZDCV
z|Ijg-E=tLJ=q0cv<!36xYx-YtFF5}X)-!m&2EW(u5TfjUwtkNH9|&Pr!hQzOUXZUD
zkpghcnUWY*V);Xssjdh+?OV(3Zt4n3uwRtnSBrcsGsdwxxJ#pF`9g1fYQ>Y3YWy`q
zJkFdui`=g_Iy%KXVO;c0k7|Mv#HZ2KVr`bEg7??4ot>Rk%=U9Fas$6vP;kF&e;6=X
z9RLT10wn$L&GL|1T|Ylug9*Mz>YrYM?qv_j9nN~IGC{$P+o=zST!SpA*SE9)gy=V+
zluGA45H9(N0YBb+!#5y#PBGDO?IM`{k(E=7Br{FSw-+{e1Cq1BKb3Xy>A0x?s^j+(
zk?#1lQRd1uiAwRN%HHBR(B};K>otxWm3c3|(J&pZOm<7294EE!{CZh9=Tq{q{3osK
zt@76ej{+Tf#v>AFan6H|?)!jHLNX^@jf<Q2Qzc}@a9Y)X`RA?s-a(jT*XE0e8tHTW
zydgufs!G+@gUh?6&(4@1P|+23-!skp3pgU@k}mYU5KeJ5<I19=-dnaLEEuwhD^O2;
zf>1XjesKbr)wz69`4EebDt{upTF=sQ_7w@ZNy<n$zQ^ow@YzIHse2!hBwmr`;6!tV
zlBUn~Lw0h;WVR?SCQ2-KD4c~{>{`0N>zJ`u7N7^?OGz4~fB22bz^iWOb1H2MHD$&i
zI>YZhxnrYG&nF}LEHsewvDUnW2z_nir4BM3TdRjl(LMq_V#ZlwwCu%a<Dg&_zttpx
ziDDOce1-cfj_2L^_kVQV4-#XV>~z8Hr#pu_;3x^TaLt6&OGe4k<>O{=;W>Hd0ykD8
z52nor5gX?1k7>GF8%!4~pP*5e%)R*rAhkaq{)+rwumg<WDqizwcz4Z0v`Zeo|4KMn
z&Y3<^Q@YI%Z%s_Ud1aDjQVHox9JXnJxXdqceHwh@K+?WNXXz#jZvrTSVb$%LUC$B(
zaD;Th@;`vgC<6@Ahm?a%`cbZ_cF{Pi+a$sI7xN)3ZRyB>C6E$Vh)UN%?Y|KT2p73A
za((@sv1+EFq3+oyM&sBsXQj0yXW)SwiTF8YKA`aRScKd1L(-{CP~b@IhCKH<ti>JC
z<6ZFd$|)n9xQx7Q=V*+flv=v3>8Eamq(Fj3W=0ax)H!F;t}E?}+$fcT+mhzzd5D!h
zsxRr>G&<aBAx~N$kWOuB@DZC2Z3K>`y{Q#X&%;E+FBq^K8#>cAXv8bd+Ttx%NIKR0
z@`Bx!$wblFl!z9Yr9M5YjSfRZ<RBc#CL3IX@>(V4S`=)1KHcx3RAZb_K2u{?|DUK#
zx?fv_cO0&Fa^YI~2FE-6ug9Kg6Vmp|{9zkoC)|9$58U!|?gv{j7GfJv=|y~r%2a9v
z9lExTu9o4eVZu*?Oi-GyQiJynLemPvBJyMcPrQ}(EwqS8=s5Y6qSN}!9O6rf{8J-G
z=tDc}!o&AAJ-u^}Yir9gzyiL(bHRs;QPPpF4T<3R^Ii>szegc^L}zEOiH16rCDi8o
zp;z{G=t4wi>GqMrjLBm2ai!HyF`Yai)_vD!>Yz|ZMwnn3h4yX9F=y<KP^3!^L;^m;
z8kQz2FYquuf`aaRxpfj>RA{bcl2Pc(B#zpFE-dSgKG>XsF}PJ(;&jJScvYrEgI@Nd
ztv7{Q$YHGgtn5%aSs!_e8*{6UX<Se~Bd)fIOv<eUKQ71j<I`0;N&A=w$Pm@`l4nt=
zn^yPm9KU9S0K=`+F3M5Vk{JL_g*!b;wM6=PJ&isb;_ZVWWJhjQ$IanYt4-nlb*}!a
zwYgs?TR_xf8Nu?u(<eIac%YmM=N#Z42XMQKzXkKJ<3z0Ntn>&Vag0j)O2Eo@%-wy+
zLJSz}Kl~Rb9nbR3?#CP*t=u%<$HvDCsJ*<~F4*sD%fe~dE~?={&%onnl4+8wQ7TJX
zq!NO=TPasYKd^eMfW3`79qQW60uiJp<cP-S2)&fX&>*6~*MT2>4!ujUnjv@5sMd*_
z9nTiT%*<hK>rw@cX9^B?bW9G@F0SmU&zu6_nanYE&^Rc?>67X47`1Y66Sr-A?HKY>
z+eqygH%5C$a364jo@j=XR6@b1jRL!d&CLS|TP3$eDbK{p%o3cZ>2pykp|f-cC4kE3
zxg(lS8vx?m4z;aNP7i330kcm_=ctGi;1=r-0wl&|Sib*2s@AaEJ0K7{O1>1h!-$Th
z51n)9U8xC8`St=FBz^D(BvchHA`@jP;TQ(ntR1tr%oD+*;zJu#57X<o@BLLBgS&j~
z)2wxUtElt(n4OA~MUOykPVrS+frXN!B!!<E8JpbshyDgc>F_PhSOituYJmI9mdu}C
z0h^u=_3?tS8NR;V^Bj-AU^-B}dZ^;u!k|if+spv}&Me^>!k^Liqd}p-nkRd~K}#J)
zG0H`2Q#h;t^PX($R1)#A8r<i6HW-i@Iowm<-lCVuclF^JZyVuDnNIyo3~_~k&H<I6
zuYWuIf+N;}Olphy_thGFeD;fvI%hOj*RvWqQp*<bS~Wl37s12%c*)^_Z8D-^fydOJ
z`QO(8bRe8}H?hMoG0a<(*Tb(+NLc-Ei@bsG_f|3+3ZI;&@V(1o=lrfM-c|r3Tc-89
z3s5*6y2hxz3mp_au;51;`D*#m>4~=tFXrymIV*d3YG_Z!0h56`6IfXjYEkYAFm<di
zORN8GTJ?3OZOF59o;>TGguWVhV+iC0nlcTnGDfc*5lI4m8Y6;8GB<jOyRRyc??E&n
zovzf+C%+uDcp4we6s0@bSJc@KJ3m(*->4&{0&<e&aZDZSq|fHwqB<w`cS>py(<e1D
z1yBc<%_w3v%ll^2Q}|v?a{FwA!N6cW+MeB=IAW&O&Bws#JzUrLtL*FMh0-rZ_*-p2
z-x*BqLj6c`JOrZ4s4B55Ld@0{YYymG1ruLjyaGtGx%8A;h!zS7AF@(|PKIWopHqI3
zFU}m3KWIFj+!u<d0XVRE@yE}5QFo=%jnh*4UhHcc84<?z0cbp<mSm)CEOz}<g$up9
zh%H&%FiG!{a+`zvTdRmex@+c#e?nWNaIQGznZTTDlcm%mTs`RHZXXYU8PdEg2?f>$
z(hGbG)qTC&zp9ctUo3aO;%M@OS&VYLQQ%9&-gj?w>*^YCLcFN+{2Xm&+e~h{o7Fu}
zi-R<8YTcvv>S=wzhlX_?RVD2a?Z;^5J}^~KV2uZt6Apx6dQn|^sN77)$PYh$P)UDY
z*Jb@_n>Ca%6eXTo0~v7d?8HzZz8!tgy%4t6rBi#Qn`v6ID>52=Q~*kNy8Jrfh_0HV
zV+h(Ww=R1Eo_TOaWO$XP%@zVP&smicg%FtG=Q>7#V8xzy3|7Nvx3y8hNY!tioHx$z
z)g%a5TJwJw)oe~i<ouXL@r_cj2y7kVy!U?cODlY0&IJz;6;aQ#O(tIGmSw(7((BG=
zGthY8tA0&oHPLT_NFQlZ91BudyBxomn3XwdqVxC|_dT?mn_amDv$~&tN9t0*_r~kO
zj`#Afh|tm;SCEB;@rpNSSf%@4RMAr(vbE78s<Ip&DtM(~OIyeCv$}K6%Vuq4_-)f*
zVjp9httLlyZR2TzH>uBwVbL|kyR#!JU~wl|elS3@bioExeMXW$#`w61ak-9}@CbD0
z6pGda(G`f>gjm%!Pyd;jI%Kc2mR>IDa31)66f5ibBvOszaYbXM;KXp|#Ls8GM9POh
zBhwhf?66N(xI6P-Jv#lGBaf3SZO&n&C75*Pa0ATe!kPc5&;+ZjPu%h5jv9T+WpNRP
zBe0ELuO*ss<neOnyn&m7K{K2s07WyZ@4?wV2movZ0+q5VYCXql)k~{2eM*T2=w0oF
zzj_Afzt}qp+>oNG>NcJDO3a<%SG@Uc926o<_h*Y%h4R-O3o2)#t<v5;BsZnxWe{mI
zo83zAeJvv4k_)6M=p7J(OZ)%eCrow-kb;!3qb3uY+xr7|^sMx!i=9sMS7HU4Rg82X
zUXj+zm|g(M$GjCID%He%s@L1lnL_&T7v$c-Sk_Qv5Nqi2U|UzhdGb7wy@P{m=bEf=
z=-0dgab7xOB0Tv?p-}U#Ne;4KAEENgqQd9BIwBqgyh)ZHOrJeTswrbaq=S<{UT^M1
zgH<TVTsyDeZ*se2E*D0*4e<d69_X|z#Rp)k{Rd*}bFaX3{s($uM`->jZI=7TgNIRh
zf<vT|6Pvz*vtlmep!-!H`W-KQ7ut`W+N|&_H<tIxeC2z`t9DTJ7XL`e84pN#nEnN8
z?t6+bq?kuE>9c5lG`_TAdEi+)6vs`ehR?2O!3UiAP@zpwXWysABN6BBEDi3qhs`$R
zrsUdqY432(a>6wn(b>aKtwy=8i#iu2a2J#tE6XQ2Gb&lb-SIBpe3eQz#2*iLuZFL0
zOa>;hGmgD%Ae>V4DT!@@-oT@jlkG6sW%KAr9W*JK65J!TyEDrvCFPhJci4cO@Gf{B
zj8_#Z2z5e<5bHlLLY8$Ds$K(15?wX+Szx1Nm~b8*Id;X|o^3VSU|0C5xI#3_Ds8Eq
zrbxD0PH9aS=mL^es0UFIb&k~z(?Nbgo+xftyc!|#EGxCUj<Y6OkXb)FTI$w%?o`dn
zV?WK@cqQf|H^t|HT#PoNiEM!V_tTlm@A}eXuXMR{=>h{cw0wsyae+;0>K)SpSKg=z
zU@2c$p7@a4`kqp|N9KThBO<&OuR0mY7riMRxKf$&5x)UGlcSPwPb=chS_vHc_^Tsk
z)(_TZAl2;=F~NJ9ZrruMzUDRayVP^#hzesd3g|ZJ-&V&NfjC}jO#ZZYa7Lt(VxfKQ
z3NH!23q>q{Ji7gs_miO0|2TL;5?I94lp<wgxZ-sg%yP{iO{ID`5lsCdHj=#H`eYab
znEIf~h*>_9mesx7*}Z=E+N~L9b8|Dszv`T+{ga`W@_l@W--xUS{>n;~NyaU&qqfsR
z@Kkd`N{2+rU9J@98+-z);Ts0h46*(T#9~RcYAkJOmbWgrs=$ti1}oYW%yp%=D9YX2
z)9bQg`tTPmm{eB?%poE-z1K%Q@E)^<XriV_u+I50kmKy-<MFf4cl6%G)RQEIC<!q`
za1tEF7w6B9W%-c1@Q1CcHQpkG^IsC%ST1LFmJ8l4TyRT8AlOmEfdeBT*FF>cVp+sm
z@ZH-$q1q;P9Fl0PcFDzo#;5{07^`!>@Vn6R3>d8=nFTld=n&x~cMPg;j|}oXS1*kP
z)oGe{Q$Ct_Q?Sh`D_VST-=qeDr{0E>76=1TP=C`1v>2K2#XzwoJ5frL+iPQ`WSGd|
z-<5}XzE&F=k{@{)0y4yZWSFu#md^>OrgBjA$?h1EXji%9nb^(pj7&{V`<s%K^hVA3
ztxNBi4qAgA|1;-Zh(_DXEcEg4){*y0bxsF!y?pm*4o80|hL$F~cZt;^cdhkq7S5hm
zuhJ1v`}^|B*XHj7AeS(Xtgj2Kgsmug6{V2Q2DL`Toy2z7u*n)_9qb*i>iMS%@7miv
z-pw@<lbkgMpf-9VJ=!r+x02@lS#!tBQm^B|;on~b;g+H2Ll5t`Fg6b(@!X&EXuk8H
zD{6yG;#LUO=b8|KF6d5EL1ExY(L`p3B&jem#fP7AkFt>SA<)iLQvwKw7=DT05*_l~
zSdFb_go4I0*kVF_%dKj0)zY3YQw!R+eGI8%^-FW#;K9snCsqXNTkGbVetgvNjzJ|>
zfH0!cV#ePH+y-UAWFt-};BJ>a8;e$j4XZt=*y@1$Q7jR_1<L-uDLpBY7Ao8r%mv6C
z7rkEgb@!4m*AM-o^~7%x0!=a^dHV=~v9{qzL8Z0m+xA%lgw;-4cT$kq&A3@KXBgV*
zoe_8i0({SO@DGK6YRsT55-q*20=#J1I@AV0qIP|XHCX;&`QqJ}WokL-mD%+0_X$ER
zt+2H;V>J##w=E_m`W~l+&gIJP!q3k#h1-)XGlypQ@zAjMF2DzP?Wctq-=0|XAX}~A
zX&m99AhDSm*I|SRR5JffO9EZ0(qeVLiVO(;QuqmE`&znYwwruz$r0`o<1zc_E$f#d
z8Jl$Og|RIm0JiE2fbhZ!5V-!eP692X18c~;c8U$nIxQ@{L|*38VeacuOQv1qY0~1H
zl-^U}!#HZ9G;{MBH)q@fT<jR7L=e$0)}xJr|F+C4nOjUmCJwNp>GP|tU9x9_FV`A^
zAb+1E(V4|>y~p+I{XGsuWB@@~v#7%-y@ik4OTtRUe`Z;l&2WfE?Z!q&$+21}-)Olg
z=qJScudkEItgi0b6KQBrrt=$riy_2eGG41es<GK}F!fP!`%GO|erzk_m1%$XPUTG;
zMD?L&aO8w2t?Qi-`t9JNwRUF`ew5Cr*L!vD3<?M=!abS0r2QSp0tO{P-^C&90I|2>
znkV~8b&(<KfQ>?CJ1Mj*BbcvRaLWCMs<Sf5<7Fv3lj|$P&Yn*;nUo<F6mj=hK&;4Y
zHHHX2=u=d6!*;QT{-ReUaJ!hjHB#roIm6WzDtqSGC4F`gu8IyDwHAOXt$0EfUn2^L
zR&{oh=(Nm934K9-4A}%uM*jzC?;X@+|F!#u-it_Y0RcgJ?*ve3B30>C5oyu|0)#Fg
z2thzl=}J+g_uflDdY4WJy(UNr5P0_e{N6qLJ#%Kyo;myc;V>d(kbKL!*SfCjlS|>O
zyQasms8tn^F{)7D0vs*=hUO{iDh5a(*b!=H^g#>o-WKaeqiUMt12nFO?{oo+%I+zD
zzXARyqPkdPtw%0$VC<$(2UDxWw~F{y<|>zTw8#y%q0#)=5Z!$&mfQOVHD-B=L1yEr
z&3|{vqt4w)2D)+}Xi+qVU%dg_Rq8e;;?0;D_C^HtsaJ>XvAu-RDD~LW6G_Fn;GeM9
zXk+uI?q?4?_(=V`>nDX2PKiFz%(kkcIJ2D!aGEo3PIpXK{z&_frbZLx8+$2HrXtiA
z8m~acy6m~X<F6>rVSrpTU@cBeOnTAc$g$baDP4S<oES9fJw3AuU*VW23k4elyBAqn
zEiLLYrSZ}N@#gjgUc{O-Pe7NA@kAkE$W=0I(Bk9DcooLZ2z)x*W$P489pTOtpWuu&
z<v^qjCCnO~-Ms6+OSR*xtet7B7oIl29ufki`-V@N%>&P=2|M6Zf+<xrqbj;06&L2<
zS%h7*sH#rTa3@-dqj&gT9z+i6tO&&FVN|=X#3F^?X1_ks)h&6%#npYpE>(k19(8lz
zJI1g!{R!_-l@-E+4d}Jxi;ju)=0hR;8zfaf4gC65D)ASjAK-sle!hxQjo55}>&WPE
z1sFc{bmx9`E^jP#dcWPSP9rei?6N`r8St0BI&^Mq8B+V%qp3*EZ%ncS`Xt3X86Zq1
z0E$(l>|iOysU>>7ZE>@!mTos1<PRHVDqqc=Qhr<UFf1X5==p1#ms<7(@2o7ULt>tR
z%Y2%XqH8s<H!qx}2Z&1RRo&dYz9jrs?qu^cK(fCb3HpGw>NzT{_~ue*ZXe|WRxJcU
z$GXGfY{3&A08jSt>-`$t>$%pr4B1fT+)syu+vq+|oF=vmsb|oYk)B;>JLKmZcqi_T
z{aavL1Bbe*V(eOOjI>!ZM#-Q^U3I>WsWx_0{r;Z_c>)F8RmN_+AlB|7pgJHi&z8=V
zFN`FRHlP<wC|9Ia8v)tlRIpV@B^nZ!bj3nkdVuLiVH&oF$0_-25hgsujbm`2KZi5V
zu&IwyTKZsoGWZ}dIn*9xEl#2w^s=?+lOg`yjAIBnw&p21=>uQOtPQFjz`rTa7~fh5
zmy!|i1GhR!nHO;8PMdYGD&GMx(T|D;efA1UjTQ%3#_TBs*sn9zArvqT^hFF#!Mn)K
zOmg9gN5)%U3dKr$Vu+!>=8EsW?E@fK9MQKLx56@uyBkp8JZEfcy&~<f89iYr9RFX1
z^Xt}oDgPC#^}opMB77|Wv8LkxPmAjRmygtd$)KZ8XqC{Vfi=iwV%2IyEGvHU%RGBH
zTNZmH=*nc36ZfJWNT=PHi1|$Q=~<;@Lx!U;eGJG^QvtNqIvM|8_xT=>Q+TxB*__=s
zQ&$?`ZJh_#&aOW~EOUp;cb#uFJuws@m^<r8lDmSZ1~?LbAS(TQNBW^@R(q!=*<$Uh
zTbaZ)nhy=_G~;GEim&9x`wuWu+73dE8*scag$j8fMT%sdzt3un)#c7^MUjSsM|GSP
z9Sh4BN@{Ip0{(q-(@;E&&0*`ag&n3z4Z&DVbF5$xr(0%4<F|i6rtM#VY)HTU=n^Y8
zvVtX-If*^$E{zucQJvk0mAbK>T;_yS<PeVf)+RUra3pLXVSrM^em?Be*&gtHwjYo;
zR@RN_R6GVbN9Ja}rOrA=S-!ibXP(5+RPAcF5nYYehK8pe$*4;+Al{)B#{z(Fejqx|
z8C9>?>t<nq;65dI9ejn({RgBbjfZTfz|MpqbEy|yBwc7%MCwiW{w6rR_Q7M**XI3e
zk)whw`3Y^dkuFS-eegoOIf-WLF4v9@mzRpfSvhdqpEq_m2UpRNDJxM7fG9O4Ksg&!
zvEZi}TeUz=$8A35(JdW^+!L#op`Rm-Rf#&o=Iq4#$>F*VXavJHPgxKU>xSrM3ES^~
z1Xu$3KmpCMy{eoV4$2?aDBeHee(@kVi;Lixfm~`IAPL8YF^J)qT!P(iav8r74R4`{
zaMdZa1nl8Hqy!1xcF)Xu6?1X#M8o!L{sBp;aVDa26F#p9q7N1xx_JHR^D-L=lOM29
zrvzPUDiCDs!|tHQSo@Ififo>QBfr!s?=hF>`!c^ZNP{i};mx%{MM6HW0dq+D*D>Bn
z*w2fYe?V{2!<7lv4H8@R#Nyw&EkApFi^zR)b5qv(%gS4r?4`aWb*H%E%Z9o0*k%-j
z?Y-0F4uD;eQ9XR3?MZzj8g`xr^@jr8U$j}0vW99e$0LiWw-LoQu1_A<e=KHJ1AyT2
z{UrPq({q9A2JdYZk{-5+tm%}}c6XJt3`cT7g*7L#XnLB~n^xyzZ#7lyZrhmt4K+Ac
z?7&5OhV4fIX5W7^cgJx;<=9C6T+PWN&wB}nPH{eXr(<QT$I)ja_yU`=wJn(fn=jv=
zl;iO<%(j2H$?X7eSpX6*u;Wz9q{F%6l3(N>kezp!B?uiXh7T>enpMiQA->WsGQ?DV
zIDW9B;k3M?SeH}YY%-he%b2$zxL8elWbhQ&ve6;`W*BmQ44ad=HQ8Db0#?~2Qtavk
zIK|a7!j-iEhfzY<j`g(a@r(`D7lVI+ycyX;y!>orLqylZL+|J}O6}#H@KIA}pB1~k
zF2)JLfci<!Km7x`5+5h=UQdFXEo?;v7O8*lbDr~-77_R|`0hnaXXiG%Q(d42|C9e&
z#Q$$oHvU^WsG`)F%i`Jk0J$R_C;ij&dxOYkN0tMZ#B$V0)`@{kE{1<S`WP-O@+Q+D
zzJGxXHp%#KGm{Y5(w+SAYp(ri|A4rKJg*Kqu4wb9{y@Oc_ATbE*q((59eTxFAr_K-
z^Pu$Hz`_+Bm!FG+Zr*o#Gz1S{V9gez@+vaIT)>wCz&@T!u)DfDPV&Xf7rnUdxEkSp
zROV0_bFzZ$ZQ*>FPzIoSsnt1Wy5XN{@%A`nu~Wh8Vbs<;m|gKdAF_l~0{b7;vaeB6
z(y46~p?@GKmMMB>gG~C9sOD=D9<jFvCJD$JYEBI>vmDz#(*OmmNMZAf|Bc5Hv#*Mo
zIW2w%fD;|>+jMTE5NrLG?+YqWrB#LwG-3U`0E3?1m(XZv1sNJJO2r@dpl-j*0>69-
zw}X!oYG7{Yr~O+g%*g&w;joNOR*9ts3l+1;VlBK?fQ7&8QQ(>w!@QM_w{M=E2IUi*
z`TRA3J%h=%sUFo6FIz!?xdpSkqLkVF4Bq1f0x$mo34$)?fN}W;oKd0koIk5-Os-X(
z1#D!Z%0T3c4_OyU9;yLl3K78$^;v$7`D`$&EFzld=q>p<T~lm};WACVlVV`37%|(D
zG~aWpGp~AjEp}qrgt<<Nk=wq_=mJtS8N(HTbcRQm;T&+4BU*WG@1Egj(k%%|I04au
zH)1UaE)<JFB*C<ERHo|Obv0S_M$^N)oW%JBSE1?hqk$~Uh}m}d1a#s}W4{Q{kQmp1
zdLF8dR(<!LT(P?$H6-jnPcVg@iUOxrgceYyR7g0>bg)6;CwrrP$71EyOFA6YbWHrY
zd543gis!5Io?vGTwHDgyACLmjA@>s_z~(=#Nk0L$Mq5Mud&doDtkIsg^-V}7O6-!}
zuj4;wvql}vQH_E{Li?ScHMrMoA|s$zjAQ79Cl3~XeWTX(X~_e1evXHS@?%AA+rbb|
zZt!8n--<?JadF`7lCp!&^^vUi)feA?H~6bJa#lq=-$UYKs5Ocg*L#H6wT)Hn1#=2Z
zO2U*IO`r4LePA!Hh;ruN5p*}Z)tAx%-mphuhn8pLpi8IDTm~6cvZXzDzE5(4Kc9N=
zK3uV|(AkK@LoI@DLJU}7ZtWOw>{0D|>Gy9^cHX4eDG&GufEd`X=W?+%x0=}ww;e?Q
z&Mwj76UgY|*5rB_M9-O4vlfxdvZH!V+wd>xPK_xa8-OB-vjBo8A5j7v*3vK1RF)`n
z_xq~`jj4vlzuhBYYw#w{ne)QH(1?FP{8a1UYa%UN9smby!iKF6>ALVYjf>^SFo=$9
zzBL+DjrR4sV7V@{qfuS;EY2gI(4Yss{J$tf{&z(S^#u~qeSOTfTeFG?V@Rwu4&<t4
z5?#ZG5;}n3A$!~Kb{ba*JsQ{CHGO!@9sTJEqh!Lj_lBA}W4x4Rp4Uol%_cwIi5_?y
zAC?_4VhSG!M^Mi`1||L(6LfPxg}s*!gs{6ZR_>YB82F5r8ubabNYDv!;vL{A01_Fz
zJRI5dnI7wuVWxRQy_`{Lx0pct%!}j{(rxAu-&>&4{I$c$J9+x5xuM0~q~2=iH&ti&
zBZ3r(kHOpfeIa;jV|R8^uv$7iW>q%z$(mi|4BC!rrKG%f24uQn1{l!<zy%F4KT`^b
z?|&WqS!=0^_|<}W0vxeBJx*+ZlN!0Wp#+WuEafWB#0SEGwfeQsDKdRZoI~M1r8+lq
zF?W-lAL%<+uk^PsL{eGfd)T;b&p#miXE?VZ7|FUj+b!d2{I+6tb6;@H!HJZ+jx41t
z^IC{XP(nOt%daAQAw9cbd8MaxacR(<P5Yksrxnm3Tb#UnX)Ye@-Zaean`mis0;8e!
za8=C1gKK><<pkfpV89`u`>h9={lr2hn6~5f#}`hfylGq@yg}ZN^5xIgw18E43tm_-
zC|>CDC9J+o))mmSZsLjI;UOsl1$y=xL|ev2)_(D0ks<XgEBN&A+CgBT*AdFQ0VM3#
zdg9|AH%y9f1Jyg~pyi&?#wEllUE(5uvvD^AP~p$jmLw5%Il28@w6@mqhgbD+`9@Qv
z_-`{0?Av~DSWm>?`%Sh!`{t<+m*aguV|9)$1#lt=HjfeQ=?$gFl$t3PRq<`*8F_HG
z>$5puYJqzqNf8F4zvTMBtknz<?k2=f6OvPg@zC+Bx|m{=(6gcyjkopZZtOAlm%cSL
z^=pwt3JoWM+?;LsW^37s%io4*23r&{Cr@vODQvJujfK|vnqlVR&PvFH{Zw9Wt<M_D
z_5NXNNm!#ya@}^$qcK3+b!BS-MvjJ=#b=QtqSX`J@0%90UVYS*R9~;U<;BUiqh;C(
zd*{Yi7OkuFb_!+1S-J>wNRMv~>TqDp{dfq6i=oahOAX;WUkczlX)MeV@?6P(;x{^6
zsC=KaPrPjr62gk|GZDY68~{_)mg}$(qyl~^0h2a<<F-l9{I)64!n)=UM?)-KENizU
zjlX~kZ$=Lz)-NYMNZ5Qc4}UDs$?z;vVFRRvwElVt*At-!nYBZix*#eL`l+0;el7jF
zbZ%kUTf5B7e4h@9GXRM?*-G8sfCj?-bd;I$iDuq(!AAwMZ2>0RbG!(`s4n7gWwUia
zRBrMQh|Dz6v1Fg3WXUzGvF>Z8{j)~LCxAtrEn;9l*K!G5)AtVuSnR7<YGAFq;Y=~I
z@hht6=gE7f#~f)xx?Y&}vqYBsE?%eWqPC~dSWN^j`t%<Vj?4g)N0SYsS<Ah<h<i9K
z9U^98BYL6t(5X4$$n+uck{E1*oio?S<~UB7219Ivf5wZcSj<1ke9LK;wpHP`q!`9C
zjxoV8tlQ875eq6~=V{gI0dxhDHHSLngoMP({;IY!JMCN;NVLoMl@ZyBmv>%xq?XWm
zcY^42uE;@{v3C$gOvptnZ~FvHdqE@XFKyMqU%5(TCI{2hG-}rf_5zLgaC%6+0+?ek
z+_S>#nQoeQhyL_>`JZ~c3l6>CVi#_Cn@SUYuO`>HK4yz-Lz1_ekjM8Gr*|^^jO37{
zd{+)aqATS7WFh!#xly`&0kyWFPpI`8CA=1tK@!o<-B)1ItL%AhSS8AJ(mKZL0B}>+
zym5^c64>k?*re`T=@``WS>D!mfttk?9)>s6#3bmos7_Qz(3O-fMn58;Xwh1|^bhk!
zqV|2{a}-AxSJZ)9cZYMLmBEa%&Ff~rCAs@6<67KtJ%lfZy^|3S1qguhGCCJ!8vu>m
z&UFM&7GeX}I36J`K38z;SryjLX1J*Pi}tQLC@6ICZZ+-!a`77TsoJ^OLqCc?BCj$B
zQzWF`QI@o_-;L-;B5a)rl={E~bs`jMtuyy#)>^OGHJv{Ee(=fGJSug79n}_S65@bi
z>s`19WwJ8*H9s(AF+?uxTOy_OfE+~9By-{i;`@(Y?QK~SIn>GwW1D}j!a6-X6nS#@
zT>|I9at9EG>@dM9)jqv6GH;e@_ZVuhX8Yj<yAL+<^>n!zTfRXGEfi;k=?@W_s2!u+
z$#{A1j|-zefQS+nY77PRm@w~iim}VnMj#Tz2`8xVJ%w>m*pn?t{$Be!2(QnmW1@CM
z>)$3`eG{*PWN)eWZi<u|nBK_lDK;1AQuw`dno2$`NkWR_CQcCoVMRhcIPWzo&#tMc
zpS^tbzVDB|4{DyPOkcBtHh=!Vg0fF52mpFxs|j+)FJ}5%P5fFzdXePDPbD8OO$Czp
zZx}E#@i?Nitm1Wh{K-lnEPF4S972H?sjm+DduZE-w(GT2gegwBJ5C?I%vl}QaY!-I
ze6}U^me-$atLb<_$$IiwS?q^}g)8Hn8Q7if((5<-yE~1%DEZA;+m38d;2SVqtCPDY
z`<?xZhw{_+qUst62vW#Y6Qz0<Osg>9zI{)b<IF(cuY65e+pa(N;aGN%s=9So`SqG<
zp+h0`mc@^)pdN0{8^`%9ddWN7Ks_rUkGjZne&5jCx~F1Mhl}vn7Z!Dum;m+=Z(F56
zPm#i<^eGTujAmm00WzX%BY1A!82kBAJb#Lwg8_NGd2a0w^|>}!aQTv!U%B1VVkLCD
zDgCiRzsVOsOb9Cc7b)L=NdMuUl+c6U)mgM5>g82Hn|M5AmDc)}+u*eP3D8!q#c)<R
zmFko(?#Yq;)V5d%xpd+$_nm{J6$fM3`kBtFEtmHj#3<uUrirX8ytAA#Hh1!<$_V-Z
zjYMpUd99vtu=K~6<hw*V9GFPFt7m6GWED25mvPXubZ=_8JF&^(4bj-sHN4cbQb7TN
zpHl$TwMD-s=J%L&Q~bi6I@&`%ts-rH&NM=i@_%(7rs)l4{d-r(7eXRE?&OVQ9^sT(
zcw@6odwUQ@y9Jj})rq4svh<bZ``iVd%}vI{1}{<+4%Ik;=T6GMA-R{#?!XhW?FjHf
zW*H*0Eo*kPD^~NXDrsjmb**I-j#eZ&t#_7Qnay^flbyp(nWunWB%f-3yDm05*s~bA
zYTjD?NzYwoDIrBn%Qz?=l=%#Jx%j$ZmN#`A9_zs_F>^_qhCSnJ<U2SrbbukoHiEHI
zMk!d{gXNu|gXr+DJ{@@;_DBg^&&l=-fK*1sDi&+$Ub|3O8o;<^lE#;2SS%?;O?E`8
z>^%YsWa?FoZcd6kaQC#lrNHukQU7EdZ5{dCKJ}xTNASzGNBU^7Uh}ut&?NZqefb&x
zK*;N1>dd5-(-D)KytBjmVN|>6^$Ur$f3wx^FVaU0XqXaaHz9--&nk55fuq@*-lwN@
z_b5fc&$BjfKt-M(04Ing9m2GbG@O^s@G`#HpZH6UU~qNEjkky6iEXOnkp^)q(r+C@
zLXX|>sb!<0juYbNZ}McUIG!Q2ul%M1B)Xi~C8hP69>w_c@Kg}Ktx(7#dhPUbSXYWY
zCHP;o1I;t^=PnVgUQTfB%&Qsu8YZ_bUQHhEKS6Zr1pHAzoOu%Z92jUwTIlc{1b8i_
zR-1py=c(Xz;IAT4s0hH?0rw4-KqFzVK8}~Mm_Cm8cS33YNA-J+Gz$inQ(|SO!Mbew
z!NvK3e6ON=4vj&C$wyS6z!RWk{B`d;HfEb#V!%}OD~n8$`?|{OIcs-UswYSprq{0<
zm;cfQZC7#5r0J@0=*{&eG22=Wx<gugFvH~HY?{x}nrg&NuK$%`_rI&P|8G7=<ACKs
z@2g|9Vm;18d{{hQG2LJ0p{o{*Hc?oM)LCAgtb>T)M9}?FYb9-VS`8Vq>l68&XT$4i
zqqLFCSs@1-L8c^KV{r>wQMGK@Qf3X!O664DIv|>?U&Vy49N0qsW=vrVF#!)TVo~L_
zA@^1=Kbj>ri`3%d%fZTbQ~Xgtz}b4~@<3S_v5Ulhj=<F0md`+zbE7t(Mj<zlzbFl@
zD?^G{NQ>QdS*T5BNgs7g%Qx+^r{Mxyg09p<DWUB4|9~8a5H~8i|8Awx6_trYoC=Cc
zSGQJl+;Zss(9K~1KHilROGO}<0|(^EDc1pmG>`p%zc>;)XK6qOtuUHFMXc!-2M9{N
z`V~$he;knk>U+%}aY=pwj#{NumRqMG?kU+9*Y#5whJ)@(5}LfsqbhKc2Z9w}V+}BN
zkI^0PzE9KzyH)YhX&bF2$a@W2WhE!vg`a{t*dT1supV2c*k|L&^jXJ7^RJeseqNm@
z1>OXQgrGU67ihDt<oWIfMk(vxv>soU1`0<N<N;->P$Up|@kj&6b6uZ2{SXW&HJmN7
zx78vZMvde9W?jE*z6Qf@nPt5)Gu<Du_*3mvmHd3;8?z*-f)*f1nQdp;@n2;+&Bk9^
z(kNQB%KV%Z$mbu+_lVOA*50P+Ha^ysMCh)H5lr)4vKdSU8i{6K_rvIG_jBW~?BZTj
zHOeZ&i2uZN4|FxeyzwEHLraY+Cd>r^%_?Oc+#T09%dsCja3&z{T#9y9=b-kEbt@aY
zk=9t9W?64h6emuK>fm`)mY9CloG#D_co%wi3dd2r>XKe#v9w@SJJ5|>;>cIhehHOF
zl=*<EZXfIhQ8%p%jaW`@^300rEnLcf><^GwQ16F^wl52P!;JMO(YUVAPrqFjUAWTC
z9Izz%>+sx!QrtW%C#nvliylL2Mc0K9nY&t+)n1s%#XE{@HxsdN36QIGB4(>@MR3yN
zwQ}Q`8W!#vXM6Jlg$rtOVa!W91E-@@Hdt>=l=?Uf{G!mc{-Rjr`<EK>(s&eaR7wv=
zkf~OmYP_Xg+^Y#Qt=gtnQ%AFykxsHkc)YlQogEMX#7Pr*O9toFoGSYGE8M2Ma0xMu
zthyveC&jO@)c_tG(b^H2%!3Hy=Vl5I8l60XJ}Nn7oPTLo#2WS|oL_yHU=iAQun;2E
z+^V}C8<&T1N)Yw4(#{cJp%a+FG)6NIa@6dqvA6wO9)+;2t-j-=Yev_9_4~P?=jZF|
z&VHip^mcPv7Gx~X(g)kL1ttJuiS6u_=>D&cKP^`aM+$4b<l|-hl%9jsdHo1f<bl_+
zL)Z~I-_o{Du0GV^jz8n0xvSvSLViNV`?n+c(AEi8G64kH{?*6St$b;Idbhw-ms?CS
zT6EMbF)xRBrRmr<u&SfknV<v9w{|1ew{Wwh*xg!xUU~U}uF2*=Ux6npV7<-G8Y{K7
zdf-;$<RDVk-8;fwq6{|)A6Tm*ZvC)!oG1)qs<2*i{iw&+HVrXyRuhg@iX~wo`C)l_
z2;`K;<UVPRADuHyN1_}xpfmJU%$p7DG~MBlKzU_fy$x!biXicTkg3bbk6P$)lBo>4
zt|Vf_533KEEak8N6mGi38V_sngThtGPiPV$cc+vAP_SDFhpm!ZrnlUuQL7=P_gr^J
zsij7OJicO3J*xBP>*sSuF@A}U<C9B%+AH*Uu;8Kto%+En^Vqpw*$c}zcQrgcJ?;_P
z6G#jybOJepWgu?`z~6@tqsqrN>*<Ghb3zZ^xqdA9MA(jMOyj~dL>$|`_-mGrW5h-j
zVejebi`cFpzqj3~9wd(u9BhdsW9L}*1=K(k2vyQnen+H;>4jcR#=_C;g6{hz{o~&c
z-q7}*^$TsgUR1EcT+v5AkRiJIQz8`wO|1=3dR=A>n;sY5jZ@%+vZYWX14<?mUG#C+
zoUIfF-@Nmw{{U<#u6si>>U402D8vHUMqmKwhdHwg7Dd`x9U4{~mcLx^&o<>ot}xkA
zK?N6wliWAaOj4<H$tT5EqN<ihKS3bsPjwsMTBr9iiTpa1)l-&MZf*!q2y~G!Ir6TG
zW}tGAY1jd3UBuHU*J#S~b;eOQAsugZJL>M;#HKyp!G7rCu^Q*923Lg&_PBH}h(A*K
z@P45CM#d(0iaA2?orLoFAn0|t3Jrth?e9gy+VshD!kiToK}_TC%8Lqun_Oj`vL$G>
zp5)fa`q6K5RxP?3)$|@_dxNK^72li*Htjxi&}^Vh%Twpccqc{U#H+S{dtj<=wHmKj
zkwOPRB1I^e9%_5><O|glw?xCmEAZRfutHd{vH{`bqkD(YrF>!(Av-Gw{{QG~(F9`6
z&^0}ZtC4T&^j@x54SlFSFvu97B^CscYhC!J?wfb8LpXPA>BoV(ikwB{>ybuF|0^dm
zB8!M2I(0U0?96ctn5kBb8ml;^IpcmzIO{kqEl^%w_<>-MSsBGSlZ^Si{yG&U!Z`MH
zBCpAa9yrKTET-?1ni}Te`)2oU1M0F(X@aQaKA-?j39<THFnB86@kn!4g$js>xw8g-
zXA7W9;a@|FEk^?V0z5ubZv_}qfc(QrnOP8Ju%k!R-`lpkz^pK(Lg+KSDS+s{(Nq)R
zKK3bouZwuRbHfku)LV@mfe^#rX{U7;MLmL>8}AS6+zX^gD4HbY&t2cn^0u|IO~d4`
zQ-4J{6!jFSdsSInCQRz%r&tl-sjJAIjRpO+{9g#5D+e{K+}hvo^D@hy8sw<RYg01g
z=&N}6!#k<#`k*by^f)JsP*1bU=LL}iKea9MizA^*r_I-c+Z=zBCYx<&P(NbwCJxry
z>!*1d;e1-!>t=>(fNMG#QRu@df-Nc9Q>CpH@#+7)d2ssi(J?ox9!{2o%brtV8`w5d
zxAYA_GjoSQ?3PIPR%SZ~gmwG27b=I5%`DFRkZE(zh+e?%g?nG6c{vSUu!Cx$|0=re
zKUcn=>NOg;u>vn5LLcllt0v$c{c>eA!=JPG^rT2ws`q(49=j8F6X4EO%4NiHqSG2;
zWP~!=bjr#B#!ij`;n5$#!b){sTJI4D*nO-8GBKdbG^4(PaL$bB&EaiRJ}JX*kZf{p
zOIEIB!+J+z4tpDVrO?U2J@kS}_CzgGdxlB0&^H@V6e7ff4Cou7=?SH-o0PF~>k=u^
zCg_fsnaQdL$bwt_DnIeTi2$#ehH|Ib?>3fwwt{bcQ9DscyYyc&FK@!XWZun+E;}L(
zPdeQnBTB!*CuN4in>chp;Zg@eqwQiiqY0cvfw{R0<Ar(rp@+>8$e_6Z1mag%o~swC
zi$bkNTavB>yFXE2QGaWm7Mc6>h~;WMTz>yJW`SLm#a&sIrIFR9uVP_X>5_T%6V)7x
zep}%FN*lF76esB`M;l4Um!#C91;4M8GQov`+1q_05YG>$IsCdxQ9sl@&&8>gy9?^=
zJgY*#?kLU$@*{G|1Z5XP^s?|DUJ6QvK+ZrucH|INXT{~wR+(g(KU2r7lf2XpgkqTN
z){QGCh9(RXQZD-K81bGZJk3p{a5+oUF-&2J-OrdA1upYdrGN<R=5RF5j#fGOloZ?4
zt=BStEapF=^`4qLEvtBM$NZMVt(z5|R=8-VGP3cS>$Qf4VNkt~Z_-mkl6N(X%C~;O
zYL$A=?51ijQirTszT^oLYf~e2Zd}6&O%BPiE*Z-)-!=n_Cf60to!IIt-#9fq0bRX-
zP+&P|35td{DCy>W{+{)iWxIeWPjzm^_Hw|DE*n#C+@lxzItY)*-U%youFe(r`A^`W
z=ns!eCtRN_&kY!>{{w0-iI@z1;F7+|=qE<6=j0`Qy%<&l61Slz>_PodQeZ);09Lh$
zqjqwvsG9{(LuJN-sWGETV{$wvg0h!Ah!uHD4#e;PQ<GK&@8bQ+K|iiWXCuOd_-|?o
zm)iWt0YLE9F={S)azV4Mewy#ogOiE;=hVwF2U#IrZb?{GjFvW_7b%x6d%1G#-Q<FT
z(#ms(6S5~KxL@q6vHk;MY-hx}Jw)5ARDJJ~DeTMV<{BQYCQg11l=lw)K0@6k3+)eJ
z78A-kNVaS??b<dMk9j#ANy0n76zes~2Kl_<DsFww|L2Iu|3hSd9w22F;iEUi)7ANJ
zT{FW3Os+oiFCqgd6m+G<{3DY4pC_Dhot07XBkdCW+#xGhV>-i3WX)2%6a7zeV%@~$
zRkYaQZmPx;I6$3YTa$6MG;jO(F}i7C$9qTfIjS*_rV?LNqRx9a{v<bc!RDPEGwj9Y
z{Nj&!0253K(d!Xum{P%5+u@{1;@~9b{z*x8qIS2UO^GDyrXBgvjBA^?yqs+#;E6q@
z@4Ei>_#r9c4Y=HyV7G(O(rOuM_Z+aVY{r$n;$u-~A=kzw$qd|%&8A~;3iV9@Ex7#t
zry(u^QJ|w~0K<zvIdnk9#`%dzZXphu{Tdq|vFXx#0`TSjEuJ47Lb}NNWf(dzRV##T
zQbeqFIxWEy+9lgyN**AJ%xUv-CaAtC5P1<s(Bm_~pUto??BmY%iQ&!K6+7jP&=zj4
z6!&sQIm|bI;nDht;G99FOHJle#hQqdBlknV$=@HiAAj;vWd~27#8UrjK&dP3?$s+Q
zZ$E`U@3VDo!~J;CME+uEUj%7pN3~fIwE11`wi-Jh179!Q;wai$b3*qn{ae2t9)d{H
z1NEYp;gCwKl#4q_PYB1i2-=Z5$pc2|FMH`iu;sp}zUZtIsI89scNg$;II&OueW@9;
zQ%KqvPI5N%zSi2c`KbzB|FuCvb(hTIJNKp?h~Mw1EcRfh_#SLk3G~)2n-74%_5CO{
z4y^w^Ok(<llUhA2bHW#ENHS5`MQK>--TU*s?604l027%37z-j=+=A`m<RVvi-|NsD
zH>xL8+3FyCZS!5qaCX;<Oz8fPBUSpleB=mtL0~?~wEat<>Q<R;30S`#ggx^RIpca*
z`$YU_9_*W!z8MF#euy(c)^}jh78aBvG_h7FDkuHOTf~!*w$5cX9ck}$TZ9YO+W8s#
zII(BXBGd!t`(53aZiMo4GEe^=d8M#C*I7jsp)0Ytsv!3IIk0oqs60m9AO88X-2eFe
z#POB!^Q(j?_<D;c)^3HLnZ#h?PXNTa17`yQlz8s;HQ2<mM=o?dbi)PrC<X4zIE1U{
z+;1Z9DBqh4I;!yd<*Hxd_x5^&3s6)6iB}-OXi$jUwaS7zQ%|E4oOIG<>+`S|#Hoi?
zGI%}j=KG<27^w7+j^%qxg4TWFO{(la5Nri6+MrJ_xa;bXOS;kgl9i`uB$D|Pe>v%k
z{=jYNRd$%sEY7j0C^w9uu&#P=>r=fZ+n=|C!a=@Mz|(r~oD2Hp!piZwZ6eY117W3t
z5V-tOmC^&mG``S>G8*cAvv$r|_c|MyG!OSo9}mDp6G>A=7!SJE_^xS8{(z(o=7%bA
zF2%W&EiP)Xd-a4!-V^Bl1;BSzgj#{#^v!zG6^V;g8>~qlcw6`5CUB~NxWP?sYPUWy
z`0asH)2Hh1DG24%a5AMz)$VYG1<U=qj_6yl3F*N)jz>@KEi8E?=V$W?wigK9jaWj(
zZwP=&f|TzpyUzNbBos^`*g_~ku7w6atZzOT);ISb-+P|Q*`loq;3pRv67NOxs7Gs%
zw|7#Kr<AzN2?f6JeEW_ehwme;kGN*gOa`d%my5q*T~*!mA$Lo7)|XAS9!TrdTX#17
z36aG5R7avL-i=aiCjRNG*=TxD8r5c5+hJ|`+((2mU19}$Jd1g7)U!DXj8Oj+)XT~x
zh@oMz?na~DY7y>FbDVq|g3Y7&+|W*q4RAiGw%FB`Q@W?VrI)0p;L)LOy@$Q-Yv)Da
zxZ4@t*1@9Nrs2JNYW7Vm?Ed%5p<2i+!(|`?0Nd_)Smt5RF}y16)nF}nijqG)#c!i}
zF3?Gjx0O4u%HSuqvJ8#Vos>oM)I|+b9R(2J_TOP>I*;j>R&@h83mwB$h7);9bv|q<
zrzSY0?%F+?Py=&dlRDe^(0{~!?fUZasJ5%OLmID#K1v<OZ@V2mNPG2&?N_xNCG#uR
zldw2d;)6Qq=CraDtA$;-`C`QTA{FQ@3hV*N23$mzf>uC0v?yOgQzA0sK7gte{|yZB
ze*XN=<x#@wDx8s6El-&!h)?6CT^`#LMh!5y^rT%`H8ULR{RPV>d0*UkHzvU6*<S<w
z^T<{$B$>$TSz*q(5!j=9iUSmIwcmg{8yHlE1Q4|{Vzh`_AJBXMeEb+hWHgTVU-aAs
z+(XZM^dCm+;1;r!9zN!DA!wo?+1xUmy{sW4diFE7M6rl;1UqIrN!mUKMZlScQoZYe
z(+FN){HkpAM#PWMM4hhuj>9eOJ5ICIQ3D`VDCpuJ(0u$PL7r=aCiC#t!Q)qga&Jg~
zc!Ws$+Tz&+gaa5l2&wM-+JVC#k!vx|N3<WAy&GxON9Fh9L02Rwy}~*~Pl)vhp~nl2
zWHO_Z`Zb`3qX)~ijb2|(fB=)LSV)>LQCeLq_OInKo3DUEzb+t4&zj2_$I~^4WGQ!w
zC*^S|Onc}2zRBsO7l@#EB;Wzs6CwO9Cgnp;VDtO1gK4~)YgsFG)kHDg9A5v(fmV$<
zrGNRi-@14(72jlZh1^CI*H`vPw_?nHw|eB2P`<s_{sJ3Jlh7)MYI;-4AvHY1qX}PM
zKx&R;fxlLRfT5=N7&E`}l}AfC%vSH-?qW}~d!zZ6uOeAGg78hVVFlF)V5qlKp4xp&
zfZ>lXb8H$vJ<lN>1=yecg>85*rQq0I-Sx28mHX(vjFo*ww?`f$n{mdEKjH^@Ea*!e
ztFh1c<&u?&9EaZ9`MBI$^Vo^EA0?=*$-}dUSFT^z`oOQm0t@f<r1_R=Y!Ul0BEZAr
z%awz|c^*v-emG?B)&$6$A+H@`ZoiLR9jc8E9Z}?ER#Pr~o$6($=A~%TaoCZddMf1H
zae)oP?EUowx#mEU`Yn5Q&hd|pvg4+?8`a*IlJ)DGxe#Vi{v9I@SJ_9HezbwgS?H|6
zO{^Yd2?_A{d=m`K3wJ}MfOzd+w*Bq5oa=KyCTe)Ls{XLDRDN1B<l3#nC@Jox+>c@z
zL=faC&P4z&L58IT0HatpQvIY^-AFLTh_ClaC)m)OHY5?`HEkOEURp)Br}<MxXpQT6
zgHiYsSyHZ3u7pUHuF@;e#Tc;0Xbx;Fw+HN$4k^H2)Rt?Um3((|+?ud0PM*H#ZA+;~
z>@jS<!oi<7N)_)M+de=$8DZMKw14Qjf-#*R#-w?8Rh66)%9>^QkLi2c@b@M<tOsMC
z9I3cHuBw^ZVDsRudBGE{k~I2<^9L|@henI|H8b@9an)CE0ONO|XZ`0Jt3gSv)}U~N
z{KfHenATbcE!1OgcF}CAAYONr>(Apz%~9FNg2a{OKzh6=jQ}GYC#I#pTsqCLlcUU+
zmS<1SjJwq3GXN=&%`LWStD6>y;|a~jsqc}l#e<47u2j$6YwPU@maN~?8i=6sn~WNN
znskok4dV8<t_}gcy^=NB@!c#d%s+MU$*r^1`#*;-#kIL3wh77s=UqK6sJiYmvgn6$
zrRJm+a|XYloaWO3GLm|AV3B`zYsGx-tDwa;Xt>`$VN<fQV6n8T;UTzBYESlB86OYD
z&;`6ZKnePP{YQlFzb$!Y1vn9`1u!wMPxk#eR-7sDGOIJ<-b!C&<gzvh*257zbNoJx
zgsHooCDXEQX5qj}GBA0N)*$VRfS|ha2AswfbP-1Uaplg0KJe(E9`)nK*Alb3kofs9
z2W&Ic$kzq<bQLGiVcl&na8f^p+vR733DKoPp3X-+3F1qj%h-w^mVf^NCFIbwq3g>W
zMb7JFD;ugREy^iaG>7r2bx>Q@|5i~%egEk!YN5&IZW+>ZZ-;9L4q*K<C!4`E-Kw#Q
zMK#EZLn{ONm7Vb=?cdxrui4JCn_%KB1E>m)9fI1M0yZ!W(A;&s5~i_BE7|&WmYcu{
zn#QSqTigq<z27?fU8gnWb97un<-mh<p6u4s9ihRW1T9$l-yQVQDSrs=(jW$5W;1qa
zFa`SRE<s&_T4Nq!Ac^kTG;J{JY#0;t>y#Td%5*o9>Y$P5_9~AAi<!ZBmRGxbV!v2_
z42rt$FICPU<K4(gT>(zf#kE}$WPRKK(8%`9y*@0-!S4L-K*z_}cVOh>n&j8~fXU`q
zk7rCq`8TAH%|jYySH<UM(M49la$X-sB|~2fB9w#7R51Bntg$i3%Jw!4)o6XHLb%Ml
z1FsWH=MeZ4Y8nU}d+J~D8R*^sBGM130ZErgQpl=^j}f${H~DdL-#V44v>Jn<?Gt=p
zqvxc3^_8CU)luoKke-wXNd8kJp`xRrlSlgRj9BO(mq4*0N?N4F>Xz>umE=6zE?W_d
zw(A~wZAZB~_W<SoOyBB@Dbl^nqSu+-gW#CjD-h^BKD+t(^>I7<<>!Da9Rv(4*s2wO
zdi;Ksx=snq<eYwYzj`mRR4$oe1SJ6-uqRdE-(>4zhP0Xi>yYyJwH7Yn*-hxMD)tu$
z{X}R2rh@(zVt~k~h}oJp7C7x)<=u%+2uFF~?F6!HCk5@*dCuP|*+^~$iv(_D2rN9-
zaqrHjm5O{s2WgbXTc=Okv!iOKt@wabx+x3%l_|gB4;Mhi243ouz0^jiL~CK>kdjb2
z^`z%@GnOZ+(i-<#t;mmdG|9#Q_`vYbiwd8qFemI*Wu)#%AS!!Ys#F|5FL|6!UDXz7
zVemsAv{IEKUYsA-A-rib_~+}YQVPU3{5X=HfHwA*RUHv_JiS6EN6Q}GtIR2_0%qTE
zENI7zc+oS84;=m>YzOb(zp8&tr{JT_p#^?02FWrc8MmXIf7WTs^_q+3U>5<wWMKE&
zRuQTcbsxgW_vAcLdb-9|=9b8^qvc^ALKfBDz)lpr4oMF(0?bOMpF6?KTBX=G&Y$VR
zez-)D|0wCn{gm`$8CNph2Qxz+dR+H3mn!CbR(j-1@#@Y*tlx_zAU(DKm@AOzVd`^=
z=qg<$$~{DMU;S|JnK9TMA184D4jCdUC!<*HDbYHL?~i3Cl*dkuvO@F%x4W|M*;u+A
zbL>9=Ce|j&(Tyti-m$|vtQ~e#Mx1fM?I}aZI`sRW*N>As=WlmC!qVQ_;>Re35jj_N
zM=%{2$xiG&rwg+lC%%CO^x7p@u0)`OM#S{$YOiHd1;H}9QUHTRoq4}6INB%l9@ZC`
zd&iCJ*Ip1bW!Jm0gn<rKgjT#VBwmfFbDWcA<1pfJPCsJ!?BHj8{;OSX4j3@7pv%9N
zltO$h`^mrUn13wEeUqH=Cx$nM56(;a9{*QFI7y*afE&?aZGD50aOKlNUQHItACbV|
zlcqZ?{t6Kfd)};B;qF%NoIQawE_{;kH^qmv;&u76ZXj6>r+{?Z^_2b~Cc3VETdgJf
zoHNfUue_oT1XVrcSljs~j{V**9-~RSf;XN8OS-bZWmuOv>*(8umP6R~-4sdgEPiED
z`9iB+ks|PKF-frZ4=D0!8M;S<ysN%6{2DB?PjMdW2q0KHB$Ke2nt>|y5Cf!jMfY*c
zRs9d7Qi%R)Uvo?<!=hAKTdKG<K?6S}@w(YmkwR(52jHhWQz4&w+S-ia+p0{p4*3{T
z_oentXL5ruR7pRKx-A^?aSxB-ufZWZAYb?Te1vhJg{(?t93O<<-8Z!C0ps|udV}vg
zdnJlwBKV$&idclFZ3DkgO3(842ViO&H{vjeSY6#gUTw6}2A$75^FI6%&<VI`1h?ka
zjC7<w4ZW8c3Nf7RVL8l_fw~{o%&!=@iBf*lo~WUI7ZsJ{A%M>csJP{n3HNdo$1Tn)
za8J2-PYEtc>|UkX(d{h2GTN&gi@JZO*y?{2YS4IXpAT7@8{b9eT4)3LaWC9LK%D^y
z<n?cmvMewar6O4m`x>?Zre**8v2w$#Xjxp>MfYP#<z^D|IuNjS%i(H_Gnsz-c+RoD
zvGS46)w`!FZY4xqaNpEcr(9dT07XQ%o(D>|={@wXN%KnVg&g&kf=cGLawy5J8Y{Tw
z8wqlrD^la2=^W`ghX8I6#!)P+q}f^R;<7KWp=%Z78gvxxU2Fl(`Kyt*B|&=dCvsDZ
zud*`$RS}fCKGxIr>@j+L#sl^&tQ6tSWeUf9Iau+JY<ek`ItKL61^_9);$H4uX_0IH
z%V7mnN&=CO^v;IBBW}UYjXPb00rYqm9D#P-2s^ArJLEFTqbZ5~tVbsU9fs9y)dSoC
zjAej68Q^FqzU?4s1&6JV7++bbc%ZbeSw%0)h5}2iv+w|Bq<&x?O+L(Z5yk<0`P{pk
zu>DN4e!t@!ajZqD7Bcg4wSS@TYVqMzX7CSR_6TBaRf%l^_`f9};cOV@j3R7G<JRwd
zFY5$y2ve|PycNPwwMz66xBSu|2bHke4E)Nk1jz#Q(52f+{SI`c$n7yJ%>J6=gwt*4
zmsQKxV-L>tlR#1akDHrmLsDR40~sn%2+_4TaAtHXlvE709J+e15)lR1F?@Z79BsA&
zg`~x*Mnhw}atU1_eDJGVL@$$~WY2q@T4Bydb0n1VVB5M$oCemh)Eo*qx$<OoWi9m&
z*Poq(Z;C4>rz^vOfUF{%m_4u$r0FD*svgTLY*4apw97UZb*zOPlr)$=4D1I%FDpQm
z80xyB#gI&cnKKG)_2tbTA0TG^2f2peP%$>&qNc8;J!fxk>v>(gRk6jn#~W&WZ5E*C
z4w+;>J*`NGC`&f<9vXN+4hWKr=;n&M(3$3N`lMS%&gRVLlst__2awRTZN@N)BR|!+
zg`}8c8G!TTl(0PL|J!2YQEgOY&?Z3P0kS-|IxK~jMS*|&snJ^IQqeL@|B22jys!m7
zfK!!xvz-MdV8FUFwfC8|!~(&-MQFahq61>&=e73{AQ%y-Fa;7<{9q4|fDTm8qC9;*
zbp&qi&n`toq|KiNOeq5O{=3lo|CzxMT+vCxw4<mRU4D9K^(?aAuSF`t>zY959yQsX
z&kvqm%T*SfJ96k4WaqLFTILq$_ZB0_OGl!tU8;kqzV(YnvvqND&f%m2iuYN4?DRbn
z2u2*DO*EA8;5rVu-F58}FjaJa>YC7@){{w8byL0bSIhf6{;!^MM<^%AfZpcNU?Y%^
zkT!w}enUcm4s~!jxXVMy>Yv7>5LA-o$?5`AZ?k4cv5SQBT$OD|%7drXkLT4}%RwIR
zaBa<Ig#cPB_Z_%<!TK|+u$<(O8-2AdH{VwvZ$EZ=js?Ti3E`*%1WE4>N=sK}0RYeU
z#&~{i^9QzH2MJ@k`asY$hO<uWi?yn$p7UJn1$HhI%8$H=b;5pIw^7`hC>O3BiCJN>
zPGh@N=qE#{r=AT0G2#!~W3YTEJL=sPqK2tD4%6BGy%nvc)PcL)Un;qB@=5*zyOACy
zfeuF>eV@G&mOUw~P2sJQA~q%0=GvY%lR{f{a<a`TQ+XEeHM_3ZSP$Oc`jiDKeNF^I
z%a6^5-@~4v#Ax=~??mZOo+$+{#)+ms6j_otG4wHqXKSjsb-67=l%PyK3;gep0AU=W
zB$U={KKMRM-rn~kU?pGvgA+o(l9kZB;+3k-Bi3R0Ab~Ijf<YmMg%xk+fRN3BcIlmk
z$EGnNvgb49juF;}OW*ZLyr{d9b8XXh#n3%ncBf*NK!)Qg5Kh87VY`a{(P;~whH0%g
z`mu@C_Z6<N>H1~I;Sn?r_Dg!@14c<MU?@=75P9a-B63eiH`6L0<AH-PsUu;;paMye
z0A2^VG5`xT0PUKZE%X&;k5n^n#0TPwE5)sG=9By^w>po)ypAo~Wp#un{p<;m4j^_q
zp*}NNFiU55;{Wjv$g){1x`P@g61HX|d2KZLvZc96Geze<Z`KhH0inG;`Bo?dE2fS<
zPb*s8si$z^t@*;MJ-D!6Tkk#gFJ`*`=l7P}$WZVUOb2CGy-!Q=0a~^aCghFxg@Hi+
za1<Cy%J79adZQb<0%!+m$KBUgq65C!_o#G@5w~8i#YW&%N_Q60w#w|q9D(c5;jd2j
z_g~53N}Ejpsu;a@^||vO5UsMHGIxO%q{+!$m@!!mGsdN5szL5U)3|m~3I;~SFtH*m
zh2gaHvY?Psi5@(Wj7P!mA+>LEOqnM!OcI@tb7%5(%fz?l#++G&f^=hDDajZWQdAC*
z^_GVHh6<yx#vXSw$!5e`FYfx*&Pn$C{Z%6AK<LLaq)dLg0c;*R1q|mG)x*uO{?>+d
zyKrSCCsY`j#UD$V!uArN9;AP&=4h&~8Aw8@juV<B>7gMyN8kL!vEhKYwN`Fa5=|c_
ztT*G`!aJ`&tNq1<C$OKJ_))2gM_Eo4bMdEC0qbIbs>qYwt=<>R7Y=73XrUto3GBIT
zgX0ucilR_uW_nXbDU)POL&m<f^i&B~_yF9)BODTi<wn`jxU7(VFaXjQgW0~^_Zd=p
zM=14*f&b?=8utqfUlAXdF(59C`TEPsc1hO<PPg2%ChDWF=!cq3UCRxJDU?9@WJIj=
z;3r$_PDF*g(d1qr5XKPajh2gjYd}&|Sg>0)Z>{B3wRQiEVx<Bho$pjU==e10eLHRA
zl!zniO@h_;XPYAeTF>Co23&J-xDX6=+B%qF0g~+h*~rTBeUAC1Uf&0MPTU<^cVPGv
zbbRo4J)7-es(Jma*vo1+VCoqNpLTDFU{QA3vL-)a1<E<_dx#3UHivwcyJ5EUsHm|v
zoisnv@L=@!b1$V=C&A>Gq5soREA&V8wT(;>hPdz-{$v01b?%cKi$#?nFQ&5!aM=i3
z-@;a0!Lmz+&Go|Ka;1yEy(}<(o_^)ml}A$mD99i6tlYiN@<Xm6FWkLsK)B<WGirBk
zq2@F!(e}<Xe%Z+I0xa668#-thB1gH^{sK@+r=|q*UK9XC*;^677R||v7CB2Ss-v8H
z^ro^uBEsp}RPt`dVLS7l;ob`2#F4$SNcF>^k58(p3cy1$Ck#Oqow?vH<l@{!T_CK4
zqMwRBA=JD;*>~s1Tov#WkrWaqn@h$#`xr=^tw!`8rS$V>+Lie_JVY8Sd~l#f=!1F8
z+?xvJ*wejFv4ZE$dep_2<Y^7kgZ;3L!_*+Wu??11Dw29vwmI5yvG`^?V@FCfo@If6
zrwF*cLO9R?2ncI6nmE@XtkiPedLb}*h@<D7g6ObBPClhVX&Ag+Vq8X#U#E6TMqaEi
z{zf#bv#a}i2|<edph#y0S@9c`MFn?sO&rH_R5=+CFzo4xq3HUn&fe22OJ4phJjK3L
zQYw;$>&9)A4>J}!hS09#4vp2<1y^NOTsm#h8Q2~DO<Y!`c591521KsI<zu2f`P1_}
zefr=^sX1<4x3bVMee_(S<(ziZ!TIE3!L9krhgHI)EQkHxYT$=@095h8-GP;RQv+%`
zWa2MF!+pZYFO@8tbVpuaZ3$ocF6rFcE~lWAdR{W$jt87p80yrYtNXGKPt3PyHF+KC
z%$(nZON<&=f-o6EJ7e)-z;X9tP4CH7j}CltYsOT2BksMz5;3(7p|71n251^xc*^P&
zcbd8X9pKF->v0qC3N|`KtVY<G@b}V?%2NS7pZl3nQ*z`&8^D@fYE?ny((v~$0~8cP
z?E^7)(*>c=NQ%4!I-MQro+Mipw+TNQV9(T6<~UUR`F)3Mp7Psr;|{%#9xO>e4-lr1
zp};h|wzQx1XZ)0cDZZ53>NQZ)N>(y+<+M?U2+kpBSh2pwXx;_?uO*ANOG_i1(+yr&
z@~*fyZ<)c_PB>~bf2>Rg>0q(zm5=R`N>49k0g^$jlNoa6gfa+kl`DX<y6Zlf;;C+G
zNLQAA9NzWi0ac2R!q~JSNd)lh3#!{&tr?4}O(Zay`8HdTUvq8w_+_B}w36-y;|>Jf
zA2j#LtQZGE=OnGW-B{|mj@y)_X!0b+k$o0RQR~-U>;nb;NNnfAK8G5ZYWoc-edPmg
z<9ITHmYN5KAkHlyck`#R1A4Jr9Q({9XHhd|!CAyHjqiP>qhMidn9;~f7#B7KnQhSN
zuLv(LL<9!BedXk0p7j!7&yjX^$Ad2S;xE8(TVnLlhdf}5LUPijR8AH<J|WzAgzkRy
z9W_hpZzEnsdICLndH8>=D*u-VjzPc@kf{;;`r8@}jTWXIp{Xm<{AM-`$UNBgz;q;i
zTOeb(k+0AWi@v3J>v-E)&lV#|fe*<VC;56iW-Bxytta-ZYF38%jbn;qhV0k+{Bm(G
z0~V47U@qK36Aw{Bk02uatd#UzM~}Al2q=xz1^k6W)OJ+%zhITtz%;H*kbCa>V~49R
z+k)j`Tk@o2+XP^VqcFjp(E9+>r0hq;nbo4meI=_*^QRL-cWHf;*mKlR^Jp@K40_}~
z?ym4m9+&ITS}ylUrLicPM972HEz<IlEdqXE+FgGprPj>MpLrpPktSIWy3T+Ttt1~C
zjU-Nx!|`U=Q%Vw83#h(V5gL&OvpbVvddz3|I?PY6TO`~VdN3@0cQ&@GbA{I~09+io
zD)7I5Os=fzs?9to9A-T?y2|)gSBwUFVL0`+aoDuDYEsg-!3SUMd=PjJI=bb-LKYTu
zMmrq15_R9i8y@{R_@!{a_3s*g0!}p_Ykbo4eERU9oDs9t*Yl3D^cNoC+4T>ZwX-8t
zd}SKsp)bG~POtgFw>f29%QM1H{_7W%;0C3}rpl`9`7eQzso6iX#L9NrR$7<UsuAX%
z%>F-Ed+Vqu!?0g>aDY)dq*Fo^q`N~Y5kZuYROxOQat4rY5KvkLDFLOsVdxI&7&>Rj
z0R}v;-}mja&)#dV^__Lr`GdtDtc3#4`##Te-@p61lH)S@x6GvVM`5%rEKq9=6w_hB
z58K4qMZ+p(dTLg&omVec)O$OvTKscy|21*{fA|1T%MoFfk~<AWH&aCz7BzvHOB-T~
z&@Y6b0``dwTCBb58lr2~v;3Y$UU|4EudLG|c*r-~pyQVVe-Q_1r|5X#&?{Dy?E2UH
z(sm^I@bw@@C}bzu$c*W`D#omYTG>hk{*_%?D>H;0#i0$MTrH2A3;dF6@W*V2hFA9I
zy?X);`|rNnuye^mwv0z&Zn?|q*KSDPR!sQUd3Y`T9{dXu$xATeaDjkGT3V(yJ%FMY
zFfK6a%kK!pJ8rMF&}B40k%cNO85v-0);!_gE9&4BMRSRqzmSw+mO4FSPT72;4QaG*
zWv<#gpg*2Qs5MY7D2=f{->Y(><yZk|+prG#NH?26YI;f3`PV|;pFj09IF{jEHMCxm
z!?McIp#W7BzNl817v3w~yi_YU8ix4Ko$?8H;4)iC{w{qqbEthj?46ly@q|zQk@i=&
z?;zHri+U_i#dwS0kX!~ZqAUM4C0$e+h<Y<Hy1lu2vs~r>+#gK&NoU88c_L1=f419K
zw@RI=N}VEN><y?`0E7U8foaxE&!fok)@}w;GP!u(hMlp1oc&5{#iw`kkxUs|z<67u
z%1!R+2RTiOn~0q>#gQ%Jv;$uHf>;NWJ7G!fZ+{6UZ%XuG@p<|mfv4nXv1)bWo;SYU
zV|>nljw4?@mg)18F|jpYnD^G+X<0lXhian<m4EXokY>tZ?pPQn{hTea@O{Xc#KB+C
z?)P&OWwG>=eUn=Y_CU!VmZ;O5$lrO{pqc4sdMxihA4`AaU@4Tj1=_GI#DS0cen3@5
zUIJuI{l6gdMbaEgI!|^<x>F|~mRNTHJ>tg|_5RmH>u;yi-c@&(z(4s+!vry;hi6+e
zJ0lhTOwY8!=J>jF0U0$(fxEjg>_C!UJglmSAYQ;EMIXU>pCjgaMH@2mqoF)BkSn<(
zn>XrQnvNg4J-7HR{N_E8>f)IsI1Z3xx~1&2R(`VQ>Y{lP)gw(ukV-e_&Dwj>&IXqS
z_ykDC)N}Wj*`za+AA}+4cM9(^86bm915k}?Kbc8>w^UAg%sR2x*NHzzk=^|OdZ#EW
z0XzpgT*@AgcIgb>6|K`_l67!A8Q>t0+6vB@2+p27d7#i+Xii5hy<ATI2;t&=k`swG
zoDkQlvtA}Yy^G+MCqty6r`Oh~vT~2<(bCo|dphU>>)c(rI$$;$J~PV<j{Shr`xp@g
z`NR4F)YhlWacc#a;a?N)%7|6%p{LGGe{yd2XV_ZJsa^k5s*d}%+^hJWMowS_=+sN`
zV&pQCvG!c&-=ERQF}u=-S=8yQxT%=8UAe)e(B$19dkn(FnF5o3ZD8~4&aT3ef#e*B
z0N*bYC&w3&570|OR!O_Qc<>WvJ!q0Gw9|0r5gPaqilW^jk!CzSV|n=&9lpkn30DYF
zr^mZZuXw>}%m4blv=koG)yWQ`)Eh8w&2jsSRzt^h^RjieoCwMO^Z{q_xyR(UED#T!
z0Uzp#IF+Z`km2(y=HKoFnvQwPnuIYw6XzRw0!Rexnx@kPOc>M;enf2;@PFEVx_-)_
zRc3#nDaH}ivB<7n_`6US5ESXBLyI3}ATL4*l|s|U^(4Vb)H?SrR?NrYGK9C}i;mvH
zHVsjQyMg^cG55{>ep&hE@e{`%^=Wjo6f_RLD;6{Jv*kP(S=`4+GZu$PeXIQ6Y9L3G
zW0Wie3~acEdjPQMtI*O;S}K|d%<)U;5mx~RLB830f3;W(6mt_3IH+LQMaAc?n!L7(
zJ#y~<&Wt|#ugSPGfLcIXE+b1MW!lV`)?oMEJi+}5`$SF?q`>UyT=PI@i_pK28~MxR
zV#Oyh!t1H?tVjuNA8ZM-_!VN&fgW@nm)aswgH~y^ztiqmy4*?cQk+JTOZtvj=%mYV
z@st>E^LL@~vqhb^i=S?BM<KJ+7t?7plurR%Y(<Ac3VVX^16eT61iGB@Ca?NNuSc4R
zZTvNH?1Cdlw;R0@iCFT^GSl@;l&w_R*YC@vhhKa|OFIH)Vt>I{UhUiGqszObm+5T0
z#0;yeVD^<MIS1rPUnk)L`ZGa8AlKIZ{|XforuyoAhtVbVbR2HnKd=g;b}1N5AQjQF
zh2<G{a&CM&AHM5JLoVdpegS4{$;Gfnv=Vu^C4S_q5PoOwdSYO4t5m-{XC)#>JYgXi
zyjRE_c8C-8B52=5_%xRwwY3WW)AY8JhhICu-DCf1vWQY=v}!6}V~Lzcm_89dpXR4t
z*ML4?k^Y5?l-TXc4%s;}&i9qyKciPi)3a@tR?O)cm#IlG#y?eHe3Q*Gy{3|6!lJE)
z#I39@frEC{5zmhRxXqOoq2aP^>z_2=bWPUGfEXu_mB$P6jT1R$<t*w#B>}7HC!}zc
zG66KRn?f~K@7W4zgA|FhdpF1(Mk)75y$Gsw^iqr1PLB<p$}YMeXo!=E-d%8!`_be(
zqB6z5O8M5dHcik8@r8(JFL9og{wfX0&5jkG#&+w^6C@^%9+}!5bsCJzgKX~5PQCe~
z^ygLF^E+CT$p9js{(Shb$C>+T+WxH?afMC47^y$`cy77ZO<@XN3w%GiKHGI73G|Yu
z<3Hkv;2Aj*|7S2#8-05HbG+NUBK~xa3Z?zVFoDk6MI^fDmd{@!%^1}_4hcUxovKgN
z(DV(J&|x5u&P2+E>>;eLC3{L%ARfv@Gf5UfeQm~8rGcY@PjZO)O`qvM7U8^SoWj}G
zi@ldinznrn5ISxS;RHP87?~)5m3u1csdsbYqN1WC2tfh*%1$}@8Q3;qVSH%`5OMO%
z!S}c3`grEIt&-+in15>DAPq24UvrR2$A8{z$(LXQxZ;*gwrGAt{sU#3!|!tnU{KY^
zpq)`G_#-G{ZLk7ku3a15F;`t;tTgH~^J+g997CanyquQrD37ezVWtd!?o4852(L^W
zv#fZ^+9~KS{&j$*lWJd1>=_JVuQ>Hqu3fO5j`0Co{ZWuw2@0X+sf({AQBN3)7;;U<
zfF6MdZUwL^$z4*8q43dikIA?d6Y3VFpWTYu_kH~l@}VBn%T?5=qpS^M&eR`5ps|x>
zhnNwGA=8^5>@28{2K{fGO_Zt37~$s0tN||a+?T^}SuwLH;sCVaNLS6=i&!F8LXjH1
z!Lo3d5k{v0Mv^Q@voG&R&po!#b!Orjm2TcI59aV8?tlDdQn5JCV3B%8W5z#)5)7;%
z@7MJw9m8-1kc=Tqa5-Cmi(|@9xL^-?H8JNg>7+SxNJ7x7#ZDA>Q~)b?1n83X6=+E4
zkw=#F^X$j`H2t=GOkTyzc_25ff=jB6Z0=`Tl)F3h#l=g5jc?w87*}xKdH}Fg`YTO-
z-O5RJW$&tN$tea2P6GkRUR05W0*j*Zwc_@sfW??|N^nf5$NQX8U=lRebGFGD$&>YR
zZdf^KyBOh2%eShlz$BGPl&LRmT5>JYQvuyXRTMogkbcaQMEZrc_jDyuf!R|Gz*%)o
z7~6WId!o}453+Psi#UMr05c})mT`>FqkNy|KvU0IM)s3s)FFrrShKgDr!wfDi9%{o
z+x<^@h{9;M?FU<}ITTkk!gaL|V2_?axClNEf!tu!a$M@AP#sNHsNbszy|YguGri^z
zd;E^8%%B|Si5~l1vp95K4q>&G1<}}N6N9qnIimRgnFmTO#Q7hu>;LvMP>&!~2QG>_
z<G_s4e-tPF*UwDyAN~E-`0pvownTdsIZGee<VC1`{T&1MrI5N>dDFs$Nm+BI+$qqU
za%LARn_py$G+&NWaPXwtVy^BRTY{7JC#3>tvTYffl>_}A!<bZGiFl94o9a)>tF^uQ
zK$*$gJa?Mo&p%|}pAn6qf1_?u8`JY~<rk5A&@vreE)lQUN<q|Vv)Ja@vQ`%BQ+8FN
zLF2;p6{>&cKbnpl3LwuMAn|8MznIrM&0r(e_<^j~R<5k;p4lsCF|-sbSUeyTNl&P*
zXe|MLr0j1wkvt9XN~y7mXqsq8wyJ4<uu<2NbsFP)u(-lYDP*<pZM-Eq`kHU%_Mzbm
zSc6&8wv~cl+Xpi2Qd9cnQp-X`I!~j4b!{SN)H6L*m4%;ocZos%2xKg{Cw-<1@FzeK
z?j^>#WFi)K{l6xs03H<DY~cjEYb-w6X#|5AZwdD9!;Uu|Q7p}I9Y9uxE(H10KA`1{
z{mTZ#rsO^z(lQ<MOtqrtK$jV-4|9+M0Y-W?sH$JH&5b_#!AHyn2^4pbkWE@y$cqyb
z{VoRisFGEl^QrQx%PQ2DdLucGW8f8b_cFj|=OBF+!|UlN9tDif`+Z(N@qCyn8%MIf
z%rz*h%AVu9AIP<!4Cx&5DM(@0uSgYr;+ks7igWl959GhGdKAUXjXM0ooKaxLHT#uo
z;Oz%}Zc>T9gY2oN-M11mO{Ty2YCS4caUMz_6{3U}f+o+0+yN@zbWYgWfkvnAH#;fi
z_TW_<;}x=gSZL5Lk5DRH`Z_1(RwSK{?b`ow^YcSBG67_v#NOL%0*q%lbeb@_nZMWI
zeL$&bX9`i5MG#zFf;FeqP4`rFf5?>*D*vjM;_DaZ**Ss0cRxfxiQ8%tSK5%zz?_O|
z1eP~XuEd|$swxtmQo8=c90FHkb<HG^wI7uswMM_g=xa#@+-5L+i3rHzmrPK_N=j?d
z?u@+9H%E`JNd(gF_HjhS%BL{Ck0TWSTmYV2p~UDd!waHdxHek2(cFZ0_1!XK`-2Pu
z6mfwtaa$m_t(<fV`eBOsnswCq+PaSy+n*qE4tSf3fSZasli)D-DCXYU^5x}t>k;sm
zKvOOG8#LEMuZagy8+}g6ZSdh(T5-@p!;MB687a5zrvY}bEW_$igeUC2Db$w%y4qCH
zm-WM+4QF&6oZuz}&b-n)FF<K@*HBX~f#19Rdf*jD_qiUN41aScpwcvQC1d_=pd_ZX
zzdp3-kNKOqw!=qc0?c`2?mMQ*WyZ>m-<C#Pxx48VHUJaOrIs(~@^wcJIq<+3(fk_c
z*X1?14C0KC(D6me3NPqD8`nr9n%-JcW&ehjJ2PBnu*Im*HBuvty~>O;GYOu9j;eq-
zlBrNdW!S9f-8_R&D$HtBpW|lDC$H1<->>o0KpPRho{RajX@(^1HQaYN>~KbyKt1Yb
zbY)VFTEWTP&S-gMpLMm-szSPXFfU~&i;fz22`(G3-y-C2>8VL5v7dQcWa^IUpI;-y
zq#2puuR0!4^-gAEHt01GM=ox&i@}g`(bH}p`SyY9w^)1RZz6PkhW3g1+{$GHv+=Jp
z#yHi&T%vg9w^%)9%1QaEBafY*{uNFXBauW;k6?F^OfJ4wO%GezFv%j?P_UWpy4u*!
zhYH3k6o7}KD^nkF`Y$W;-+lbE?-D+_<?LI%Yt}haBX;#ZagfKauP5+B>*J2Y5oCHl
zrW<h1TNjX0FBq8^igZ7qHs()P#R(gAQ*k}W@jWXKswLM%4X7Ke>)Sj_?8WI*IiX#-
zUJ1cWlO9mI;~FxD-%nOag4wC^b+j=BvACO$T3B2I_H`pH0ovgl-8;TBMx*`0?d5zz
z;^?Yc@A<>}j1p%utPt8Qh!qIqwOQH>ucwgC96jC%mVaet+{vaz(MMVG9p2wRi|dIC
zq*`omzLl}%tWp2TSG6f+SHF{aAZZ?Q6b8AEW9S?!Cz>RtRcrKPMP<E4LA6c-NP&|o
zBj?KxB(aZuh{O&aI?<oiviJM+_Hubi<-BYz8RXe!nN5O{hI<;hvVFOo+Ppt92zXDC
zyLX2`mi{lQFqthBb&g&aS~;5i86PWY9qW<a{X)VqD_34+Tnd<ywIR~y;hGgK(fiX#
ziw_36{pFT@Tj1J)=NCBu=ZLh^#L^P5#XKu)%%J0(3EH*axFeVj+L3v>mO~D`cwJdL
zX?1Ne-z7Gx5`^Q;>H?wT0*g*_wVBZ{Qo80B9TFWO)>FEm^lLoM^xLmTSmPcY9V{-+
z6GU<7sB`6(SJdKzfGZJ$7RG0d;fTf<W5)yi-dc_K!<L2o+X~q{oD0HE%hJX3wFSep
zwx=QK1h&1v7v<e}%0mNtM?jR*(@fe)Q!{d{fJwF-)ZCoqunlJsF7B>ZEn;}7>Og<G
zcOBvA@FRQkSrqMPW$zXNoFs1)GSUhu4P+hox+wm!Y=33Ke+4$-qv!8Gk3X(TJEAzT
zl#i*mM>ES4m0+@W`vac5X!$UU4#7&dXseC9{4VRKZ+|U5!T`lrqkd-lp(&vkeq0Zx
zW2%g*y;dAygb^RE`H-91elQrz!0UBU1Gj=jaMrKP+U2S3^r$c3e~g}NbC3@SLqMm!
z1gbB6ryZ6E(AFQD9Df)XJ<`;(BDItu{p7x!1OaCTOZn+fv@q92?I}%c)h2SpmVTe>
zRn!rS`>3A{y}BLek69w7Fi|SKn;?}2c0wsxPjKafG|%~CV5gL$tw%Yx9ZmDA2d!OV
z=(4JG*|un%7qQBRy@Hia5+e{U$sS0#-IcXuITuFX&z`@lmGP&(pxVR&JEFRMsdyZp
zXD=oOISm(XvbIKB`tuet%-;wZnQ=CqR<0?1zWnt(PB8N%)2bqn%FtgUxg%nUp}8VN
zLr6aHd{}*Jlc)VZ9>jBb#u2905YhUFp0RSB0t*N*=Up)RVf}KDFoM66S4d)A#pXp3
zTZzSYpE8#KlDqOx6_|C=smloTPAdP}-n{xgQNFpDF>5lTGlSx=a9s1=fc<v)oT*K6
zd#c#R<co{l-7o8*aSCe8@RX5B{oyJcn8I{9R=&8iXy^53zFdwH5=BTMD@u{6q#_Ne
zA8QetuxwPs8av<wk9Y0%x#0v!y|v7?PWNF}w~(G)SWo5RNZz%r0!ZdZ;c{fqj4mk|
z`mBOKxxp(=@dp$_mHbw#TKE+*&MTVM?K(!WChu(y6^}Q91|G8)ALI0{oR;Uy-5;Ss
zbT;2@XH#RZQv36Dn3jkvpuJr7reG_4-<RXgGvRxj?#xFSPWP>uzvPnQm%@mk@vl)W
zg`!N<EA6hodfdP~MZ2`jceew-izX|BeDP*_%;*-3G{C#$DjYhE--2|*9fI){FG`(5
z0F?vTk8x*~4)4^|D_F)!KxGPle1^@OPml1ZNBQIOJb9~~HQ1enXBCfArFZB)F)MJ_
zaqWdDFy?goIY$a&OqRR6Q{8uzl!c@D(;)0le?gxp#LXwInWvB`XIzMk&+jnri&aGm
z<E0gTmk8kfc@Z15>v9jvv(fM$l-vLJ8Q=eBruTn~diWM}u!LSY$DC@EzSeJUjHFnZ
z&(rJH$K_5^f9IYx5EL|C75EVQV7y6il_Azzy{XBT_pMCt;ag*&N<5?ut)#<60hSo(
zATJX`-S%G0IMWa7HP}Ziez(>K#03nBk_<j0rFQ;in3UC6^R|ohm+^r!Y5K9WIPX30
zQY(Kja$)qZLvlTY%aByd@P7Xba)yR$jmLZ=_mS$d=<y2nMK)Vb&jg>TiD*&V`eyy{
z3Z7o&a0%gs2Rs5VlD4rB#<0}xUNR>kMs6id>5xpc7^80et2g5KPi-GgeIm{a#+UML
z-)u<+ZmO*-FaCmhJz*$%=Uc$9i3#~Rj|uNF{83_2Rx=}X7!U1y2NF_sK#JhRat@Av
zRezWQ6rKqMStkv?rNSxlHHs4O)bowq1U3`^As9qhSkTIC(1#-%CY5}k&vJt1zd5&~
z2gtK&DD%~uf|!g~b<HjH)nPLqaBJR`4bIB^h6Kew-;?n{IcrSF@W2ZH*v(~VT2dP0
z)~A@<{U@R$(=t!rYPo}1eu^rb;yv3-tES;(mVDu`cf9@%Kv8E)bbBq60Yqt~i}v*D
zxU3@4#i7N<wnPMObZ}ctQa?WAH6XXi!T6x8RnU-+`_(2ox7WiBI=jDwxW8?I+zPnj
zszcD>t6AZ}KOLMs8VA0-&wfp)DmUK#%YaOQ@trwP@vOy|0qE~^{h-qW={J*_`9t46
zf1#&wI97Z2hCC#Fvqc(nt$>#MQed#HuLT_)wDu;ic*O8L=mey`B`XLdVQxHI31v7*
zW3X=;92Yz1=MjWj>?$~3pdh#w=wvd)IMu!eBf1tK-H|PH?Nm0z^s{CNC-Hu5s=CfS
zaHeY<jtI_f8VjgNYE)?6&M?pI;F7S(p?E0|7dPJFR`g{3hlct_B&VgNTV4^ngy<R2
zxS;hXCE{nZCzj?;V%M<smXjtbq`OMs*=U@7cH!2K53YYFS0Dn?kQtBB;HhK!QmJJ8
zGP0T@QGd)h=#|bWenHsj3>p$qbt8C4<mfHczM1nm*E|L(v(^%%71VGCj$dB74x8wA
z2i#HmaE!EWh%)-+m!d^{n^Ha<eZoHAK2V;Ywzd`2J8}+$G*@JnvC1GH@lZJ$BU69%
zsZ)k#6<6ncAigEWO05pYsj^rna@q<>KM-vVniD@)o-nkhuNX{B1zv0=hy>x2M?m#z
zy8h@MRvmRy-faRiX!0rD7Ztg8e}wLV7arX^Aq8nDa?hlv77c4RS8Jl4D=~R721p(O
zpm!f_&vUpur2>n<=~~jiHW82@_<i1(b9tF@do9Z7CSxtw_~7hy6ktO5a>(V`l`KuF
zv>p|elnN*KZ=kvVzRp54p_;>|uMlvL>PevEMwdXJFvTG|(R!xETFK<JPHFQxr9eM|
zt)As+I_T=*#ENM+(@$Hu-#<m7zM6dhLS+y%Ok>*y_<Wf#MXM4`57zob=8cM+zCou~
z=}k?ZQV6K6WX9D|9VGySI+<TjVt@KPc_XZHetf9o$M~4;iqe!09pBXei)ymEXwVQz
z9aBiSM@zNz&tf34Rfi9kNcV74Cm(#NeH9Y*{5dGeC?m3Udidz<gB@S9x=58a-XcU(
zs;Bn-5032DrVFZ0EOhhD!COq|^eZ|!d>dv1;-B_el6O`?@?rg#*Bw_ehVqdf&Cflo
zqlOP3FYqsM$I%8Ibq9z6UI8Lqlj^p-xUe|~U~>OH&Ph)EDJe$T-#Q?#-R(Hq`ZZ%|
zr=us4@FCb-c8@|MI-J3xE@h_9nnV97THd4z%@rrgtN&6+v}!PtK}|sIjqb2CI40&K
zYSRWheM{yq@C&UKzB%Q|q;y3z_(AQ!<TZl=N0Q>OJK}|IJWz-uI6WeU>Q={!>r6g`
zGQIlNm}o3u1>We0Aq%W8k;lDdgSvONP^W3k@YDBO*4t90ivw^T4{p*I-ra9818A;}
ztL5O$@hbcC=KA_1;p1o9WIXsBso*lf9vg7y_!@Nb$?M*bU;1sOX879$-ORkd#y9GY
zV;3?EU!RbHxMD8a+I~LYmSeWpYhglXe<@xLx3~9EPkuK5dJ_W_DTY9P1=vTeq&b(-
zdpQ^iK+^{$jr2gEjv_^gg(SZWWggxA<e!i7Mat-p1O2?(CPH8!r2Q`lJ^@2ho#@Ak
z8i+1a?WX7FdIle^Zp5ew%&Q~W;KH1Bbtz&4A_afy*_xAAy*nJ`yO=4er$u>nZn+w*
zE#t;gsB{g=C0{2!-;&Xfo@vH%U@}$%7}}-{t$qhO9F`IVg*@A56p3jo`X}TVCQ$~t
zo6*V9@7$7)m5OSLziP@dT`_9%e!;k2BESupCMOWhKFWUL2zeHaUspC`<%EZHO;g%|
z(&`_T?ZU5bUA#f+(shV@=n%-Gl^82b6WwHFpJ%MaLDoyR4sGMDR#Br{q1+pmCH8xY
zy@TrMIW9l*bYP@>VgcTZ&AjylLc;g3ik7Q63~zU(GNk6<Xld@l*?P4Fg)Q)0^SM@x
z9KKpsSanlza<$`+zH>TbYk(=qjj=|RXrV=?s~W2RNy&Cf$&B6;R%9EbLgF0)MQed?
z8ayW!xhj40TBEg@a`tP6!v@n^Rj2!m*ITG!pcE3wj)AE*&in<{SfzG*63#S*&OLOk
zj$f2kd=Ngtd^YN@hRI*$Rc$v+&B?b@Io~~ICs0XfK+1P%fB?k-5KoZ&5gn1A2+95M
zn8SzDalBF5oX$L1GygwZ(nW0PYLy#mJK4Kxx4KOCaX4xzH3uuzxvmE_RsZ{|<bQY7
z{GVSp^yLb#j`dLU2oT%6=tq2h7gMuvI?SzU-Z6I`=~PSKlIUYiDAvyLJH=$_OD<8A
z;o~utaVZ3Sn%4u}Hx|G5K>!QbL>$XALJJ_B>kI#amXnPqQGL$BoidJ$i4-w00&n7g
zDK$1YgPAgx5P*bvt`OSq4YBp_u5G^c?vvqpaA{l!b^(+u!=C%{_xxSg9QixBUQWnx
z$<^9AvOA<x^i}=t(@_%O;>iA!OA>w#M=eFZU+Lxl>CtE;9dVdQtpWY$FCYm4fk!=e
z=2~Fo`j~E{7WtkbRZY%Ms9pfc)Q=O5!ES8Nt2UNLU^=<#E<-3ow|MIB1tS}p<9{9j
zvP_}u@PFBJNL3@R`5JSYb>Vz;h8I7(%CbjF>}LyaI&fTgbAZq-Ichyhw@E%92s%$>
z!dA_m*oe>7!e!n&2FM0QolkI<mfbJn?pI`<eLda$=yvo3q=c~(@T2rq8@WL%(6o?1
zUn`|`EeWWf*750UP14UTI#CW9AeXQpH{s(r`%+BWDhnwK&YlqB+n;XE=Dg%?4l)jh
zvSKw!ZRztPQ{ENlsM;l(sp{yRDolA;`Qy4Q@aLLdgUq6K<fe@IMEX413_)1x-C3Ld
zhMv*O>R6a?@B-iX0j&dH`+N(4$>%gpaaXE|Ix(3zD8t{js*mDg_?_|u=Z3q$F13Hx
z2;kB63T_(pR{U5^tbeI`4Db-Xp}fP^p2f<@=YLWr5I0mofES`p2>I`Bb0Iet)6RA4
zE8_+Z>>X<_K0K|=%JHs87F63C`KzFRrjFHPoc-8^g6S+R^^k>l63nyZvbAVLB+c5w
zRmC=u=VP2IM*;jLbC7?1k9(W+?|27oNYlv55wR9-Lf`6*utn6HgKA|7xsOEgr9Q1~
zT14Bmz7I=0eSR1&4yK39^B6zln5QpJ068F2C1rPSzoNN%ei@9gVWpdblEm2Fa$4O(
zEU~ioGHJ2ZIfpEXps5pW3+HU*=+lhD)Nd!a5<dwF6EP<I6i_OIRD*n30A>5Ow!hTm
z5pPunk6-jF#>4?<f}XY`ZMQc>F_i6VE!O3Bn0#a_<uXRak4d$IhMqTTG9qc=<>1Q7
zA%Wbh;OB8Z<w6rp3~MGY`=y8Em0Id*5}1+@<lMk~IjA$gq@gFia63(DUaum1*ve$p
zN+~b?Rr+@Y=KO0Jn+B`$HT(0){cnxeqGj9D7DTzJpsa!rL}9r-8WQ3!>iTtA<%&8J
z-nQl8)f;p7KQvwGm&jGph-w%qChqmO9pay|gPfc-FT%Mcds!LZo%PD4>}0cH5`p1v
zo=s;Q<DI>YU*bZIQeC8YQTue*+bSIE71hux>DD{S0p5ADizZq!8SB|p39ANh{1sP3
zzWz<FjOe#n=tJpiUhd)XHJ(qpNq6;xtAlzaz_Jj-)j(#fX#>hM<R<xHG86VOyNts_
zK_PreR&0TMzABn!Z3q!tC2^WR{%vA~BGRM@$u7v^LHfzO=xn6ch173chHkadgnJry
zv}*HNq=JwU`)_2C6>jpOCe-@i-gnyu)#xW-X_myf_0<$=zsjZ-=)#oZARrH_#ceYH
zSt=H5D}W+i+_ssa?Anihgdn0Bkbvx&>Y|;yd}|~8b>d5R9P>0B@5V`653dw#_Hhs$
zYrXFVxq9xmR)z)T+l|}nOXY_)@7LTuSKi7^V0B!_7O->KY|)i7mQAe2cWIR4X!>pZ
z;XG(wG1)f$&co-G@JD`0k~Wvr3lqLdN-7@gS){N0D_HHxM!MvKT7yNCH@_ahA%#0j
zh5k&anjrDc1MXd<YDHc4hN-$mHeO=16MG3b=$~~e8&iPHnr>XZUgYB?krwu$RG47+
z{*XM3fw0O=ab+v2d<7OOZc2kXt4ZXGrP?(-B=6-TvbL3MXL$KieJeg6<Y89j9d;TZ
zt}x+zx+pd`yuRpzmm8x(aNiv8R;_#PnNkgTFH;0QGJ)<6PY<2`+2<`?KZ%Nb5pxs_
zk)Q=p&echQj#}`x&!tA<km0Xu;&vaEF1<@4DnkSIRZ`RNs4F&S2*wV&Bt9y#nDkh0
z-Y&{TRf5$bK-s??HDWs1B)hg}U&^3$JJygOB5$ef{k$LvhmIAUxq@t^+P{EN_*+x`
z948Ie|5edr<kvq~61R>^cV(fCZ`~G8Xp^Q#KQ%R-;q1xb8#1rr#7==5s{}m4K{Lsd
z(?>o0gaDl@JUwfwCf?G~)qz57qc+I=-F)yF$l^U<f;@H(H=}a)XClTD|9BcewSM5z
zIVez}=0YkViHp-CPd|!A^hB56hdOPk#4E@3In_im4qHe-yg+jTZjgT-<$*o(c0IAH
zoaj?OhCeZYi!z~`%_6qnn8?C?{P*r=Y~fIz-L!AYuh+7feKLMwKy^N56!M2~Rh|SS
zm}?7Vk{?APPs^X63O=5)qZ_+Ywes6JOY;at$fOQq>81$%3*y%#AVKrh017)SGUGP%
z6MzSu_zUXN7X_YFX4Z@~<=grKo6gq_lSm%UPtq0S3iH))**h^wl0e>ju{s_fYPF@_
z5TyxuNig=S--r!pV_1ShPDRl-0mSA0>gY^gQDiOL>8C<yr7KTWBrRfz=a&U(Dby==
zwba=-O5G!XZ}&<fLf^*x$^Govvs|L$tBa>7v#<jXdx_Ud6PZtVQd4J{A`u+Fanmo&
z3{lhdUzHgfdXl}(8B2dN+e8Hi2%9dh9z`+>B`a5YqKJo%FS)5VCFw;!;lSIy7z1I?
zL8Zw5c=xM@{Y=xSjhZ{APJ(_nNo;)N*7^vEQBeRuP#U-7EX1%;um<qM19Xm#7JqbF
zeD!t<+s@VW*Ke_Wdm0LCl^L#_v`q7#gE9{#Scw9uCSaY<hW>(-I$$e+b{Oe_vk@ru
zyLLhb7&n?_jhb6JR9n;RI?(Pi&$g$irDwA4$!2Y7sF>JjY-&h6w1}G%Qd&PjNYKe{
zPc|{FY4Qyno-t8e%`FLu4{&gBuOrK+;j$+yh)|DvEzGtv-cqtDL){~vkNaE+dI!CK
z?Y6DFBY{wj1datVj-3KCcRLqzff<h0?&t0I{GeSvN^xCe0;JpmTF<|u$`OH&Ca_#2
zIR#L;Eu-pcuQ=%lrUas_ZmoVr*6b!d`5tFlXt>G5zJq8hvBp=U%O9R^4Jx0nP_0IQ
zL4v&qU(oT~(JjQ5KClvb4F$-H4N;FcK5=9gy^pc*VE=<Q29<@hWk0G%c}J{G9q_Kz
zTfSyYlzu10oJ&4>#mMqCm$cXd*pV$_zdMuee0F)WHid)u4Q5A`CyEZ(?4OnF+2H@l
ztxFOy-Xfq4y3#Knx_+j)Arar{`tu{x&zaER?5@}l_Ib9Z;(_PWO|N0zK+VC}ba2q}
zvr&(lQdjn(<c<Q}eZA?@RTi@C=^VQ$55EC5al8}Gh@j+Aot<nFG<Atpt*=#dfTz=X
zXp)4w9^z~6-6j@m=R#<uYDKfj`GxpsC)**rn=o8ORhBrwu7v`%R;W8F(nJE#&wyc{
zxS75RLwi%=>3yg2pARb=YE$?=7)3;o=vI(A#KhT8QJzP93To`Ut5w*-{ug9Big!ee
z(NdIWJiDfua9o-mpK^K-G$UA2fv7u>G2fD)Z95p%|GsNVh?<)Eh|<ip{c1vM$(u;)
zIt#~T`C5*LLUb{CZLK*jH5Y7`6fWAm5^**sao;FpaQVZ<$_mVMql8U^O8uXs^Q4p)
z3RZ8XvU@+@e0xhb&L@X931LUy$02PaC9$bpB1#8XzZzAIbxAv;&0RbX=5pT=1w&p>
zl>64ACpzY+3gFhQmE#TvPNn(L1OIl)6A2xXQ6T}p89EfKr-fszN+VWY71cC%P^_`(
zlTi6U<$W)gE$~L(i2@28aWY!PP#fEZf{$CH2V7sgwS<Kac~0<f3qk1Y%Un`p)KQ4P
zxbs&76%k&^wxD~qyorC3gw%lzGkIYK2ibaeTOL&_!(-3<#hJJn<t`&g9C3}qlfp=n
z2~0%xjJ3#{%<j}o*ZSh>3n|jZ4Awprz|ama7O-Tw2R;BqRC{s)<5)$ikJQVvU&s~I
zUD{jDH`|8&-Vp&DrB+lV)WHLF3rKq4u0XNR$GMZ`o((CQv`1jzhvE|{hdrvQ*QA2%
zde$TTvyj6W%JHJVpw4H5f;mKh!X*d+Bp+s^QG1BM2jM+ZL$?`UVGf$bIRHy!K`5mi
z5bH{ST^U1iN<n_&vHlNMdr+yrR3hI~D%(COL>qB9{49K{#%f*olRvnHYP3v_Y3Cx%
z5U8GYk0s`(LiLoo)cOSz+dAU#%%KBoEYU#ND_CpAK1+=5o6SZ;%Ivg=^QR=SI7CP`
zPZEl>N2B!~#*2wslUaJZboQgpy+H$_?g;tEBOE8)AkV)b7Oe2Mw@^RLrr+ZSj(l=U
z2~M>!s-G-BD1t%9-*HdN)oW1BVWkJ(!(_oP9@B@KoEIJh?W%FyX!@U_8P=MYW1l!W
zsAMpG6g!Cy>-wQ$4GP_|X#-^o4tY{9SBZ|d(=R~1B=dD~zBomNJFW9|#{bX+xdH#I
zNUXdvy5nj79K!zodE)R6S;x_nT{R{M!N1djzAloV+)kbhtIss4C+)<cTU%Qj!Z)wT
zL4@3t<jN$7(gHy%M66+?c8YJPxq3x#cFZaZ!m9%GUraeyGs(@JuSs_CoJVv8>DxHr
z^g?8>W~|X#9dgXfI8$Y8V?T4#m%vZlp5E!{?<`;i$J-sphcNTbRFN0XZnrR{nMCPS
zN+~_BQqARr%aH&1H}MLXbg{6t#`t?ChNc)Hq-srlm(arC{tEbye-zFI*I6#f%xd_@
zCRyNe{4oAWx@gStf)U5Kx(Fe=v_PNaJFQW#GQ#t?QIP;XV&*-~iPHUzFL`lVYyv@_
zK&t%$!hng%UcAGMk<Wva)X-L(p3RKm89B#*i}^yx4?w_lHX@f2gce^D9f=!ClKtpK
zX6W=T_%%DVthxh<0E8CUM8nFT-{gn{$Qz*ZJ9bkOP4b(Q2P3%;O|Hj)(-jI)>Qn6j
z%&Wb3UCHv_)jKcps!$r$pcGr|SCjXHFc$9HfOiQ;AW*x*aRbg#k<p|gCG(nR4lF9#
zcd^7iGeC28wVC?5LtMP}N;iLMz_iJ7D?&X~*BHdW>M1LA@iU`!j$%_oU1z3qtX=v6
zdGCy62Xj|hJK*(pmnXjEUcm6E*G(8{#NE<a2|qrGd65Ta;Ii#qF%OCYoi4}TQjI#^
zGB58^`zmLZPJMrd*1+YVW5`#QoWobdMcHp&osO{hTQs7b!>z{5#{s?7>Zkr&*G~yQ
zX>pEYfCJ9Vm;WztlB)lsD?EVxS_CNShXc>Wdph}3W6x^z%&ofDZ@||EJ9X0^T4F+b
zHLiZ%(4^E!9kOC=C?oiN){bkvls|)YT{9y$C{3*_(e!kn6;D+v<nZ7ESp!V45EJo^
zk;_Nvkeh&fcPh@R@%aT+844MluBYF>cCrKQEMS_cu4FwY26n7-HgdJwdUXe=Xmw1X
zTW^Rcfvw{OP>&&qZ@VR(3Vg7a7UWE20UB}jbkU$tN5<tPD=?-6XrKsh)x)w9<CjJN
zTa{tcfDwkgWT!!Q>Xg2;bYi||+{cKHFsN@!F2#P8Cd}X7XZ5?!S4^Tu^u5h@i4GJ_
z>|qXMuDyuWQ(zgN$8W8!ks57>-%6eBXuA@bDPl{u;$xN=(Q!H74NU;6FnxDY|7)99
zEUD`*UT|>>@Q8CyJ)u@)pkQT9)Y7uamk*&ztdC-Vd&`r&oUT!b$@NQE?@j@1CKxDk
z_VM&JL~Wk}`ILwjf!dn7W^ww^)wzimE>u)*FChx|DdCb=Gr6_<7eztGdo`iWGO2$-
z^dNKtcfj*;M{(`CUya(e)D=xSg$|*X9L#~=N=ENYr-e@DQ0zPf#Dp)x*>CZA#4=-a
zLmqdMC<4D$4An-B*|94ygK~bC<@#lllYEq^XqZT>=jAyoLH#pxp#7zOHT@)zYZ?iZ
zvugEqa;~+1Th%X~Fvgfq&?1?DCPYB40&B1ksogPvvYO8!+TCI~p-uy2hjC4&uqbAc
zx?nX+H15Ius8_!t@`43il!E1QXEagPowvM``}}2C$#P<V!F8PDdzoz?lzg0t1jYGn
z!e!l&E&waVsFcWhBLa{zT9l4}VZA9||APL=E&l~6^Fp_}oe40TGaW*Ud(2!WdL2v8
zY;)g`JNC6Xffj>RnJ*6v1MyJdUF@qSqNV<(4FOFFk!&@B_g>g63t_vMbGMipwDGj&
z5<X~=Tu0~J<eNSKIJVLqro7HnJJeFs#SP6p`Pb3vk#}>$=uDb_H&M6_+dJRV9lZv0
z#b*UKm(J+iyD%$o4u#!<XQkN<k$&@T=Pjpr&KXc*J*6~b8=gDrJfb!+GBjh*xEA_g
z`+&9NF(~eCJ1&`vD$6T9QI<$k{>dksmCe(K9ATD^cJJ`LIimwH2Ug(>+`w);Qnuwl
zm{&y@gv#xt#=IYow_BpK&OT-}PTCzIe_Ml9!sr%3`PHL!QqPyp7kb$eRPvuwUO;6P
z+kuSIB()iO3v%ObwqYh8IMI46W}9;cJR{Zgb@MEdast0A<EH10>kK|<M-Y5}ud0}o
zhc+-guPw5l3u>MQWaV}5X#B%-nc%bl833gHp93(bt$0|5DH*M=iY2kn=f-)04JBp?
zQ?*@zahi~BkWc=dMp#5Eu_!-y-f&^Tq|?XIZIgGb$fP_5u6PDImhY(h_a>Vi1i<;-
zz%qIaOP`s5$d;@*a=mUID_?6FKQx>>X8)8z%KrN*UK=VpriFgmQ~8ub$NqxBgn+3q
z$~CU*5jzlibN6k<h5`b{s+=qG;_7*<G{(LVvpKzcymZK;VZ(9U)Tj922(AY5y(1~t
zY6!%&+nZl^EHP&oNX1sK>+Sz|_Uuu+dXI|lu_`c3QKerDwO$D<Dc#mf&uqx5{@fVz
z{I?Lz15$2v2xCa5SDE!1SLYtU>|QYBT^tnGUgV+8k7nOAwxE(hCyq3O+(h@5D`~K?
zQUy0Yumk1t2PIe3^@SLiw$TCop@v2%gLi?8ADP=->?8309y&u3SQ^=m*pd;L^(%l~
zv7sWracH(<$`SxnsH8$a0q3xT&TgSkF61=azA>Trjr<`k^yt{z5O?ofXsAatO@@t9
zu$ExkW!&9MKT=qmHstH=s4-Tg;XIoXfEUep=cDuINUuJG`~@*lt-xqy1d$s2Bv1Xy
zp$T^9<S)QIMH`n6P`x&=cR}r%ebjHD21H1x=Ey5L9~w+Xe*c@;eGfWrt@}9h|CWrf
ztqg473sAQm^1&JA`3m35A!{;nboTUhswS*p)Bg-F&ZU4dfk1$?WOC*kaI%x#%{gVN
z0!%r)w<0*!=Z1aE?2-qLz@oFCZt@UZiG{@g_uYmq;L)x2FK{fhzr~#?cl^n3+H*`}
z?=$#JD3e*0HKZ3A^}EFX8QQ9}V8Fa^&wapNpz{ZncU&FEBME@e_AT)4Ur?XGm;|Da
z|2EclOWyW(Jl+ms;+5GA6{kCl!2dBaBj;YH_jl-5k7&Y3rf={b&Rz&!Jqw?jOrY!@
zKaw=8$=uxj$Iu!t)L!rS#k+U{cJf{o)qyri(8>ILoQ+Q@`+Ccj=cOEiRaaAaIzqwQ
zY*uq>>((+i_9?K?tA6OE|Km*{>x4zS=Op*t-b!uNEY+WH!X<pKXwJ=%9qC`$AqUL?
zFt6(2p=&w262i}(18*7c=n^^PW_L<TTuqUF45UHF4yG54R#%Ui*Cy|uWOGueNjq*8
zTr^_<{COw(<JM|fV^9(+BdiUGb%-O|q;L=>a-=sP{ZCjeRC(M%(*sxc5=@b&5s#OC
z`oc4|OZOO*oCAe~yy>^5c@<31S}CQL29vO1UGSXDK|Ddb---przd~ltftuEzCi$IB
zt(<--l<z{z)Y)GUqrI5eRqScnOp?_6d?YP*@F0km7R+&MKmPjMcd~zduO=$sKew2o
zYaw9Y-vFxke`H%vKj@EMurm0-7Ula}6k9`#F`h`mXg~X&>d7a=V^1It#?n|<P>MPv
zcagi?-4|Usv}Uu-rNhnAPq|ZEilfwIRdj*P$KfVZem(0q0^2fxO)c|>ZLOxDPg8-l
zoQUUtw0Z>Sbvj)Jn8S;;Z0~nT^MN0;x7=lADKLaZ_}j1XQyB7=RTgV{5{R9}rs#V6
zCV)n2Y`|cVDqR3IVsl}5TMH<s@lFnNKBP&2>p5<KR<}xX?YR-~q~wtO1vNTj*MUwA
zYQ!+-2I44xGyseB8Kjv5E;HDte$M88oUt2?)lEGVbY?8ticCGgxU&&b>yok>kVV!3
z5=BQdI#EyhoGvr!-8uhh@vEu9no1(6N4g8L_XtR2eKzae+!a838qcFlQr=j8hC`;C
zgXhl!rt$zg_gRUWg(coZ|9>s4e+dGdzaUPbk-2-Vr(m;JGre+LW1{il%)D`UO~;2T
zy4i%ENx+YLA=#P1cjXI9c+na?!!fbtBjLD=Y}U+Oe5%0AZIwSTa}^&?1N?P9m~GnU
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
X5X2ClC8=<FalbdavxfLXK>Ys#%5#Pr

diff --git a/examples/arealite/configs/gsm8k_sft.yaml b/examples/arealite/configs/gsm8k_sft.yaml
index 75a94b488..b9bad0956 100644
--- a/examples/arealite/configs/gsm8k_sft.yaml
+++ b/examples/arealite/configs/gsm8k_sft.yaml
@@ -6,13 +6,19 @@ cluster:
   name_resolve:
     type: nfs
     nfs_record_root: /tmp/areal/name_resolve
+seed: 1
+total_train_epochs: 1
+tokenizer_path: ${model.path}
 
 model:
+  experiment_name: ${experiment_name}
+  trial_name: ${trial_name}
   path: /storage/openpsi/models/Qwen__Qwen3-1.7B/
   init_from_scratch: false
-  pad_mbs_to_max_tokens: true
   gradient_checkpointing: false
   bf16: true
+  mb_spec:
+    max_tokens_per_mb: 4096
   optimizer:
     type: adam
     lr: 2e-5
@@ -24,30 +30,46 @@ model:
     gradient_clipping: 1.0
   backend: fsdp
 
-trainer:
-  experiment_name: ${experiment_name}
-  trial_name: ${trial_name}
-  fileroot: ${cluster.fileroot}
-  wandb:
-    mode: disabled
-  seed: 1
-  exp_ctrl:
-    total_train_epochs: 1
-    eval_freq_steps: 1
-  tokenizer_path: ${model.path}
-  mb_spec:
-    max_tokens_per_mb: 4096
-
 train_dataset:
-  type: gsm8k-sft
   batch_size: 128
   shuffle: true
   pin_memory: true
   num_workers: 4
 
 valid_dataset: 
-  type: gsm8k-sft
   batch_size: 128
   shuffle: true
   pin_memory: true
-  num_workers: 4
\ No newline at end of file
+  num_workers: 4
+
+# Utilities
+saver:
+  experiment_name: ${experiment_name}
+  trial_name: ${trial_name}
+  fileroot: ${cluster.fileroot}
+  freq_epochs: 1
+  freq_steps: null
+  freq_secs: null
+
+checkpointer:
+  experiment_name: ${experiment_name}
+  trial_name: ${trial_name}
+  fileroot: ${cluster.fileroot}
+  freq_epochs: 1
+  freq_steps: null
+  freq_secs: 3600
+
+evaluator:
+  experiment_name: ${experiment_name}
+  trial_name: ${trial_name}
+  fileroot: ${cluster.fileroot}
+  freq_epochs: null
+  freq_steps: 1
+  freq_secs: null
+
+stats_logger:
+  experiment_name: ${experiment_name}
+  trial_name: ${trial_name}
+  fileroot: ${cluster.fileroot}
+  wandb:
+    mode: disabled
\ No newline at end of file
diff --git a/examples/arealite/gsm8k_sft.py b/examples/arealite/gsm8k_sft.py
index 2fbbc71e0..a9b5380a5 100644
--- a/examples/arealite/gsm8k_sft.py
+++ b/examples/arealite/gsm8k_sft.py
@@ -1,18 +1,19 @@
 import os
 import sys
 
-import torch
 from datasets import Dataset, load_dataset
 from datasets.distributed import split_dataset_by_node
 from torchdata.stateful_dataloader import StatefulDataLoader
-from transformers import DataCollatorWithPadding
 
 from arealite.api.cli_args import SFTConfig, load_expr_config
 from arealite.api.io_struct import FinetuneSpec
-from arealite.engine.fsdp_engine import FSDPEngine
-from arealite.trainer.sft import SFTTrainer
+from arealite.engine.sft.lm_engine import FSDPLMEngine
 from arealite.utils.data import pad_sequences_to_tensors
+from arealite.utils.evaluator import Evaluator
+from arealite.utils.saver import Saver
+from arealite.utils.stats_logger import StatsLogger
 from realhf.api.core.data_api import load_hf_tokenizer
+from realhf.base import stats_tracker
 
 
 def process_gsm8k_sft_dataset(dataset: Dataset, tokenizer):
@@ -42,10 +43,9 @@ def main_sft():
 
     rank = int(os.getenv("RANK"))
     world_size = int(os.getenv("WORLD_SIZE"))
-    tokenizer = load_hf_tokenizer(config.trainer.tokenizer_path)
+    tokenizer = load_hf_tokenizer(config.tokenizer_path)
 
     # Create dataset and dataloaders
-    assert config.train_dataset == "gsm8k-sft"
     train_dataloader = StatefulDataLoader(
         get_gsm8k_dataset("train", tokenizer, rank, world_size),
         batch_size=config.train_dataset.batch_size // world_size,
@@ -54,7 +54,6 @@ def main_sft():
         collate_fn=pad_sequences_to_tensors,
         drop_last=config.train_dataset.drop_last,
     )
-    assert config.valid_dataset == "gsm8k-sft"
     valid_dataloader = StatefulDataLoader(
         get_gsm8k_dataset("test", tokenizer, rank, world_size),
         batch_size=config.valid_dataset.batch_size // world_size,
@@ -66,22 +65,52 @@ def main_sft():
 
     # Initialize engine
     ft_spec = FinetuneSpec(
-        total_train_epochs=config.trainer.exp_ctrl.total_train_epochs,
-        dataset_size=len(train_dataloader),
+        total_train_epochs=config.total_train_epochs,
+        dataset_size=len(train_dataloader) * config.train_dataset.batch_size,
         train_batch_size=config.train_dataset.batch_size,
     )
-    engine = FSDPEngine(config=config.model)
+    engine = FSDPLMEngine(config=config.model)
     engine.initialize(None, ft_spec)
 
     # Run training.
-    trainer = SFTTrainer(
-        config=config.trainer,
-        train_dataloader=train_dataloader,
-        valid_dataloader=valid_dataloader,
-        engine=engine,
-        inf_engine=None,
-    )
-    trainer.train()
+    saver = Saver(config.saver, ft_spec, for_recover=False)
+    logger = StatsLogger(config.stats_logger, ft_spec)
+    evaluator = Evaluator(config.evaluator, ft_spec)
+
+    total_epochs = config.total_train_epochs
+    steps_per_epoch = len(train_dataloader)
+
+    logger.info(f"total_epochs={total_epochs} step_per_epoch={steps_per_epoch}")
+    global_step = 0
+    for epoch in range(total_epochs):
+        for step, data in enumerate(train_dataloader):
+            with (
+                stats_tracker.record_timing("train_step"),
+                stats_tracker.scope("sft"),
+            ):
+                stats = engine.train_lm(data)
+                engine.step_lr_scheduler()
+                stats_tracker.scalar(**stats)
+
+            with stats_tracker.record_timing("save"):
+                saver.save(engine, epoch, step, global_step)
+
+            with stats_tracker.record_timing("eval"), stats_tracker.scope("sft-eval"):
+                # No need to log anything. Logging will be handled outside
+                # via stats_tracker.export().
+                evaluator.evaluate(
+                    valid_dataloader,
+                    engine.evaluate_lm,
+                    epoch,
+                    step,
+                    global_step,
+                )
+
+            logger.commit(epoch, step, global_step, stats_tracker.export())
+            global_step += 1
+
+    engine.destroy()
+    logger.close()
 
 
 if __name__ == "__main__":
diff --git a/functioncall/code/local_verify.py b/functioncall/code/local_verify.py
index d8c9ff6c4..a174ebb13 100644
--- a/functioncall/code/local_verify.py
+++ b/functioncall/code/local_verify.py
@@ -95,7 +95,7 @@ def call_verify(problem, generation, debug, timeout=SINGLE_CASE_EXEC_TIMEOUT):
     return result["result"], result["info"]
 
 
-def code_verify(id2info, generateds, query_ids, debug=False):
+def code_verify(id2info, generateds, query_ids, max_workers=None, debug=False):
     assert len(generateds) == len(query_ids)
     problems = [id2info[qid] for qid in query_ids]
 
@@ -106,8 +106,10 @@ def code_verify(id2info, generateds, query_ids, debug=False):
         infer_args.append((problem, generated, debug, SINGLE_CASE_EXEC_TIMEOUT))
 
     run_results = []
-    num_process = max(1, os.cpu_count() // 8)
-    with concurrent.futures.ProcessPoolExecutor(num_process) as executor:
+    if max_workers is None:
+        max_workers = max(1, os.cpu_count() // 8)
+
+    with concurrent.futures.ProcessPoolExecutor(max_workers) as executor:
         run_results = executor.map(call_verify, *zip(*infer_args))
 
     for run_result in run_results:
diff --git a/pyproject.toml b/pyproject.toml
index 962c9b9bf..4f752ebc5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -53,9 +53,9 @@ dependencies = [
     "hydra-core==1.4.0.dev1",
     "packaging",
     "tabulate",
+    "gymnasium>=1.1.1",
     "torchdata",
     "autoflake",
-    "gymnasium",
     "tensordict",
     
     # Monitoring and logging
diff --git a/realhf/api/core/data_api.py b/realhf/api/core/data_api.py
index ce6d9bf95..f698a76d6 100644
--- a/realhf/api/core/data_api.py
+++ b/realhf/api/core/data_api.py
@@ -8,6 +8,7 @@
 import random
 import time
 from contextlib import contextmanager
+from functools import lru_cache
 
 # NOTE: We don't sue wildcard importing here because the type
 # `Sequence` has a very similar name to `SequenceSample`.
@@ -47,6 +48,7 @@
 RL_TASKS = ["math", "code", "rlhf", "stem"]
 
 
+@lru_cache(maxsize=8)
 def load_hf_tokenizer(
     model_name_or_path: str,
     fast_tokenizer=True,
diff --git a/realhf/base/stats_tracker.py b/realhf/base/stats_tracker.py
index 0ecc7af8b..7fea2935d 100644
--- a/realhf/base/stats_tracker.py
+++ b/realhf/base/stats_tracker.py
@@ -1,4 +1,6 @@
+import time
 from collections import defaultdict
+from contextlib import contextmanager
 from enum import Enum, auto
 from typing import Dict
 
@@ -49,6 +51,17 @@ def _get_full_key(self, key):
             return key
         return "/".join(self.scope_stack + [key])
 
+    @contextmanager
+    def record_timing(self, key):
+        start_time = time.perf_counter()
+        try:
+            yield
+        finally:
+            # NOTE: timing records are fixed under the "timeperf" scope
+            full_key = f"timeperf/{key}"
+            self._set_reduce_type(full_key, ReduceType.SCALAR)
+            self.stats[full_key].append(time.perf_counter() - start_time)
+
     def denominator(self, **kwargs):
         for key, value in kwargs.items():
             if not isinstance(value, torch.Tensor) or value.dtype != torch.bool:
@@ -252,3 +265,4 @@ def _max_of(self, key, reduce_group):
 export = DEFAULT_TRACKER.export
 scope = DEFAULT_TRACKER.scope
 scalar = DEFAULT_TRACKER.scalar
+record_timing = DEFAULT_TRACKER.record_timing
diff --git a/realhf/impl/dataset/math_parser.py b/realhf/impl/dataset/math_parser.py
index 5189c5db1..30e8bd1d4 100644
--- a/realhf/impl/dataset/math_parser.py
+++ b/realhf/impl/dataset/math_parser.py
@@ -7,7 +7,7 @@
 
 import regex
 from latex2sympy2 import latex2sympy
-from pebble import ProcessPool
+from pebble import ProcessExpired, ProcessPool
 from sympy import N, simplify
 from sympy.parsing.latex import parse_latex
 from sympy.parsing.sympy_parser import parse_expr
@@ -289,6 +289,7 @@ def strip_string(string, skip_unit=False):
 
     # remove percentage
     string = string.replace("\\%", "")
+    string = string.replace("\%", "")
     string = string.replace("%", "")
 
     # " 0." equivalent to " ." and "{0." equivalent to "{." Alternatively, add "0" if "." is the start of the string
@@ -398,7 +399,7 @@ def extract_answer(pred_str, data_name, use_last_number=True):
         pred = pred_str.split("答案是")[1].strip().split("\n\n")[0].strip()
     else:  # use the last number
         if use_last_number:
-            pattern = r"-?\d*\.?\d+"
+            pattern = "-?\d*\.?\d+"
             pred = re.findall(pattern, pred_str.replace(",", ""))
             if len(pred) >= 1:
                 pred = pred[-1]
@@ -836,6 +837,12 @@ def parse_lines_in_parallel(
                 # print("[debug: timeout]")
                 logger.warning(f"Timeout occurred while justifying the math answer.")
                 x = (0, "timeout", "timeout")
+            except ProcessExpired as e:
+                logger.warning(f"Process terminated abnormally: {e}")
+                x = (0, "error", "error")
+            except Exception as e:
+                logger.warning(f"Other error occurred: {e.__class__.__name__}, {e}")
+                x = (0, "error", "error")
             label = label or x[0]
         labels.append(label)
     return labels
diff --git a/realhf/impl/environment/math_code_single_step_env.py b/realhf/impl/environment/math_code_single_step_env.py
index c07278f0a..ce9061efe 100644
--- a/realhf/impl/environment/math_code_single_step_env.py
+++ b/realhf/impl/environment/math_code_single_step_env.py
@@ -57,6 +57,7 @@ async def step(self, action: Tuple[str, List[str]]):
                 self.id2info,
                 answers,
                 [qid for _ in range(group_size)],
+                max_workers=1,
             )
         elif cur_task == "code":
             answers = [extract_code(x) for x in answers]
@@ -65,6 +66,7 @@ async def step(self, action: Tuple[str, List[str]]):
                 self.id2info,
                 answers,
                 [qid for _ in range(group_size)],
+                max_workers=1,
             )
         else:
             raise NotImplementedError()
diff --git a/requirements.txt b/requirements.txt
index 0af83fcaa..5318511cd 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -69,8 +69,8 @@ word2number
 Pebble
 timeout-decorator
 prettytable
+gymnasium>=1.1.1
 swanlab[dashboard]
 torchdata
 autoflake
-gymnasium
-tensordict
\ No newline at end of file
+tensordict

From e2745b921aecb69ad1da8b146d0cc1c4e077423e Mon Sep 17 00:00:00 2001
From: Jayon02 <12012211@mail..sustech.edu.cn>
Date: Fri, 11 Jul 2025 08:52:26 -0700
Subject: [PATCH 05/10] add autotp for hf

---
 arealite/api/cli_args.py     |   9 +++
 arealite/api/io_struct.py    |   1 +
 arealite/engine/hf_engine.py | 112 ++++++++++++++++++++++++-----------
 arealite/utils/save_load.py  |  30 +++++++---
 4 files changed, 109 insertions(+), 43 deletions(-)

diff --git a/arealite/api/cli_args.py b/arealite/api/cli_args.py
index ca4b78bd8..2b5c5f6aa 100644
--- a/arealite/api/cli_args.py
+++ b/arealite/api/cli_args.py
@@ -104,6 +104,14 @@ class FSDPEngineConfig:
     )
 
 
+@dataclass
+class HFEngineConfig:
+    autotp_size: Optional[int] = field(
+        default=1,
+        metadata={"help": "DeepSpeed AutoTP size"},
+    )
+
+
 @dataclass
 class TrainEngineConfig:
     experiment_name: str = MISSING
@@ -136,6 +144,7 @@ class TrainEngineConfig:
     )
     backend: str = ""
     fsdp: FSDPEngineConfig = field(default_factory=FSDPEngineConfig)
+    hf: HFEngineConfig = field(default_factory=HFEngineConfig)
 
 
 @dataclass
diff --git a/arealite/api/io_struct.py b/arealite/api/io_struct.py
index 3033af8c3..b9144e877 100644
--- a/arealite/api/io_struct.py
+++ b/arealite/api/io_struct.py
@@ -175,6 +175,7 @@ class SaveLoadMeta:
     with_optim: bool
     tokenizer: PreTrainedTokenizerFast | None
     base_model_path: str | None
+    distribute: bool = False
 
 
 @dataclass
diff --git a/arealite/engine/hf_engine.py b/arealite/engine/hf_engine.py
index ea25709db..d264ed88f 100644
--- a/arealite/engine/hf_engine.py
+++ b/arealite/engine/hf_engine.py
@@ -3,9 +3,11 @@
 import time
 from typing import Any, Callable, Dict, List, Optional
 
+import deepspeed
 import torch
 import torch.distributed as dist
 import transformers
+from safetensors.torch import save_file
 from tensordict import TensorDict
 from transformers import (
     AutoConfig,
@@ -14,10 +16,9 @@
     get_linear_schedule_with_warmup,
 )
 
-from arealite.api.cli_args import TrainEngineConfig
+from arealite.api.cli_args import MicroBatchSpec, TrainEngineConfig
 from arealite.api.engine_api import (
     FinetuneSpec,
-    MicroBatchSpec,
     SaveLoadMeta,
     TrainEngine,
     WeightUpdateMeta,
@@ -34,7 +35,10 @@
     unsqueeze_mb_list,
 )
 from arealite.utils.fsdp import get_cosine_schedule_with_warmup
-from arealite.utils.save_load import get_state_dict_from_repo_id_or_path
+from arealite.utils.save_load import (
+    get_state_dict_from_repo_id_or_path,
+    is_existing_local_path,
+)
 from realhf.api.core.data_api import load_hf_tokenizer
 from realhf.base import logging, name_resolve, names
 
@@ -54,6 +58,7 @@ def __init__(self, config: TrainEngineConfig):
         # initialization
         self.initialized = False
         self.weight_update_group_initialized = False
+        self.local_rank = int(os.environ.get("LOCAL_RANK", 0))
         self.world_size = int(os.environ.get("WORLD_SIZE", 1))
 
     def train(self, mode: bool = True):
@@ -67,15 +72,10 @@ def initialize(self, addr: str | None, ft_spec: FinetuneSpec | None):
 
         """Initialize distributed communication and model."""
         if not dist.is_initialized():
-            dist.init_process_group(backend="nccl")
-        if dist.get_world_size() > 1:
-            raise RuntimeError(
-                "Distributed training is not supported in this engine. "
-                "Please use FSDP for distributed training."
-            )
+            deepspeed.init_distributed(dist_backend="nccl", world_size=self.world_size)
 
-        torch.cuda.set_device(int(os.environ.get("LOCAL_RANK", 0)))
-        self.device = torch.device(int(os.environ.get("LOCAL_RANK", 0)))
+        torch.cuda.set_device(self.local_rank)
+        self.device = torch.device(f"cuda:{self.local_rank}")
 
         dtype = torch.bfloat16 if self.config.bf16 else torch.float16
         self.model_config = AutoConfig.from_pretrained(
@@ -83,15 +83,13 @@ def initialize(self, addr: str | None, ft_spec: FinetuneSpec | None):
             trust_remote_code=True,
         )
         self.tokenizer = load_hf_tokenizer(self.config.path)
-        with torch.device("cuda"):
-            # initialize scratch model from config
-            model = AutoModelForCausalLM.from_config(
-                self.model_config,
-                torch_dtype=dtype,
-                attn_implementation=self.config.attn_impl,
-            )
+        model = AutoModelForCausalLM.from_config(
+            self.model_config,
+            torch_dtype=dtype,
+            attn_implementation=self.config.attn_impl,
+        )
 
-        self.model = model.to("cuda")
+        self.model = model
 
         if not self.config.init_from_scratch:
             # Load model from a initial checkpoint path,
@@ -102,9 +100,20 @@ def initialize(self, addr: str | None, ft_spec: FinetuneSpec | None):
                 with_optim=False,
                 tokenizer=None,
                 base_model_path=self.config.path,
+                distribute=False,
             )
             self.load(load_meta)
 
+        if self.world_size > 1:
+            if self._check_autotp():
+                self.model = deepspeed.tp_model_init(
+                    self.model, tp_size=self.config.hf.autotp_size, dtype=dtype
+                )
+            else:
+                raise RuntimeError("DeepSpeed AutoTP configuration error in HFEngine. ")
+
+        self.model = self.model.to(device=self.device, non_blocking=True)
+
         # Set up optimizer
         if self.optimizer_config is not None:
             assert (
@@ -153,6 +162,21 @@ def initialize(self, addr: str | None, ft_spec: FinetuneSpec | None):
 
         self.initialized = True
 
+    def _check_autotp(self):
+        tp_size = self.config.hf.autotp_size
+        config = self.model_config
+        num_attention_heads = config.num_attention_heads
+        num_key_value_heads = config.num_key_value_heads
+        hidden_size = config.hidden_size
+        intermediate_size = config.intermediate_size
+
+        return (
+            num_attention_heads % tp_size == 0
+            and num_key_value_heads % tp_size == 0
+            and hidden_size % tp_size == 0
+            and intermediate_size % tp_size == 0
+        )
+
     def destroy(self):
         """Destroy the engine and release GPU memory."""
         self.model = None
@@ -164,7 +188,7 @@ def destroy(self):
 
     def save(self, meta: SaveLoadMeta):
         if meta.weight_format == "hf":
-            self._save_model_to_hf(meta.path, meta.tokenizer)
+            self._save_model_to_hf(meta.path, meta.tokenizer, meta.distribute)
         elif meta.weight_format == "dcp":
             # TODO: implement DCP save/load for HF
             raise NotImplementedError("DCP format saving is not implemented yet. ")
@@ -176,7 +200,7 @@ def save(self, meta: SaveLoadMeta):
 
     def load(self, meta: SaveLoadMeta):
         if meta.weight_format == "hf":
-            self._load_model_from_hf(meta.path)
+            self._load_model_from_hf(meta.path, meta.distribute)
         elif meta.weight_format == "dcp":
             # TODO: implement DCP save/load for HF
             raise NotImplementedError("DCP format loading is not implemented yet. ")
@@ -198,27 +222,47 @@ def _load_optimizer_state(self, path: str):
         self.optimizer.load_state_dict(optimizer_state_dict)
 
     def _save_model_to_hf(
-        self, path: str, tokenizer: Optional[transformers.PreTrainedTokenizerFast]
+        self,
+        path: str,
+        tokenizer: Optional[transformers.PreTrainedTokenizerFast],
+        distribute: bool = False,
     ):
         """Save model in HuggingFace format."""
         if self.model is None:
             raise RuntimeError("Model not initialized")
-        os.makedirs(path, exist_ok=True)
+
+        if self.local_rank == 0:
+            os.makedirs(path, exist_ok=True)
+
+        if self.world_size > 1:
+            dist.barrier()
 
         state_dict = {k: v.cpu() for k, v in self.model.state_dict().items()}
-        self.model.save_pretrained(path, state_dict=state_dict)
-        self.model_config.save_pretrained(path)
-        if tokenizer is not None:
-            tokenizer.save_pretrained(path)
 
-    def _load_model_from_hf(self, path: str):
+        if distribute:
+            save_file(
+                state_dict, f"{path}/tp_rank_{self.local_rank:02d}_model.safetensors"
+            )
+        else:
+            self.model.save_pretrained(path, state_dict=state_dict)
+
+        if self.local_rank == 0:
+            self.model_config.save_pretrained(path)
+            if self.tokenizer is not None:
+                self.tokenizer.save_pretrained(path)
+
+    def _load_model_from_hf(self, path: str, distribute: bool = False):
         """Load model from HuggingFace format."""
-        full_state = get_state_dict_from_repo_id_or_path(path)
-        self.model.load_state_dict(
-            full_state, strict=not self.model_config.tie_word_embeddings
-        )
-        if self.model_config.tie_word_embeddings:
-            self.model.tie_weights()
+        if self.local_rank == 0 or is_existing_local_path(path):
+            if distribute:
+                path = f"{path}/tp_rank_{self.local_rank:02d}_model.safetensors"
+            full_state = get_state_dict_from_repo_id_or_path(path)
+            self.model.load_state_dict(
+                full_state, strict=not self.model_config.tie_word_embeddings
+            )
+
+            if self.model_config.tie_word_embeddings:
+                self.model.tie_weights()
 
     def upload_weights(self, meta: WeightUpdateMeta):
         if meta.type == "nccl":
diff --git a/arealite/utils/save_load.py b/arealite/utils/save_load.py
index 7df9a3f7b..19bc9850d 100644
--- a/arealite/utils/save_load.py
+++ b/arealite/utils/save_load.py
@@ -1,4 +1,5 @@
 import os
+from pathlib import Path
 from typing import Dict
 
 import torch
@@ -41,18 +42,21 @@ def get_state_dict_from_repo_id_or_path(repo_id_or_path: str) -> Dict:
     else:
         # Assume it's a local path
         local_path = repo_id_or_path
-        if not os.path.isdir(local_path):
-            raise ValueError(
-                f"Local path {local_path} does not exist or is not a directory, "
-                f"or {local_path} is a huggingface repo id but huggingface_hub is not installed."
-            )
 
     # Step 3: Load all .safetensors and .bin files
     file_paths_to_load = []
-    for filename in os.listdir(local_path):
-        filepath = os.path.join(local_path, filename)
-        if filename.endswith(".safetensors") or filename.endswith(".bin"):
-            file_paths_to_load.append(filepath)
+    if os.path.isdir(local_path):
+        for filename in os.listdir(local_path):
+            filepath = os.path.join(local_path, filename)
+            if filename.endswith(".safetensors") or filename.endswith(".bin"):
+                file_paths_to_load.append(filepath)
+    elif os.path.isfile(local_path):
+        file_paths_to_load.append(local_path)
+    else:
+        raise ValueError(
+            f"Local path {local_path} does not exist or is not a valid path, "
+            f"or {local_path} is a huggingface repo id but huggingface_hub is not installed."
+        )
 
     def _load(filepath: str):
         if filepath.endswith(".safetensors"):
@@ -82,3 +86,11 @@ def _load(filepath: str):
             except Exception as e:
                 raise RuntimeError(f"Error loading checkpoint from {path}: {e}")
     return state_dict
+
+
+def is_existing_local_path(path: str) -> bool:
+    try:
+        path_obj = Path(path)
+        return path_obj.exists() and (path_obj.is_file() or path_obj.is_dir())
+    except (ValueError, OSError):
+        return False

From f35262f86209b56471f2d98862e03813b715d43a Mon Sep 17 00:00:00 2001
From: Jayon02 <12012211@mail..sustech.edu.cn>
Date: Fri, 11 Jul 2025 10:11:42 -0700
Subject: [PATCH 06/10] refactor test

---
 arealite/engine/hf_engine.py                  |  17 +-
 .../{test_fsdp_engine.py => test_engine.py}   |  50 ++++--
 arealite/tests/test_hf_engine.py              | 161 ------------------
 3 files changed, 41 insertions(+), 187 deletions(-)
 rename arealite/tests/{test_fsdp_engine.py => test_engine.py} (81%)
 delete mode 100644 arealite/tests/test_hf_engine.py

diff --git a/arealite/engine/hf_engine.py b/arealite/engine/hf_engine.py
index d264ed88f..68d7fde0e 100644
--- a/arealite/engine/hf_engine.py
+++ b/arealite/engine/hf_engine.py
@@ -294,15 +294,15 @@ def step_lr_scheduler(self):
         assert self.lr_scheduler is not None
         return self.lr_scheduler.step()
 
-    def _prepare_mb_list(
-        self, input_: TensorDict, mb_spec: MicroBatchSpec
-    ) -> MicroBatchList:
+    def _prepare_mb_list(self, input_: TensorDict) -> MicroBatchList:
         assert "attention_mask" in input_ and "input_ids" in input_
+        if isinstance(input_, dict):
+            input_ = TensorDict(input_, batch_size=[input_["input_ids"].shape[0]])
         input_ = amend_position_ids(input_)
         packed_input = pack_tensor_dict(input_)
         mb_list = split_packed_tensor_dict_into_mb_list(
             packed_input,
-            mb_spec,
+            self.config.mb_spec,
         )
         mb_list = pad_mb_list(mb_list, pad_value=0.0)
         # NOTE: We unsqueeze here because huggingface transformer models requires
@@ -313,7 +313,6 @@ def _prepare_mb_list(
     def train_batch(
         self,
         input_: TensorDict,
-        mb_spec: MicroBatchSpec,
         loss_fn: Callable[[torch.Tensor, Dict], torch.Tensor],
         loss_weight_fn: Callable[[Dict], float],
     ) -> Dict[str, float]:
@@ -324,7 +323,7 @@ def train_batch(
         assert self.lr_scheduler is not None
 
         self.optimizer.zero_grad()
-        mb_list = self._prepare_mb_list(input_, mb_spec)
+        mb_list = self._prepare_mb_list(input_)
 
         total_loss_weight = torch.tensor(
             sum([loss_weight_fn(mb) for mb in mb_list.mbs]), dtype=torch.float32
@@ -372,12 +371,11 @@ def train_batch(
     def eval_batch(
         self,
         input_: TensorDict,
-        mb_spec: MicroBatchSpec,
         loss_fn: Callable[[torch.Tensor, Dict], torch.Tensor],
         loss_weight_fn: Callable[[Dict], float],
     ) -> torch.Tensor | None:
         """Evaluate on a batch."""
-        mb_list = self._prepare_mb_list(input_, mb_spec)
+        mb_list = self._prepare_mb_list(input_)
         total_loss_weight = torch.tensor(
             sum([loss_weight_fn(mb) for mb in mb_list.mbs]), dtype=torch.float32
         )
@@ -405,14 +403,13 @@ def eval_batch(
     def forward(
         self,
         input_: TensorDict,
-        mb_spec: MicroBatchSpec,
         output_seqlens: List[int] | None = None,
         post_hook: Callable[[torch.Tensor, Dict], Any] | None = None,
         aggregate_fn: Callable[[List[Any]], Any] = torch.cat,
     ) -> Any | None:
         """Forward pass with optional post-processing."""
         cu_seqlens = pack_tensor_dict(input_)["cu_seqlens"]
-        mb_list = self._prepare_mb_list(input_, mb_spec)
+        mb_list = self._prepare_mb_list(input_)
 
         if output_seqlens is None:
             output_seqlens = (cu_seqlens[1:] - cu_seqlens[:-1]).cpu().numpy().tolist()
diff --git a/arealite/tests/test_fsdp_engine.py b/arealite/tests/test_engine.py
similarity index 81%
rename from arealite/tests/test_fsdp_engine.py
rename to arealite/tests/test_engine.py
index d295408d3..0d741fd30 100644
--- a/arealite/tests/test_fsdp_engine.py
+++ b/arealite/tests/test_engine.py
@@ -1,7 +1,7 @@
 # Copyright 2025 Ant Group Inc.
 # Licensed under the Apache License, Version 2.0
 
-"""Test script for HF Engine implementation."""
+"""Test script for Engine implementation."""
 
 import os
 from typing import Dict
@@ -52,29 +52,47 @@ def mock_input(
     )
 
 
-def mock_loss_fn(logits: torch.Tensor, input_data: Dict) -> torch.Tensor:
-    """Mock loss function for testing."""
-    return torch.mean(logits)
-
+def get_engine(engine_type: str, model_path: str):
+    from arealite.engine.fsdp_engine import FSDPEngine
+    from arealite.engine.hf_engine import HFEngine
 
-@pytest.fixture(scope="module")
-def engine():
-    os.environ["WORLD_SIZE"] = "1"
-    os.environ["RANK"] = "0"
-    os.environ["LOCAL_RANK"] = "0"
-    os.environ["MASTER_ADDR"] = "localhost"
-    os.environ["MASTER_PORT"] = "7777"
+    engine_cls = {"hf": HFEngine, "fsdp": FSDPEngine}[engine_type]
 
     engine_config = TrainEngineConfig(
-        experiment_name="test-fsdp-engine",
+        experiment_name=f"test-{engine_type}-engine",
         trial_name="test0",
-        path=MODEL_PATH,
+        path=model_path,
         optimizer=OptimizerConfig(),
     )
-    engine = FSDPEngine(engine_config)
+    engine = engine_cls(engine_config)
     ft_spec = FinetuneSpec(total_train_epochs=1, dataset_size=100, train_batch_size=2)
     engine.initialize(None, ft_spec)
-    print("✓ Engine created successfully")
+    return engine
+
+
+def mock_loss_fn(logits: torch.Tensor, input_data: Dict) -> torch.Tensor:
+    """Mock loss function for testing."""
+    return torch.mean(logits)
+
+
+@pytest.fixture(scope="module", params=["fsdp", "hf"])
+def engine(request):
+    os.environ.update(
+        {
+            "WORLD_SIZE": "1",
+            "RANK": "0",
+            "LOCAL_RANK": "0",
+            "MASTER_ADDR": "localhost",
+            "MASTER_PORT": "7777",
+        }
+    )
+
+    model_path = "/storage/testing/models/Qwen__Qwen3-1.7B/"
+    if not os.path.exists(model_path):
+        model_path = "Qwen/Qwen2-0.5B"
+
+    engine = get_engine(request.param, model_path)
+    print(f"✓ {request.param.upper()} Engine created successfully")
     yield engine
 
 
diff --git a/arealite/tests/test_hf_engine.py b/arealite/tests/test_hf_engine.py
deleted file mode 100644
index 927b3e985..000000000
--- a/arealite/tests/test_hf_engine.py
+++ /dev/null
@@ -1,161 +0,0 @@
-# Copyright 2025 Ant Group Inc.
-# Licensed under the Apache License, Version 2.0
-
-"""Test script for HF Engine implementation."""
-
-import os
-from typing import Dict
-
-import pytest
-import torch
-from tensordict import TensorDict
-from transformers import AutoTokenizer
-
-from arealite.api.cli_args import MicroBatchSpec, OptimizerConfig, TrainEngineConfig
-from arealite.api.io_struct import FinetuneSpec, SaveLoadMeta
-from arealite.engine.hf_engine import HFEngine
-
-VOCAB_SIZE = 100
-MODEL_PATH = "/storage/testing/models/Qwen__Qwen3-1.7B/"
-if not os.path.exists(MODEL_PATH):
-    MODEL_PATH = "Qwen/Qwen2-0.5B"
-
-
-@pytest.fixture(scope="module")
-def mock_input(
-    batch_size=5,
-    min_seqlen=10,
-    max_seqlen=20,
-    device="cuda:0",
-) -> Dict:
-    """Create mock padded input data (same format for huggingface) for testing.
-    Returns a dict with input_ids, attention_mask, and position_ids.
-    """
-    pad_token_id = 0
-    seqlens = torch.randint(
-        min_seqlen, max_seqlen, (batch_size,), dtype=torch.int, device=device
-    )
-    max_seqlen = int(max(seqlens))
-    input_ids = torch.randint(
-        0, VOCAB_SIZE, (batch_size, max_seqlen), dtype=torch.long, device=device
-    )
-    attn_mask = torch.zeros((batch_size, max_seqlen), dtype=torch.bool, device=device)
-
-    attn_mask[
-        torch.arange(0, max_seqlen, device=device).unsqueeze(0) < seqlens.unsqueeze(1)
-    ] = 1
-    input_ids.masked_fill_(~attn_mask, pad_token_id)
-
-    return TensorDict(
-        input_ids=input_ids,
-        attention_mask=attn_mask,
-    )
-
-
-def mock_loss_fn(logits: torch.Tensor, input_data: Dict) -> torch.Tensor:
-    """Mock loss function for testing."""
-    return torch.mean(logits)
-
-
-@pytest.fixture(scope="module")
-def engine():
-    os.environ["WORLD_SIZE"] = "1"
-    os.environ["RANK"] = "0"
-    os.environ["LOCAL_RANK"] = "0"
-    os.environ["MASTER_ADDR"] = "localhost"
-    os.environ["MASTER_PORT"] = "7777"
-
-    engine_config = TrainEngineConfig(
-        experiment_name="test-hf-engine",
-        trial_name="test0",
-        path=MODEL_PATH,
-        optimizer=OptimizerConfig(),
-    )
-    engine = HFEngine(engine_config)
-    ft_spec = FinetuneSpec(total_train_epochs=1, dataset_size=100, train_batch_size=2)
-    engine.initialize(None, ft_spec)
-    print("✓ Engine created successfully")
-    yield engine
-
-
-@torch.no_grad()
-def test_forward_microbatch(engine, mock_input):
-    engine.eval()
-    x2 = (
-        engine.forward(
-            input_=mock_input,
-            mb_spec=MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100),
-        )
-        .squeeze(0)
-        .mean(-1)
-    )
-    x1 = (
-        engine.forward(
-            input_=mock_input,
-            mb_spec=MicroBatchSpec(n_mbs=1, max_tokens_per_mb=100),
-        )
-        .squeeze(0)
-        .mean(-1)
-    )
-    input_ids = mock_input["input_ids"]
-    assert x1.shape[:1] == input_ids.shape[:1]
-    assert x2.shape[:1] == input_ids.shape[:1]
-    assert torch.allclose(x1, x2, atol=1e-1, rtol=1e-2), (x1 - x2).abs().max().item()
-
-
-@torch.no_grad()
-def test_eval_batch(engine, mock_input):
-    engine.eval()
-    eval_result = engine.eval_batch(
-        input_=mock_input,
-        mb_spec=MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100),
-        loss_fn=mock_loss_fn,
-        loss_weight_fn=lambda x: x["cu_seqlens"][-1],
-    )
-    assert isinstance(eval_result, torch.Tensor), "Evaluation should return a tensor"
-    assert eval_result.is_cuda, "Evaluation tensor should be on CUDA device"
-    assert eval_result is not None, "Evaluation should return a loss value"
-    print(f"✓ Evaluation successful, loss: {eval_result.item()}")
-
-
-def test_train_batch(engine, mock_input):
-    engine.train()
-    train_result = engine.train_batch(
-        input_=mock_input,
-        mb_spec=MicroBatchSpec(n_mbs=2, max_tokens_per_mb=100),
-        loss_fn=mock_loss_fn,
-        loss_weight_fn=lambda x: x["cu_seqlens"][-1],
-    )
-    assert isinstance(train_result, dict), "Training should return a dictionary"
-    assert train_result["grad_norm"] is not None
-    assert train_result["lr"] is not None
-    print("✓ Training successful")
-
-
-@torch.no_grad()
-def test_hf_save_load_weights(tmp_path_factory, engine, mock_input):
-    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
-    path = tmp_path_factory.mktemp("hf_engine_test")
-    save_load_meta = SaveLoadMeta(
-        path=path,
-        weight_format="hf",
-        tokenizer=tokenizer,
-        with_optim=True,
-        base_model_path=None,
-    )
-
-    old = engine.forward(
-        input_=mock_input,
-        mb_spec=MicroBatchSpec(n_mbs=1, max_tokens_per_mb=100),
-    )
-    engine.save(save_load_meta)
-
-    for name, param in engine.model.named_parameters():
-        param.zero_()
-
-    engine.load(save_load_meta)
-    new = engine.forward(
-        input_=mock_input,
-        mb_spec=MicroBatchSpec(n_mbs=1, max_tokens_per_mb=100),
-    )
-    assert torch.allclose(old, new)

From decf3c1799762624becb1f107952ece9fd061ef8 Mon Sep 17 00:00:00 2001
From: Jayon02 <12012211@mail..sustech.edu.cn>
Date: Fri, 11 Jul 2025 10:16:17 -0700
Subject: [PATCH 07/10] fix bugs

---
 arealite/tests/test_engine.py | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/arealite/tests/test_engine.py b/arealite/tests/test_engine.py
index 0d741fd30..6c5d07a3f 100644
--- a/arealite/tests/test_engine.py
+++ b/arealite/tests/test_engine.py
@@ -87,11 +87,7 @@ def engine(request):
         }
     )
 
-    model_path = "/storage/testing/models/Qwen__Qwen3-1.7B/"
-    if not os.path.exists(model_path):
-        model_path = "Qwen/Qwen2-0.5B"
-
-    engine = get_engine(request.param, model_path)
+    engine = get_engine(request.param, MODEL_PATH)
     print(f"✓ {request.param.upper()} Engine created successfully")
     yield engine
 

From fbccf6de2e4779a1f62e78beea114aaeee4b1792 Mon Sep 17 00:00:00 2001
From: Jayon02 <12012211@mail..sustech.edu.cn>
Date: Tue, 15 Jul 2025 10:17:03 -0700
Subject: [PATCH 08/10] fix issues

---
 arealite/api/io_struct.py    |   2 +-
 arealite/engine/hf_engine.py | 105 +++++++++++++++++++++++------------
 pyproject.toml               |   1 +
 requirements.txt             |   1 +
 4 files changed, 71 insertions(+), 38 deletions(-)

diff --git a/arealite/api/io_struct.py b/arealite/api/io_struct.py
index b9144e877..40ff81f67 100644
--- a/arealite/api/io_struct.py
+++ b/arealite/api/io_struct.py
@@ -175,7 +175,7 @@ class SaveLoadMeta:
     with_optim: bool
     tokenizer: PreTrainedTokenizerFast | None
     base_model_path: str | None
-    distribute: bool = False
+    naive_distributed: bool = False
 
 
 @dataclass
diff --git a/arealite/engine/hf_engine.py b/arealite/engine/hf_engine.py
index 68d7fde0e..6f865c231 100644
--- a/arealite/engine/hf_engine.py
+++ b/arealite/engine/hf_engine.py
@@ -2,8 +2,6 @@
 import os
 import time
 from typing import Any, Callable, Dict, List, Optional
-
-import deepspeed
 import torch
 import torch.distributed as dist
 import transformers
@@ -58,8 +56,6 @@ def __init__(self, config: TrainEngineConfig):
         # initialization
         self.initialized = False
         self.weight_update_group_initialized = False
-        self.local_rank = int(os.environ.get("LOCAL_RANK", 0))
-        self.world_size = int(os.environ.get("WORLD_SIZE", 1))
 
     def train(self, mode: bool = True):
         assert self.model is not None
@@ -67,15 +63,20 @@ def train(self, mode: bool = True):
         return self
 
     def initialize(self, addr: str | None, ft_spec: FinetuneSpec | None):
-        # Initialize distributed enviroments and load model.
+        """Initialize distributed communication and model."""
         assert addr is None, "HFEngine does not support remote initialization."
 
-        """Initialize distributed communication and model."""
-        if not dist.is_initialized():
-            deepspeed.init_distributed(dist_backend="nccl", world_size=self.world_size)
+        world_size = int(os.environ.get("WORLD_SIZE", 0))
+        if not dist.is_initialized() and world_size > 1:
+            try:
+                import deepspeed
+            except ImportError:
+                print("Warning: deepspeed is not installed. Some functionality may be disabled.")
+            deepspeed.init_distributed(dist_backend="nccl", world_size=world_size)
 
-        torch.cuda.set_device(self.local_rank)
-        self.device = torch.device(f"cuda:{self.local_rank}")
+        local_rank = int(os.environ.get("LOCAL_RANK", 0))
+        torch.cuda.set_device(local_rank)
+        self.device = torch.device(f"cuda:{local_rank}")
 
         dtype = torch.bfloat16 if self.config.bf16 else torch.float16
         self.model_config = AutoConfig.from_pretrained(
@@ -83,13 +84,12 @@ def initialize(self, addr: str | None, ft_spec: FinetuneSpec | None):
             trust_remote_code=True,
         )
         self.tokenizer = load_hf_tokenizer(self.config.path)
-        model = AutoModelForCausalLM.from_config(
+
+        self.model = AutoModelForCausalLM.from_config(
             self.model_config,
             torch_dtype=dtype,
             attn_implementation=self.config.attn_impl,
-        )
-
-        self.model = model
+        ).to(f"cuda:{local_rank}")
 
         if not self.config.init_from_scratch:
             # Load model from a initial checkpoint path,
@@ -100,20 +100,19 @@ def initialize(self, addr: str | None, ft_spec: FinetuneSpec | None):
                 with_optim=False,
                 tokenizer=None,
                 base_model_path=self.config.path,
-                distribute=False,
+                naive_distributed=False
             )
+
             self.load(load_meta)
 
-        if self.world_size > 1:
+        if world_size > 1:
             if self._check_autotp():
                 self.model = deepspeed.tp_model_init(
-                    self.model, tp_size=self.config.hf.autotp_size, dtype=dtype
+                        self.model, tp_size=self.config.hf.autotp_size, dtype=dtype
                 )
             else:
                 raise RuntimeError("DeepSpeed AutoTP configuration error in HFEngine. ")
 
-        self.model = self.model.to(device=self.device, non_blocking=True)
-
         # Set up optimizer
         if self.optimizer_config is not None:
             assert (
@@ -188,7 +187,7 @@ def destroy(self):
 
     def save(self, meta: SaveLoadMeta):
         if meta.weight_format == "hf":
-            self._save_model_to_hf(meta.path, meta.tokenizer, meta.distribute)
+            self._save_model_to_hf(meta.path, meta.tokenizer, meta.naive_distributed)
         elif meta.weight_format == "dcp":
             # TODO: implement DCP save/load for HF
             raise NotImplementedError("DCP format saving is not implemented yet. ")
@@ -200,7 +199,7 @@ def save(self, meta: SaveLoadMeta):
 
     def load(self, meta: SaveLoadMeta):
         if meta.weight_format == "hf":
-            self._load_model_from_hf(meta.path, meta.distribute)
+            self._load_model_from_hf(meta.path, meta.naive_distributed)
         elif meta.weight_format == "dcp":
             # TODO: implement DCP save/load for HF
             raise NotImplementedError("DCP format loading is not implemented yet. ")
@@ -225,38 +224,70 @@ def _save_model_to_hf(
         self,
         path: str,
         tokenizer: Optional[transformers.PreTrainedTokenizerFast],
-        distribute: bool = False,
+        naive_distributed: bool
     ):
         """Save model in HuggingFace format."""
         if self.model is None:
             raise RuntimeError("Model not initialized")
 
-        if self.local_rank == 0:
+        rank = dist.get_rank()
+        world_size = dist.get_world_size()
+        if rank == 0:
             os.makedirs(path, exist_ok=True)
+            self.model_config.save_pretrained(path)
+            if tokenizer is not None:
+                tokenizer.save_pretrained(path)
 
-        if self.world_size > 1:
+        if world_size > 1:
             dist.barrier()
 
-        state_dict = {k: v.cpu() for k, v in self.model.state_dict().items()}
+        state_dict = self.model.state_dict()
 
-        if distribute:
-            save_file(
-                state_dict, f"{path}/tp_rank_{self.local_rank:02d}_model.safetensors"
+        if hasattr(self.model, "module"):
+            state_dict = {
+                k.replace("module.", "", 1) if k.startswith("module.") else k: v.cpu()
+                for k, v in state_dict.items()
+            }
+        else:
+            state_dict = {k: v.cpu() for k, v in state_dict.items()}
+
+        if world_size > 1 and naive_distributed:
+            # Only support store parameters from model partitions respectively
+            gathered_state_dicts = None
+            if rank == 0:
+                gathered_state_dicts = [None for _ in range(world_size)]
+
+            dist.gather_object(
+                obj=state_dict,
+                object_gather_list=gathered_state_dicts,
+                dst=0
             )
+
+            if rank == 0:
+                for i, state_dict in enumerate(gathered_state_dicts):
+                    save_file(
+                        state_dict,
+                        f"{path}/rank_{i:02d}_model.safetensors"
+                    )
         else:
             self.model.save_pretrained(path, state_dict=state_dict)
 
-        if self.local_rank == 0:
-            self.model_config.save_pretrained(path)
-            if self.tokenizer is not None:
-                self.tokenizer.save_pretrained(path)
+        if world_size > 1:
+            dist.barrier()
 
-    def _load_model_from_hf(self, path: str, distribute: bool = False):
+    def _load_model_from_hf(self, path: str, naive_distributed: bool):
         """Load model from HuggingFace format."""
-        if self.local_rank == 0 or is_existing_local_path(path):
-            if distribute:
-                path = f"{path}/tp_rank_{self.local_rank:02d}_model.safetensors"
+
+        rank = dist.get_rank()
+        # Only support load full model parameters from huggingface
+        # and load model partition locally 
+        if rank == 0 or is_existing_local_path(path):
+            if naive_distributed:
+                path = f"{path}/rank_{rank:02d}_model.safetensors"
             full_state = get_state_dict_from_repo_id_or_path(path)
+
+            if hasattr(self.model, "module") and not hasattr(full_state):
+                full_state = {f"module.{k}" if not k.startswith("module.") else k: v for k, v in full_state.items()}
             self.model.load_state_dict(
                 full_state, strict=not self.model_config.tie_word_embeddings
             )
@@ -270,7 +301,7 @@ def upload_weights(self, meta: WeightUpdateMeta):
                 self._init_distributed_weight_update(meta)
             self._update_weights_from_distributed()
         elif meta.type == "disk":
-            self._save_model_to_hf(meta.path, self.tokenizer)
+            self._save_model_to_hf(meta.path, self.tokenizer, meta.naive_distributed)
             update_name = names.update_weights_from_disk(
                 self.config.experiment_name,
                 self.config.trial_name,
diff --git a/pyproject.toml b/pyproject.toml
index 4f752ebc5..cd4e26dae 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -86,6 +86,7 @@ dependencies = [
     # Distributed computing
     "ray",
     "redis",
+    "deepspeed>=0.17.2",
     
     # Web frameworks
     "fastapi>=0.115.12",
diff --git a/requirements.txt b/requirements.txt
index 5318511cd..178e95835 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -74,3 +74,4 @@ swanlab[dashboard]
 torchdata
 autoflake
 tensordict
+deepspeed>=0.17.2

From 24390d776f58b12342e35a21f45fb89f4e5a2287 Mon Sep 17 00:00:00 2001
From: Jayon02 <12012211@mail..sustech.edu.cn>
Date: Tue, 15 Jul 2025 10:22:32 -0700
Subject: [PATCH 09/10] format files

---
 arealite/engine/hf_engine.py | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/arealite/engine/hf_engine.py b/arealite/engine/hf_engine.py
index 6f865c231..b3c0b6532 100644
--- a/arealite/engine/hf_engine.py
+++ b/arealite/engine/hf_engine.py
@@ -2,6 +2,7 @@
 import os
 import time
 from typing import Any, Callable, Dict, List, Optional
+
 import torch
 import torch.distributed as dist
 import transformers
@@ -71,7 +72,9 @@ def initialize(self, addr: str | None, ft_spec: FinetuneSpec | None):
             try:
                 import deepspeed
             except ImportError:
-                print("Warning: deepspeed is not installed. Some functionality may be disabled.")
+                print(
+                    "Warning: deepspeed is not installed. Some functionality may be disabled."
+                )
             deepspeed.init_distributed(dist_backend="nccl", world_size=world_size)
 
         local_rank = int(os.environ.get("LOCAL_RANK", 0))
@@ -100,7 +103,7 @@ def initialize(self, addr: str | None, ft_spec: FinetuneSpec | None):
                 with_optim=False,
                 tokenizer=None,
                 base_model_path=self.config.path,
-                naive_distributed=False
+                naive_distributed=False,
             )
 
             self.load(load_meta)
@@ -108,7 +111,7 @@ def initialize(self, addr: str | None, ft_spec: FinetuneSpec | None):
         if world_size > 1:
             if self._check_autotp():
                 self.model = deepspeed.tp_model_init(
-                        self.model, tp_size=self.config.hf.autotp_size, dtype=dtype
+                    self.model, tp_size=self.config.hf.autotp_size, dtype=dtype
                 )
             else:
                 raise RuntimeError("DeepSpeed AutoTP configuration error in HFEngine. ")
@@ -224,7 +227,7 @@ def _save_model_to_hf(
         self,
         path: str,
         tokenizer: Optional[transformers.PreTrainedTokenizerFast],
-        naive_distributed: bool
+        naive_distributed: bool,
     ):
         """Save model in HuggingFace format."""
         if self.model is None:
@@ -258,17 +261,12 @@ def _save_model_to_hf(
                 gathered_state_dicts = [None for _ in range(world_size)]
 
             dist.gather_object(
-                obj=state_dict,
-                object_gather_list=gathered_state_dicts,
-                dst=0
+                obj=state_dict, object_gather_list=gathered_state_dicts, dst=0
             )
 
             if rank == 0:
                 for i, state_dict in enumerate(gathered_state_dicts):
-                    save_file(
-                        state_dict,
-                        f"{path}/rank_{i:02d}_model.safetensors"
-                    )
+                    save_file(state_dict, f"{path}/rank_{i:02d}_model.safetensors")
         else:
             self.model.save_pretrained(path, state_dict=state_dict)
 
@@ -280,14 +278,17 @@ def _load_model_from_hf(self, path: str, naive_distributed: bool):
 
         rank = dist.get_rank()
         # Only support load full model parameters from huggingface
-        # and load model partition locally 
+        # and load model partition locally
         if rank == 0 or is_existing_local_path(path):
             if naive_distributed:
                 path = f"{path}/rank_{rank:02d}_model.safetensors"
             full_state = get_state_dict_from_repo_id_or_path(path)
 
             if hasattr(self.model, "module") and not hasattr(full_state):
-                full_state = {f"module.{k}" if not k.startswith("module.") else k: v for k, v in full_state.items()}
+                full_state = {
+                    f"module.{k}" if not k.startswith("module.") else k: v
+                    for k, v in full_state.items()
+                }
             self.model.load_state_dict(
                 full_state, strict=not self.model_config.tie_word_embeddings
             )

From 4f0ac55b4a0c30e58b18b46561b12ed957ce8583 Mon Sep 17 00:00:00 2001
From: Jayon02 <12012211@mail..sustech.edu.cn>
Date: Tue, 15 Jul 2025 10:31:38 -0700
Subject: [PATCH 10/10] Squashed commit of the following:

commit 9ed043f6ab83cf9c9b38e0251ad08009a73243e8
Author: Wei Fu <36355462+garrett4wade@users.noreply.github.com>
Date:   Tue Jul 15 10:24:48 2025 +0800

    format (#174)

commit 8cc9b1feb5ed03cfa42f3ed588dd5f6ec16e5e55
Author: Night <32424487+PrinsYin@users.noreply.github.com>
Date:   Mon Jul 14 19:22:00 2025 -0700

    added LocalSGlangEngine and test (#170)

    * added LocalSGLangEngine

    * upload test file

    * add build args

    * fix sgl_local generate

    * improved sgl local robustness

    * test

    * test updated

    * added fallback when sgl engine isn't initialized

    * finish test local engine

    * added LocalSGlangEngine and test

    * format and fix

    format and fix, raise when generate missing field

    format

    * change cli_args.py

    * add comment header

    format

    ---------

    Co-authored-by: ChangyiYang <changyiyang2023@gmail.com>
---
 arealite/api/cli_args.py                   |  48 ++-
 arealite/engine/sglang_engine.py           | 377 ++++++++++++++++++++-
 arealite/tests/test_sglang_local_engine.py | 144 ++++++++
 3 files changed, 551 insertions(+), 18 deletions(-)
 create mode 100644 arealite/tests/test_sglang_local_engine.py

diff --git a/arealite/api/cli_args.py b/arealite/api/cli_args.py
index 2b5c5f6aa..4763d5134 100644
--- a/arealite/api/cli_args.py
+++ b/arealite/api/cli_args.py
@@ -213,6 +213,39 @@ def build_cmd(
         dist_init_addr: Optional[str] = None,
         served_model_name: Optional[str] = None,
         skip_tokenizer_init: bool = True,
+    ):
+        args = SGLangConfig.build_args(
+            sglang_config=sglang_config,
+            model_path=model_path,
+            tp_size=tp_size,
+            base_gpu_id=base_gpu_id,
+            dist_init_addr=dist_init_addr,
+            served_model_name=served_model_name,
+            skip_tokenizer_init=skip_tokenizer_init,
+        )
+
+        # convert to flags
+        flags = []
+        for k, v in args.items():
+            if v is None or v is False or v == "":
+                continue
+            if v is True:
+                flags.append(f"--{k.replace('_','-')}")
+            elif isinstance(v, list):
+                flags.append(f"--{k.replace('_','-')} {' '.join(map(str, v))}")
+            else:
+                flags.append(f"--{k.replace('_','-')} {v}")
+        return f"python3 -m sglang.launch_server {' '.join(flags)}"
+
+    @staticmethod
+    def build_args(
+        sglang_config: "SGLangConfig",
+        model_path,
+        tp_size,
+        base_gpu_id,
+        dist_init_addr: Optional[str] = None,
+        served_model_name: Optional[str] = None,
+        skip_tokenizer_init: bool = True,
     ):
         from realhf.base import network, pkg_version, seeding
         from realhf.experiments.common.utils import asdict as conf_as_dict
@@ -256,20 +289,7 @@ def build_cmd(
             args.pop("allow_auto_truncate")
             args.pop("file_storage_path")
 
-        flags = []
-        for k, v in args.items():
-            if v is None or v is False or v == "":
-                continue
-            if v is True:
-                flags.append(f"--{k.replace('_','-')} ")
-                continue
-            if isinstance(v, list):
-                values = " ".join(map(str, v))
-                flags.append(f"--{k.replace('_','-')} {values}")
-                continue
-            flags.append(f"--{k.replace('_','-')} {v}")
-        flags = " ".join(flags)
-        return f"python3 -m sglang.launch_server {flags}"
+        return args
 
 
 @dataclass
diff --git a/arealite/engine/sglang_engine.py b/arealite/engine/sglang_engine.py
index 6d8ee10be..777091e8d 100644
--- a/arealite/engine/sglang_engine.py
+++ b/arealite/engine/sglang_engine.py
@@ -1,6 +1,375 @@
-from arealite.api.cli_args import SGLangEngineConfig
+import asyncio
+import threading
+import time
+import traceback
+from concurrent.futures import ThreadPoolExecutor
+from queue import Empty, Full, Queue
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
 
+import sglang as sgl
+import torch.distributed as dist
+from tensordict import TensorDict
 
-class SGLangEngine:
-    def __init__(self, config: SGLangEngineConfig):
-        pass
+from arealite.api.cli_args import InferenceEngineConfig
+from arealite.api.engine_api import InferenceEngine
+from arealite.api.io_struct import (
+    LLMRequest,
+    LLMResponse,
+    RolloutStat,
+    WeightUpdateMeta,
+)
+from realhf.base import logging, name_resolve, names, pkg_version
+
+if TYPE_CHECKING:
+    from arealite.api.workflow_api import RolloutWorkflow
+logger = logging.getLogger(__name__)
+
+if pkg_version.is_available("sglang"):
+    if pkg_version.is_version_greater_or_equal("sglang", "0.4.4"):
+        SGLANG_TOKEN_OUTPUT_IDENTIFIER = "output_ids"
+    else:
+        SGLANG_TOKEN_OUTPUT_IDENTIFIER = "token_ids"
+
+ROLLOUT_POLL_WAIT_TIME = 0.4
+RID_CACHE_SIZE = 128
+
+"""
+Local SGLang Inference Engine
+SGLangEngine currently only supports single-controller. Cannot be used in SPMD
+"""
+
+
+class SGLangEngine(InferenceEngine):
+
+    def __init__(
+        self,
+        config: InferenceEngineConfig,
+        engine_args: Optional[Dict[str, Any]] = None,
+    ):
+        config.max_concurrent_rollouts = (
+            config.max_concurrent_rollouts or config.consumer_batch_size
+        )
+        self.config = config
+        self.engine_args = engine_args or {}
+
+        qsize = config.queue_size or config.max_concurrent_rollouts * 10
+        self.input_queue = Queue(maxsize=qsize)
+        self.output_queue = Queue(maxsize=qsize)
+        self.result_cache = []
+
+        self.exiting = threading.Event()
+        self.lock = threading.Lock()
+
+        self.rollout_stat = RolloutStat()
+
+        self._version = 0
+
+    def initialize(self, addr: str | None, ft_spec: Optional[Dict[str, Any]] = None):
+        self.engine = sgl.Engine(**self.engine_args)
+
+        self.rollout_thread = threading.Thread(target=self._rollout_thread)
+        self.rollout_thread.start()
+
+    def destroy(self):
+        self.exiting.set()
+        self.rollout_thread.join()
+
+        if hasattr(self, "engine") and self.engine is not None:
+            try:
+                self.engine.shutdown()
+            except Exception as e:
+                logger.warning(f"Error shutting down engine: {e}")
+
+    def set_version(self, version):
+        with self.lock:
+            self._version = version
+
+    def get_version(self):
+        with self.lock:
+            return self._version
+
+    def _rollout_thread(self):
+        """Thread that runs the rollout loop."""
+        try:
+            asyncio.run(self._rollout_thread_async())
+        except Exception as e:
+            traceback.print_exc()
+
+    async def _rollout_thread_async(self):
+        data = None
+
+        rollout_tasks: Dict[str, asyncio.Task] = {}
+        rid = 0
+
+        try:
+            while not self.exiting.is_set():
+                # Load next data from controller
+                if data is None:
+                    try:
+                        data, workflow = self.input_queue.get_nowait()
+                        logger.info(f"Get data from puller: {data}")
+                    except Empty:
+                        logger.debug(f"No data from puller stream.")
+
+                # Check capacity
+                if dist.is_initialized():
+                    world_size = dist.get_world_size()
+                else:
+                    world_size = 1
+
+                cannot_rollout_reason = []
+                capacity = max(1, self.config.max_concurrent_rollouts // world_size)
+                can_rollout = len(rollout_tasks) < capacity
+                if not can_rollout:
+                    cannot_rollout_reason.append(
+                        f"Exceeding capacity: # running tasks {len(rollout_tasks)} >= capacity {capacity}"
+                    )
+
+                # Staleness control
+                version = self.get_version()
+                ofp = self.config.max_head_offpolicyness
+                with self.lock:
+                    sample_cnt = self.rollout_stat.accepted + self.rollout_stat.running
+                expected_version = sample_cnt // self.config.consumer_batch_size
+                not_staled = expected_version <= ofp + version
+                can_rollout &= not_staled
+                if not not_staled:
+                    cannot_rollout_reason.append(
+                        f"Staled: expected version ({expected_version}) = "
+                        f"global sample cnt ({sample_cnt}) // batch size ({self.config.consumer_batch_size}), "
+                        f"current latest version {version}, "
+                        f"offpolicyness {self.config.max_head_offpolicyness}."
+                    )
+
+                if not can_rollout:
+                    logger.debug(
+                        f"Cannot submit new rollouts. "
+                        + "\n".join(cannot_rollout_reason)
+                    )
+
+                # Create new rollout task
+                if can_rollout and data is not None:
+                    task = asyncio.create_task(
+                        workflow.arun_episode(self, data), name=str(rid)
+                    )
+                    rollout_tasks[str(rid)] = task
+
+                    with self.lock:
+                        self.rollout_stat.submitted += 1
+                        self.rollout_stat.running += 1
+                        logger.info(
+                            f"Submit rollout rid {rid}. "
+                            f"Submit: {self.rollout_stat.submitted}, "
+                            f"running: {self.rollout_stat.running}, "
+                            f"accepted: {self.rollout_stat.accepted}."
+                        )
+
+                    rid += 1
+                    data = None
+
+                # Wait for rollout completion
+                tasks = list(rollout_tasks.values())
+                done = []
+                if tasks:
+                    done, _ = await asyncio.wait(
+                        tasks,
+                        timeout=ROLLOUT_POLL_WAIT_TIME,
+                        return_when=asyncio.FIRST_COMPLETED,
+                    )
+                else:
+                    await asyncio.sleep(ROLLOUT_POLL_WAIT_TIME)
+
+                # Collect done results
+                for task in done:
+                    traj = await task
+                    traj: TensorDict
+                    task_rid = task.get_name()
+                    rollout_tasks.pop(task_rid)
+                    self.rollout_stat.accepted += 1
+
+                    try:
+                        self.output_queue.put_nowait(traj)
+                    except Full:
+                        raise RuntimeError(
+                            "Output queue full. Please increase queue_size."
+                        )
+
+                    with self.lock:
+                        self.rollout_stat.running -= 1
+                        logger.info(
+                            f"Finish rollout {task_rid}. "
+                            f"Submit: {self.rollout_stat.submitted}, "
+                            f"running: {self.rollout_stat.running}, "
+                            f"accepted: {self.rollout_stat.accepted}."
+                        )
+        finally:
+            # Cancel remaining tasks
+            for task in rollout_tasks.values():
+                if not task.done():
+                    task.cancel()
+                    try:
+                        await task
+                    except asyncio.CancelledError:
+                        pass
+
+    async def agenerate(self, req: LLMRequest) -> LLMResponse:
+        """Async version of generate using local sglang engine."""
+        if not hasattr(self, "engine") or self.engine is None:
+            raise RuntimeError(
+                "Local SGLang engine is not initialized, cannot generate."
+            )
+
+        # Prepare request payload
+        gconfig = req.gconfig
+        stop_token_ids = gconfig.stop_token_ids
+
+        if gconfig.n_samples != 1:
+            raise ValueError(
+                "LocalSGLangEngine does not support n_samples > 1. "
+                "Please call generate for multiple times with n_samples = 1."
+            )
+        sample_params = {
+            "top_p": gconfig.top_p,
+            "top_k": gconfig.top_k,
+            "max_new_tokens": gconfig.max_new_tokens,
+            "temperature": 0.0 if gconfig.greedy else gconfig.temperature,
+            "stop_token_ids": stop_token_ids,
+        }
+
+        completions = ""
+        prompt = req.text if req.text else None
+        input_ids = req.input_ids if req.input_ids else None
+
+        # Make request
+        start_time = time.perf_counter()
+        accumulated_output_tokens = []
+        accumulated_output_logprobs = []
+        accumulated_versions = []
+        stop_reason = "length"
+        while (
+            stop_reason != "stop"
+            and len(accumulated_output_tokens) < gconfig.max_new_tokens
+        ):
+
+            try:
+                outputs = await self.engine.async_generate(
+                    prompt=prompt,
+                    input_ids=input_ids,
+                    sampling_params=sample_params,
+                    return_logprob=True,
+                )
+
+                completions += outputs["text"]
+                if prompt is None:
+                    prompt = outputs["text"]
+                else:
+                    prompt += outputs["text"]
+
+                meta_info = outputs["meta_info"]
+                output_tokens = [x[1] for x in meta_info["output_token_logprobs"]]
+                output_logprobs = [x[0] for x in meta_info["output_token_logprobs"]]
+
+                finish_reason = meta_info.get("finish_reason", {})
+                stop_reason = finish_reason.get("type", "length")
+
+                accumulated_output_tokens.extend(output_tokens)
+                accumulated_output_logprobs.extend(output_logprobs)
+                accumulated_versions.extend([-1] * len(output_tokens))
+
+            except Exception as e:
+                raise RuntimeError(f"Local SGLang engine generation failed: {e}")
+
+        latency = time.perf_counter() - start_time
+
+        return LLMResponse(
+            completions=completions,
+            input_tokens=req.input_ids if req.input_ids else [],
+            output_tokens=accumulated_output_tokens,
+            output_logprobs=accumulated_output_logprobs,
+            output_versions=accumulated_versions,
+            stop_reason=stop_reason,
+            latency=latency,
+            ttft=latency,
+        )
+
+    def update_weights(self, meta):
+        executor = ThreadPoolExecutor(max_workers=1)
+        return executor.submit(self._update_weights, meta)
+
+    def _update_weights(self, meta: WeightUpdateMeta):
+        if not hasattr(self, "engine") or self.engine is None:
+            raise RuntimeError(
+                "Local SGLang engine is not initialized, cannot update weights."
+            )
+        if meta.type == "disk":
+            try:
+                update_name = names.update_weights_from_disk(
+                    self.config.experiment_name,
+                    self.config.trial_name,
+                    meta.model_version,
+                )
+                save_timestamp = int(name_resolve.wait(update_name, timeout=120))
+                load_timestamp = time.time_ns()
+                logger.info(
+                    f"Begin update weights from {meta.path}, responded in {(load_timestamp - save_timestamp)/1e6:.2f} ms"
+                )
+                # Update weights from disk,
+                self.engine.update_weights_from_disk(model_path=meta.path)
+
+                logger.info(
+                    f"Loading weights done in {(time.time_ns() - load_timestamp)/1e6:.2f} ms"
+                )
+                self.set_version(meta.model_version)
+            except Exception as e:
+                logger.error(f"Failed to update weights: {e}")
+                raise
+        else:
+            raise NotImplementedError(f"Unsupported weight update type: {meta.type}")
+
+    def submit(self, data: Dict[str, Any], workflow: "RolloutWorkflow") -> None:
+        try:
+            self.input_queue.put_nowait((data, workflow))
+        except Full:
+            raise RuntimeError("Input queue full. Please increase queue_size.")
+
+    def wait(self, count: int, timeout: float, should_accept: Callable) -> TensorDict:
+        tik = time.perf_counter()
+        accepted = len(self.result_cache)
+        while (
+            accepted < count
+            and not self.exiting.is_set()
+            and time.perf_counter() - tik < timeout
+        ):
+            try:
+                result = self.output_queue.get(timeout=ROLLOUT_POLL_WAIT_TIME)
+                if should_accept(result):
+                    self.result_cache.append(result)
+                    accepted += 1
+                else:
+                    with self.lock:
+                        self.rollout_stat.accepted -= 1
+            except Empty:
+                time.sleep(ROLLOUT_POLL_WAIT_TIME)
+        if self.exiting.is_set():
+            raise RuntimeError("Rollout engine is exiting, cannot wait for results.")
+        if accepted < count:
+            raise TimeoutError(
+                f"Timed out waiting for {count} rollouts, " f"only received {accepted}."
+            )
+        results, self.result_cache = (
+            self.result_cache[:count],
+            self.result_cache[count:],
+        )
+        return TensorDict.cat(results, dim=0)
+
+    def rollout(
+        self, data: List[Dict[str, Any]], workflow: "RolloutWorkflow"
+    ) -> TensorDict:
+        """Submit a batch of requests to the inference engine and wait for the results."""
+        for item in data:
+            self.submit(item, workflow)
+        return self.wait(
+            count=len(data),
+            timeout=self.config.request_timeout,
+            should_accept=lambda x: True,
+        )
diff --git a/arealite/tests/test_sglang_local_engine.py b/arealite/tests/test_sglang_local_engine.py
new file mode 100644
index 000000000..2cf4dce0b
--- /dev/null
+++ b/arealite/tests/test_sglang_local_engine.py
@@ -0,0 +1,144 @@
+# ================================================================
+# NOTE: This test file is dedicated to LocalSGLangEngine testing.
+#
+# Unlike remote engine setup which is managed via a pytest fixture,
+# the LocalSGLangEngine requires explicit `initialize()` to construct
+# the engine instance at runtime. Therefore, each test must manually
+# create and destroy the engine.
+#
+# Because of this lifecycle difference, tests for local and remote
+# engines cannot be placed in the same test file.
+# ================================================================
+import os
+import time
+import uuid
+
+import pytest
+import torch
+from tensordict import TensorDict
+
+from arealite.api.cli_args import (
+    GenerationHyperparameters,
+    InferenceEngineConfig,
+    SGLangConfig,
+)
+from arealite.api.io_struct import LLMRequest, LLMResponse
+from arealite.engine.sglang_engine import SGLangEngine
+from arealite.workflow.rlvr import RLVRWorkflow
+from realhf.api.core.data_api import load_hf_tokenizer
+from realhf.base import seeding
+
+EXPR_NAME = "test_sglang_local_engine"
+TRIAL_NAME = "trial_0"
+MODEL_PATH = "/storage/testing/models/Qwen__Qwen3-1.7B/"
+if not os.path.exists(MODEL_PATH):
+    MODEL_PATH = "Qwen/Qwen2-0.5B"
+
+
+def build_engine_config(**kwargs):
+    return InferenceEngineConfig(
+        experiment_name=EXPR_NAME,
+        trial_name=TRIAL_NAME,
+        **kwargs,
+    )
+
+
+def build_engine_args():
+    return SGLangConfig.build_args(
+        sglang_config=SGLangConfig(mem_fraction_static=0.3, enable_metrics=False),
+        model_path=MODEL_PATH,
+        tp_size=1,
+        base_gpu_id=0,
+        served_model_name=MODEL_PATH,
+        skip_tokenizer_init=False,
+    )
+
+
+@pytest.mark.asyncio
+async def test_local_sglang_generate():
+    seeding.set_random_seed(1, EXPR_NAME)
+    config = build_engine_config()
+    engine = SGLangEngine(config, engine_args=build_engine_args())
+    engine.initialize(None, None)
+
+    req = LLMRequest(
+        rid=str(uuid.uuid4()),
+        text="hello! how are you today",
+        gconfig=GenerationHyperparameters(max_new_tokens=16),
+    )
+    resp = await engine.agenerate(req)
+    print(resp.completions)
+
+    assert isinstance(resp, LLMResponse)
+    assert resp.input_tokens == req.input_ids
+    assert (
+        len(resp.output_logprobs)
+        == len(resp.output_tokens)
+        == len(resp.output_versions)
+    )
+    assert isinstance(resp.completions, str)
+
+    time.sleep(5)
+    engine.destroy()
+
+
+@pytest.mark.parametrize("n_samples", [1, 2, 4])
+def test_local_sglang_rollout(n_samples):
+    seeding.set_random_seed(1, EXPR_NAME)
+    config = build_engine_config(max_concurrent_rollouts=2, consumer_batch_size=2)
+    engine = SGLangEngine(config, engine_args=build_engine_args())
+    engine.initialize(None, None)
+
+    gconfig = GenerationHyperparameters(
+        max_new_tokens=16, greedy=False, n_samples=n_samples
+    )
+    tokenizer = load_hf_tokenizer(MODEL_PATH)
+
+    workflow = RLVRWorkflow(
+        reward_fn=lambda **kwargs: 1.0,
+        gconfig=gconfig,
+        tokenizer=tokenizer,
+    )
+
+    data = {"messages": [{"role": "user", "content": "Hello, how are you?"}]}
+    result = engine.rollout([data] * 2, workflow=workflow)
+
+    print("Here is the result ", result)
+    assert isinstance(result, TensorDict)
+    assert result.batch_size == torch.Size([2 * n_samples])
+    engine.destroy()
+
+
+@pytest.mark.parametrize("ofp", [1, 2, 4, 8, 16])
+@pytest.mark.parametrize("bs", [2, 4])
+@pytest.mark.parametrize("n_samples", [2, 1])
+def test_local_sglang_staleness_control(bs, ofp, n_samples):
+    seeding.set_random_seed(1, EXPR_NAME)
+    config = build_engine_config(consumer_batch_size=bs, max_head_offpolicyness=ofp)
+    engine = SGLangEngine(config, engine_args=build_engine_args())
+    engine.initialize(None, None)
+
+    gconfig = GenerationHyperparameters(
+        max_new_tokens=16, greedy=False, n_samples=n_samples
+    )
+    tokenizer = load_hf_tokenizer(MODEL_PATH)
+
+    workflow = RLVRWorkflow(
+        reward_fn=lambda **kwargs: 1.0,
+        gconfig=gconfig,
+        tokenizer=tokenizer,
+    )
+
+    data = {"messages": [{"role": "user", "content": "Hello, how are you?"}]}
+    for _ in range(bs * 2):
+        engine.submit(data, workflow=workflow)
+    time.sleep(5)
+    assert engine.output_queue.qsize() == min(bs * 2, bs * (ofp + 1))
+
+    engine.set_version(1)
+    for _ in range(bs * 2):
+        engine.submit(data, workflow=workflow)
+    time.sleep(5)
+    assert engine.output_queue.qsize() == min(bs * 4, bs * (ofp + 2))
+
+    engine.destroy()