From 6058e1bb29441d64d24f23bafdf5fd94b9da6336 Mon Sep 17 00:00:00 2001 From: "jagan.pp" Date: Sat, 4 Jan 2025 08:03:12 +0000 Subject: [PATCH 01/39] adding model validation and initalization --- .gitignore | 1 + __init__.py | 0 core/__init__.py | 0 core/layers/{decoder => }/decoder.py | 0 .../{model.py => translator/construe.py} | 57 ++++--- core/models/{ => translator}/decoder.py | 7 +- core/trainer/__init__.py | 0 core/trainer/utils.py | 142 ++++++++++++++++++ core/trainer/validator.py | 137 +++++++++++++++++ study/advance_pytorch.md | 131 ++++++++++++++++ 10 files changed, 447 insertions(+), 28 deletions(-) create mode 100644 .gitignore create mode 100644 __init__.py create mode 100644 core/__init__.py rename core/layers/{decoder => }/decoder.py (100%) rename core/models/{model.py => translator/construe.py} (84%) rename core/models/{ => translator}/decoder.py (94%) create mode 100644 core/trainer/__init__.py create mode 100644 core/trainer/utils.py create mode 100644 core/trainer/validator.py create mode 100644 study/advance_pytorch.md diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ba0430d --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +__pycache__/ \ No newline at end of file diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/core/__init__.py b/core/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/core/layers/decoder/decoder.py b/core/layers/decoder.py similarity index 100% rename from core/layers/decoder/decoder.py rename to core/layers/decoder.py diff --git a/core/models/model.py b/core/models/translator/construe.py similarity index 84% rename from core/models/model.py rename to core/models/translator/construe.py index e394dd3..b26aa13 100644 --- a/core/models/model.py +++ b/core/models/translator/construe.py @@ -2,7 +2,7 @@ import torch.nn.init from core.configurations.base import BaseConfiguration -from core.models.decoder import DecoderLayer +from core.models.translator.decoder import ConstrueDecoderLayer from core.layers.layer_norm import LayerNorm from core.utils.masks import _update_causal_mask from core.layers.positional_embedding.rope_projector import RopePositionEmbedding @@ -10,7 +10,7 @@ from torch import nn -class LLM(nn.Module): +class ConstrueModel(nn.Module): def __init__(self, config: BaseConfiguration): super().__init__() @@ -24,7 +24,7 @@ def __init__(self, config: BaseConfiguration): # Decoder layer stack self.decoder_layers = nn.ModuleList([ - DecoderLayer( + ConstrueDecoderLayer( config ) for _ in range(config.num_layers) @@ -35,21 +35,6 @@ def __init__(self, config: BaseConfiguration): model_dimension=config.hidden_dim ) - self.lm_head = nn.Linear( - in_features=config.hidden_dim, - out_features=config.vocabulary_size, - bias=False - ) - - self.apply(self._init_weights) - - def _init_weights(self, module): - if isinstance(module, nn.Linear): - torch.nn.init.normal_(module.weight, mean=0.0, std=0.02) - if module.bias is not None: - torch.nn.init.zeros_(module.bias) - elif isinstance(module, nn.Embedding): - torch.nn.init.normal_(module.weight, mean=0.0, std=0.02) def forward(self, input_tensor, attn_mask=None): if attn_mask is None: @@ -62,9 +47,6 @@ def forward(self, input_tensor, attn_mask=None): attention_mask=attn_mask ) - # Get token embeddings first - - last_hidden_state = () for decoder_layer in self.decoder_layers: hidden_states, _ = decoder_layer( @@ -72,17 +54,42 @@ def forward(self, input_tensor, attn_mask=None): causal_mask ) - if hidden_states is not None and hidden_states.numel() > 0: - last_hidden_state = hidden_states - hidden_states = self.final_layer_norm(hidden_states) + return hidden_states + + + +class ConstrueAutoRegressiveModel(nn.Module): + def __init__(self, config: BaseConfiguration): + super().__init__() + self.config = config + self.model = ConstrueModel(config) + self.lm_head = nn.Linear( + in_features=config.hidden_dim, + out_features=config.vocabulary_size, + bias=False + ) + + self.apply(self._init_weights) + + def _init_weights(self, module): + if isinstance(module, nn.Linear): + torch.nn.init.normal_(module.weight, mean=0.0, std=0.02) + if module.bias is not None: + torch.nn.init.zeros_(module.bias) + elif isinstance(module, nn.Embedding): + torch.nn.init.normal_(module.weight, mean=0.0, std=0.02) + + + def forward(self, input_tensor, attn_mask=None): + hidden_states = self.model(input_tensor, attn_mask) logits = self.lm_head(hidden_states) if self.config.output_last_hidden_state: return { "logits": logits, - "last_hidden_state": last_hidden_state + "last_hidden_state": hidden_states } return { diff --git a/core/models/decoder.py b/core/models/translator/decoder.py similarity index 94% rename from core/models/decoder.py rename to core/models/translator/decoder.py index ec0f347..33764bc 100644 --- a/core/models/decoder.py +++ b/core/models/translator/decoder.py @@ -4,14 +4,15 @@ from core.configurations.base import BaseConfiguration from core.layers.attention import RopeAttention +from core.layers.decoder import DecoderLayer from core.layers.layer_norm import LayerNorm from core.layers.point_wise_projection import PointWiseGatedProjection from core.utils.masks import _update_causal_mask -class DecoderLayer(nn.Module): +class ConstrueDecoderLayer(nn.Module): def __init__(self, base_cfg: BaseConfiguration): - super(DecoderLayer, self).__init__() + super().__init__() self.input_norm = LayerNorm(model_dimension=base_cfg.hidden_dim) self.self_attn = RopeAttention( @@ -28,7 +29,7 @@ def forward(self, hidden_state, attention_mask, output_attentions=False): """ https://arxiv.org/pdf/2002.04745 (PRE-Norm) - + x = embedding of each tokens (B x S x D) mask = self_attention autput (B x S x D) diff --git a/core/trainer/__init__.py b/core/trainer/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/core/trainer/utils.py b/core/trainer/utils.py new file mode 100644 index 0000000..876e6b3 --- /dev/null +++ b/core/trainer/utils.py @@ -0,0 +1,142 @@ +from typing import Callable, Dict, Optional +import torch +import torch.nn as nn + + + +def get_initializer( + init_type: str, + activation: Optional[str] = None, + embedding_init: Optional[str] = None, + **kwargs +) -> Callable: + """ + Returns a weight initialization function based on the specified type. + + Args: + init_type: Type of initialization ('xavier', 'kaiming', 'normal', 'uniform', 'orthogonal') + activation: Activation function used after the layer ('relu', 'leaky_relu', 'tanh', etc.) + embedding_init: Special initialization for embedding layers ('normal', 'uniform', 'xavier', None) + **kwargs: Additional arguments for the initialization function + - embedding_mean: Mean for normal embedding initialization (default: 0.0) + - embedding_std: Std for normal embedding initialization (default: 0.02) + - embedding_padding_idx: Index for padding token + + Returns: + Callable that initializes network parameters + """ + + + def init_embedding_weights(embedding_layer: nn.Embedding, method: str) -> None: + padding_idx = kwargs.get('embedding_padding_idx', None) + + if method == 'normal': + mean = kwargs.get('embedding_mean', 0.0) + std = kwargs.get('embedding_std', 0.02) + nn.init.normal_(embedding_layer.weight, mean=mean, std=std) + elif method == 'uniform': + bound = kwargs.get('embedding_bound', 0.05) + nn.init.uniform_(embedding_layer.weight, -bound, bound) + elif method == 'xavier': + nn.init.xavier_uniform_(embedding_layer.weight) + + # Zero out padding token embeddings if padding_idx is specified + if padding_idx is not None: + with torch.no_grad(): + embedding_layer.weight[padding_idx].fill_(0) + + + def xavier_init(m: nn.Module) -> None: + if isinstance(m, (nn.Linear, nn.Conv2d)): + if activation in ['relu', 'leaky_relu']: + gain = nn.init.calculate_gain('leaky_relu' if activation == 'leaky_relu' else 'relu') + else: + gain = nn.init.calculate_gain('tanh') + + nn.init.xavier_uniform_(m.weight, gain=gain) + if m.bias is not None: + nn.init.zeros_(m.bias) + elif isinstance(m, nn.Embedding) and embedding_init: + init_embedding_weights(m, embedding_init) + + + def kaiming_init(m: nn.Module) -> None: + if isinstance(m, (nn.Linear, nn.Conv2d)): + mode = kwargs.get('mode', 'fan_in') + nonlinearity = activation if activation else 'relu' + + nn.init.kaiming_normal_(m.weight, mode=mode, nonlinearity=nonlinearity) + if m.bias is not None: + nn.init.zeros_(m.bias) + elif isinstance(m, nn.Embedding) and embedding_init: + init_embedding_weights(m, embedding_init) + + def normal_init(m: nn.Module) -> None: + if isinstance(m, (nn.Linear, nn.Conv2d)): + mean = kwargs.get('mean', 0.0) + std = kwargs.get('std', 0.02) + + nn.init.normal_(m.weight, mean=mean, std=std) + if m.bias is not None: + nn.init.zeros_(m.bias) + elif isinstance(m, nn.Embedding) and embedding_init: + init_embedding_weights(m, embedding_init) + + def uniform_init(m: nn.Module) -> None: + if isinstance(m, (nn.Linear, nn.Conv2d)): + a = kwargs.get('a', -0.05) + b = kwargs.get('b', 0.05) + + nn.init.uniform_(m.weight, a=a, b=b) + if m.bias is not None: + nn.init.zeros_(m.bias) + elif isinstance(m, nn.Embedding) and embedding_init: + init_embedding_weights(m, embedding_init) + + def orthogonal_init(m: nn.Module) -> None: + if isinstance(m, (nn.Linear, nn.Conv2d)): + gain = kwargs.get('gain', 1.0) + + nn.init.orthogonal_(m.weight, gain=gain) + if m.bias is not None: + nn.init.zeros_(m.bias) + elif isinstance(m, nn.Embedding) and embedding_init: + init_embedding_weights(m, embedding_init) + + initializers: Dict[str, Callable] = { + 'xavier': xavier_init, + 'kaiming': kaiming_init, + 'normal': normal_init, + 'uniform': uniform_init, + 'orthogonal': orthogonal_init + } + + if init_type not in initializers: + raise ValueError(f"Initialization type '{init_type}' not supported. " + f"Choose from {list(initializers.keys())}") + + return initializers[init_type] + + + +if __name__ == "__main__": + class SimpleNet(nn.Module): + def __init__(self, input_size: int, hidden_size: int, output_size: int): + super().__init__() + self.embedding = nn.Embedding(19, 100) + self.layer1 = nn.Linear(input_size, hidden_size) + self.layer2 = nn.Linear(hidden_size, output_size) + + def forward(self, x): + x = torch.relu(self.layer1(x)) + return self.layer2(x) + + # Initialize network with different strategies + model = SimpleNet(10, 20, 2) + + # Using xavier initialization with ReLU + xavier_init = get_initializer('xavier', activation='relu', embedding_init="normal") + model.apply(xavier_init) + + + diff --git a/core/trainer/validator.py b/core/trainer/validator.py new file mode 100644 index 0000000..d43cf87 --- /dev/null +++ b/core/trainer/validator.py @@ -0,0 +1,137 @@ +import torch +import torch.nn as nn +import numpy as np +from typing import Dict, Any +import matplotlib.pyplot as plt +from core.trainer.utils import get_initializer + +def validate_initialization(model: nn.Module, layer_type: str = None) -> Dict[str, Any]: + """ + Test weight initialization properties of a model. + + Args: + model: PyTorch model to test + layer_type: Optional filter for specific layer type (e.g., 'Linear', 'Conv2d', 'Embedding') + + Returns: + Dict containing test results + """ + stats = { + 'mean': [], + 'std': [], + 'min': [], + 'max': [], + 'near_zero': [], + 'layer_names': [] + } + + def analyze_weights(module: nn.Module, name: str): + if hasattr(module, 'weight'): + if layer_type is None or module.__class__.__name__ == layer_type: + weights = module.weight.data.cpu().numpy() + stats['mean'].append(np.mean(weights)) + stats['std'].append(np.std(weights)) + stats['min'].append(np.min(weights)) + stats['max'].append(np.max(weights)) + stats['near_zero'].append( + np.mean(np.abs(weights) < 1e-6) + ) + stats['layer_names'].append(name) + + # Analyze each layer + for name, module in model.named_modules(): + analyze_weights(module, name) + + return stats + + + +def validate_embedding_padding(model: nn.Module, padding_idx: int = None) -> bool: + """ + Test if embedding padding is correctly initialized to zero. + """ + for module in model.modules(): + if isinstance(module, nn.Embedding): + if padding_idx is not None: + padding_weights = module.weight.data[padding_idx].cpu().numpy() + return np.allclose(padding_weights, 0) + return False + + + +def validate_activation_variance(model: nn.Module, input_size: tuple, n_samples: int = 1000): + """ + Test if the variance of activations is maintained across layers. + """ + model.eval() + activations = {} + + # Hook to capture activations + def hook_fn(name): + def hook(module, input, output): + activations[name] = output.detach() + return hook + + # Register hooks for each layer + handles = [] + for name, module in model.named_modules(): + if isinstance(module, (nn.Linear, nn.Conv2d)): + handles.append(module.register_forward_hook(hook_fn(name))) + + # Generate random input + x = torch.randn(n_samples, *input_size) + x = x.long() + x = torch.abs(x) + + # Forward pass + with torch.no_grad(): + model(x) + + # Compute variance of activations + variances = {name: act.var().item() for name, act in activations.items()} + + # Clean up hooks + for handle in handles: + handle.remove() + + return variances + + +def validate_model_initial_states(model, config, input_size, n_samples): + stats = validate_initialization(model=model) + + print("\nInitialization Statistics:") + for i, layer in enumerate(stats['layer_names']): + print(f"\n{layer}:") + print(f"Mean: {stats['mean'][i]:.6f}") + print(f"Std: {stats['std'][i]:.6f}") + print(f"Min: {stats['min'][i]:.6f}") + print(f"Max: {stats['max'][i]:.6f}") + print(f"Near zero: {stats['near_zero'][i]:.2%}") + + assert validate_embedding_padding(model=model, padding_idx=config.padding_id), "Validation of padding index failed" + + variances = validate_activation_variance(model=model, input_size=input_size, n_samples=n_samples) + + print("\nActivation Variances:") + for layer, var in variances.items(): + print(f"{layer}: {var:.6f}") + + +from core.models.translator.construe import ConstrueAutoRegressiveModel +from core.configurations.base import BaseConfiguration + +config = BaseConfiguration(model_name="small_lm", num_layers=2, hidden_dim=128, intermediate_dim=512, + max_positions=256, vocabulary_size=64000, num_heads=2, attention_dropout=0.05, + batch_size=8, weight_decay=0.01, + learning_rate=5e-4, + tokenizer_path="/workspace/vipin_g6/personal/pretraining/english_tokenizer/english_tokenizer.model", + dataset_batch_size=16, dataset_shuffle=True, num_epochs=2, eval_frequency=1, + eval_iter=10, + model_max_sequence=256) + +model = ConstrueAutoRegressiveModel(config=config) +initalizer = get_initializer(init_type="xavier", activation="relu", embedding_init="xavier", embedding_padding_idx=config.padding_id) + +model.apply(initalizer) +validate_model_initial_states(model, config, (10, ), n_samples=1000) \ No newline at end of file diff --git a/study/advance_pytorch.md b/study/advance_pytorch.md new file mode 100644 index 0000000..de5597f --- /dev/null +++ b/study/advance_pytorch.md @@ -0,0 +1,131 @@ +## Weight Intialization Advanced +`calculate_gain` in PyTorch is used to compute the recommended scaling factor (gain) for weight initialization based on the activation function. This gain helps maintain proper variance of activations throughout the network, preventing issues like vanishing or exploding gradients. + +Here's how it works: + +```python +import torch.nn as nn + +# Different gains for different activations +linear_gain = nn.init.calculate_gain('linear') # = 1 +tanh_gain = nn.init.calculate_gain('tanh') # ≈ 5/3 +relu_gain = nn.init.calculate_gain('relu') # = √2 +leaky_relu_gain = nn.init.calculate_gain('leaky_relu', negative_slope=0.2) # ≈ √2 +``` + +The recommended gains for different activations are: +- Linear/Identity: 1.0 +- Tanh: 5/3 +- ReLU: √2 ≈ 1.414 +- LeakyReLU: √2/√(1 + slope²) +- SELU: 1.0 +- Sigmoid: 1.0 + +These gains are derived mathematically to preserve the variance of the activations. For example: +1. With ReLU, about half the values become 0, so we multiply by √2 to maintain the variance +2. For tanh, the 5/3 factor compensates for the compression of values to [-1, 1] + +Here's a practical example: + +```python +def initialize_layer(layer, activation='relu'): + # Calculate appropriate gain + gain = nn.init.calculate_gain(activation) + + # Apply Xavier initialization with the calculated gain + nn.init.xavier_uniform_(layer.weight, gain=gain) + if layer.bias is not None: + nn.init.zeros_(layer.bias) + +# Usage +layer = nn.Linear(100, 100) +initialize_layer(layer, activation='relu') # Will use gain = √2 +``` + +The gain is particularly important when using Xavier/Glorot initialization because it helps ensure that the network starts with weights that are well-suited for the chosen activation function. This leads to better training dynamics and faster convergence. + + +## Hooks in Pytorch +A hook in PyTorch is a function that can be registered to a layer/module to track or modify its input/output during forward/backward passes. Hooks are incredibly useful for debugging, monitoring, or modifying layer behavior without changing the model code. + +There are three main types of hooks: + +1. Forward Hooks (`register_forward_hook`): +```python +def forward_hook(module, input, output): + print(f"Output shape: {output.shape}") + +layer = nn.Linear(10, 5) +# Register the hook +handle = layer.register_forward_hook(forward_hook) +``` + +2. Forward Pre Hooks (`register_forward_pre_hook`): +```python +def forward_pre_hook(module, input): + print(f"Input shape: {input[0].shape}") + return input # Can modify input if needed + +layer.register_forward_pre_hook(forward_pre_hook) +``` + +3. Backward Hooks (`register_backward_hook`): +```python +def backward_hook(module, grad_input, grad_output): + print(f"Gradient shape: {grad_output[0].shape}") + +layer.register_backward_hook(backward_hook) +``` + +Here's a practical example showing common use cases: + +```python +import torch +import torch.nn as nn + +class SimpleModel(nn.Module): + def __init__(self): + super().__init__() + self.fc1 = nn.Linear(10, 5) + self.fc2 = nn.Linear(5, 2) + + def forward(self, x): + x = torch.relu(self.fc1(x)) + return self.fc2(x) + +# Create model +model = SimpleModel() + +# Store activations +activations = {} +def get_activation(name): + def hook(module, input, output): + activations[name] = output.detach() + return hook + +# Register hooks +model.fc1.register_forward_hook(get_activation('fc1')) +model.fc2.register_forward_hook(get_activation('fc2')) + +# Run model +x = torch.randn(1, 10) +output = model(x) + +# Print activations +for name, activation in activations.items(): + print(f"{name} activation shape:", activation.shape) +``` + +Common use cases for hooks: +1. Feature extraction: Capture intermediate layer outputs +2. Debugging: Monitor gradients and activations +3. Visualization: Track layer activations for visualization +4. Gradient clipping: Modify gradients during backpropagation +5. Layer output modification: Change outputs without modifying the layer + +Important points: +- Hooks return a handle that can be used to remove them later: `handle.remove()` +- Forward hooks can't modify outputs (use pre-hooks for input modification) +- Hooks should be lightweight to avoid performance impact +- Hooks are called in the order they were registered +- Be careful with memory when storing activations in hooks From 2c987cdea35791b9cd04a4ae28e0edb76f325a8b Mon Sep 17 00:00:00 2001 From: "jagan.pp" Date: Sat, 4 Jan 2025 08:59:13 +0000 Subject: [PATCH 02/39] have to validate the model --- core/layers/attention.py | 6 +++--- core/models/translator/decoder.py | 13 +++++-------- core/trainer/validator.py | 17 ++++++++++++++--- 3 files changed, 22 insertions(+), 14 deletions(-) diff --git a/core/layers/attention.py b/core/layers/attention.py index 3b99945..332592b 100644 --- a/core/layers/attention.py +++ b/core/layers/attention.py @@ -64,7 +64,7 @@ def forward(self, input_tensor, attention_mask, output_attentions=False): if self.use_rope: cos, sin = self.rope_position_projection(query_state) # B x S x D - query_state, value_state = apply_positional_embedding(query_state, value_state, cos, sin) + query_state, key_state = apply_positional_embedding(query_state, key_state, cos, sin) attn_weights = torch.matmul(query_state, key_state.transpose(2, 3)) * self.scaling @@ -72,13 +72,13 @@ def forward(self, input_tensor, attention_mask, output_attentions=False): if attention_mask.dim() == 3: attention_mask = attention_mask.unsqueeze(1) # Add num_heads dimension attention_mask = attention_mask[:, :, :, :key_state.shape[-2]] # B x H x Q_s x K_s - attn_weights = attn_weights * attention_mask + attn_weights = attn_weights + attention_mask attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_state.dtype) + attn_weights = nn.functional.dropout(attn_weights, p=self.attention_dropout, training=self.training) attn_output = torch.matmul(attn_weights, value_state) - if attn_output.size() != (b_size, self.num_heads, seq_len, self.head_dim): raise ValueError( f"`attn_output` should be of size {(b_size, self.num_heads, seq_len, self.head_dim)}, but is" diff --git a/core/models/translator/decoder.py b/core/models/translator/decoder.py index 33764bc..40ada42 100644 --- a/core/models/translator/decoder.py +++ b/core/models/translator/decoder.py @@ -43,20 +43,17 @@ def forward(self, hidden_state, attention_mask, output_attentions=False): residual_x = hidden_state hidden_state = self.input_norm(hidden_state) - - hidden_states, self_attn_weights = self.self_attn( + hidden_state, self_attn_weights = self.self_attn( input_tensor=hidden_state, attention_mask=attention_mask, output_attentions=output_attentions, ) + hidden_state = self.attention_dropout(hidden_state) + hidden_state = residual_x + hidden_state - hidden_states = self.attention_dropout(hidden_states) - - hidden_states = residual_x + hidden_states - - residual_x = hidden_states + residual_x = hidden_state - hidden_state = self.post_attention_norm(hidden_states) + hidden_state = self.post_attention_norm(hidden_state) hidden_state = self.mlp(hidden_state) hidden_state = self.dropout2(hidden_state) hidden_state = residual_x + hidden_state diff --git a/core/trainer/validator.py b/core/trainer/validator.py index d43cf87..727a2c6 100644 --- a/core/trainer/validator.py +++ b/core/trainer/validator.py @@ -5,6 +5,8 @@ import matplotlib.pyplot as plt from core.trainer.utils import get_initializer +torch.autograd.detect_anomaly(True) + def validate_initialization(model: nn.Module, layer_type: str = None) -> Dict[str, Any]: """ Test weight initialization properties of a model. @@ -72,11 +74,20 @@ def hook(module, input, output): activations[name] = output.detach() return hook + + def nan_wrap(name): + def detect_nan_hook(module, input, output): + """Hook to detect NaN values in module outputs.""" + if torch.isnan(output).any(): + print(f"NaN detected in {name}") + return detect_nan_hook + # Register hooks for each layer handles = [] for name, module in model.named_modules(): if isinstance(module, (nn.Linear, nn.Conv2d)): handles.append(module.register_forward_hook(hook_fn(name))) + module.register_forward_hook(nan_wrap(name)) # Generate random input x = torch.randn(n_samples, *input_size) @@ -109,7 +120,7 @@ def validate_model_initial_states(model, config, input_size, n_samples): print(f"Max: {stats['max'][i]:.6f}") print(f"Near zero: {stats['near_zero'][i]:.2%}") - assert validate_embedding_padding(model=model, padding_idx=config.padding_id), "Validation of padding index failed" + # assert validate_embedding_padding(model=model, padding_idx=config.padding_id), "Validation of padding index failed" variances = validate_activation_variance(model=model, input_size=input_size, n_samples=n_samples) @@ -121,7 +132,7 @@ def validate_model_initial_states(model, config, input_size, n_samples): from core.models.translator.construe import ConstrueAutoRegressiveModel from core.configurations.base import BaseConfiguration -config = BaseConfiguration(model_name="small_lm", num_layers=2, hidden_dim=128, intermediate_dim=512, +config = BaseConfiguration(model_name="small_lm", num_layers=2, hidden_dim=32, intermediate_dim=512, max_positions=256, vocabulary_size=64000, num_heads=2, attention_dropout=0.05, batch_size=8, weight_decay=0.01, learning_rate=5e-4, @@ -131,7 +142,7 @@ def validate_model_initial_states(model, config, input_size, n_samples): model_max_sequence=256) model = ConstrueAutoRegressiveModel(config=config) -initalizer = get_initializer(init_type="xavier", activation="relu", embedding_init="xavier", embedding_padding_idx=config.padding_id) +initalizer = get_initializer(init_type="kaiming", activation="relu", embedding_init="kaiming", embedding_padding_idx=config.padding_id) model.apply(initalizer) validate_model_initial_states(model, config, (10, ), n_samples=1000) \ No newline at end of file From 98a896566203779df9b88f57247fa05d38f1cca8 Mon Sep 17 00:00:00 2001 From: "jagan.pp" Date: Sat, 4 Jan 2025 16:35:51 +0000 Subject: [PATCH 03/39] model execution adjustments --- core/layers/attention.py | 147 ++- core/layers/decoder.py | 61 -- core/layers/layer_norm.py | 19 +- .../positional_embedding/rope_projector.py | 23 +- core/models/translator/construe.py | 76 +- core/models/translator/decoder.py | 2 - core/trainer/validator.py | 34 +- core/utils/masks.py | 79 +- study/transformers.ipynb | 932 ++++++++++++++++++ 9 files changed, 1135 insertions(+), 238 deletions(-) delete mode 100644 core/layers/decoder.py create mode 100644 study/transformers.ipynb diff --git a/core/layers/attention.py b/core/layers/attention.py index 332592b..fefb74b 100644 --- a/core/layers/attention.py +++ b/core/layers/attention.py @@ -1,15 +1,21 @@ +from typing import Optional, Tuple from core.configurations.base import BaseConfiguration from core.layers.positional_embedding.rope_projector import RopePositionEmbedding from core.layers.positional_embedding.rope_projector import apply_positional_embedding from torch import nn +import torch.nn.functional as F import torch import math class RopeAttention(nn.Module): + """ + Implements attention mechanism with Rotary Position Embedding (RoPE). + """ + def __init__(self, config: BaseConfiguration): - super(RopeAttention, self).__init__() + super().__init__() assert config.head_dim is not None if config.hidden_dim % config.head_dim != 0: raise ValueError( @@ -17,80 +23,115 @@ def __init__(self, config: BaseConfiguration): f" and `num_heads`: {self.num_heads})." ) + self.config = config self.attention_dropout = config.attention_dropout - self.head_dim = config.head_dim self.hidden_dim = config.hidden_dim self.num_heads = config.num_heads + self.head_dim = config.head_dim self.scaling = 1 / math.sqrt(config.head_dim) + # Initialize RoPE if enabled self.use_rope = config.use_rope - - if config.use_rope: + if self.use_rope: self.rope_position_projection = RopePositionEmbedding( - hidden_dim=self.head_dim, + hidden_dim=config.head_dim, max_positions=config.max_positions, base=config.rope_base ) - self.query_projection = nn.Linear( - in_features=config.hidden_dim, - out_features=config.hidden_dim, - bias=False) - self.key_projection = nn.Linear( - in_features=config.hidden_dim, - out_features=config.hidden_dim, - bias=False) - self.value_projection = nn.Linear( - in_features=config.hidden_dim, - out_features=config.hidden_dim, - bias=False) - - self.output_projection = nn.Linear(in_features=config.hidden_dim, - out_features=config.hidden_dim, - bias=False) - - def forward(self, input_tensor, attention_mask, output_attentions=False): - b_size, seq_len, _ = input_tensor.shape - - query_state = self.query_projection(input_tensor) # [B * S * D] - key_state = self.key_projection(input_tensor) # [B * S * D] - value_state = self.value_projection(input_tensor) # [B * S * D] - - query_state = query_state.view(b_size, seq_len, self.num_heads, self.head_dim).transpose(1, - 2) # [B * H * S * D] - key_state = key_state.view(b_size, seq_len, self.num_heads, self.head_dim).transpose(1, 2) # [B * H * S * D] - value_state = value_state.view(b_size, seq_len, self.num_heads, self.head_dim).transpose(1, - 2) # [B * H * S * D] - + # Initialize projection layers + self.qkv_projection = nn.Linear( + config.hidden_dim, + 3 * config.hidden_dim, + bias=False + ) + + self.output_projection = nn.Linear( + config.hidden_dim, + config.hidden_dim, + bias=False + ) + + def forward( + self, + input_tensor: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + positions: Optional[torch.Tensor] = None, + output_attentions: bool = False + ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]: + """ + Forward pass for RoPE attention. + + Args: + input_tensor: Input tensor [batch_size, seq_len, hidden_dim] + attention_mask: Optional attention mask [batch_size, seq_len] + positions: Optional position indices + output_attentions: Whether to return attention weights + + Returns: + Tuple of (output tensor, optional attention weights) + """ + if input_tensor.dim() != 3: + raise ValueError(f"Expected 3D input, got {input_tensor.dim()}D") + + batch_size, seq_length, _ = input_tensor.shape + + # Fused QKV projection + qkv = self.qkv_projection(input_tensor) + qkv = qkv.view(batch_size, seq_length, 3, self.num_heads, self.head_dim) + qkv = qkv.permute(2, 0, 3, 1, 4) # [3, batch_size, num_heads, seq_len, head_dim] + query_states, key_states, value_states = qkv + + # Apply RoPE if enabled if self.use_rope: - cos, sin = self.rope_position_projection(query_state) # B x S x D - query_state, key_state = apply_positional_embedding(query_state, key_state, cos, sin) + cos, sin = self.rope_position_projection(query_states) + query_states, key_states = apply_positional_embedding( + query_states, key_states, cos, sin + ) - attn_weights = torch.matmul(query_state, key_state.transpose(2, 3)) * self.scaling + # Compute attention scores with improved numerical stability + attn_weights = torch.matmul(query_states, key_states.transpose(-2, -1)) + attn_weights = attn_weights * self.scaling + # Apply attention mask if provided if attention_mask is not None: + # Convert mask to proper dtype + attention_mask = attention_mask.to(dtype=query_states.dtype) + + # Add head dimension if needed if attention_mask.dim() == 3: - attention_mask = attention_mask.unsqueeze(1) # Add num_heads dimension - attention_mask = attention_mask[:, :, :, :key_state.shape[-2]] # B x H x Q_s x K_s - attn_weights = attn_weights + attention_mask + attention_mask = attention_mask.unsqueeze(1) + + # Ensure proper sequence length + attention_mask = attention_mask[:, :, :, :key_states.shape[-2]] - attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_state.dtype) + attn_weights = attn_weights + attention_mask - attn_weights = nn.functional.dropout(attn_weights, p=self.attention_dropout, training=self.training) + # Compute attention probabilities with improved numerical stability + attn_weights_float = F.softmax(attn_weights, dim=-1, dtype=torch.float32) + attn_weights = attn_weights_float.to(query_states.dtype) + + # Apply dropout during training + if self.training: + attn_weights = F.dropout( + attn_weights, + p=self.attention_dropout, + training=True + ) - attn_output = torch.matmul(attn_weights, value_state) - if attn_output.size() != (b_size, self.num_heads, seq_len, self.head_dim): + # Compute attention output + attn_output = torch.matmul(attn_weights, value_states) + + # Validate output shape + expected_shape = (batch_size, self.num_heads, seq_length, self.head_dim) + if attn_output.shape != expected_shape: raise ValueError( - f"`attn_output` should be of size {(b_size, self.num_heads, seq_len, self.head_dim)}, but is" - f" {attn_output.size()}" + f"Expected output shape {expected_shape}, got {attn_output.shape}" ) + # Reshape output and apply output projection attn_output = attn_output.transpose(1, 2).contiguous() - - attn_output = attn_output.view(b_size, seq_len, -1) + attn_output = attn_output.view(batch_size, seq_length, self.hidden_dim) attn_output = self.output_projection(attn_output) - if not output_attentions: - attn_weights = None - - return attn_output, attn_weights + return attn_output, (attn_weights if output_attentions else None) diff --git a/core/layers/decoder.py b/core/layers/decoder.py deleted file mode 100644 index 7ff0290..0000000 --- a/core/layers/decoder.py +++ /dev/null @@ -1,61 +0,0 @@ -"""Decoder Module implementation""" - -from torch import nn - -from core.configurations.base import BaseConfiguration -from core.layers.attention import RopeAttention -from core.layers.layer_norm import LayerNorm -from core.layers.point_wise_projection import PointWiseGatedProjection -from core.utils.masks import _update_causal_mask - - -class DecoderLayer(nn.Module): - def __init__(self, base_cfg: BaseConfiguration): - super(DecoderLayer, self).__init__() - - self.input_norm = LayerNorm(model_dimension=base_cfg.hidden_dim) - self.self_attn = RopeAttention( - config=base_cfg - ) - self.attention_dropout = nn.Dropout(p=base_cfg.attention_dropout) - - self.post_attention_norm = LayerNorm(model_dimension=base_cfg.hidden_dim) - self.mlp = PointWiseGatedProjection(config=base_cfg) - self.dropout2 = nn.Dropout(p=base_cfg.attention_dropout) - - - def forward(self, hidden_state, attention_mask, output_attentions=False): - """ - https://arxiv.org/pdf/2002.04745 (PRE-Norm) - - - x = embedding of each tokens (B x S x D) - mask = self_attention autput (B x S x D) - - Self-attention sub-block 1 - x => norm(x) => n_x => att(n_x) => (a_x, a_score) => a_x + x => h_x - - MLP sub-block: 2 - - h_x => norm(h_x) => n_hx => mlp(n_hx) => n_x => x_x + h_x => h_x - """ - residual_x = hidden_state - - hidden_state = self.input_norm(hidden_state) - - hidden_states, self_attn_weights = self.self_attn( - input_tensor=hidden_state, - attention_mask=attention_mask, - output_attentions=output_attentions, - ) - hidden_states = self.attention_dropout(hidden_states) - hidden_states = residual_x + hidden_state - # point forward inner bloc - residual_x = hidden_state - - hidden_state = self.post_attention_norm(hidden_states) - hidden_state = self.mlp(hidden_state) - hidden_state = self.dropout2(hidden_state) - hidden_state = residual_x + hidden_state - return hidden_state, self_attn_weights - diff --git a/core/layers/layer_norm.py b/core/layers/layer_norm.py index e0da0e1..260d6ee 100644 --- a/core/layers/layer_norm.py +++ b/core/layers/layer_norm.py @@ -1,16 +1,21 @@ """Implementing Layer Norm""" +import numbers import torch from torch import nn +import torch.nn.functional as F class LayerNorm(nn.Module): """ Class the contains LayerNorm This is same as transformers implementation """ - def __init__(self, model_dimension, epsilon=1e-12): + def __init__(self, model_dimension, epsilon=0.00001): super(LayerNorm, self).__init__() - + if isinstance(model_dimension, numbers.Integral): + # mypy error: incompatible types in assignment + model_dimension = (model_dimension,) + self.model_dimension = model_dimension self.gamma = nn.Parameter(torch.ones(model_dimension)) self.beta = nn.Parameter(torch.zeros(model_dimension)) self.epsilon = epsilon @@ -19,11 +24,7 @@ def __init__(self, model_dimension, epsilon=1e-12): def forward(self, x): if isinstance(x, tuple): x = x[0] - mean = x.mean(-1, keepdim=True) - variance = x.var(-1, unbiased=False, keepdim=True) - - # Layer normalization computation - output = (x - mean) / torch.sqrt(variance + self.epsilon) - output = self.gamma * output + self.beta - return output + return F.layer_norm( + x, self.model_dimension, self.gamma, self.beta, self.epsilon + ) diff --git a/core/layers/positional_embedding/rope_projector.py b/core/layers/positional_embedding/rope_projector.py index f3798b1..aff703d 100644 --- a/core/layers/positional_embedding/rope_projector.py +++ b/core/layers/positional_embedding/rope_projector.py @@ -24,17 +24,34 @@ class RopePositionEmbedding(nn.Module): def __init__(self, hidden_dim, max_positions, base): super().__init__() self.hidden_dim = hidden_dim + self.max_positions = max_positions self.base = base + rotatory_matrix = self._get_cache_rotatory_matrix( + max_positions=self.max_positions, + hidden_dim=self.hidden_dim, + base=self.base + ) + self.register_buffer("rotatory_matrix", tensor=rotatory_matrix, persistent=False) + + + def _get_cache_rotatory_matrix(self, max_positions, + hidden_dim, + base: int = None): + + if base is None: + base = 10000 + positions = torch.arange(max_positions, dtype=torch.float32) angular_freq = 1.0 / ( - self.base ** (torch.arange(0, self.hidden_dim, 2, dtype=torch.int64).float() / self.hidden_dim) + base ** (torch.arange(0, hidden_dim, 2, dtype=torch.int64).float() / hidden_dim) ) angular_freq = angular_freq.float().unsqueeze(0) # 1 x D/2 positions = positions.unsqueeze(1) # S x 1 rotatory_matrix = positions @ angular_freq # S x D/2 + return rotatory_matrix + - self.register_buffer("rotatory_matrix", tensor=rotatory_matrix, persistent=False) @torch.no_grad() def forward(self, x): @@ -53,4 +70,4 @@ def forward(self, x): cos = emb.cos() # B x S x D sin = emb.sin() # B x S x D - return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype) # B x S x D \ No newline at end of file + return cos.to(dtype=x.dtype), sin.to(dtype=x.dtype) # B x S x D diff --git a/core/models/translator/construe.py b/core/models/translator/construe.py index b26aa13..71e4b74 100644 --- a/core/models/translator/construe.py +++ b/core/models/translator/construe.py @@ -4,7 +4,7 @@ from core.configurations.base import BaseConfiguration from core.models.translator.decoder import ConstrueDecoderLayer from core.layers.layer_norm import LayerNorm -from core.utils.masks import _update_causal_mask +from core.utils.masks import create_causal_mask from core.layers.positional_embedding.rope_projector import RopePositionEmbedding from torch import nn @@ -35,28 +35,34 @@ def __init__(self, config: BaseConfiguration): model_dimension=config.hidden_dim ) - - def forward(self, input_tensor, attn_mask=None): + def forward(self, input_tensor, attn_mask=None, output_attentions=False, output_hidden_states=False): if attn_mask is None: attn_mask = torch.ones_like(input_tensor) hidden_states = self.token_embeddings(input_tensor) - - causal_mask = _update_causal_mask( - input_tensor=hidden_states, - attention_mask=attn_mask + causal_mask = create_causal_mask( + attention_mask=attn_mask, + shape=input_tensor.shape, + dtype=hidden_states.dtype, + device=hidden_states.device ) - + output_attentions_weights = (hidden_states) + layers_hidden_states = () for decoder_layer in self.decoder_layers: - hidden_states, _ = decoder_layer( + hidden_states, attention_weight = decoder_layer( hidden_states, - causal_mask + causal_mask, + output_attentions=output_attentions ) + if output_hidden_states: + layers_hidden_states += (hidden_states, ) + if output_attentions: + output_attentions_weights += (attention_weight,) hidden_states = self.final_layer_norm(hidden_states) - return hidden_states + return hidden_states, (output_attentions_weights if output_attentions else None), (layers_hidden_states if output_hidden_states else None) @@ -71,48 +77,14 @@ def __init__(self, config: BaseConfiguration): bias=False ) - self.apply(self._init_weights) - - def _init_weights(self, module): - if isinstance(module, nn.Linear): - torch.nn.init.normal_(module.weight, mean=0.0, std=0.02) - if module.bias is not None: - torch.nn.init.zeros_(module.bias) - elif isinstance(module, nn.Embedding): - torch.nn.init.normal_(module.weight, mean=0.0, std=0.02) - - - def forward(self, input_tensor, attn_mask=None): - hidden_states = self.model(input_tensor, attn_mask) - logits = self.lm_head(hidden_states) - if self.config.output_last_hidden_state: - return { - "logits": logits, - "last_hidden_state": hidden_states - } + def forward(self, input_tensor, attn_mask=None, output_attentions=False, output_hidden_states=False): + last_hidden_state, output_attention_weights, hidden_states = self.model(input_tensor, attn_mask) + logits = self.lm_head(last_hidden_state) return { - "logits": logits + "logits": logits, + "last_hidden_state": last_hidden_state, + "attention_map": output_attention_weights if output_attentions else None, + "hidden_states": hidden_states if output_hidden_states else None } - - def generate(self, input_ids, max_length=100, temperature=1.0): - with torch.no_grad(): - for _ in range(max_length): - output = self.forward(input_ids) - - # Next token logits - next_token_logits = output[:, -1, :] / temperature - - # Sample next token - next_token = torch.multinomial( - torch.softmax(next_token_logits, dim=-1), - num_samples=1 - ) - - input_ids = torch.cat([input_ids, next_token], dim=-1) - - if next_token.item() == self.config.padding_id: - break - - return input_ids \ No newline at end of file diff --git a/core/models/translator/decoder.py b/core/models/translator/decoder.py index 40ada42..8649f66 100644 --- a/core/models/translator/decoder.py +++ b/core/models/translator/decoder.py @@ -4,10 +4,8 @@ from core.configurations.base import BaseConfiguration from core.layers.attention import RopeAttention -from core.layers.decoder import DecoderLayer from core.layers.layer_norm import LayerNorm from core.layers.point_wise_projection import PointWiseGatedProjection -from core.utils.masks import _update_causal_mask class ConstrueDecoderLayer(nn.Module): diff --git a/core/trainer/validator.py b/core/trainer/validator.py index 727a2c6..8bb185e 100644 --- a/core/trainer/validator.py +++ b/core/trainer/validator.py @@ -129,20 +129,20 @@ def validate_model_initial_states(model, config, input_size, n_samples): print(f"{layer}: {var:.6f}") -from core.models.translator.construe import ConstrueAutoRegressiveModel -from core.configurations.base import BaseConfiguration - -config = BaseConfiguration(model_name="small_lm", num_layers=2, hidden_dim=32, intermediate_dim=512, - max_positions=256, vocabulary_size=64000, num_heads=2, attention_dropout=0.05, - batch_size=8, weight_decay=0.01, - learning_rate=5e-4, - tokenizer_path="/workspace/vipin_g6/personal/pretraining/english_tokenizer/english_tokenizer.model", - dataset_batch_size=16, dataset_shuffle=True, num_epochs=2, eval_frequency=1, - eval_iter=10, - model_max_sequence=256) - -model = ConstrueAutoRegressiveModel(config=config) -initalizer = get_initializer(init_type="kaiming", activation="relu", embedding_init="kaiming", embedding_padding_idx=config.padding_id) - -model.apply(initalizer) -validate_model_initial_states(model, config, (10, ), n_samples=1000) \ No newline at end of file +# from core.models.translator.construe import ConstrueAutoRegressiveModel +# from core.configurations.base import BaseConfiguration + +# config = BaseConfiguration(model_name="small_lm", num_layers=6, hidden_dim=32, intermediate_dim=512, +# max_positions=256, vocabulary_size=64000, num_heads=8, attention_dropout=0.05, +# batch_size=8, weight_decay=0.01, +# learning_rate=5e-4, +# tokenizer_path="/workspace/vipin_g6/personal/pretraining/english_tokenizer/english_tokenizer.model", +# dataset_batch_size=16, dataset_shuffle=True, num_epochs=2, eval_frequency=1, +# eval_iter=10, +# model_max_sequence=256) + +# model = ConstrueAutoRegressiveModel(config=config) +# initalizer = get_initializer(init_type="kaiming", activation="relu", embedding_init="kaiming", embedding_padding_idx=config.padding_id) + +# model.apply(initalizer) +# validate_model_initial_states(model, config, (10, ), n_samples=1000) \ No newline at end of file diff --git a/core/utils/masks.py b/core/utils/masks.py index 99b57f7..1ef4e65 100644 --- a/core/utils/masks.py +++ b/core/utils/masks.py @@ -1,42 +1,39 @@ +from typing import Optional, Tuple import torch - - -def _update_causal_mask( - input_tensor: torch.Tensor, - attention_mask: torch.Tensor, -): - dtype, device = input_tensor.dtype, input_tensor.device - input_rank = input_tensor.ndim - - if input_rank == 4: # [B, H, S, S] - batch_size, _, sequence_length, _ = input_tensor.shape - elif input_rank == 3: # [B, S, D] - batch_size, sequence_length, _ = input_tensor.shape - else: - raise ValueError(f"Unsupported input tensor rank: {input_rank}. Expected 3 or 4.") - - min_dtype = torch.finfo(dtype).min - target_sequence_length = attention_mask.shape[-1] - - causal_mask = torch.full((sequence_length, target_sequence_length), fill_value=1, - dtype=dtype, - device=device) - - if sequence_length > 1: - causal_mask = torch.tril(causal_mask) - - if input_rank == 4: - causal_mask = causal_mask[None, None, :, :].expand(batch_size, 1, -1, -1) - else: - causal_mask = causal_mask[None, :, :].expand(batch_size, -1, -1) - - padding_mask = attention_mask[:, None, None, :] if input_rank == 4 else attention_mask[:, None, :] - - if padding_mask.device != device: - padding_mask = padding_mask.to(device=device) - - causal_mask = (causal_mask * padding_mask).to(dtype) - causal_mask = 1.0 - causal_mask - causal_mask = causal_mask.masked_fill(causal_mask == 1.0, min_dtype) - causal_mask = causal_mask.contiguous() - return causal_mask +from torch import Tensor + + +def create_causal_mask( + attention_mask, + shape: Tuple[int, ...], + dtype: torch.dtype, + device: torch.device +) -> Tensor: + """ + Efficiently creates a causal mask without redundant computations. + """ + seq_len = shape[-1] + batch_size = shape[0] + mask = torch.triu( + torch.ones(seq_len, seq_len, dtype=dtype, device=device), + diagonal=1 + ) + + # Directly create with -inf instead of using masked_fill + causal_mask = mask.masked_fill(mask > 0, float('-inf')) + + # Expand to match input shape + if len(shape) == 4: # [B, H, S, S] + causal_mask = causal_mask.view(1, 1, seq_len, seq_len) + else: # [B, S, S] + causal_mask = causal_mask.view(1, seq_len, seq_len) + + if attention_mask is not None: + if len(shape) == 4: + attention_mask = attention_mask.view(batch_size, 1, 1, seq_len) + else: + attention_mask = attention_mask.view(batch_size, 1, seq_len) + + mask_value = torch.finfo(dtype).min + causal_mask = causal_mask.masked_fill(attention_mask == 0, mask_value) + return causal_mask \ No newline at end of file diff --git a/study/transformers.ipynb b/study/transformers.ipynb new file mode 100644 index 0000000..c40495e --- /dev/null +++ b/study/transformers.ipynb @@ -0,0 +1,932 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "\n", + "# Add the root directory to the sys.path\n", + "sys.path.insert(0, os.path.abspath(os.path.dirname(os.getcwd())))" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from torch import nn\n", + "import torch" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from core.configurations.base import BaseConfiguration\n", + "\n", + "config = BaseConfiguration(model_name=\"small_lm\", num_layers=2, hidden_dim=32, intermediate_dim=64,\n", + " max_positions=256, vocabulary_size=64000, num_heads=2, attention_dropout=0.05,\n", + " batch_size=8, weight_decay=0.01,\n", + " learning_rate=5e-4,\n", + " tokenizer_path=\"/workspace/vipin_g6/personal/pretraining/english_tokenizer/english_tokenizer.model\",\n", + " dataset_batch_size=16, dataset_shuffle=True, num_epochs=2, eval_frequency=1,\n", + " eval_iter=10,\n", + " model_max_sequence=256)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "embedding = nn.Embedding(num_embeddings=config.vocabulary_size, embedding_dim=config.hidden_dim, padding_idx=config.padding_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dummy Input Shape :: torch.Size([3, 10])\n", + "Input Tensor:\n", + "tensor([[326, 814, 65, 400, 351, 0, 0, 0, 0, 0],\n", + " [925, 279, 903, 63, 229, 660, 334, 324, 0, 0],\n", + " [864, 977, 264, 554, 314, 823, 605, 664, 117, 221]])\n", + "\n", + "Attention Mask:\n", + "tensor([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0],\n", + " [1, 1, 1, 1, 1, 1, 1, 1, 0, 0],\n", + " [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])\n" + ] + } + ], + "source": [ + "dumpy_input = torch.randint(1, 1000, (3, 10,))\n", + "attention_mask = torch.ones_like(dumpy_input)\n", + "\n", + "dumpy_input[0, 5:] = 0\n", + "dumpy_input[1, 8:] = 0\n", + "dumpy_input = dumpy_input.long()\n", + "\n", + "attention_mask[0, 5:] = 0\n", + "attention_mask[1, 8:] = 0\n", + "\n", + "print(\"Dummy Input Shape :: \", dumpy_input.shape)\n", + "print(\"Input Tensor:\")\n", + "print(dumpy_input)\n", + "print()\n", + "print(\"Attention Mask:\")\n", + "print(attention_mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input id embedding value :: torch.Size([3, 10, 32])\n" + ] + } + ], + "source": [ + "hidden_state = embedding(dumpy_input)\n", + "print(\"Input id embedding value :: \", hidden_state.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Decoder Layer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Layer Norm" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import numbers\n", + "import torch\n", + "from torch import nn\n", + "import torch.nn.functional as F\n", + "\n", + "class LayerNorm(nn.Module):\n", + " \"\"\"\n", + " Class the contains LayerNorm\n", + " This is same as transformers implementation\n", + " \"\"\"\n", + " def __init__(self, model_dimension, epsilon=0.00001):\n", + " super(LayerNorm, self).__init__()\n", + " if isinstance(model_dimension, numbers.Integral):\n", + " # mypy error: incompatible types in assignment\n", + " model_dimension = (model_dimension,) \n", + " self.model_dimension = model_dimension\n", + " self.gamma = nn.Parameter(torch.ones(model_dimension))\n", + " self.beta = nn.Parameter(torch.zeros(model_dimension))\n", + " self.epsilon = epsilon\n", + "\n", + "\n", + " def forward(self, x):\n", + " if isinstance(x, tuple):\n", + " x = x[0]\n", + " return F.layer_norm(\n", + " x, self.model_dimension, self.gamma, self.beta, self.epsilon\n", + " )\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Output shape: torch.Size([3, 10, 32])\n", + "Mean (last dimension): tensor([[-1.1176e-08, 1.3039e-08, -3.7253e-08, -2.6077e-08, -2.8871e-08,\n", + " 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00, 0.0000e+00],\n", + " [ 1.4901e-08, -2.2352e-08, -2.2352e-08, 0.0000e+00, -3.7253e-09,\n", + " -1.4901e-08, -1.8626e-08, 3.7253e-08, 0.0000e+00, 0.0000e+00],\n", + " [ 2.2352e-08, 0.0000e+00, -7.4506e-09, 7.4506e-09, 1.3039e-08,\n", + " -3.7253e-09, 1.8626e-09, 7.4506e-09, 2.2352e-08, 0.0000e+00]],\n", + " grad_fn=)\n", + "Std (last dimension): tensor([[1.0160, 1.0160, 1.0160, 1.0160, 1.0160, 0.0000, 0.0000, 0.0000, 0.0000,\n", + " 0.0000],\n", + " [1.0160, 1.0160, 1.0160, 1.0160, 1.0160, 1.0160, 1.0160, 1.0160, 0.0000,\n", + " 0.0000],\n", + " [1.0160, 1.0160, 1.0160, 1.0160, 1.0160, 1.0160, 1.0160, 1.0160, 1.0160,\n", + " 1.0160]], grad_fn=)\n" + ] + } + ], + "source": [ + "layer_norm = LayerNorm(config.hidden_dim)\n", + "output = layer_norm(hidden_state)\n", + "print(\"Output shape:\", output.shape)\n", + "print(\"Mean (last dimension):\", output.mean(dim=-1))\n", + "print(\"Std (last dimension):\", output.std(dim=-1))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Optional, Tuple\n", + "\n", + "from torch import Tensor\n", + "\n", + "\n", + "def create_causal_mask(\n", + " attention_mask,\n", + " shape: Tuple[int, ...],\n", + " dtype: torch.dtype,\n", + " device: torch.device\n", + ") -> Tensor:\n", + " \"\"\"\n", + " Efficiently creates a causal mask without redundant computations.\n", + " \"\"\"\n", + " seq_len = shape[-1]\n", + " batch_size = shape[0]\n", + " mask = torch.triu(\n", + " torch.ones(seq_len, seq_len, dtype=dtype, device=device),\n", + " diagonal=1\n", + " )\n", + " \n", + " # Directly create with -inf instead of using masked_fill\n", + " causal_mask = mask.masked_fill(mask > 0, float('-inf'))\n", + " \n", + " # Expand to match input shape\n", + " if len(shape) == 4: # [B, H, S, S]\n", + " causal_mask = causal_mask.view(1, 1, seq_len, seq_len)\n", + " else: # [B, S, S]\n", + " causal_mask = causal_mask.view(1, seq_len, seq_len)\n", + " \n", + " if attention_mask is not None:\n", + " if len(shape) == 4:\n", + " attention_mask = attention_mask.view(batch_size, 1, 1, seq_len)\n", + " else:\n", + " attention_mask = attention_mask.view(batch_size, 1, seq_len)\n", + " \n", + " mask_value = torch.finfo(dtype).min\n", + " causal_mask = causal_mask.masked_fill(attention_mask == 0, mask_value)\n", + " return causal_mask" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Causal Mask Shape :: torch.Size([3, 10, 10])\n" + ] + } + ], + "source": [ + "causal_mask = create_causal_mask(\n", + " attention_mask,\n", + " dumpy_input.shape,\n", + " hidden_state.dtype,\n", + " hidden_state.device,\n", + ")\n", + "\n", + "print(\"Causal Mask Shape :: \", causal_mask.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/root/anaconda3/envs/ai_experimentation_env/lib/python3.11/site-packages/matplotlib/colors.py:1405: RuntimeWarning: overflow encountered in divide\n", + " resdat /= (vmax - vmin)\n", + "/root/anaconda3/envs/ai_experimentation_env/lib/python3.11/site-packages/matplotlib/colors.py:1405: RuntimeWarning: overflow encountered in divide\n", + " resdat /= (vmax - vmin)\n", + "/root/anaconda3/envs/ai_experimentation_env/lib/python3.11/site-packages/matplotlib/colors.py:1405: RuntimeWarning: overflow encountered in divide\n", + " resdat /= (vmax - vmin)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "_, axes = plt.subplots(3)\n", + "\n", + "sns.heatmap(causal_mask[0, :, :], cmap=\"Blues\", ax=axes[0])\n", + "sns.heatmap(causal_mask[1, :, :], cmap=\"Blues\", ax=axes[1])\n", + "sns.heatmap(causal_mask[-1, :, :], cmap=\"Blues\", ax=axes[2])\n", + "\n", + "plt.show()\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Rope Positional Embedding + Attention \n", + "\n", + "\n", + "for rope positional embedding implementation details see, `study/rope_positional_encoding.ipynb`" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from core.layers.positional_embedding.rope_projector import RopePositionEmbedding\n", + "from core.layers.positional_embedding.rope_projector import apply_positional_embedding\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "\n", + "class RopeAttention(nn.Module):\n", + " \"\"\"\n", + " Implements attention mechanism with Rotary Position Embedding (RoPE).\n", + " \"\"\"\n", + " \n", + " def __init__(self, config: BaseConfiguration):\n", + " super().__init__()\n", + " assert config.head_dim is not None\n", + " if config.hidden_dim % config.head_dim != 0:\n", + " raise ValueError(\n", + " f\"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}\"\n", + " f\" and `num_heads`: {self.num_heads}).\"\n", + " )\n", + " \n", + " self.config = config\n", + " self.attention_dropout = config.attention_dropout\n", + " self.hidden_dim = config.hidden_dim\n", + " self.num_heads = config.num_heads\n", + " self.head_dim = config.head_dim\n", + " self.scaling = 1 / math.sqrt(config.head_dim)\n", + " \n", + " # Initialize RoPE if enabled\n", + " self.use_rope = config.use_rope\n", + " if self.use_rope:\n", + " self.rope_position_projection = RopePositionEmbedding(\n", + " hidden_dim=config.head_dim,\n", + " max_positions=config.max_positions,\n", + " base=config.rope_base\n", + " )\n", + " \n", + " # Initialize projection layers\n", + " self.qkv_projection = nn.Linear(\n", + " config.hidden_dim,\n", + " 3 * config.hidden_dim,\n", + " bias=False\n", + " )\n", + " \n", + " self.output_projection = nn.Linear(\n", + " config.hidden_dim,\n", + " config.hidden_dim,\n", + " bias=False\n", + " )\n", + " \n", + " def forward(\n", + " self,\n", + " input_tensor: torch.Tensor,\n", + " attention_mask: Optional[torch.Tensor] = None,\n", + " positions: Optional[torch.Tensor] = None,\n", + " output_attentions: bool = False\n", + " ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:\n", + " \"\"\"\n", + " Forward pass for RoPE attention.\n", + " \n", + " Args:\n", + " input_tensor: Input tensor [batch_size, seq_len, hidden_dim]\n", + " attention_mask: Optional attention mask [batch_size, seq_len]\n", + " positions: Optional position indices\n", + " output_attentions: Whether to return attention weights\n", + " \n", + " Returns:\n", + " Tuple of (output tensor, optional attention weights)\n", + " \"\"\"\n", + " if input_tensor.dim() != 3:\n", + " raise ValueError(f\"Expected 3D input, got {input_tensor.dim()}D\")\n", + " \n", + " batch_size, seq_length, _ = input_tensor.shape\n", + " \n", + " # Fused QKV projection\n", + " qkv = self.qkv_projection(input_tensor)\n", + " qkv = qkv.view(batch_size, seq_length, 3, self.num_heads, self.head_dim)\n", + " qkv = qkv.permute(2, 0, 3, 1, 4) # [3, batch_size, num_heads, seq_len, head_dim]\n", + " query_states, key_states, value_states = qkv\n", + " \n", + " # Apply RoPE if enabled\n", + " if self.use_rope:\n", + " cos, sin = self.rope_position_projection(query_states)\n", + " query_states, key_states = apply_positional_embedding(\n", + " query_states, key_states, cos, sin\n", + " )\n", + " \n", + " # Compute attention scores with improved numerical stability\n", + " attn_weights = torch.matmul(query_states, key_states.transpose(-2, -1))\n", + " attn_weights = attn_weights * self.scaling\n", + " \n", + " # Apply attention mask if provided\n", + " if attention_mask is not None:\n", + " # Convert mask to proper dtype\n", + " attention_mask = attention_mask.to(dtype=query_states.dtype)\n", + " \n", + " # Add head dimension if needed\n", + " if attention_mask.dim() == 3:\n", + " attention_mask = attention_mask.unsqueeze(1)\n", + " \n", + " # Ensure proper sequence length\n", + " attention_mask = attention_mask[:, :, :, :key_states.shape[-2]]\n", + " \n", + " attn_weights = attn_weights + attention_mask\n", + " \n", + " # Compute attention probabilities with improved numerical stability\n", + " attn_weights_float = F.softmax(attn_weights, dim=-1, dtype=torch.float32)\n", + " attn_weights = attn_weights_float.to(query_states.dtype)\n", + " \n", + " # Apply dropout during training\n", + " if self.training:\n", + " attn_weights = F.dropout(\n", + " attn_weights,\n", + " p=self.attention_dropout,\n", + " training=True\n", + " )\n", + " \n", + " # Compute attention output\n", + " attn_output = torch.matmul(attn_weights, value_states)\n", + " \n", + " # Validate output shape\n", + " expected_shape = (batch_size, self.num_heads, seq_length, self.head_dim)\n", + " if attn_output.shape != expected_shape:\n", + " raise ValueError(\n", + " f\"Expected output shape {expected_shape}, got {attn_output.shape}\"\n", + " )\n", + " \n", + " # Reshape output and apply output projection\n", + " attn_output = attn_output.transpose(1, 2).contiguous()\n", + " attn_output = attn_output.view(batch_size, seq_length, self.hidden_dim)\n", + " attn_output = self.output_projection(attn_output)\n", + " \n", + " return attn_output, (attn_weights if output_attentions else None)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "attention_layer = RopeAttention(config=config)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Attention Output shape :: torch.Size([3, 10, 32])\n" + ] + } + ], + "source": [ + "output, attention = attention_layer(\n", + " hidden_state,\n", + " causal_mask,\n", + " output_attentions=True\n", + ")\n", + "\n", + "print(\"Attention Output shape :: \", output.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.heatmap(attention[-1][1].detach().numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch import nn\n", + "from core.configurations.base import BaseConfiguration\n", + "\n", + "from core.activations.gelu import PytorchGELUTanh\n", + "\n", + "\n", + "class PointWiseProjection(nn.Module):\n", + " \"\"\"\n", + " point wise project as native from `attention is all you need`\n", + " with slight changes in activation relu -> gelu tanh approximation\n", + " https://arxiv.org/pdf/1706.03762\n", + " \"\"\"\n", + " def __init__(self, config: BaseConfiguration):\n", + " super().__init__()\n", + " self.up_projection = nn.Linear(config.hidden_dim, config.intermediate_dim, bias=False)\n", + " self.down_projection = nn.Linear(config.intermediate_dim, config.hidden_dim, bias=False)\n", + " self.act_func = PytorchGELUTanh()\n", + "\n", + "\n", + " def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:\n", + " return self.down_projection(self.act_func(self.up_projection(input_tensor)))\n", + " \n", + " \n", + "\n", + "class PointWiseGatedProjection(nn.Module):\n", + " \"\"\"\n", + " point wise project as native from `attention is all you need`\n", + " with slight changes in activation relu -> gelu tanh approximation\n", + " https://arxiv.org/pdf/1706.03762\n", + " \"\"\"\n", + "\n", + " def __init__(self, config: BaseConfiguration):\n", + " super().__init__()\n", + " self.intermediate_size = config.intermediate_dim\n", + " # print(f\"## config hidden dim {config.hidden_dim}\")\n", + " # print(f\"## config intermediate dim {config.intermediate_dim}\")\n", + " self.gate_projection = nn.Linear(config.hidden_dim, config.intermediate_dim, bias=False)\n", + " self.up_projection = nn.Linear(config.hidden_dim, config.intermediate_dim, bias=False)\n", + " self.down_projection = nn.Linear(config.intermediate_dim, config.hidden_dim, bias=False)\n", + " \n", + " self.act_func = PytorchGELUTanh()\n", + "\n", + " def forward(self, input_tensor: torch.Tensor) -> torch.Tensor:\n", + " return self.down_projection(self.act_func(self.gate_projection(input_tensor)) * self.up_projection(input_tensor))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "projection_layer = PointWiseGatedProjection(config=config)" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Projection Output shape :: torch.Size([3, 10, 32])\n" + ] + } + ], + "source": [ + "projection_output = projection_layer(output)\n", + "\n", + "print(\"Projection Output shape :: \", projection_output.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [], + "source": [ + "class DecoderLayer(nn.Module):\n", + " def __init__(self, base_cfg: BaseConfiguration):\n", + " super().__init__()\n", + "\n", + " self.input_norm = LayerNorm(model_dimension=base_cfg.hidden_dim)\n", + " self.self_attn = RopeAttention(\n", + " config=base_cfg\n", + " )\n", + " self.attention_dropout = nn.Dropout(p=base_cfg.attention_dropout)\n", + "\n", + " self.post_attention_norm = LayerNorm(model_dimension=base_cfg.hidden_dim)\n", + " self.mlp = PointWiseGatedProjection(config=base_cfg)\n", + " self.dropout2 = nn.Dropout(p=base_cfg.attention_dropout)\n", + "\n", + "\n", + " def forward(self, hidden_state, attention_mask, output_attentions=False):\n", + " \"\"\"\n", + " https://arxiv.org/pdf/2002.04745 (PRE-Norm)\n", + "\n", + "\n", + " x = embedding of each tokens (B x S x D)\n", + " mask = self_attention autput (B x S x D)\n", + "\n", + " Self-attention sub-block 1\n", + " x => norm(x) => n_x => att(n_x) => (a_x, a_score) => a_x + x => h_x\n", + "\n", + " MLP sub-block: 2\n", + "\n", + " h_x => norm(h_x) => n_hx => mlp(n_hx) => n_x => x_x + h_x => h_x\n", + " \"\"\"\n", + " residual_x = hidden_state\n", + "\n", + " hidden_state = self.input_norm(hidden_state)\n", + " hidden_state, self_attn_weights = self.self_attn(\n", + " input_tensor=hidden_state,\n", + " attention_mask=attention_mask,\n", + " output_attentions=output_attentions,\n", + " )\n", + " hidden_state = self.attention_dropout(hidden_state)\n", + " hidden_state = residual_x + hidden_state\n", + "\n", + " residual_x = hidden_state\n", + "\n", + " hidden_state = self.post_attention_norm(hidden_state)\n", + " hidden_state = self.mlp(hidden_state)\n", + " hidden_state = self.dropout2(hidden_state)\n", + " hidden_state = residual_x + hidden_state\n", + "\n", + " return hidden_state, self_attn_weights\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "decoder_layer = DecoderLayer(config)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "decoder_output, attentions = decoder_layer(hidden_state,\n", + " causal_mask, output_attentions=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "class Model(nn.Module):\n", + " def __init__(self, config: BaseConfiguration):\n", + " super().__init__()\n", + "\n", + " self.config = config\n", + "\n", + " self.token_embeddings = nn.Embedding(\n", + " num_embeddings=config.vocabulary_size,\n", + " embedding_dim=config.hidden_dim,\n", + " padding_idx=config.padding_id\n", + " )\n", + "\n", + " # Decoder layer stack\n", + " self.decoder_layers = nn.ModuleList([\n", + " DecoderLayer(\n", + " config\n", + " )\n", + " for _ in range(config.num_layers)\n", + " ])\n", + "\n", + " # Layer Norm initialization\n", + " self.final_layer_norm = LayerNorm(\n", + " model_dimension=config.hidden_dim\n", + " )\n", + "\n", + " def forward(self, input_tensor, attn_mask=None, output_attentions=False):\n", + " if attn_mask is None:\n", + " attn_mask = torch.ones_like(input_tensor)\n", + "\n", + " hidden_states = self.token_embeddings(input_tensor)\n", + " print(attn_mask.shape)\n", + " causal_mask = create_causal_mask(\n", + " attention_mask=attn_mask,\n", + " shape=input_tensor.shape,\n", + " dtype=hidden_state.dtype,\n", + " device=hidden_state.device\n", + " )\n", + "\n", + "\n", + " output_attentions_weights = ()\n", + " for decoder_layer in self.decoder_layers:\n", + " hidden_states, attention_weight = decoder_layer(\n", + " hidden_states,\n", + " causal_mask,\n", + " output_attentions=output_attentions\n", + " )\n", + " output_attentions_weights += (attention_weight,)\n", + "\n", + " hidden_states = self.final_layer_norm(hidden_states)\n", + "\n", + " return hidden_states, (output_attentions_weights if output_attentions else None)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [], + "source": [ + "model = Model(config)" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([3, 10])\n" + ] + } + ], + "source": [ + "output, attentions = model(dumpy_input, attention_mask, True)" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([3, 10, 32])" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "output.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [], + "source": [ + "from core.trainer.validator import validate_model_initial_states" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Initialization Statistics:\n", + "\n", + "token_embeddings:\n", + "Mean: -0.000425\n", + "Std: 0.999283\n", + "Min: -4.689465\n", + "Max: 4.892149\n", + "Near zero: 0.00%\n", + "\n", + "decoder_layers.0.self_attn.qkv_projection:\n", + "Mean: 0.001068\n", + "Std: 0.103101\n", + "Min: -0.176547\n", + "Max: 0.176750\n", + "Near zero: 0.00%\n", + "\n", + "decoder_layers.0.self_attn.output_projection:\n", + "Mean: -0.001130\n", + "Std: 0.103176\n", + "Min: -0.176758\n", + "Max: 0.175817\n", + "Near zero: 0.00%\n", + "\n", + "decoder_layers.0.mlp.gate_projection:\n", + "Mean: 0.000397\n", + "Std: 0.101356\n", + "Min: -0.176768\n", + "Max: 0.176636\n", + "Near zero: 0.00%\n", + "\n", + "decoder_layers.0.mlp.up_projection:\n", + "Mean: -0.000113\n", + "Std: 0.102286\n", + "Min: -0.176508\n", + "Max: 0.176717\n", + "Near zero: 0.00%\n", + "\n", + "decoder_layers.0.mlp.down_projection:\n", + "Mean: -0.000708\n", + "Std: 0.071396\n", + "Min: -0.124769\n", + "Max: 0.124804\n", + "Near zero: 0.00%\n", + "\n", + "decoder_layers.1.self_attn.qkv_projection:\n", + "Mean: 0.005238\n", + "Std: 0.101242\n", + "Min: -0.176656\n", + "Max: 0.176754\n", + "Near zero: 0.00%\n", + "\n", + "decoder_layers.1.self_attn.output_projection:\n", + "Mean: -0.005065\n", + "Std: 0.101385\n", + "Min: -0.175676\n", + "Max: 0.176358\n", + "Near zero: 0.00%\n", + "\n", + "decoder_layers.1.mlp.gate_projection:\n", + "Mean: -0.002864\n", + "Std: 0.101891\n", + "Min: -0.176536\n", + "Max: 0.176570\n", + "Near zero: 0.00%\n", + "\n", + "decoder_layers.1.mlp.up_projection:\n", + "Mean: 0.001448\n", + "Std: 0.102296\n", + "Min: -0.176653\n", + "Max: 0.176675\n", + "Near zero: 0.00%\n", + "\n", + "decoder_layers.1.mlp.down_projection:\n", + "Mean: -0.000822\n", + "Std: 0.072286\n", + "Min: -0.124877\n", + "Max: 0.124973\n", + "Near zero: 0.00%\n", + "torch.Size([10000, 10])\n", + "\n", + "Activation Variances:\n", + "decoder_layers.0.self_attn.qkv_projection: 0.097020\n", + "decoder_layers.0.self_attn.output_projection: 0.016452\n", + "decoder_layers.0.mlp.gate_projection: 0.257783\n", + "decoder_layers.0.mlp.up_projection: 0.255544\n", + "decoder_layers.0.mlp.down_projection: 0.009152\n", + "decoder_layers.1.self_attn.qkv_projection: 0.249121\n", + "decoder_layers.1.self_attn.output_projection: 0.025791\n", + "decoder_layers.1.mlp.gate_projection: 0.294981\n", + "decoder_layers.1.mlp.up_projection: 0.219470\n", + "decoder_layers.1.mlp.down_projection: 0.009540\n" + ] + } + ], + "source": [ + "\n", + "validate_model_initial_states(model, config=config, input_size=(10,), n_samples=10000)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ai_experimentation_env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 757b10737d02692efbd820afa28fae92758c2a34 Mon Sep 17 00:00:00 2001 From: "jagan.pp" Date: Sun, 5 Jan 2025 13:41:30 +0000 Subject: [PATCH 04/39] training script development --- core/configurations/base.py | 10 ------ core/models/translator/config.py | 40 +++++++++++++++++++++++ core/models/translator/trainer.py | 24 ++++++++++++++ core/trainer/utils.py | 51 +++++++++++++++-------------- core/trainer/validator.py | 34 ++++++++++---------- pyproject.toml | 1 + requirements-dev.txt | 3 ++ study/transformers.ipynb | 53 +++++++++++++++++++++++++++++++ uv.lock | 29 +++++++++++++++++ 9 files changed, 194 insertions(+), 51 deletions(-) create mode 100644 core/models/translator/config.py create mode 100644 core/models/translator/trainer.py diff --git a/core/configurations/base.py b/core/configurations/base.py index 0a20ad8..99092ac 100644 --- a/core/configurations/base.py +++ b/core/configurations/base.py @@ -20,16 +20,6 @@ class BaseConfiguration(object): use_rope: bool = True rope_base: float = 10000.0 output_last_hidden_state: bool = False - batch_size: int = 32 - weight_decay: float = 0.001 - learning_rate: float = 2e-5 - tokenizer_path: str = "./tokenizer" - strides: int = 2 - dataset_batch_size: int = 256 - dataset_shuffle: bool = False - num_epochs: int = 4 - eval_frequency: int = 1 - eval_iter: int = 1 def __post_init__(self): if self.head_dim is None: diff --git a/core/models/translator/config.py b/core/models/translator/config.py new file mode 100644 index 0000000..7d6d63f --- /dev/null +++ b/core/models/translator/config.py @@ -0,0 +1,40 @@ +from dataclasses import dataclass +import os +from core.configurations.base import BaseConfiguration +import randomname + +@dataclass +class TrainingConfig: + tokenizer_path: str + experimentation_name: str = randomname.get_name() + save_path: str = None + weight_decay: float = 0.001 + warm_up: int = 0 + learning_rate: float = 2e-5 + num_epochs: int = 4 + eval_frequency: int = 1 + eval_iter: int = 1 + optimzer = "adam" + + def __post_init__(self): + self.save_path = os.path.join(os.getcwd(), self.experimentation_name) + if self.save_path is None: + os.mkdir(self.save_path) + + +@dataclass +class OptimzerConfig: + beta1 = 0.99 + beta2 = 0.98 + + +@dataclass +class DatasetConfig: + dataset_path: str + batch_size: int = 32 + dataset_shuffle: bool = False + + +@dataclass +class ModelConfig(BaseConfiguration): + pass diff --git a/core/models/translator/trainer.py b/core/models/translator/trainer.py new file mode 100644 index 0000000..d8fb4c9 --- /dev/null +++ b/core/models/translator/trainer.py @@ -0,0 +1,24 @@ +from core.models.translator.config import ModelConfig, DatasetConfig, TrainingConfig +from core.dataloaders.dataloader import load_tokenizer + +## Initialize configurations +model_config = ModelConfig(model_name="Construe", + num_layers = 2, + padding_id = 0, + hidden_dim = 512, + intermediate_dim = 3072, + max_positions = 2048, + layer_norm_eps = 1e-05, + model_max_sequence = 2048, + num_heads = 8, + attention_dropout = 0.1) + +dataset_config = DatasetConfig(dataset_path="./dataset", + dataset_shuffle=True) +training_config = TrainingConfig(tokenizer_path="/root/AI-Uncomplicated/core/tokenizer/bpe/pre_trained/europian_ml") + +## Load model and tokenizer + +tokenizer = load_tokenizer(training_config.tokenizer_path) + + diff --git a/core/trainer/utils.py b/core/trainer/utils.py index 876e6b3..80df7d7 100644 --- a/core/trainer/utils.py +++ b/core/trainer/utils.py @@ -1,8 +1,33 @@ +import math from typing import Callable, Dict, Optional import torch import torch.nn as nn +def calculate_gelu_gain(): + """ + Calculates the gain for GELU activation with tanh approximation. + Uses numerical differentiation to find the variance preservation factor. + """ + def gelu(x): + # GELU with tanh approximation + return x * 0.5 * (1 + torch.tanh(math.sqrt(2/math.pi) * (x + 0.044715 * x**3))) + + # Generate random input samples + num_samples = 1000000 + x = torch.randn(num_samples) + + # Calculate numerical derivative + epsilon = 1e-6 + x_plus = x + epsilon + x_minus = x - epsilon + derivative = (gelu(x_plus) - gelu(x_minus)) / (2 * epsilon) + + # Calculate variance of derivative (gain is square root of this) + gain = float(torch.sqrt(torch.mean(derivative**2))) + + return gain + def get_initializer( init_type: str, @@ -50,6 +75,8 @@ def xavier_init(m: nn.Module) -> None: if isinstance(m, (nn.Linear, nn.Conv2d)): if activation in ['relu', 'leaky_relu']: gain = nn.init.calculate_gain('leaky_relu' if activation == 'leaky_relu' else 'relu') + elif activation == "gelu": + gain = 1.70093 else: gain = nn.init.calculate_gain('tanh') @@ -116,27 +143,3 @@ def orthogonal_init(m: nn.Module) -> None: f"Choose from {list(initializers.keys())}") return initializers[init_type] - - - -if __name__ == "__main__": - class SimpleNet(nn.Module): - def __init__(self, input_size: int, hidden_size: int, output_size: int): - super().__init__() - self.embedding = nn.Embedding(19, 100) - self.layer1 = nn.Linear(input_size, hidden_size) - self.layer2 = nn.Linear(hidden_size, output_size) - - def forward(self, x): - x = torch.relu(self.layer1(x)) - return self.layer2(x) - - # Initialize network with different strategies - model = SimpleNet(10, 20, 2) - - # Using xavier initialization with ReLU - xavier_init = get_initializer('xavier', activation='relu', embedding_init="normal") - model.apply(xavier_init) - - - diff --git a/core/trainer/validator.py b/core/trainer/validator.py index 8bb185e..b7e610b 100644 --- a/core/trainer/validator.py +++ b/core/trainer/validator.py @@ -129,20 +129,20 @@ def validate_model_initial_states(model, config, input_size, n_samples): print(f"{layer}: {var:.6f}") -# from core.models.translator.construe import ConstrueAutoRegressiveModel -# from core.configurations.base import BaseConfiguration - -# config = BaseConfiguration(model_name="small_lm", num_layers=6, hidden_dim=32, intermediate_dim=512, -# max_positions=256, vocabulary_size=64000, num_heads=8, attention_dropout=0.05, -# batch_size=8, weight_decay=0.01, -# learning_rate=5e-4, -# tokenizer_path="/workspace/vipin_g6/personal/pretraining/english_tokenizer/english_tokenizer.model", -# dataset_batch_size=16, dataset_shuffle=True, num_epochs=2, eval_frequency=1, -# eval_iter=10, -# model_max_sequence=256) - -# model = ConstrueAutoRegressiveModel(config=config) -# initalizer = get_initializer(init_type="kaiming", activation="relu", embedding_init="kaiming", embedding_padding_idx=config.padding_id) - -# model.apply(initalizer) -# validate_model_initial_states(model, config, (10, ), n_samples=1000) \ No newline at end of file +from core.models.translator.construe import ConstrueAutoRegressiveModel +from core.configurations.base import BaseConfiguration + +config = BaseConfiguration(model_name="small_lm", num_layers=6, hidden_dim=32, intermediate_dim=512, + max_positions=256, vocabulary_size=64000, num_heads=8, attention_dropout=0.05, + batch_size=8, weight_decay=0.01, + learning_rate=5e-4, + tokenizer_path="/workspace/vipin_g6/personal/pretraining/english_tokenizer/english_tokenizer.model", + dataset_batch_size=16, dataset_shuffle=True, num_epochs=2, eval_frequency=1, + eval_iter=10, + model_max_sequence=256) + +model = ConstrueAutoRegressiveModel(config=config) +initalizer = get_initializer(init_type="xavier", activation="gelu", embedding_init="xavier", embedding_padding_idx=config.padding_id) + +model.apply(initalizer) +validate_model_initial_states(model, config, (10, ), n_samples=1000) \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 9d570e3..fa7517a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -16,6 +16,7 @@ dependencies = [ "omegaconf>=2.3.0", "pynvml>=12.0.0", "pyyaml~=6.0", + "randomname>=0.2.1", "regex~=2024.11.6", "requests~=2.32.3", "rouge-score>=0.1.2", diff --git a/requirements-dev.txt b/requirements-dev.txt index a15089d..37eb1aa 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -23,6 +23,7 @@ dill==0.3.8 docker-pycreds==0.4.0 evaluate==0.4.3 filelock==3.16.1 +fire==0.7.0 fonttools==4.55.3 frozenlist==1.5.0 fsspec==2024.9.0 @@ -86,6 +87,7 @@ python-dateutil==2.9.0.post0 pytz==2024.2 pywin32==308 ; sys_platform == 'win32' pyyaml==6.0.2 +randomname==0.2.1 regex==2024.11.6 requests==2.32.3 rouge-score==0.1.2 @@ -105,6 +107,7 @@ sympy==1.13.1 tabledata==1.3.3 tabulate==0.9.0 tcolorpy==0.1.6 +termcolor==2.5.0 threadpoolctl==3.5.0 tiktoken==0.8.0 tokenizers==0.21.0 diff --git a/study/transformers.ipynb b/study/transformers.ipynb index c40495e..909171f 100644 --- a/study/transformers.ipynb +++ b/study/transformers.ipynb @@ -906,6 +906,59 @@ "\n", "validate_model_initial_states(model, config=config, input_size=(10,), n_samples=10000)" ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GELU (tanh approximation) gain: 0.6666\n" + ] + } + ], + "source": [ + "import torch\n", + "import math\n", + "import numpy as np\n", + "\n", + "def calculate_gelu_gain():\n", + " \"\"\"\n", + " Calculates the gain for GELU activation with tanh approximation.\n", + " Uses numerical differentiation to find the variance preservation factor.\n", + " \"\"\"\n", + " def gelu(x):\n", + " # GELU with tanh approximation\n", + " return x * 0.5 * (1 + torch.tanh(math.sqrt(2/math.pi) * (x + 0.044715 * x**3)))\n", + " \n", + " # Generate random input samples\n", + " num_samples = 1000000\n", + " x = torch.randn(num_samples)\n", + " \n", + " # Calculate numerical derivative\n", + " epsilon = 1e-6\n", + " x_plus = x + epsilon\n", + " x_minus = x - epsilon\n", + " derivative = (gelu(x_plus) - gelu(x_minus)) / (2 * epsilon)\n", + " \n", + " # Calculate variance of derivative (gain is square root of this)\n", + " gain = float(torch.sqrt(torch.mean(derivative**2)))\n", + " \n", + " return gain\n", + "\n", + "gain = calculate_gelu_gain()\n", + "print(f\"GELU (tanh approximation) gain: {gain:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/uv.lock b/uv.lock index f61fc76..df46287 100644 --- a/uv.lock +++ b/uv.lock @@ -50,6 +50,7 @@ dependencies = [ { name = "omegaconf" }, { name = "pynvml" }, { name = "pyyaml" }, + { name = "randomname" }, { name = "regex" }, { name = "requests" }, { name = "rouge-score" }, @@ -85,6 +86,7 @@ requires-dist = [ { name = "omegaconf", specifier = ">=2.3.0" }, { name = "pynvml", specifier = ">=12.0.0" }, { name = "pyyaml", specifier = "~=6.0" }, + { name = "randomname", specifier = ">=0.2.1" }, { name = "regex", specifier = "~=2024.11.6" }, { name = "requests", specifier = "~=2.32.3" }, { name = "rouge-score", specifier = ">=0.1.2" }, @@ -533,6 +535,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b9/f8/feced7779d755758a52d1f6635d990b8d98dc0a29fa568bbe0625f18fdf3/filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0", size = 16163 }, ] +[[package]] +name = "fire" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "termcolor" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6b/b6/82c7e601d6d3c3278c40b7bd35e17e82aa227f050aa9f66cb7b7fce29471/fire-0.7.0.tar.gz", hash = "sha256:961550f07936eaf65ad1dc8360f2b2bf8408fad46abbfa4d2a3794f8d2a95cdf", size = 87189 } + [[package]] name = "fonttools" version = "4.55.3" @@ -1851,6 +1862,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 }, ] +[[package]] +name = "randomname" +version = "0.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "fire" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e8/c2/525e9e9b458c3ca493d9bd0871f3ed9b51446d26fe82d462494de188f848/randomname-0.2.1.tar.gz", hash = "sha256:b79b98302ba4479164b0a4f87995b7bebbd1d91012aeda483341e3e58ace520e", size = 64242 } + [[package]] name = "regex" version = "2024.11.6" @@ -2221,6 +2241,15 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/9e/0f/3571e551b524b3d3ddfa7fd3ec8065941faf4ae1278efefcef976d93587c/tcolorpy-0.1.6-py3-none-any.whl", hash = "sha256:8c15cb3167f30b0a433d72297e9d68667c825bd9e2af41c8dd7dfbd3d7f7e207", size = 8111 }, ] +[[package]] +name = "termcolor" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/37/72/88311445fd44c455c7d553e61f95412cf89054308a1aa2434ab835075fc5/termcolor-2.5.0.tar.gz", hash = "sha256:998d8d27da6d48442e8e1f016119076b690d962507531df4890fcd2db2ef8a6f", size = 13057 } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/be/df630c387a0a054815d60be6a97eb4e8f17385d5d6fe660e1c02750062b4/termcolor-2.5.0-py3-none-any.whl", hash = "sha256:37b17b5fc1e604945c2642c872a3764b5d547a48009871aea3edd3afa180afb8", size = 7755 }, +] + [[package]] name = "threadpoolctl" version = "3.5.0" From 841f14147e37601e42c981c0a370e4699ca72b2c Mon Sep 17 00:00:00 2001 From: "jagan.pp" Date: Sun, 5 Jan 2025 13:45:35 +0000 Subject: [PATCH 05/39] added pycache for gitignore --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index ba0430d..32e7a1c 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ -__pycache__/ \ No newline at end of file +**/__pycache__/** + From 1c15a530c61ad83259d30023184406f294f493ec Mon Sep 17 00:00:00 2001 From: "jagan.pp" Date: Sat, 11 Jan 2025 14:48:34 +0000 Subject: [PATCH 06/39] added tokenizer utils --- .../models/translator/notebooks/trainer.ipynb | 277 ++++++++++++++++++ .../european_tokenizer/spm_buffer.model | Bin 0 -> 2446754 bytes .../european_tokenizer/tokenizer.config | 1 + core/tokenizer/__init__.py | 3 + core/tokenizer/setencepiece_to_tokenizer.py | 76 +++++ core/tokenizer/tokenizer_loader.py | 97 ++++++ core/tokenizer/{bpe => }/trainer.py | 2 +- core/utils/sentencepiece_model_pb2.py | 48 +++ 8 files changed, 503 insertions(+), 1 deletion(-) create mode 100644 core/models/translator/notebooks/trainer.ipynb create mode 100644 core/models/translator/tokenzier/european_tokenizer/spm_buffer.model create mode 100644 core/models/translator/tokenzier/european_tokenizer/tokenizer.config create mode 100644 core/tokenizer/__init__.py create mode 100644 core/tokenizer/setencepiece_to_tokenizer.py create mode 100644 core/tokenizer/tokenizer_loader.py rename core/tokenizer/{bpe => }/trainer.py (99%) create mode 100644 core/utils/sentencepiece_model_pb2.py diff --git a/core/models/translator/notebooks/trainer.ipynb b/core/models/translator/notebooks/trainer.ipynb new file mode 100644 index 0000000..eaecaa0 --- /dev/null +++ b/core/models/translator/notebooks/trainer.ipynb @@ -0,0 +1,277 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "import os\n", + "\n", + "# Add the root directory to the sys.path\n", + "sys.path.insert(0, \"/root/AI-Uncomplicated\")" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [], + "source": [ + "from core.models.translator.config import ModelConfig, DatasetConfig, TrainingConfig\n", + "from core.dataloaders.dataloader import load_tokenizer\n", + "\n", + "## Initialize configurations\n", + "model_config = ModelConfig(model_name=\"Construe\",\n", + " num_layers = 2,\n", + " padding_id = 0,\n", + " hidden_dim = 512,\n", + " intermediate_dim = 3072,\n", + " max_positions = 2048,\n", + " layer_norm_eps = 1e-05,\n", + " model_max_sequence = 2048,\n", + " num_heads = 8,\n", + " attention_dropout = 0.1)\n", + "\n", + "dataset_config = DatasetConfig(dataset_path=\"./dataset\",\n", + " dataset_shuffle=True)\n", + "training_config = TrainingConfig(tokenizer_path=\"/root/AI-Uncomplicated/core/models/translator/tokenzier/european_tokenizer\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import regex as re\n", + "import sentencepiece as spm\n", + "import core.utils.sentencepiece_model_pb2 as model_loader\n", + "import torch\n", + "import json\n", + "\n", + "class SPMTokenizer:\n", + " def __init__(self, tokenizer_path, bos_peice=\"\", eos_peice=\"\", padding_peice=\"\"):\n", + " self.path = tokenizer_path\n", + " self.model = spm.SentencePieceProcessor(model_file=os.path.join(tokenizer_path, \"spm_buffer.model\"))\n", + " \n", + " with open(os.path.join(tokenizer_path, \"tokenizer.config\"), \"r\") as handler:\n", + " self.config = json.load(handler)\n", + " \n", + " self.peices = [self.model.id_to_piece(id) for id in range(self.model.get_piece_size())]\n", + " self.unused_token_pattern = \"\"\n", + " \n", + " self.token_slots = self.config[\"available_unused_slots\"]\n", + " self.filled_slots = 0\n", + "\n", + " self.special_tokens = self.config[\"special_tokens\"]\n", + " self.__special_token_slot_map = {}\n", + " \n", + " self.start_token_idx = self.model.PieceToId(bos_peice)\n", + " self.end_token_idx = self.model.PieceToId(eos_peice)\n", + " self.pad_token_idx = self.model.PieceToId(padding_peice)\n", + " \n", + " # def add_special_token(self, token_value):\n", + " # if self.filled_slots < self.token_slots:\n", + " # self.special_tokens.append(token_value)\n", + " # self.__special_token_slot_map[f\"\"] = token_value\n", + " # self.filled_slots += 1\n", + " # raise ValueError(\"Slot full\")\n", + " \n", + " \n", + " @property\n", + " def available_special_token_slots(self):\n", + " return self.token_slots\n", + " \n", + " \n", + " def get_unused_peices(self):\n", + " unused_peices = []\n", + " for peice in self.peices:\n", + " if re.match(self.unused_token_pattern, peice):\n", + " unused_peices.append(peice)\n", + " return unused_peices\n", + " \n", + " @property\n", + " def vocab_size(self):\n", + " return self.model.vocab_size()\n", + "\n", + " @vocab_size.setter\n", + " def vocab_size(self, value):\n", + " raise ValueError(\"Assigning value not supported\")\n", + " \n", + " def encode(self, inputs, add_special_tokens=True, return_type=\"pt\"):\n", + " if isinstance(inputs, str):\n", + " inputs = [inputs]\n", + " encoded_tokens = self.model.Encode(inputs)\n", + " if add_special_tokens:\n", + " for idx in range(len(encoded_tokens)):\n", + " encoded_tokens[idx] = [self.start_token_idx] + encoded_tokens[idx] + [self.end_token_idx]\n", + " \n", + " if return_type is None:\n", + " return {\"input_ids\": encoded_tokens, \"attention_mask\": None}\n", + " elif return_type == \"pt\":\n", + " paddded_tokens = torch.nn.utils.rnn.pad_sequence([torch.tensor(p) for p in encoded_tokens], batch_first=True, padding_value=self.pad_token_idx).long()\n", + " attention_mask = (paddded_tokens != self.pad_token_idx).to(torch.int32)\n", + " return {\"input_ids\": paddded_tokens, \"attention_maks\": attention_mask}\n", + " else:\n", + " raise ValueError(\"unsupported return type\")\n", + " \n", + " def decode(self, tokens):\n", + " if isinstance(tokens, torch.Tensor):\n", + " tokens = tokens.numpy().tolist()\n", + " return self.model.Decode(tokens)\n", + " \n", + " # def save_to_folder(self, folder_path, name=\"model\"):\n", + " # m = model_loader.ModelProto()\n", + " # m.ParseFromString(open(self.path , 'rb').read())\n", + " \n", + " # fillable_peices = list(self.__special_token_slot_map.keys())\n", + " # for p in m.pieces:\n", + " # if p.piece in fillable_peices:\n", + " # p.piece = self.__special_token_slot_map[p.piece]\n", + " \n", + " \n", + " # with open(os.path.join(folder_path, f\"spm_buffer.model\"), 'wb') as f:\n", + " # f.write(m.SerializeToString())\n", + " \n", + " # with open(os.path.join(folder_path, f\"tokenizer.config\"), \"w\") as f:\n", + " # config = {\n", + " # \"vocab_size\": self.vocab_size,\n", + " # \"available_unused_slots\": self.available_special_token_slots,\n", + " # \"special_tokens\": self.special_tokens,\n", + " # }\n", + " # json.dump(config, f)" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "metadata": {}, + "outputs": [], + "source": [ + "token = SPMTokenizer(training_config.tokenizer_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['', 'what', 'is', 'zo', 'ho', 'cr', 'm']" + ] + }, + "execution_count": 103, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[token.model.decode(i) for i in [token.model.Encode(\"\")[1]] + token.model.Encode(\"what is zoho crm\")]" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 1, 3027, 1670, 2465, 1840, 2418, 108127, 2],\n", + " [ 1, 2222, 1670, 2031, 1482, 2, 0, 0]])" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "token.encode([\"what is zoho crm\", \"this is jagan\"])[\"input_ids\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 105, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "token.add_special_token()" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "token.model.PieceToId(\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [], + "source": [ + "for p in m.pieces:\n", + " if p.piece == \" ⁇\":\n", + " print(p)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ai_experimentation_env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/core/models/translator/tokenzier/european_tokenizer/spm_buffer.model b/core/models/translator/tokenzier/european_tokenizer/spm_buffer.model new file mode 100644 index 0000000000000000000000000000000000000000..12f27ab80e041710e74244d24cefce2238708692 GIT binary patch literal 2446754 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 zZawgBJ@9Tl@NPZuZawgBJ@9Tl@NPZuZawgBJ@9Tl@NPZuZawgBJ@9Tl@NPZuZawgB zJ@9Tl@NPZuZawgBJ@9Tl@NPZuZawgBJ@9TL@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n` z@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgU zZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+ zBk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n` z@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgU zZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+Bk*n`@NOgUZX@t+ zBk*n`@NOgUZX@t+Bk*oB@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR z@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5k zZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1 zGw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR z@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5k zZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1Gw^OR@NP5kZZq(1 zGw^OJ@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB z@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&c zZY%I^EAVbB@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&cZY%I^ zEAVbB@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB z@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&cZY%I^EAVbB@NO&c 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

qeglx$hFaSE?swR; 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

Okm;gAVDH*0h8s6-S}V z>Do+u2qOPdYl@?XkxI(AXI^*&kt)1NT|AnUQ=GtR>Hip#8a%^c;&DIo+3i`GJpqu* zLHke?jS!3NI?AUIgM+^n$fCu5uSxc4I5xO$wjIl7kl|Ypsyg$ZosSNIV+`PMa;b(Htx zj^wUtYDmvyYG|bN+D`!*^74IK=pcTl{&%!Hygx^$YjC!zhEsaU7eKA7_D<;_h_u!H z6wI$s;c%gX4pKsr_Fy{~@J)yWjQkc6UT?vBtu()bq>YxxehX&O0*`$UAB=g>7G(t~Lo=z)|fIt#)63JKeFE@CU%>YvaFkniKxdmDkI1;q?;%E5n=ZlTwCG0!6ZXq%@L~dy=*j zSuO1pkc#+oHJDTV4o9Z18X!&sgz4?{^2+ga2p;POa>K$IsKM~r?7x-anJ^VKCZIQU z10naDwya|B@H@?M^dP~XgUrXq>(n?^0}%c#2_X1A50sYBZW)Tp{P{hfcEa%jr0?;# zFsfdN2*ZYa3JXO8l3ck68O?BbaZgmsx&35$2?T2lU+uG(hE#VuOR$$AmD!S@?V|Lz zH#3oy$>oY9uXk&zyAr9))LoiI9?7ZQRd98Gw;hxx&ufx^OLH^qUW*(Qm~+3Vp``#^ z*THr3d$heaLR=3lrnCkHxB*27(<4K)pw)=f`tEl7_*!%%&11X#u+{_8(c5~97kBZ! z0XmSK1Ho0<8zFKP7m(C8AtK0fwr(4%TR?bNKE$V*E`iEtIH{FkbXy0?C*Rbu<2X>J zA8JH0Af8)nuH4!m*S@GebQ?fH*nDjBNPasyEoi0|KzHP^w}q%QgWZ|;S+>gai1dd6 zYGU=eZ8lK+PU(0Ej8>GpvHto-1{nH7UYA{6`y&4dfD*?!qYhtEA$l&HFs)o@5IvW@ zZStByrv}^opjK~kngvEQ&F7dJ(evSp*7nX8A7)U>1~SrS{L#uvn*gO+ceGpO z?n38FEh<7P@$MvQ8)y|A<{os4-Nr@?-`lg9{Dr zYRr)pWqqa7F6tt)SJ9E<*5#uWfJQ-H>sbi1MyEjLvvqc$Ej5mSQt#z;J}@#I1^U$T zKh-3SlVizdakPSL(UpchKS0 z(tfbT{4OlajqxpR?7s(!Je_=H*g$5a;e}IS^qQLc0W^6F?v2?Gdp@i5g%;2JBaq4) zov)7l@d{Cnd7t#e&2h1GgHQ9kf<(|J5E`N}t3>`eYOtVLK3oS9D@wmtzUa8E#9eMq z`KxVZ;{Ot!A|>_@?!E#IGmM1FyPbA{7<8&q zK7K{^9s0UaYo(d|=0WPi0S5N|xn^$rJz3d{(J22wXe#@LH_$O2Unz@Iv86v(Pd^bD z_SVv>%hmcMNJOB+6XMC8=Ff=LQ_x}GUGal0lT(wXMF6N=PeVuWGZfs`flmiT@b)Fj zyXp*pQi`J9!a$#yEc7rmQ(7y|4VekY#=K97d< z8vwp*L?`0aNx4u8*jm5S6s8O%REm0Tf1AGZ|zSfriW`kX; zqh{41CX(Rof2htqiNJI%E7Z_bPd?a*mtqEn-t2%TJ3>4`O*KMYBwG%ZK4 z)`1=Ek)9Mw&0p@(WH#H*@L}LF^q?haJJ^0a2{iB$Hoc6K#kB|tTzHs-$EpN={sFOOFM196wTkO}(Lq_68AX%UFX^|lt~`Y<|OyJFZK zL50WNlhea(xqCDTn0-r+Ife>{Wklz=UJShs)Cz^9qC@zNxm8=%lE<5f@Zy| zWTonDXVM-3`C`IX>DKRp($3iT|J4caA;a-49E@lV=wv#?6{|YU2gg%1^?>(`?+Z^f6~eIRRy0S(Q!fvXtEk7Y6ZMOAYZ4>V2B&#l~An^(^Tpp;>e4osjIc7VcHB}G!FI?TnOR89+) z-*oy*U=h#Fg71u2OI_MuH2lQH;WCiIPPAyImm^49*oDgT3RH$tjh>57sXDFmU+F=b z&)V|Px(XSFheatTqN@S0SpQtXaX-+tT@ZG+qP( zE?#cv8Pr*$8aP)cy-{+a^^3LWFg3qq&Rvfjv}tFAn|WdbC>?UNoNj8z0{0uC;lBJ0 zeQFcHhigko-EKjpEasqgWN9lTIghodyb^5#5n`RKqf{Wm$eJNG^qt7$Uz@<5-`W96 zSC#y>4s4+xW9fE4dbMg&-*=#Oh&Jxu*%P-#B;}$f-tIC*%0*9Lh1h&C0Mwf8o0%;9 z#OGwY6?+1K&t2nF%?o9+zc)2%*-o12a^l46XJpXqK&bYcs~yU z^GQBO?F`97kW}-|GL=4z)M}P0Kr$1?-#kP$Vuhc{8DS2M?6VEW=5^7>O9F&kgrmL zYu$bf6?s`N)-3coAY<}O#dREez0yowR#E5kZD?BTj8rd<;nM z-`6~HKS}zbT@%g8g@p38H(#NIpi-RG(^C^I0L7O*g9=1i z6Yy7%e38F5(SDsQTp?0c(QkSdZbTbup1$9L6t?Zwd;h!seq18IM=SiQ8hw87JH;E~ zd=B_A58FxYpZbeymdaA{Gdg8kTT_kHzjQ<`I?7Jv$otdfh5no0N^V_LUGR5Qs&=C8 zd;0@9`1109t&#qOCsuNw9GaQ0ox>9$l9X1hRbk*Hfab`7Tka<#B9`6LH5Ht4oOV3{ zWdofBc61B;TQ2ET}YT>fDxFa{x_AAXLkbGn-MUS$94kIg0Squ{}Wu7aaB+_^!hc*LTFJ+ornT&=Ikl+ZebS5{a#=17vHFq{G-#8pHaYd{l(}viom< zWS+4!aA1P^U(IVHSdr&jKiq_fyf(Pim8Q{iVV-J!Ut4>M+AX7I^b`a_d7x`Ru$92) zbPZ%a%ZR6VBCMCHbZb%>5?0sIy4#RxoP1L2z}M}7aAGH1`a631gT?io$VjYAZ8f+K zLzH8@>8m4%Warw6QgFrq$(2KVMHUbX7u$;+;^MA#5a5CSp4ioM6Pm^ngaGTbbtSk9 z8KuGeq|RD3+}+>OZkuj;4qbHke*UdiN>FtZvgP%c% zxxGAA$p2Zu@hy}p^4xeuDL({HN$U_`z4}~7%1gR-6P|~pVB1>VF(`4LJ5<+r6}? zmtb0zR#Hma%cvBB+Ceg}p!1Ra2ShxD3q|MbuJ--&hsR=FYFe04qhz0QoAeqH1 zdbB5~+j_8ftS1l<0R1{TU*odb9H-uZgkv^Or$ehBy$MU9riV>rZy^<+;*ntD9TX-U zr5QLqz6%Hwo0_KdUJ_(4s>av%0mjmq+Ry!+ojjdaLjvlmE3QtYHUvy-%6>jywFO!KKv6b-S zfU2_`hW$E}VQKvqYDN;Hs_QG$w}9|jtu?-Q-@(F#vlj~XJ$leiDiqxh$aLR7*Qu)c zc0=8dK!u-f-mE_%!uImv8X)N$kYu?uUFzyDJr7%c=G2MWkNLHOt@ZI*@#b&+&Bb z=nP#I_`)Kp9RZNp*&fJwsD)KI2cZaR?#9*h4^)aU>_kNA=I22MePLm2a6sUESO)q( zPY)KL7k~_zn{Q$9=ufjxB9n_i$@XS^lrzA^JyAs)Yi@^^fbu0b!z}-`HKR-Wi*>BH zs^zl&;>hyR3QbNI0j1zmEiB&^o!-oPLlr@%VP#F&`p8v1(XOQhYSh(ejd8IF$xaC} z9M^H@X7lLC(Ae&FT;w`P$#JSI1=k}Y6Ja!LNGbIVpfsuNb=wWA2OvYZWv+X4M%(fC zwLMuy6EYyJ2UM%liclN+V=Kk#-5UWo#X_@aY(nP4)!=uPU)~lF#+=#l(XB}?s75<> zv8^Yc9vd7G-O(XqT}^Owk>oJWmQMre&*ypZ&DL?7+wxqzBwx6_Kert{ySwfZxdWt1 zxVOi*=uUJ*u~4Q|N=OoDb~F6+7(UQgHp%+>7$U;o?z*N*KHlGFG+Q9<3BX{m$o*Ya z)JdR0b*%KHsh*(SHkV0z23Ue=SHI38@|ERde9x3>9uh9gN}#tc0*KnqON-Ta069=_ zte&Rp5XVw~WxMMUl>9D0a@B*H#o%s8+I1bQE)AT?1Ez|7rrO25s0@V5|55SpL*_HO z_HeU=-VaKyOnuGj@c=|oOv<=;5D~`N<4T!$2#{X=uP>*1puz!@6dOmGsUGPm)>$S# zic()K{zJ_AFV+n81R(5Cz1nQ?WKXgv0)R>SDL@LLmE{JIr$HtC z-Q^JXOwXdO6|bKCY)2>o%|ZDP1Xr}i2{Qs!BXm0~RBt?wu8vX`dU^&bO`-*noNM<> zzLX?&2wXFI8I=y`N}CGd*Q^b%KqLMQwbFbQ8P12SE8FD%8VKh)huS)f7_^d^(GvEN z4zN~K8#oGxytyCQ)-1LBSjXzR3vR5M*XuCZ+PWiaFSbP2`|Tb0hj&fQ)kE zqjmA+JLuE_qgFf3@os-*TW%zK50H|$xGe`;-tQ2lS}YWteE$QdQ zeNVBvt@wUGM^M(B4u!nH(gCVZ*Fnmk{EmcF4&!qvFF$uocntd+dvNg!EG97Zp|kIq zS<#(-?WuQRf*_BqAAXlix%d=4e16YlWY!K1lLugBDU_QNsvBO|lWnIh%J(8b3NwDt^NW$>ZH{E_@H^65;>TRR zbC*KW{&tt&c@8pM1{`dntk@yrd3U)7$-3yL*QJiZ>857en44r#Ov&|p|9FE-jnUg3w( zV)d`>&mCHooU`9IM(+jh}5pf3##bLlSw%MNrJ!Bm~CXqPeVgegBCix$fC*1W<>Z5f~q+=dP- z)wP=1cYDue&UbVvJ?D;&kxE6xF>BoUHyHQ-W&<9Eg-u4-G8UAEHv+^$xdoMNcMPdu zdxX%_KF0G)Eunj;rs;S!5uya;P@IRMmZmjCZsl`bJ7mJ#k*?v$c{fMNky*Zegre22Qc8(ek3 zQgX1YK=*_ud)~cry0_=V)nR<7w2J$ZM3I*tuSmo9_arpOeJa6r3&^zacYj9*@sso_ z3~7zX4VMqIW_Vf}`?ieTn*{`e9M9>O5 zZkL=Ug2`i!@*Hog}{(>bTYCe&?G4T<)!f%@>f=)7rZJ@yni|Toh{?^eaem z=T9}+f}DO08WeYAv@Q<#1`wGvU!^9=Z+jv>8`T@X17O<4T{ZZBkJ77Ftzs1MbI@|z zQPm&O0|~b%PE~n74PGu)jbefd(_6}_@(VJh+Q4F4qt368aOfa@?ehEzJbyU|+e_`9r7IBOt6jyYm{&p~sIj5h+7Z60CsB*7zOPOWwx-P=*C6u6 z&FvcOYtaPZ8m(#?*P)VIc`)b{*8{>3wb_03s`-YV!$?~ntwu)@%P&kWKkxo5doVp8 zvs#I7JwPcY+j4gUf)FY)RyCuIJ%i~PXUN-0@J+C=xwUQnZ9#{zbqAcjqlo}yXeHru z+d@>7BI-wf)uK?X>_kUqwgB7hU$;V1sJa-I9zg*~4&KlaZtu_Ss`B|J<~u-xx!Mh4 z44kDK-w6zpbF3|_9-VfIQ&o&~dhJl%zc7YQA?BD_WiSp1BV!e6ylP;gLvzgsRp}-{ z`F357$wE*kT&8+n!*ze1y_f(AyS3!&vj7sx>8^Ri;7fIKz9hH^id-rHbPb3HAgM_v zI?Kn>JD2*4Wi)99>AOH_!>h_G;cg@;h~wab6r#EZ?YkUqJ-oN4UAu>laUU|@932~N zN8j$x+xot-NP~L-ojxQ~;l1pzOKn%_!Jh1v-R&wBbYCM(4K2UiRJ@0w0|8Td`Q}$SYg;BENPCpKa5S%19l*=ohfGLuLAToIpp~v9(-~1c8M}L24 zzFkfFG+@x&>Vi*I`b@oCYu_wh0y-?1toj#oM@ygbfcMJrbvnO_Uxc4}?zFk;Z& z2fC>ib)6-+ctZ;rK)~!jF^KURKrLC#XSND^Git{xWfY3QZ}fYc{@=;xkZkt&Uo<_`D}- zy{8;Fz5u0x+r9SjS#z&`_GN$9gxpT#eFaGo_VMrY=GTDKrjt}S_y!#gmS0%Zd$9U# z&t*kl`VJD|+|&bGeBWQ(Rbl(90)7DHW0Ou{QBr>F0CP?4;{62p|H!%@P|wGAU-*(F zNs=u|@<_7fkt9hT+x#)c{Kov|%*=0i#^ zp3T^r4AMXEYBxO2$Y(oxH-5<=$Ye-IUjE3>>cDat5RgGSfN5nFa}FRqV*U6YuVLs{ z=Ynu4Zwa5*BP_cnDuwfVgoV|=Wct1Ul;)dWeZ|nd5UolzOfc;tl!1D|8~;l5=#h2M zIGVkrN8ZNhgAN3pPO~;sRj!vo!?}`T;t~0Bm~z^BYN{&`a=ErF(y#1+Ym;d8(>7PZ zGSKYrTSeCQP-J^*-CEN(_E7tsrc}n8AYm!ql-^}CAeA)^NhL4q6v$SqIdKf_Mns)UtrUah5%rCn^$#!QuVz~jW@=-6}*gxLrnL*MB zI)%1JF1^9cfMhxq`s^RK>y-Z8kSG9YD(NYhP43~pgB0RJ+Wq=NIDT&@H?A0F_aU)q&!K%K#NCfd z#@lESRqFvjI(;+Jpgk_d&V$h8-fla|{h^N7CN|@qhaq7IE9l%*cm$L>dl15M`zU(o z4Foy0dJLebO@k}Z$9wn*@(kglho7tWqR1WqV{4`k8J_aH+Izb3=V??rQ5hplHlKrs zJ4TPUL?%?>XOqH8`8jybZ^diR`Bl3=k52KNO4q&F7XYbJJy6r8trtN`Jl^)<>^*uE z9zZIMm-F2U*6ymjf>g*-8foTNQAuxXyzXGA(Gid`Q2n_2sqtP5Z6@C^H6qIE=(RF6 zW!M`%4Na4mq}~Lj?xmvCzj5|07*6qDN6q1PI>hL>B;P?Q)82AWO4vw1ekmQd_?`Ch zjD|$sM-NP8JQC*h*-%M6(h4 z2^JAoU!-y+;c{c@^JIH6_yly)%cU^F1Z0gr1OH9} zrR2Q9*04GmuvTUAH9L^~tvjCrPgy2P>^SxJqzIlw1#$%_`Lz)ttJ%4{5vDM94s=E-uB@TNi|k1ks+f1aoG;n5I_31;})<`p^2$X1`P95@*M6tue9%ma1MiOB^Fy^fa#1SKFZ3*2D1F zRp(aQ0ZPvFZl-S5?dabZ*~-ai7a&dVwYw(L?1o_WWIO!5p@%oq)b-XIe+TM>m~_zr z(aXBzX24K0+mm)!eG4ef`KLPH8SPOVOxFSC7(kW_yeUv}AkvN1{NNNlVo48l9X-|@ zTXRL<2S}s2jINod(aB}97WbKu=8N_g-CU18Ki>45^MEvyqbnC5Cre|y2*h{0vAtZk zS$Sd0Nk~_@uH3lXimZ9dwG09VBAYR`7+Az4r;@o193IS%(~OmF?{*MI^G92gY^k*F z2qN9>^X|Uj<((a|M{Mq1?&`?GRE|mR?uch}+AiT9Nci9wUrzU;(@(aRYjNU62mWzs z^{+a`{TH|bGqEq9jkk| zyk_cChdb6TakQD}Sy)OrT(+&9-*dqK|5f|;!qf9Tye6AHP^$}p1X%4aD+&&vIsgIM3ye{um06B15F5csF>|#yUh7&k7*7x2OU9&8}^$#P?Jj_a%TUh zue=^&@uqG{;8GNy(eA6s=hR5Jv#!7xrw#k^b?z)n}^*yaN~-aLF8J)X3vq zU@Ei0VLsUeoor?gxFyjxPVe`WN(#jI4*+S@b{F?Uq(W;><@~58V4)cX#>cSayu`!H z;EweZUv(r_sbqgYdC)* zs6a5~VA*ke?YE+q|0PE*J@zI(`r9h?ZN59RSAg#j3Zx#UR*}E&;i;h0qCbF2f_bJ* zls_hd;clyl7eDm~#fz5a&xz2SbP!EY;eiIP1^!n+7Ui9bTzJ|5SR$MF+QebJ98*2-B3^M#$Voh5Lsbe8&?LRj2kK@qT;To*!9p68CWk}!? z&?(%uxFtEU18%t#H&04*Zs+B8a{pS6S=8keKxX*^v(A<1usooG?WZP|yQKo1hDe1+ z##q|WQ`SN8=}>H)nrNE1Gf*k@E_)6_30lDjk%L|GS%B30+PW2Yb`Nh8DZ_L6=gs9N z_*`VT*=~QC(@7&Rj2M|NZT0zx@XgT^pF0GSj#$6EFhwZoh)XIgQ%NO|)MR+@yE!Si z7@DG8Ux6+`rYiHimXk_Cm&q6ZGNcl8cwR#Xe=hG4JT+i~xB?vmqcz_u3(mW0TYRN2 zy7^+=!?-HR=%d4N+WG)`W?8%|$VNcw*lt`xHbL;5Zm(v&%{_wq5OrH;3m{x`@ve;N zMA-_%HA*0zbQ>a7n`_5&+tJCvremb0;T;e;D8$BX#1d4-?zW}jn&9pPIOvo^C2l}T zaR1UiDt_&DBRagf+Hxzsn-YL}IL0bBqmv^UupQst0!bdrTx2$1Qlp8a5Z8~_<@qtR zLUB1<%ku;(dDJ~7c}xP5rd?J$DBlN3i|#E&`!upQdwUC@^sX~K(6)LyX|AWD|Fl!I z`HqzBSZ&f5A*#D~&3Df-T6;RpA&~f;CB~Apz|K9Vu`A%Ti5*bctZ1j(VCqvMmFfI; zl)^d!i_s}E{BUO}Gv1vEfgcl9(z}ot5Rc1s!{%;)HZ~MB$vych@Yd|p@9nX@qeTos z%G`ud6UhDj4?*l;|KS2BEPkdP7!1`q^++OX#9XKC z-v@uVj{#CMTExu0kAuRU#c_|5Hj&{8SUTyBkvi3V5}iWS+FdpPPeD|n?X8F%q4qCK z)_udnJ+?>f@%mYG);0F6rHd(tXV3LO8(2zHcc4?UGFxhb;tL=Zy%l?3^fMLRI@_+@ zy#$c|c!brLd*nJU@G>>IB9XUTP0``!Q2N>Bw#hyM83y50>6u{JbLzOZ3AU`3s1#HC+m>Fa4I_>Pv0Y_!TO-A8hU~zD9?E z(@cfc`x`*oe1k=BAxF{QCXMo_rNrO$IAp3aL;N1Fw&IKv@@uB~0hVI!Hl*7*2_$t{ zh&3AlqDO33cgN}h$Dd&-k>i{Zz48}8ihN^h$6tGZIu4W7Z-8)cq|6eI`X6fvIJ+zt zfJXyTlqT0;>oFZ+P)0vQa)96xyXuw0mNY z=6qI z;dhOrnYvth9wO}CQ-{UpBg0*~khW}IkO0&aZ5Fu@iM1xd%IcyXduMI#FGf}_+jbHj z{7wg1x3q9@WYSQ(G@o7MCp-8pBa(gHNvrAla!7bd@2F#5(P=)9)ci_x8p!?IQes_| zBn-sW$8sTJJtTQmiSL4@j$V$?e|DpX=382@ zZ79#AH^5R)!cPt28vznl&kgu`6Dl3ZMwfdl{!QsPfXS_0n|EeXUMX%#M4EvK$&7}o zsY5PfsIaPx(3k6;;sgk*OhZaKiAX8fK@_+50fyzH2~=%AJPl0wIn(imLpev9frU?t zRceX&4_tr(~9pCU!rX*c6V`x3n5Pg2Om!kH>oimtmUn`iVsF;2N7tas^V&N+gKn z^%P*ObFkMg@%8CIdCMidJ={Z)pvK$L(X$}6VrE<&_c@ew_l+Mk8dsF;d4Tz0s)q9m zey1Ar2c|vJMI!6x+x|pxfeLrWR-dtWw2i>aJyLB!OE>fiB;4`xmb$#!>CNrt@DX&X z;-zr*9HP7iN~djFls3z~-lOekJKs0Zkzq~Ki&i3xJ)R2~qw;<^iyI5fh z@-`r;+q~4?(inKB2P%mgBi`+RYYMgMy$4W@OzX<{erUX?Gg4wmr+MfT$0v~Vt=Tct>ZeG3%Z^PWe1@oOF~atX(xQjGrjD(@K!$lN zYl*6$FF~?eP^+)}lu{i|(^VkST->JG_qSK%z5%8%2kM1yalTFT{g#^V{2V%&LD3eM z?>khd&+U%N51{b3+~h03kAP%U{yXb>Cw_Y52B?x5KjI zU_)W8>Uvt~&5!Q^N6qiHIwGF{OCxQnv`$2(S5snP+ev68TPVJr>~}a)UDL-?07H*k z8rACU{We(AyShZ<(|Vk}t_S1d=>Yv_P~@C}N_NCMM;d4L;6$jJA-R9~TqtR`dCp5%*Lr1tKB70`+7+w|fGP7e+jml0^fa32 zSl#m?kWvr+l`cl5)Yq*(CDBVdU2a^78|Yyucy{D3rqatg6160u12PO>n`$M$0+2%N zu4(T|WGZ5W)ae1S<9F!RQhShl)_17A4pRemBPc5}p>xzZWz(2#f~vsmXj89mMy(Bx zr`eVhJ|L+Q=|w--+Ed9b3zv))Y8y0#`h#tL^FzA5C$+F-j@K)8^gsu#sO`jJSBE%! zU-Uv80i;9LmS{3>0Hr&TVJF6$P;?_KT$wC6>L#RWxF}Ioy&084JAK8VThQTY*{j;L zi~{;Wpks=)1|Lf@?9i)L6R6ZGZ#JsKWQVN4G1%S*3eP;>q84--kYvXjW}T1B0EPn_ zvaieWG(Z(_4sPnI_fhBlOzV*KXBLJFPK(fiuh1soE`!1hjvmXKxAbrA!6-78X-df= zpzvp`E}h+m95^t=$vVwOkJ2u1yrj?E0ZK)#86R!$5!?wennp*;aOW;WMo1aE*csM% zyBnBd8~XM5WK(e815L3H%#N)dF6r%Fkn+?)Rq5gGL#8}s>PsZJACS~nmN=G+y5Rxf z&>d&Tn;Fl89kDtvAR?Lcl(47Xw0jt!(57L6+#@}Fso~01{G&a*`<%7Ae5?oYnqnIh zkM|&aR4*HXPXJO&X7{DiWSvh)fy#)H1>z}0<|AEn))mN784*&zdZI^9IP#PGVYGU$ zIBjGMYZiYtfMu2Q#XUIl93Tz1wPda5lYsBn%vQU;fDTKT!md;kyqE|M@%GoX?U#_@ zeXjpu(aRmOfygC`S3u!^-G-FytAJXtH#k=D)3oVuk7UxLa&H+S>vfQ7yXmajZy-|I zwp_l6Oy@KQxTRM@)LXC&Mu&Kkd>b8R=D8COL*7LofeyW^9jCX`rFVg;?1Cx27W?-g zsU4OY>uUEtD4bt?xP+U5^B?q(;|vN|x)4!7sWfM9)jK`{q`10nor___$FStNnYVxv zBtC(p0y%^Dv?rqvmM7%T0BdD$o8>Z({T!HTuB$_bI<>*CFQE9fRKCbm=gS^wTj`BU zr6|x>P?OmnN<*oCjY{^LnK03yprgX(cdN{K7S~js-};jJ?VOsfMfN*D3f9~?rU>8n z^!D>vN|VxK)l>31)Q^C)>Gm2hKOu*~jNhZRFZ;PeZQZCT=$AxVXCGY0NWUV(#r>;K zA1LSFzd=+=N3IRlQGZ@5>ebA4X*Z7sB-35<$YYQxd0l}VZq*zMOrqDvYFt7o=Dy2bv9BR{X}4@6QM}BlR(2@7-b4WpaG;`%&fj@$*2mR(&Mq_ zjob56K`D>R2u*i%8YIQGl`Jj7K8<{Ok9nQTgKa51qsP3)X;eFu>4DabOpmglCE|e6 z@SH5+`q}8}JHtluoSw#%{YXtn=RyqJrBZX9=XdJVZ0rd*fTVUk3CfvF4=^^nG^)}U z_5ggbV$?-wLK)-5DXp)vk3tFa^^~%2r3rjY;QF85>fu z^mOVF!&0*uPzywqD~NQ5dB$VSk=|BNlGH;i2qmj;gN1vet52%dc691F>N<#ddIuo= zcioaU-_^e}T(1GK8<0dT(X2ab?{)($L*h?YQ>vhng&hM=$2Xx(}X85F*i z1v`bCM?$1?3pjqxLO6#^HA;I#u*qjfgNLf0FCx{MKB#)>GOC)Q z`JTKLu~up`p|n;YVL{ynnqI)?+d8BRFv6v{yS+oz!0ig}9iUW~{{l+f>hO2MZXYd_N@F zn*(s6vVQkd48om2%->=^iX?vj+OMIfV99w zow+@ROiujh)R3TX0pU8eQb`O?gktAiYNsbr$zyI@dV4&(Mw|iGRC0hs@wDHmU)?^b zVjWHb=JNmR?};#|RKoyT65%<(kYaNe-u#6>pEyh9$C4O>3Wu7w+w^cR!ZeWU>nxe3tQ{dQ}d+{dJi&; zR(dz{+WUa8Yh`I}{BL)*+gKm;cs11P?TZf~*h7lNi;ob=iU?4zUuf2kVH&wyRmtWP zR2W#3Wiwa*v`2CsZ8-S*3>JQHv7}Fa{(CgnaGFotFF-P;`;+mPJ^b~v)25oQ&?PtS zBB=CF<>8B`=OIQ95b8{aUivcgS$TD(R?&V0gipg} zv3wK!1e8hHqG|k}QK@tZg3Y}8m!8a)+F}w-5~B_xw9jv-w9hqDeD+G?s3+I5shyES zs=88iG*GanJhWav3@7p3EsJzh;$q%^($?y6prsexhK=}PUw-Er_NFU zod}A|xaj2@8cVDro=b13TA=!p*QtOs>S$Auo!063_Kw8q z=y0;`%h#zRzMKKn%#N-x;Y>u592sq|sGilM)S`&BbvAi6FeNj|w&8RRBsJ*!K}>n>B{COZ5EHrP<)ez_RnC*<7g1zR}3!tgVhNXJHEb8R(UL5Ul^|T9o zuE$uX$>&jNg%!3wO%_-Lg-u?lsTj*W4dNMJ#&jx>6rPuFAy#?_CtTB|s=lo!GB`20 z9gx07Ky|^PW~4iMGJD*yA%!H8M_}Ccs1A7-AWgo$Hr#h3!-Rv>8`ZUPAL|}?s$Kpw zYVh6Lkx~|wW!Qa?RCIkg>MT?6`$4H_Jx?dr10C34Ga}N1J(=b~8^0fdq~_N-&?bbS zjX91`$sT^Ev^UnvS&t%<{6QNh$v@V=^BzX-Kn??7no)1q1DPhMG)sT?N&@gUxv%btyxIeJ-OYm_#n5%c^jhUp4*{E z>A^`rwamN=sQHl3Xk+d@RN8iZvu$`Eoh~~&SI_*_ocjUHgtFufI#LHB<=s%O|4APC zy3V$k$kD%ATAQu}kapp7WYU`>j(0#cWtXn)v;1Bv>z~j4&SW-PFL%1CgN0uJYY}P> z*?k#esy%c26(ZHPp?$fw_h0ApQWLqqL1-(6rOhe-x5yNG^w8e&nerVVxy_Evk!(0C zCvyP9jd@o&i5%$kHM2nZYv%Bl+yPC_C1loy>nDiJ$_Z7?u|J30JmSDv#eP91@3IjF z{0az@SICih=jyivVgWNg-+cTZ_0Ma8%3aLLNGyGPpHwwmXllkASBj3#*W5cVM0avs`XFg2Hub3UqA&>VJN&?6sY zUQmGYm>%Bpp>G$$JQKcU7S?*xZ6nHK%^dSQ(5vZMTbRg>6xFbd@lng;T_|9 z4Jrfaa*%?RPC|eyP&Eo>D#-1%{`tg zLEO#|Iv}am&aHGGNyU6RUZ*Ie4nWv5W=5oU$DWBEh=^TE>d6kwKIvzU>` z-JmdNB{%m;CHM4rPH(HZ?(OmFOr#wp-`C@jBPsi8LAbxiTRJd%(1iX#kEgln1~7@E z$0MQ>^h$1c2o`qJ_v+IRqqQmBU{&i86qb;I%{q@FQUeYU4=t7k=&^if0;Z&oBhs<1 zEhUP?pMazvX{nMdi|tPWv1;{jdxa1io&qFYXUPlAY5LQkY6^`@>46B}uc^8DS!B3o zt)PmlmGe2+nih#atC_K!m^`1D96_~V_yRHoq?&7H(=S4dJfaMt!|xQsd#CmMJHZ1~ zlSB5nuk`4Qa+k_7;MI=k@XdVhNKd4+uKp=LKoKmNhg;g3xu-I}4o{aU!wDJ zGi`x;6Qlr5>q-C#Rf~Yk-$vn4F@f}fSeu&4@aNrpoL?%5`n|-fgE;(uA2l?S!?IGv zd;m$!C&v$XkQDSGD5Ff95#y%Yi2ewgB9~&+%<*vt=0>QGC_exx#}?uN83diiVzbKs zRP~C_U}?{Fb&LA*9wZNERC|5_OZIk{ZQEN%r(Z&c4tR)fjnYKUDrKNOpem&kfha@0R91{S>Z!H*8a@mMRPAVx z6ef&c0ggdQdu6YtIM(m9%^#BdaS3WZ-n@<=f|4|?qzRA^f=u4CbsQ?K6Cr82og@Lu z4|JGa{u$MUC<01jQhj;Gp~RC@U}?;@B%a!XuqmC+3Fm1&$d1}qoF39iMiY$BKqeom zmzpE!KtQR=H6Dgn>$3pq4(tf)nU>}c{A{S&FV$A{9KRKVZ%Tq&uU>?-{Uyp zZjt`9iV6ARq6(GII(B8TtN{^dMakPyi0x)C}WZV zT5X!DpWY0_;$@q2BkUGb8riG4I6R6@S$C~Ivqu%j0LEr66-*>9lbjlElc$W+7Np#nIN((iIN>;OD`^$iOz60EnmTb2O2xDR;Da z83f%|%-Y#iv#bD9Fz-#aV7EaAj!zp>wYcLBywLUn$Hqa??>3~sqf(EiM5_(bBcP$~)laeLQAk*{zfMJFrYrNufSDn@VZ-z_ zp6?!qrbr7*?NH!}o|+leE1IMc$S_lQ_+qq4&riX^hV^wM^E5K0+PeDkLhG)FK{fT1 zFQaGu#*=#NkHqvGYGCU8c+(v|4@s5FBOm<-IypL7TiU;WO80-UhuO(R2U(=khO6qm zj83W?ezgOtS0Hk&OMDpjY7c*X+mIbWr{Xkzb-U`do`CcFW-|YJkFvYjf4lTC zIllQj;uY~)ecpnE6U>Y97}nc85Fd~hK%xi)Z>CC9{I1{1!3;yctyShdK-%d5t*D)A z8+q?TlWskx+@7}i095tk8bAmC5S98@=}SWR2vWJ+ilZO<9gdnRm|xej`w1*uFK+?_ z5%j>3gUu@cvktVQLUIT|tJ5*Iwf+lavP`1Hj~;_(*UI-RK#Dy|Tx{~l*C5&IBnx^N zp`)iltI^y?e%q0W#sL}*kP{m!67*VYPuH_lq!SR{ zYy37zoq!w~E2j}B0#e?&|KNW0Bxn*|Zg-wePAd51;Eia4Og>iE)qkmJ;?$nb2FERA z+SX{N{T|TKPwSDVgHi%68S0M58Gux=4xme1KeNY*UrNwfpcH7sYz_6Zd!)JpRBOyR zL5!yMk`x z(?V20gOxm41)9q3ET^ICkzpdIN=+-fu}7=R^i!TqFD`9@ChNMCrPFN&s9>pGE&BwO zo)Fhs?KosBL{8-zq;wD45l=|nCtka{byJ6G%Q8Nr>))J6Qx4lo%DJV7*vo-!o5x2%;Ty%gC(_HLu*^h;)v<<8=bT!r}waupHVul&v2@1g1p^cD0;*gc?|3S49v(r_9a{ zYZLQH55TkZnC_>Bs0E#d{s?=NN z+|C65*wb29{p=@XO1Yb%Q_W^SCqU`sD!?zuaH(x@9Mb@jyITX4ZL0noD4gBgj?0dE zdM(a@CEbq50Z1-e%Zmc!7>K56hwFq6R2r|mJVYIM94yRn5yQLT27%%qpLk^-r30OS zN?B~tSK6lkL{Q2*SGT{YMgn-y#f)7QJQ*(usRek5&a^hNn>`2 z1?9zlhtV{Sb@J92eF-#W-M}`J%z-u-{{F%XFQgkmggf<;(1EJkNY6n;LX|k9CckgQcL^2pJltT>{+HLrgEt?wvF*Z%zmr%t3T4$RKY z)WO6UAe^6y2e7|8Y67IR`sMEHNEtoGoBz+j>ZSVtT3%?U@q~>2ofT}&N;7~ol(XvQ z34IPyeehqLI1w~ZSmip5YAqsC3yRjTXm@vB1T8 zb0=^QC{^QR%T|HF0ZF+IPF1_zmn2NbudrmiA7xayT0=?U`(z{2v3zVV?DSmH+YneQ|uG{4qU| z*!-4D>Pf^}_purAYMBsEB?QY)9D5ouObb&p?KO+TkZQ+g+XbFyQL4^0Ta^~SHFDGv8_J|mWG{nTX*IL@;UQo(* zeThOE;z;7Vg;GZKuMJdbcb&DMhVfXE0_g%U^d@To;R20w(}xbumamex`sd}{A|QDvL2Uurj^bkAvFfRE6lEkmxxvSn#`x>CXkC*E1n;v`} z>8I9^Zy`!+qgQznJ9-E;ViZW~_#L54DoNl6NJc>}oHxUe9?DJoc3krlBz!O*>pnlD z!$q%m?;9&uOazY}Xs>&#Y7rS;)DR3vmD)Xod9#0|f@ z5~g~^ur)mvodJ$9(J(x)Zx((1Efo{p$By7nGt*Tl^90*j z9dg)vuvwj)4N9lhcqRFeyD;S(a7wT^Qd88q=uC6lOIdXuGF`-V^>Vs?K7a;##+rA5 zpXpHL;I=$;UIJpGHK_x$LCXg!fkpNu}e_e)3 z?)AKZ_PiXBwCL=_z5<KD4!xK4bltclXTVb1 zh4H~a~7Xbh6-d9qV&CVDLS6Fm!??3gB! zLCxU%VBytXo1>9=7wt(Nz?6(*iSgDqW_mcHIB~Bv#T+oj*yB!6xxt%<7+w4Kl$LrC z5f+bFTlC9ifTq4y2fEcy+*Js20;!`1wZ$x(pxXcg!zK@r;j2Y%PaKQE)<5nfc=R}R za4*iCfE1g%lD$)_|4Q%x>C!Au%Y6CnBw*@l`pJ8cDZZXFUW>%NkRexgcX^-SKA1x9 zzM9n0KT~y;_g($(0ho%^n5`>N4Q!JxHQX>dAFo$9e68gth86C-$t0)Z>^l) z@jFGEnLZEoAr`F{WGdW5at2k3BdlQZDv3*^JZs19Aa@Q;vT{JxQu znsYw}r1I37?KO%|ASv+3Of$%-N`DGeCx#5;Hi@61+Q@PorNW;hljz)3^TP8*Li5R2 zv+0+pWbvPt>S7MrqeqypXGzH(9axxYo33vFYkcMLw%JsC+c5%|yUk_m^&Kn>B4`sH zzDH-FYoleVW=!e-08R-vl>sWn2OwoC)6Ay(fP{BmI-Xvf#G9W%NqnST@cIQE&e&5p zVsC1jUwcY&YWud|dP;MYRn7kRsKaadGq*3T&C!4)y{p|#ItHEG7p%0LZT#I)$AVJC zx(r<%>o`c5vUi-TW6mmzXfg^q9r@Y=WScX4_z@Gg zE^t==eswuYI2&0bthsAAr+?d7j5xQ)H5-<=dmcb}tvMc>N1u-_+3rpS3;hEi8;1f*p~*`yIn(COZD z9AdkC>lV#F5m3Oj=wbAh{M>OZam3Hm$hygh(|ocGq$ilUYa6*8m7eg2mK1>mlKj}o z%Wqc?vDbUqHB5FxQs(Q+K@edCP%}f>D$sPG)L-uu_NE@YyujB~a5E&_+Fh&ZEy$tQ z*HbWMA3X|63D!5iSz|rM{*nPFkjZ{K8xlO81f&ji0lb=MA4C!I7T$FKJbr80c+qh5 z6kHIm*L&wWun;M29`L{K0GpG(Mey3Lq4q$le~wr7WjF?m%(NF~ZbhY?$LqdQ>ohB{ z)cTrQer`ji4zpuCvJ*N0sRI)m#xLX!NElNOS-4O~@&JV~ldFHGgSe{)*~tp7Sqj|^ zO5P@&dW~9U_w;D|iK^|rJ&f&&HKJ}9+}FeGZ1!~b_b_v_W6ph>r!!c}xHj`V2uU>@ zBi4TSAwc-{`#GY4^)T2d*wfBjdYr3ob@hxG0vMXl%gr@aKL*Ku+3t^6|6i+MW*eafP^Ir?PkT3=y1)VvS?RF90BPJ%i|@$KHa|)k88Fjh~)d|$Ru7pi%=t{ zo5Oj@bNR};-YoNck3BNR^+l;%UI3-^=Hm7g(ThFMlGo6h1EZHZw0BJ{{W3_Y_BtXZ ze)L4Hp3;Ym%U2=cY(3bh?T-L-F_T7h@Yi~Txe@OesO9Sr=}op<9dCqCWh{CVk)-P7 zPrzIGT1p|h5kwX=zAg?8mbdQ!dy_O@sqaFvFUdU+j|dp4??LrymN#uOd%s6(cSe=^ z14x=@e|x|3Lv+frGehyCq+ngzc=a}-NDuFZj=A&`bX@3%m8LLP=Gs-2Pkl-m>y?t) z;(Z3eq60j$X_(JZ840zNm)W5snI6Zsui1%w3CXxz7!lwrx~9#dKPN4Mehr~tP(u^f1suAO4qTT>@Haqmo2b{2sfj2@o>{{- z5T>ZcMLZgo@#C&)-VQtll*EOo9p$lraK7D{HmZ(;;9@(U65#lrNP8W-&J<4Q(1g47 zZDBbPG!)v(htDTazo!cXh zO}R!c=kt1~HT^Ilr6{)HS2CcV*A0m;JVfCly%Q6 z*Id4C>+$Qfo9}UwN)NPCx2q&}KvMigPlAzDdL*h?E1N;K8zh(i~o?*!Dm>+&q7+=UvLHqREY?Z@wiW%XF8>$wa3cqz&~&~&KPzbNdz$W(5I zw`#S$uLHDHHB|2hRI!{g(}*CFkB1N38?AxyAS@gsGqrj0p`HfA`P=g#Ok+{qUfU&)^u)@t zYOZOZUQ8g1EX`0&S1$pyn9ELeP3UD*gtq3J&^bdJ@2`MUcW$$r-PWre;R~tlqK8V9A@sMGfHhdJ=VIs`T0KLz0yN632V`%?D8Y_}hPL6Xl1fl$f$; zWM=hW=uCP-H5*m;`xuh^ck(_GA84PzQZEl8YS>TFX~fbLd8Dv*H=p&S>doaE#GiL$ z_tbRT{eICCx>|nJCurSeW~#*Sukz99g!jGlim%bBQVgMTIP**->EN;u1l-`vii^F zgI|E*rkmA=+H~+MNOh=ZFzGi$n09Ekt|cDz>{=pw$Hkxo*FZ-D6KEqZkdANAsm+0^ zjoksU1eVs{PJSq<1Yqu+qX#~|f2#}S5qZy}xQv=N|=IQ8UuslVt+`8)-u(XGx!=_k0 z6OuaZrlM7mvjG2_`BjZf&3kr_y8mD#>vKACO^H(``g0*E|LAgs@I6lwJIl$S`$b^<~}SDs-|gp=;JPKXOXP_>DF~ zYC_)F<6Yeh2{)lrWvAU`?6(<^mf(4r3Y)wFN#BlzysDRO3u&I+QTy!e zzkev06X;}bAJo?NNk~@ggY~4w zK4ePcOhJ*QI}J*@8riZ{+xZ!o;l40lXCHG2#jxF}BjtHi7*7XUE7Kytn7!Wezx?|* z9(}d;t%=I(eU)wnr7Wv|W=|re+mIO;Gvn@Z);&l{Jkkq11)@t}OHwoF9k5i4j*!1z zniWXq(C!>k!SCwf%)%VpINE_^aF?kVWk2H-MZE{Ch7@#IaBokmdWx+fn?1rzPm5(= z^LulDN7^Mu0^b7={4`{yr)xWaT@Ql7AT|f(w&o!~8p-{8lib6JqtAJDHs?N%fQD(f z9Lr`scobNCf0Z!|4GYSwy}#}iKkj$3D3J+gp8%v;|HQJT-4S~-;n(e2N1E|FC0IRD zH$b0G{PM#(>25Z8rpGrY&NPL@v!HaG`6c{%E>Wt`4lP7^9-usX>LB0+ztcL%b{z2{ zByH%Dj#IUgv0my)tdp~K^<_XxJ)upT-uD$y7(uvW#NF1?SAp4MuU$j4=r|o>KE4@o~tukH^DLkSRM$g4#cQ3P_=@j*11H>QW2N)h_1q9;Ldiru+gB zt~rdDFEa!33rt;R>psa>`OR4-(Z%m1x9qLArdEN3F=f!ar;KyH?SYt>nXD*QAo?<+ z>e_35k4lCvXz8y_YJsKhQ#8Ue(Xsy66WUHUSk?Qf2cy(kyOQ`bFhy8r47T;*7f|@3 zgIB~~ds2Jck*sm~TMt4sD0|1F{&lTxJb#Xr-sEUVdR`qPHp^VoSDBz>T{COjUQB6$qA*l+>>Q+TYaYbPh7(r}cn`tnJgUf%?slhH#%);n_g z-zhzW&8GBDMa!UhFK!2xr}Zf1wX~+a(-XunCLvYpodL-7*c2Rkqt}?ISb9vawKNsS zSsme7prw9xPpd8xE6+KA5)y4Ih%P;RdE~7YI1iFm+CR-{d^P&{AiZp%bV(QZy*8R^ z4Z5%gw_uF6UB^YB^bv)fbj`SmdND9V$yQ`;_1}4$f?fhm7o!N^gT1*Z=_!sJ^Z-!Z zox7|~Kxs1XA4C;W%jS0Q z&_DQ-FKK2+M~pEy-U%;|T2lVpuB`4xsgwn=%u_;G`LxB2h_r=VHQh~}UL3Cp|K?7Y z`%Xtf=#)|&%mRut+JopVm^6k?@y6z7+fID~QqyIv(vyBG*m#~c+SlW9Nh0}abOzE? z*>}t!Gmy&IRdMD3!+bKs_gH)7aJ~mxDQi=53LxT!xwafhmMOM^F2hr>x|djz)~%4# z#^XUHnGjt-N?>|y=eM`@5PZB4ghjd?6qY&0F}vJ>9wwlglL#yT)#cKMnBw=)JL7&y z7I(v{7uAE>2JG)u$F0%eKB2hWkK64thS_-~9=r=V`=xD4Ki%k|=2R zABiTYK^Ec|styFk>mv0-U=rL`UGrf-GnjbSpQ>$1i5HI~71M3`j(QZ8qPf$jVvnIy zjsxRFT;d5}=!vy2fIN`|6l3ES$`(}kTSx87wRAp}0K?OZPos29XEU-pjL3NW4?ZcM z1*Qxn4kdi9)0^9p_I!`DeSUUA6E-mgm~OPO9zTDvhZ%22IBf^>5-<$Fzxk2&j37w` zy2iLtg$*w4UjZvcEe&nxzKTw>y6o)Gpk|IE2~*QSyHoO74>LC6grjY&UhiRexwZJd zfgYx`HhD1x#)vneVOz;lG<5_OP+0Fqd4+i!kb({lZbsU<{X5__b5=Q$agQvvgU@$; zXj4FK(ceQ1oZi3KTn_4G?{{!zcGQ9Nq3SUo0Fy7*{WZ6L2ncJp|8XmsrGGD}So?kq z2xqdBDr2%wV5!f_n1ho__ft@s)u593XPq|H=|`WVb?0e4Q)m4m6oI*n5xztvxm}hz zHy8*mJ^HNYgb6R`bj*V*tgj{b4J757nxR@881Ol zeSZU`TZ}O(wB$D*;72{Tmh&G5A1O!wj!cz>ALR=qd^P#9w>uWC9F$RJ{^LRr>xDcX zk($<8heIa-hQVCQVZ}HRqOHq+Lhr*v*-AY{8XNuP<-6}X_SMfNOIioLh4ztFA#QtWy) zr{>>tAnDza2pn&cQh+JcavQDZg|@q|KLQFm>9z|Aq?80`eh^Eby08ZrR8AKGl8vX0 zct3AfkuFZGnwjToeZ8d9ylrFhrRc#*VTq9xWl8oom%%fAZ{9&NK@CZBY}7UlB$J-h z2DhsTCq1cl+pj$`UQ+*6@N}N?g|#-buZLnPqXS0+WR)Js!+~UrF{78f0@W=K*3rXe zzf*=GUp?xAk!|6 zO)Q7I(HTt5sZ!f9+>j`0(=LhKh+ONabq-2uNdU!~FD=>4$aJ{2MXvhZk`Q$#zV1|y zBEuuT)%)|}W6%`dx!kB=6CG%>Kj|gO$Y^hE@b~raGag10VH%K}n`y?MHOCAnrQI{) zya1QyAmQwdM%LgFb{?2|J3pg#ta)RxN42$TZ`m*Zj!>+YrQEF$9fzq%nQg70j3dGW zHr&<&?`P0mCl|MO%Oz2wsn)`x1lD8yP&#|%I_$3=iNQA zYX%P}_dt}z+s(!Ddr^dqEhdut{7fSsu+EZSI_)y;9|?9bPXh)mDS}b(3*r0(aJ89rUjh#``eL`u{;cL7?#0)u->{|Sh1z7 z#qZgkDzS>+860^Il+x%UdkBVgrt~}z!&jds2CDcA$mBd?=Ge3LM9PccRE<5lyK3|= ziRUE0sbgM7rc%}t$-aUPM=6EM+v2M|z((p)k_v6)2-HB--Lt#!-ZrESyk*UxUR9&wEDK6;c(3tZGC^IL*?D)sZw0L3rdll z(N$jW0m5#^O_X-kSnvObKz!m6UV1`24LXLF(1$(D`h5;!2{0YlJ3C!=%^w4lt+r&J z_^Au+cjha#Pf-J(`Sd9T(`S&BedG9oyIRyepM%2d#inWaqDQh7u}F|!dWiKTH=+wV zHHkaO60*LA$=F$RU9bD5r(ue8HICo{2|H$|H6gL31JhG;73X_EQXO6olJgHeoqE)- z_Rc>-Qh_lhRn74Hrw-M7&+RSDpFv8qTqZU|7gTDvqiw8zMJtPa=WyHnw;_18wMYH6 z%}DV{aWrD+iQ190(rJGAiE+oGQ?GI^re4PZObpIy2rT_0^n$y{x}FHh zD4MV}VsettKUA03z4H*vo<5Dv^BC8}m z1v-t{83+Yjs`o|D^g9{xCx$)?ounuX2r9^A#S*yLE9qrVze@Tzo z9u*>`0C0ACyxE);6EA}(p5SGvcR4CG+fWO`6$x%(U>VkKGhPWv`KjG?$E!MhU3+$T zeUGt^&2KSlBP876!K-w&n>sKuyZXQ6vKf#n>%Os`+yY7sOXctAp#+SrK!scVGrI$< z+}5MzH66U(4jNiwcC?=O*#XcJ3(cj%E=0<{wLOl#yNBlDrFNG$0II2|wiW!wP<5e1 zf4B*iIokfgQd4HLa=bZ#ND-yZy9JdTW*9D!M$qZV1n*{(KL$w&_i>S`*(LyM94Asw z_V0@vOXAi(K$?}h%c)DX*>n%I;OI;~Gl1kvFvh959$@>(>R;tDp8)zruJtdXlj?rY z3^|vS(=se`fBa6;%b0s_O-xc6>w>*U}lQ> zvaWg5Z>cV?9SJ^$PSz=kk3QGa8T^>n?(unG>Ns0F_7{-p2WBA3z2#Xqhsm zX+mD_X-qcX$#0;;guR{t!Tp-n-vox89HupW>st^dCAQmjyp2dnYy36c);pjSZPQW> zmUnv!o4B8=G~eqXoYDRx`2$UIxbQrZho4E$#8k37$paLomkv)y{s_>f|61HWMx=Z; zM%;H2J|I}3xv#&P@PSH?YF6RRfbO&3;C4j(Ev1{7J z^smrq*BwjB`E~z1(H=(sCZFBgZ5pg^k;&p}mpyc^?|S$#&kvJ4&|&|Y;gdi=08>3T z&dke1kB-=0@~}Z=0!bCiMx=yFniCivxu_(OUl8HQb?d23P-|LV^83n~IQ$#jIJ(z>5QK{J<>MA(lqes{+F>&ZBt$(mMEXFa*$<51^ts3|cgJ?} zNB_8c^(o>9GCA$>s6frz7eLZjWwT682fGlK>df1xYvYRm(zI_capdAqI&^vSzXUZT z>6D-}yO%I*m-p41vjVK}qOHkaAg8g`W#qS1n3dn@6TxJ7y16pIHRx zGt6hIPb{O7tDS54mTFp#TcMh8+y71Bk)OM?(rtc*pWDi*%k9XtlRd4cipUm_VL9U7 zthordvqSB6evON}Kw07Ey~;4Qra!y8hol=?Sbc@qd=Dr*)4x^i-cBDFS$&>_(P{FS z{O?CAAcnWgyAL2!zzwt9MQE@GAvGV>E}2Y$8j3sB+{TeBK>CQi5tT>(Y}XtYw~vBk zuw2(bCHGiJ>dNNQ=W%3M-LC8qC^|6DV3`*7$qp zRGM_h>R(J2Z=i=MZK~~9-vlH#Y;Dfs--0B~lK7iz_P0A^Bk1JP_%u`f`&p4*CL=<@WkoFS|j}m+)k@ zou7JXf7JnvS%S>h04ZDMmFyctTGk_M3{jm4n~c8g=yfBj|6^t(zM;N@rcygs|4Ohx zrqB!Q*}No7tN;xx^8($$v68KS?6IcHJMB+M?dt@;R{Wn)X}-Vxm!;*JVSedJ@S|LB zBx#9XVachU)tM=|^EXiD^nE3tXS^NtKiBH+vBZ+%js_%R8!~m<=NORuZPIF|eQb}x z@q4YA#{tsem?fZ(M-NgB=OAv6dTqUI4NmCcHuK0z*g#8G$5{VIf<})uUN1|wIjaWZ z$?!DJ^#p3koYDdQ;4A-A0cnrgLFZLCq6aj!opfb-*!r9fteQ}UiFgKT;E^MYcFpxn z&@dl1!Sbw5*K|VsK&LdGVym_}2QUot;i$DVspmos-+#D}7}8@*+lnjy`GB;aw?*_- zf=EY}7UOyILP(0St!Y*+LZ_tbMn`j=crhp?*)qOTWA73`y4tQP*rg%K%XHbK5M*-Q zxwypMk`w|-9t$j~NFeAij8j_<=WY2M(DZ1wKSUL35Jo8c<5t z>rJE)bjm{IT7FhYBpu?ZPK|JTHz+f^O$=egQdRQG4dB#kT`ARWL@ML{x=njie!uar z7Z6AijJaR4MZ5)>EK81ADt{rP2|ZKu+nC=2k4MVM*91C^#ss$RtxW>t$~JAWE{yC$ zrVX?}U8X4MV;Yzlf-}Q~-0Pl!CE@K(?};SnKBu?af%6?%H|n0MF0cqm<~#&c4_F2y zH+o+07B@SuTY;&Og=nd*g)2QNvwV9B{WeIAqbMM6@83mfceL+-gvXqC&`IuFY)ZO2 z!2>&*ao=6&)Xa`m)ROq_hACyUc5erI_XIFa)cdmfuy-$i4Z6ks z`R+jx{quqTUH5g?fu9e8!mCLuRL$KFL56bFDPc2_c^IYx?5!UCNKfRz>YqJBs24p7 z3h&Af#{P-+qSj+Q9Iq-mu%7#PlG#${zEAj_>W{L)AgiF$+i$cZsdMvs1&qkjlerpG z+JjC{gVJ^rv(qJB90q8C{a*7?%V$wZ`I@%GKNouS->n&C9sGQcu04t^F91^f;d($F zFue%OD06&Q3tJl)FF~=pUaMkTf(Y+u7#u2)RC-DW`3rERwBGW56_{4JroCpVvPXW8 zSr6T)!fTM!iD7fe&94KJzx%BCry-Q;4XFHCH;MCRPsQWr&0ox0khC2~)b-k#IqGeg zQRRi~rbK=RnT+azU`f8)Q(-vSG+XaMQeZl?vQs9v^gtss<@AQ+0?8C{pv==h?BwR! znSS(p60~z|_W2m3kxYYSF!2d0C7qsPpx<13d*P0wNnGf()d(`@SmF z7yUESvC-Nid^+9ZUL@6 z>32QQY(0)kd;z3zbx2q9>kmEJx;pu42bn*@lKq~#$oUg8ebcT(B0qQ9iwBDL3p$Bj zN4sAN%3nJ&J9==oy4`P(^o%VWjIX&jJ?e$Em~N0Y9re)=45tt)OZj8^cM7St7dsY` zZf_hM(7&n<#{pw+^oJ(>I$uxEKi-FQ3XV$o-g$-$)1k8NZcm_`2ul6-j@PPm5<0B? zPvyde1OrF~*E3@+SG}k7R7T4Hq#k=Y6%?lJsr&_>5#U^tlLZ8x+Ckp;F$3rMehRWPzk`d#lS` zfJ_bdtTct%g&o*DK3+2FMLmgfl2Y61iyB@+B1Qw7Y&Q9|h2y zVOyg%A!TFgsCL+l3L8~Kl3UQJ`p$@9TLJMPkYnVsF{w?RZoJK>RGFje@zF|ddyjry zs<8u*4(XVBku^!J%e#Pzz$M+^?jo zyr5EFw*jKEo(5&ylC{RX#ne`m8K@fNp<~I+p~FUTqD8WkmAW zM!oXpf2CZy6%-b*0d*8dp#n)!%cjd*tZ=u%l1E7q^0*zK?8J(V8|YO~>ET;yO1KlL z00-L8xeJjDOv&vY@ZE_!;pJN#zXuh5*7aQ18cQj3FHnB&4h{Dd?*k-<&2>5aexw{2 zZR?c}AW|!{GvDy~z=I$>s!r8RK^{ugAWATK75RAZDx{E?=8%xqTiQVQ9@5G@a!Ic)CB)pNRY-I$8d4&tkm> zMX3TxbzBp5p^li+0~z^yIn5-efNET89~^kK2cSqNI7;ORXc&rQpSmP$^t=X4x7jh? zu426oNa4qr^fymbs`Lg_YyQI*cRWT$L8Lg238G(tqz>0jl_KKp-$O6}uJXK-1SXr! z{JV&>;m9KC4`*psU<1?m?shiXOoHBrh8dHdFmmcbNCBl^ul^S@3QEE784Et@p$8xT zv@9T9XSTGrpZJ|pu5VtGKSgUc6L4#`&yYi>86R7H**fq!WSIMMbj@ycrCctPQ+&z> zfYQ76w7FIFB{*5^Ans7Kpof|^A8FM+zJ{ev79ZOnZT<~NDXDP@Dm}`a3EK&aR{9P$ zOfz+n&T)OMyWjVarjDBHvGE635@***I#kpjK|}B1nZ0&xKS9#y>y%3VKlfOhs~$BL zegUQAbLH8w9j*Kd!)#8gO51`+RsTR5agOtEJ)1I`RFk72nGtr@@^?(gRS#4Z8;)@s|V#h(WY*obf<5AKlTaGnrq7%?5blrlG{E2|{XL@I>WK2Rh0pjH5(h!{NcjO+@ zZHfD9dg4=jNYQyS!=Y2rscYMnH4~cCU{x544z`|-Y9pL|y9j3>hoMyO>tVF4&jg0` ztVL82bQUP>Rz7yt>`2dsrY0kfIrZCf01C|$G*QKGJf@b@?&tN8UNx+Nbv{6;DodX) zK&b~~3>!bqcwxSlpGjrDC|^x)Eb!!VF*>y@k0!kF33CZ-C`ze8$tVCtIW$Xtxy zl6Z;1P58YWh!Y(5JyphdS0ELLrl-zru0##}G_NByLz%0fLne#1;e?b9*oD<%un~}+ zGFNiVCS-c7H~y&Ni7Aj2g+_So9D7SoW@JL~XjcGf0sdrd1N72u9cs78%Is=;qWymE zyaS-l%faR~hju(u9cQ!yI(qGh#u8o2El+9m31qr!>0(JG=#+@wUelC!mwm95n-83p z>NF(GSa1x`+#$~NK*l_uyQ4?pN1l9wOyO5wE}J%q-UXs^+`N$r z#m`|z8@>aM??W86Jlxck)YC{x_sG|g$F^I zMTmH#btE;2nGf}_rO0Z>qYr~>HTp|=2YLjd5Y0NWJ*@XAU?{d1P-?^dSi;jZ7|o9( zvZT1D!_Kd=QOYNhjLvXic26m5o&-dY*lj43Q9)E@Pr=hIsxDKj|8Amsx<~dn!81na zVL%u`**)bhP6=Dj0=0NMl|(+*Be~8~SA(Aiq|IIYlBqi@grg7p}HO zzu{-fw!1wM`(}@?nVVq$79@O89U?S4hz~(BD1{BV1d%Re3E1Zpb8Rqv?1NNs!g(zL1)0Xt zi>psnU;Y#rX4b2_hZO!ZNXlz7QAcK<_aH1Pn;X9`AgO^z(j1RS=SxuL<_rPXHTA%+ zdcfKr@?b|k0VVl^hnmFu4Z!?(Yl;2e`mMyy3ihqOLNGz5aJ#rAt4-4PJ$B7*lKTOW zq8!BC=1=EGP+CMB&P)%P!>-Ya~85Y6>_Sm1^xa^-JOyKyn$KtqYpRqBYr`Hmx1kL$CYCr8?O< zz5^7NwP>FJNWFN3a8RzCCw8b5Eluh_36xB94Y5u}4|70iS7^3R=?EPZZ6wz{K^K}|>IwT2uZB=E@=#iG2Yd+)nOi*}a6G9k4s^8?HF=Oy-1a^;=uIwDY zQzowX+8y(AA-cD{Sq<;=P^l@CCKtV>bv`I9*k=8Y1tv*mFt<0u1y(g~cZPi~(@hwFSL!qJLd|rcI5L9k`a>K+Em}gn16W z)N>l0np1o>Ur{pO*P9Xa2eEC>j^m{1E!RC!&8K5ZTQGj5A7<#RS zZVvhuz?914ldg z%6(7i5FbXR|C8^^pHi{>5n!5;PInNP9))FYX!pS%Lxzf2nb)Rgm1PlvaLnhxIuWWd_l)iwJjZN3Lhfp^w5-}jLc zH>cLFBg&-@dP=(vnIz~-5{IIyoyL5WI4a4w$rG*R9pqzJ8ry{+sgX+{n6`SjR{u;8z)Nj)9-+F zK9Wi}RO3{13N>0zJeDxyG*FnqMz2Yer}s#7%UbRXv|{kZ zDEOI(WI@uejoMi~^p^Ha>)B{*p!!w`(grd)^6$3#R2ed!+mmq0S3TuCKt|heDXes{ z=O-QhB$^K90%VG5Up6^qbX^G1ht~Odk)O$=US4kux)`M9r6g{*1TH~iwu9K(lwXQU zE%uJD{!dMF86b_fVciab1u|WLSm(9E(qLTy!-f$`3aSr8_|F4+-S%nX-&IhVYQc=h z^@%dprt*#XXz=Y?Dz`+N(5W@;rzxz-)0-2>6`j)BIG{nN+FY)%rX^!^g#Q!b67d3( z9b!pO<=Zo_&uoXMPTSV)Bx3Z4+?qF~-!90|8|b1B)oQpKgiUPKYukQ9k1{)|9V`tu zLNI|B1~s@T#N=$v8aE?qK5Fk84?Zbx>G2nw{v6cQqlvQma(NFQLtqyVnu@Gy6FsOQW!OnTVlO7}L znurzwVS%HSINMnUbqzqdub?`2^iIU^LAu=SG^bQ6J?dbVOuPWC4UTqzdpkfM-L!#F z;it+fQW*jfD$r^E?RtymueJLwV5;Z2f%g6o@dB12UfT?AmE;~!@|kcRgRS=lC|yuw zpZfsXk!qpl<@-_c#vz_^G5P^?de!V`c_k!gKnA|f&M?ibIp!f)a@j-(kj%q9P+OPU z!OkNc(>|rB7Vc44jkR(tM(fd&DY0FDeH@T}$%hYVqm$Q{@0KT#DeL;?V*V*~O17t- zzHJ)Rr(u;r&cY6(Qk#*Ima*g69%m2*O3>(7GmrOpGfAVzHWVKYh2TRQtXPf%}eSqwB*k&veih86bp$}21k1OBpirz;M#nZPH@8cmVuag3Q zf=acvmZzLgk!j%l^9KnapP`fS{yJD8RwRJ+h2*C?U!aGH(yn0k(0HvYUjpU##U20s z@5vS+{!f2o3q&f%wuoM(2EaG4FsZg3&4aNzVl{uPQt-VSQ& zrr$yugnZyqY`nBqf9DrQSd#{i1}Z*zhJ`|L=@>wo#KJpMUXhN4#DUuHGI-Xd;}Tg1 zSsZE4V;P&BwKvdpAXBHI_mV_F zDT}slW{Gzu;Rs zDgs7XIl?q&049n9~8Bo|_NPEw~q zDf{-eU710LS)P+A#p7HLu%`)5^XQ~Xl59Qz7K1D}b6c^wqs?6Iaq3u{D1uJD>uMiY z!qZAmruKG)+y<%HDKAIf-jm>a-+X@uI#n-a%RCboWxKN{QjQu+xp5aH#dkla*4Ddw zI@=tCl0|wHeq5SXFogMJbT;+N@uSJ&Y0(Fq5EM;*?Dkf{s2HPs>|jCk`Sv$ zsxco5!N3hK9!3nUP-bw7^avzX@f7dcBSVh@QwlRfUH>DA^q2>{;7~jE$01q4*DU)F z6}z7RB$AL5bqqxYNl5KZ z_V9b?7gNp1<_7>xgaT-|@D=kxzJcuA5Z$x4!3 zl4PxwBuT#Jr!i*6Tr*=>D>-M*IWuSG%sFT0{Fs@ulH?;RNmlapmCM)qx^Vf(`nc?@ z%UbKq$69M8Ns=TpGo3-jDn1`SbDo^>{v>kLTmr#Ix6csi5VD z`Gk@l0fjaD7viD(bx0WB%nO$PD(5#~skCKlU%A|Em3|XEbX>+w)E%8RliCKp-RZHt zby9c~-5H#h-QEG=n>}icoOe+vjn@gA)zW)C%HTkhuA@WEI-*344?rf6x)WSd(TB(| zYWdN&+5e~myT=ZfuYivMY5!VNONoHjp8!`{qO9pZMQ6HO?W)=ISUE={n?RMgRx~~E zb5yESW1=mqUnGF{XNxCaqEe;V8J2(&_zIG2=EmDq-q7_b=z(g*Z_qk5hhD1kEg}V- zota&jA|EU0cR<~TA5Z5key6VVZneAqAs^dx{-fW?e0!PSDeq4`c->~z0eO4fy8OG}Dq_H8%K0PTCQ8qK%zs>|Cp^|Ten3)ZJ@K$*=srMlcA$e#_xC8yhNnuS z@IVi-VXjAh|d8 zI3WFD%D%Q)SMwGGcKRwgq&P|Vu z8bHtXxU74cQ6+fnm+f%o(dz%I=Oi%G0M%gng3-}T0ah*+M@YN zk8?eDiTd5EfRx%f)c9l*`Cfw!!<)4Y*#uqF>+8b5?ssbBLbt+}MGg23a5AG0b=9ZY zw7dz7I?lxFJjyYWzH6+%)@5=4qbziHULi!SD{ zlT^U>5_J6y+e~=xBMh7x#x?tVfJ_%@_C16WK%|MXw5jq}u#ccJI9Tp%>dfO~bc)D? zoTUh<1d<}MV5f>ObUy8Y%70Z2rq3WUUw)nmGV*g|^t*MYObaHr+E0D~mz$M7SKYou zhpSElI1RMzDZ9+Cz!<-}ym5W)cQ~A8%w8AdV zm>_=Z-`q(vZhuFo6r)}|)?$Ao@YXsWIp(#Mk7cMPrDFl9l`T{2FvoSo28c6VLJCAt z@*Lv{Jq62kDUD79gjq(*1eJU>@ku?@rrZZVxrg%BOFiFR%H30d=^oPyizVhYE!3&d z%*M_4$7#rv&^$F)z4i1S&C_*;dQ>52K*OU|O%HWukGHNpfJI#CA@pRNI=iQ{VpLrH z=xM2p-KgGYY$?IC^d+#a9hV}swEt2tJ`78Z+fOS zlVlP|ig;6N-7$3XpFd11c|Z@C04X)~N(m2|V-H~9K|TMmH{S`227L99sh-B%VXmU) zHPbXGeWK>Dn#V1iv%r6SeC4vd+p}bo9^Zk4bpdqnHOhB@Xm|EdYudXoia1bT>Hu3y&3KRB8Q|PGxF?fK zM)&pzYipBoA95(JJ9rYj9}qTsjzE1LK&NaJFuaU4W$=T*)XDy*J?QdKkG9wDgM5Nc z=4FnxqTYI>$D5;7Yv(l(V`TY1G|oJRGJG`9|LBMYk=|5uc(nxeNKas=X{3oKkfG;V zcj!fWEOxqeE~^etcdU%qp|EFQ={|KKy}5OH7Nji1;F^k_LxnSh!x|GW08*tU5Kw0{ zeMus@6Q$Ry&HmeNzvXzNOteY(wG9ij|zA8@-@k~Q#&U30GfJiExRs42|$0X4pH3u z2$|f%o56}2I-?Ctf-nU_-9DUGc~if6cN7wQl7bm@<8w_8ZTST z74J7>s=oO~k_bwpR_7pveLcQxJKspwR9 zHCY))PV2x-=|G4c9jLp}`rH`+HKtlDN$Je~S?@1d{VYJ{#`zgX4QC@$O}EqNuC&%U z3Blz=>l)|w5bc@BTKCRN2u3$e95^4DQOAMqSnkSP087Dl&y18N=0ZUD#c#&cxL$uz zM_lbR|2T^2h;*Aa;}S@kZ|!DsNB=%%i&4GrGDvDOTUxiv6MPb@WO>D(!3TTrEAzd{ z8ibEOzuR_IjH@B3$;cSx_JKM`z6O@AIvl6hH!hC@BoRbP+OEO+d}|NCrp^UOA^=6d zX%zvae{242$RB|8>l(2Hmp0#wK~tuEWRR&cIhg<@pZ!c}>q+Q6JrM20qN$N60#dhn z;HT|Zr$U!#(mZNRqrU(P2$X(wt*S?p=7VwI2y z_Yh3Jlz)-;m(Uov6r+SYP)X9czuTr4Vcb>)w!r?6zyU51EGDK{Z3>NOae1S8nbm{E~NAOE3N)GOQod3pvnj7eycH zshHlS@-Vv1cxBP?NKzmOwkMb#MW)aU&mC9Q{PGw~W3S#q)X2|z$nFV0hsWex%Pj$L z#d7M&o`yRUE6&hh@?2`XUDS3`oIbK7{ zCeNB5L72Ozsv%zYJH2^S4ffXZ^#&+qj=eY&ki_QdRzttlV|e2_7v$gW(1DpH*A6k_ zC@6x7Qx+bV>&lAA?|>s#*M{bRbJ17^y$cWDHZGJZ?>+RN`W2$hihkvNAJQ>wYKWp4 zlOI4+i;_;8AH@$r_*~CHm1z7CQm^-9bY1uV7&Y|X11w639RVozpLK9uf(IZ4+Qq9h zu_LtIHt#2x{yDmmUy7%}FM9ADlT((uFVW%Q%zkzO68tI=40kgZ(W6IjZ&m@m=@G6i z8!$P13rQKv?#$fv9UztDP|~A{Qu)5e;&QrKHvRxnF4=4;#qy6m0Q1*o*ZmVjvX&&) zay7sI3`qBJ$8EtHr~CW@!!2*J)pO&&qB20n%+&`cN5)v%HRF=sd`UGuYq3-Y%)djz zw`-f3>mNM?ZHEgDWRWASD^47)!_Q+8snccxWYhH?2O7F_NzT)C9q9NTY<*di)i^o< zl%7<_1Lg6O6$-YU2-nlc%{wF$L@gFm&4T%4)F7uYVX5=o+RvW?#WD7CleO_X6*;iI zUOFa}|<_aRCw^)M1w@Uf4f+ zlb5K13|n@Nd(C7zPrO_V4IkVUs~&#|Af-Rx{#bG5(w@$mdcpFt9>8MWE-+mV39r=F zLol_;x&oGT*Ows_>yaL4j!LC=5rh}mz&v}&<__X&&`S2@H;L>5F^#$AM0?_Qy4|Lx z8efY}&MOCf zeCMW@U!z6IXVXG6cG!W$cW+|XsM^^BlXtZK&7GbYDHrCqpmkjq`8vz3i7KNTEXucq zny$`3QbAeA_ABzJpJC_b+_)YCq*{(0bMU)Bg1%8yJ1f^0!bE2WnEc;4)kCr!@5IE+djoAS+d{i!!iCCq34L>6&nY##t&e z#JxSj!u+E51#5l052i57&k`P_c|TGviqQ1hkOv?cmWsD>w?TJ)5FTE*W|Omlhd`>i zfB9cZYJV7&daWW(b9+?JZ>_0k=zVpJ}U8NK*`OEb2XBm1!QtzKvdR$H9(#N zhV?V-zGy>wLfjm9@&WWBD7E#g-BIITiUxBPrr7QF@P z-NbZM=VfohhAudchewfNi<|tl1i#ahne#S4W5T;VnY&PX3rqrc>bni*)e+o-- zc2mt5b)DUn7qs611LODapR5yu-xGu0u<1qq z=rI-@Y#JHI{O>C02yE<7oT%9%izvWeF#M>gKc z#oj+osaQ##gif*Xh@vE)wf}aP76>HhWH8H3(c~`0Iu$e&f3mvj<)OY)EqClcx>@&*{MM5Z<|f zwDuZnG_8c1o!7DTijke-`LO?7Mj5W$UEo7nvxE*}2|8Jh+CwYrMF8D;)s7vsCw_-1 zCX%HlQD2hJo2y!v`klg90EXL9m%%iGm1Hj#UXBXWx7FNqMUPOI@gqB52^*H6Ox0n< zRf)N;&5YD2$Q0B3Tb#Kj-)sEVrgSwjB`sf=Q{}{PEhsD?tIl|jt+wXX-PZeH9$0EV zO*iz2bt2O4|c5X}M`ld2?dV((S9%EvTW=%YQAua<>AK9H$9w61oji6LoDnZufiO zL7h5R3yt;^+?lDZ@>mbUQ?fh3a+v@n(RO=M9rh$pnJJmT+JV5{9&ci1j3JbsGX+ZP zyDg~tb>Vs%ruJH8{U#y{3ZqGOf*(MnGJ8f2mtZ~*NWM4jXVRf0i;(bUX&i43g=8i= zQ`R_3$n;z?I{x2*PJ&A#3w5FBPCycDmN+`eT|LUw!Xe}9ZnO+^h30we9^|k9mno`8 zB5~+mAdappW6S&eP8M|}EsOgBYBbRnvIh|1cXZG)d=R9J65^d+_=iH{$0#v?T!K!H z29&er)<};4BjuE}P)*0#Uq1@BB5hw!F!6KXb@{3mj&uT37LyfG^$A2uy0fm}6HR)I zQj)~L<0)7;c<}IErF$Bkj7JQb_E-EF;i79=x6R#QILzb{U*A1Zr~vE5v7DW0!%6gm)|I(7KYDF1(nXXxvr+X z9Wr-BNGZr9SC$z{^-c%2meq$dn;w6$RMGDt)q)mblA4`-f=>22Qfu}PAmOqGw=xR! zAxKr3aT^UEAyS}C^*+JJ$W*dMG7iE%fvv17d`a>RSv~mEq_RXzr9wd@m!0a^*RT>CXTr5GeJS$qRa7I{Ed7T@+@tW6D_ z+ID{jQ#qN+=lc-$KHBdG#4rF{#n%z)#XyRdAK@v?_VM!d@l&U7T7E-Ce@2I=TSpGi zK~bS}q~w{JLw|*=^l_Xg%SF=q4X!jC-I1YwN8m^?wQl$Q(No!Edoc$&=Jl0odyk_o z!mH!4u(Z#$b-HsLGF(^~Gc0Nx9S=(RcTJ9B)CrxAPp=a@y@Np@5v9{!GZz13^uXAe zxut~?E>8ia${wX@&y$@BQ49-4yX^l>YwCWyx zHPKl;xSJt@pWW%}o7>!TIz8E(b)1VH1{qU*37pph%&_-lJAzIJrQ|!J+fG#{yP!vN zp{EAxg&nAM3o|bQq-bT@x0edwVn_!5!KK~S_jU?+2{6^8SJEVx_H?$Fl_l*+2TYl} z0GIa|3ao%vpwm4#8?VgiLduHdN_hIYoy`19ld7+R4b9<=s3tF84a$0V!GBFAL4_U5 z|I+R?tOj6rt|6~Qq_9ilb>($EI{l~VA~zscS~knmMo5xVrkcVw0V2_q$(DnC_nDiR zvBifZUB2!JA?TEJo))(m_iamJga1c7-vN-lBmdTKc80W4tuDKQn~_P;xF^)#lITA3 z(pg7(w|0QpXSx2mtpn84b>--GKw8WTpk)tLyS7na(k=5f@<@-xPhPDp6M(2ab2-VF zvc;^ zd$(%SlNc^bZ_115(tthpDE4zp&&3Uwbc{H?yeyNnD7D8Ll5ToI0! zb@l^29ZrwSdEkQp3?N42aO9z$5N6lvS#$EkJ=U5%ZP)fl4^?*GhTva>dNfIud^1&A ztj9V%H$B4==yCMW5y#uRxg?by}!BQGg68{vO?2A9sy^TIWS&_z)ir@^=QaA2uHGdOQ-SxGJiDr)XRu8fK+U#t_c^eWYlN++VKiUIHq{(#eK+<_O)xdeT z2dJ}`5*Xj>0Y+=X{XQ~PTjT6hE*~U@QS0!qUBvhhl6>0>)>YV#5=eh=blarBk0IfG z=@)sP5b6_H(x%I=Y5G$@ElbVW@@GAbVrq@N&pSe8>oq?z3nW=P$WcMP`b$t+=+E;K z@=FiMoR6fZ(Z24GO_$frG}|{I`A_bxL!oaGDcy$g>5_TA17x7(#rn2necwY7kxLx^ zA!%q@z3)dv8hptH^6zg<4+_JdI(}meq?$KPk_T$v2kg2(w7jIYv zj|V8k%mHn5LjSnG9C1*v0MZ7|m~v`!Qo@gvY1PR+{07QfY&->!I=Z3cz=nbaQZsL> z@M#FUovmw0Es1J+8Vp9xNI>?^8v0B`>gouA{4g^n@w0$QydJGs{`X`Th`RA)$9)n_ z3Nrn0sXX;D7InG!~o|X-Aaj_aNTduFh~l4>Gqf;SEN@3nXn}QIg0- zp)Ce-_Wj}>WADhmCR|(s3ESJ9lS`3d-yoQcqT zN*r6;({kQ2M%z}JqxDJ4Sg*(HH=xo0wco4`w=v)OX()ZoCR8d(&*Z59scr#lA7p5j)$vGh!1kj(k^^lZ$WxmWck zz^NTkQEm71h)xrlv)8=|F>24zHiT0>L~|mn_|uRuO<{7JH46$W*k(~n)<8c1!?=;= z%xWGH9&k-kyNJaO&_R{JbEpHWnJMT!OMrpBV=L@6(nZW zE<=(p^!S?x%l8){nH%^UCzc>3x5~XZGD#1;dst6i>Bt0E-L;i{H4(TO($cRX40jK- zS3QsP!0k$~uKPM9HQel`4(S7(25@1jSnwu5_8w(6y52&h#p~p>omafwBW&ReNqLWU zU=7=Uec~NJ>eF5sc^8>3Qqx4uB)ITi53`{r%=eK)vk9Q*EBgnql#~lq^2>+lFrMG9 zc1-aRqz1vRvfBL^k&4g^mWA3U0GuFZ)hzdE|6J|>l=3rxQ7m{?RLe};sIrYLRo3tE!p*;XU` zib`1*_VH_4w#L7Kv|X8f)r|W)GNs%-&P|FG{^)Vqg_lb7m^W4emCNd~$~zWfbZ+0V ziiF{J#P^bChjCEtd%O=R+nNKVK05)uqPD5$Eo%v@u5uzg-RZh|ZssK9Fk{r!5K;$V z7?38}8iS`m^oyC+Ag3ZyNlUYhrM_?)Nb#<#TeqkCo#e`}(Z@3Y>52^htXjp!Gkc&t z^?W$l1CS=QwAH*)q0R=TLYv#;gXf@Au+oN2ID0=AlC;}U7^(fkd9cQ-ZFDC+1&8ib zaToLybosp{vR?>EZFZ0En_(S9_~?NSFv+M9c`;-dO*oVz)=OYo{=avq#O>ats4Ra? zvsfCqx};Ovt;-V704Pc4a@5d8>Uv~NNmq2}AUD9xI`T?T*g@hiJNyz*uL5c}$3jhZ zyc#+1)lEY_6mjetm_kivs$7i<|Cn+r$=W1fq+MT%^!3QJ)VK|m-S7rL_)GEL%#t^D zWRYIG*2zr}yl51TLQ*Jd zJB1kgS0SQ4n}Doz+vaLw4{I6bo0iT+%z(@Q|fNO0`tj(Q zq=d~I*bk6M&?yVa$-_ewB|XHxnVPO&=;^qXW)_I7`eKhaLD^KY#Y>4-A~ctigcEcM zG%?xE@LvIh<;1jE@7N0TYR78Mnm_OIRE`wSBPat~7Hwx9PP%`>l#_5~!FQQ;V4U-l@BhRaCis~%uOb3Xlb zPh#tg*~aAZ4FoUvcUG`(5vkd=<6?h@OxZ`v514HZv81P9Rcnm>0g`^Wsn)__2mfP7 z9VzxR^`D^XL^>r=*M#{qK#uJ#DDu-UNOR?ln|6>-{7#!kafwO4fieXdoh;CsZO!k% zFk!zf6Bz|9kLADm-1NQ2{2wa`{de4pFO16eSWviKPVmZ6>~WCPl_91{v?llCVG36{ zm9Tt5Psf34?7>b1C2!V*#>h$NVNB@my4uMd7+x7X1rQdyZAl}7OeJy7A}o#5Kw4yn z>u3a&5XO^{dImzroHIpB`b<>vu5LvtLF?d~){sT~Ol5fM-CIi^eF!X7_K12r0XP?u zytg`#Z~=)pk~HT1JimXXA+{Y*vI{`9Ld37rg{ahIeVq?ngiO^vhh2NQixYZ&+;J?s z*8X{vH#nW^Qb3B&k$}E;8Ctcu<}s!&N2IW9*PHtG3P=j;I%VEAx-v1wc}gH}Ad*}u z9odhdm2P}`qD>&z^ythcqv=@<($`$PBy9K{h9L(RM(cZ&^1s$3j17r0J!4|s=(h|G zj@Pj?Q3HuLHGitimVDH4=jx8|R%Cc{y>6mew{>9fDzyWU3h$a){^vTh-PsWrEg0^R zH6U_ae#4b1?SBh0gMopDxvI7Dt-!F!89_W>-3ChLmb~ifxA%y<-6))5hz}eEM*e2w z?2vTDB6F-Kn3vL(Y@)}PCs$$Z0r@>Z^`~eoIcjfDt=)9S6az}sDR^3Ghcg92NT!Q^L{wYOxBxHDyO7CYbjBzw=x$IoZ`{h>gGw=pPR%Fqy^vwx6Q-qqUr%Fc zgaPfGmE?YqGFfD_-UA2;?#UebASxwPqrL2zgm?&+Ox%EKd&Gwmr@4rx_&_N%EA2K7 zKZ>mJ(}cgr5GjtGM43K3-hut}|CWv?07-ph7o%}Oo`gt`2U=vGPqDDbpTVtYiZ00zgqtVSo$0j7n?_F+#J=w z(@S>Rb(1{MszTM>W(S-enCQ!bENTqj_ zW&TvXsroJ~Y`(tK%kLq>)fklxa`pR3#y&=gK0u^IH1X}7`VS#Vxas^B4w^GRf~8JrpJp_YEa~r08+aYuB{?>!P1En^5 zT=mg>-vcaf+pnVx@iQ#kv2Ghp2vYu>JqY#_LZzl@YTGI1&*)Tnry=+YN~+}wA)@=Q zfb>;YllPd)>&c+s62~60l*PZJlH2~e4D<(520C_>Y{$I0(iBbV-CZh%V_{0$+4aIgb=mcacYTsPa;fWm>Bj@QcCv||;V9l;41Bw-^DLed>SUD)E zb@NnY`h|nEUFA5GJOLZ#5qtP%Bmzl^==@aa4D?V0*Ksl6On~x}ca`TXM7qWJ^j;o# zWpj3itRHr{n(!QuGOgDh=lYrC`PIh2^Ux^(-%s>9WDAH4caKjvbt+x?1%Pxc6KeC! zRcT(>BQ82QZk|RUX|7@x)n1v^UJTU4*2ubae+ddlgm2E8F70X5I#-pu3=$s2`*KOO zmv_u5`o8KsG#x!=_UaB@AgLH*44l0REh}oiW<_*0GL{V7cpaYSxxht_wkf!#C$+B( zl9Y0F58GV$PAnf;aaX+7mt-=xucoc_o!;&NLV6E$8f%mjAptf5!d`AIca>zY36eQw zdilthPNV7qZULJa7t5A)YfnW#uG_=g0O9N^@3=OJoB9KovebL@WRgzrXuc9|Mq_|k zzsV4{AX5@1CGAY)){bnSAuA}`ZII+MURJvM+Zn;_z;rQ|rDaV>9s#AAdUoBR9s}r; zoIYPk1nH^hFV&}N;OqhF2QEF-Ji9lPL#}!qVG5O^)n=q_I8Q@Tw`euet08=QBOf~~nK$5j4HiNW79kIr-(V+O~2-D`a1HS{JAr8-C>79P3 zHZ;V)khCd9*XNQ`d&!--YpAcHIz<^=kL!1jCq@~h*+e|?XN=iWazBZ#5jNN?J=GJ)!F;nA zNdj22bpvSxm9AgxWRem8j?aQq4Vxd;cn+PClg64M#|w}W8|vuz#U7eSqf{^b8Jhax z2;^l*7-)*!L+x7q@0A{GyB$s;uR_wVXD93IPR_4^Qj&%Cq|lKb$*60GTdyYs^R*fu z|IDorSni#zt=->j^B1kQtMSA+QjU>bCt8~SC@LLCB2ac5bd%IzaS(snll z{V_TP+A=;rF*Qm3^$937+EI5`KkYHLlVlv$bb9B3vVHy>owAgRnL%j$0$7XU8fp+f zBiWhpt?IN)?Qxf{dOG~58)sjmWlKxmjC;Nr$iL+c_isb$SUYRXeTPiF%C_1f|2+T~ zof7Zf9V46{AgNg$S~nZEA3>=+GZvNqDUl>vs`t`c{oEr>FaIym*8c)ZR^CjgPV;Mz zHD`h^5#YBT%QCosaxbp^4wBWZW6!o_`J+d&Lun3IkNH1WnyaZ0m?{xfU}62bvaCK1 zney&;rJAsUPFJzLY<>C!h=H=Hj!#bXI|bcZn-Zc*2doJtyPOONOX|U%*UE126i_Fv210?UO4p67R@d|B7V>H+6l}Yyg)f3cxY?(xttiPaPPmz=|GxSc=TkR+HAYL8QFYb{abn;Rw^+l5}=T! zVTG|OG$WWjz_4m$Vv?PgEy!NbFlH<+*fj-6k+-=}SKAQ6Nl%OoYx$t4^33*_tIKm1 z-AF>UlZtlqQnj52YOE2Dht)CKB2rylYnXFYvLuc}kaRQRxruG5)7(-@;EqmH(+Ynl zI=oSSPE;Fs7chN#a(Yoi1-%+iP%k`-k_T7sP=j+jfx{!QdLKvEsbiLyK zPM2dGQb~_7T2H;H^@AO0SD3AU4?$G9xjYu&;hqFfd3yaL=rlqzKd24oqo5Sj3|pi2 zF+eq~;YlVzSW5nz|CT_~1M)Odu122h0A<<;dHg8=b`E`*nxqHVwP#nkE_((LRyhGU zu)yx32IsTTwECQjpSX(C&-IX&ev-yNH>;r+pvFw|O!Z=ZFP0GZlHX}Zp2EmpFL#>0 zRtJ3rtxB{v*!U`9Xc=>bk@H#yX7=wc@$U#=WjL1Uc3oSk*5K0ImTo1j|s1CV*9TviG2Au3{^rvS&N>By`{M3EkE`FZO0()N7ZAzKgf zml66&hgd~E!)XDD1eB81jtcM@ASE;Zxg*t%&n5RcJRDnhXjTorKd%2jS(BGdng z4f{%M{#7D0|F$*SzV0C=%JGWc_zfg^mv=6e`!-PwnVWd>C7Ga8S%%8I|C-WD@cX{U zD}!gX{{fK9X)2ni`6Hwz=eea4-hT>ZK-56|8I^9Ei$A&J^$RqULCrc2)~kpA3e5Vj zxtt&TmUNVFottdGqmpY`Lyi;Q{(uaVVqHTiz8v$`N*(P+3pf^#Sao(=!~Qr(VjUbG z^_+(Oay-a5z5Y69Gk&JDmSJ+JQ%o#45gOK69Li(CNj;JB4saH121r;t_ z4o{8R!$(@-3W(I}v+E6#H2+0tALp7Frn7ct5In;u5oL&xCT&jVBP6l z-9Jk4S^a-4AUR%FkAEt|dPsVMefq+R`T7QEdeDIpemkqM8$oGnBUq2xgig(C2G&F5 zy#le+wVP}VUEOuOOT;B}Rri2CTy(Pq= ztqO|~L`vnPPYG^AYw&9|`0ak;6D@yDsH3Q1X*Npi+N;x#0aKir*>*E@0+8ZvuRFzi zI(eX;%-oAimAUO;(>F!@n1acre8pQCrhAB4S50~PRHRv0s#to^NF$)+TYGGSZN3Bi za4uogVh0Y#N$DX#@?LNShC4QOT7sqWYuXsT1D(>3)HRhmk!g)Og{W-qf+Sx^&2xA6 z6x@lE;ypbIyGZ_MX-go{mK+?})84J0oX$0{`+P~gw%2T1ch&Ci(TOZfkI5uG5KE=> z-v>d%sI7_pK(nHLsE4bm#a@(b0%`-f8vPMOs=C8108&Y(caPWN@fcb&NUj?D@qAr= zeXwbK0v%4+dNo949N_=fH|%;xAp`3n+zW4&onAU(8p|t!m|dDPPTfcAi4Nj7|<~YVZ6CGHvF~ z^J>Ib0jUf_ZthbED3G)SwS3*6C8B^btm~E8UGsUK^>wJZVXE5djUH(gUxMwa#y3F* z&$+aQZ~2M&mK=3{JJGz(OEB?U&6Kt-fxm-Fvn;hcjqjpU*ml*KSOSpF(`?;}$3 z-Sn~5|2}}Eu4}ifB8wm;=ZtONc%4vugvQ{CE8 zGu6zM`1x56vfZJLx_k~8MrQfmF0t(kkm{ArOd4OJhORnXr!Xme1x%eygi`ss(>G17 z*BalThxRceS5dx&V1mXk5d@KfT60Q;^F1IuplTp`Ad|d(kNCpu3koRzX4Khl9g#dXZSto*aOrt$R9l&8b2ET zzl@cjc+CH`Qn2gCYXLYGon*=iu_>O91Epc+#`(H!H$#tyg&ob;uO59uM_l~3-V;6` zE0c3sw6+TiCjrBV>)S2OlhH$dGfM}T|3*AI1(d3-TWscJr}i*6@&Vc0`JM(!{%iJ> z!2&@95{8eL;m;X8j^&l;sj6p!uvLTAsnl7h-zlGi9+!9O==D;VZZpzMq%T7#EKcugHVBs|vPqi=l5Yn1YIZqf z5OmmH9+O&LSAkZVYcCtDXhnc2QuEs><~1Er6Ni=L5lA@cxs#f7*8+yl-rf~m-=oaU zA2tclkn|{J?t*I@0jb=osrfxFvTDLjJ&@PJ%Mb4sKnhL!p=(NLD@d!CuD<4?ZOEa0 z2x---J37K6)@bQ~b|wl|?5lx(Gcu)LGcr+%pj&zjmkTFrvc45kgR^;Tysd|K<+*aW zy#w26G!=6ckYc)nM9NmKF;L32$b&gj~TsI<=K*GXR*i0ZntLM79 zQmfk2`CKn|H7BpLJ@~=Hb^dw)Jrsf3-OiCPk`(B>+Iq8yOo_;X&FJ7z(jfBH28tYl zHe8lmtC!*(`HE{h+QqRuJI%6Q@^>Y4oq>yccc{skLnX4@gBp776s2lwmwRC9>!f!vfDNjgY{grM6y{+07bB2#U@9g$ zM*(TD>5&p{-bwVjjZIgANIAW8)EfJ}9)F(vpepZo;NZ+?9UXtr<51=|jm(FTFu;wj zyyN!~D7kK*EaRJx(Iq^%d92w!K@F?1-BImrYWMajG;^obB^O{xCW**AyN1N)s8qKu zcAMV50Hg!#*tUvPf=o%uh^T3lz5-#_@{yV_zD7i3XNGM|@(5e2h9Z6AOHyWEQ6uMD zKx)9B3|4*D0~}mxC;Q)bV1pWn@dF^t+|B;DX0;z7Db99Vp5=chnV&$ZBzEs{d!wrL zbB|f(zBNdH>4@i|Cd)ScSI9~`mM-qMglK1I;rZ_n>l_s^Ii<&M20_NgF>kjPFzmNk zDvm`B{f5D^T-6~G{5ahm1qsNeX3KR1 z5vW zkXdTnZ2@E|*uVT5i{D*)YNNLmD%o-&Aj~#YYPYqyr`dr{VQZGJRCe|dTbftKn|laT z>vV0_Z-JyUuC4Kucad)G(Ws~}|2A}5haYHCMCtu+?_q3@^?_0J&>r>fNu5uOfl`O% zf0^Gcr6wFqK*J2jZpH3B03BhpnN9CSBrE!cvZzptsh$o+2K^47DLTM3G__xTzQ*Nj zk7=EljJt#bJxu8h$th_3(<|4krZGXuIB$U;LTL2$s|Y84hL7!1up-{kkyYjN*ra?X zBz)ukf5v=Y1-%QH1ajHcBYzNUdm9$d@3g>+a=pud!u&Ulr;>BnE<0h|)`}jFPaZ3$f8;&oK$>gT-GU&(2FF`3B5mE)eLSsj4 z4!=%x!}QuRdif^b^0M5wh)gOo&aCL~+YQL?pvi%{j*d(jz6YhcI!K*WRyX?rm};n7 ziE%#y!q|0nAL%EghR{Fi)a~aUns`==*e@NJU=;%RwMW09R`K7EYEjC18WKc?i3{SB z+t&C* zG$wfSI_K4@cTytYWgo|c!|_T1!I(6o3t2BQ)|*8phlaLz$QDQZvaRAGp7 zE?9lJyewJlJXEq8-diDgfL6-a^b!{UQXfZEG9q|DGBor9mX^i2i(t~NYv*cwai|4G z5^}kur=S6eAs(TNq#dUrl6J zLaLjOm%-yz{d0*#H7c%#q&G5hBYhx^vE_d;A+AnfRVtl$Rbnk9>|nEETuPS1p|F|h-dCRpnl zGj-)oK$>7?BKql@JF>2n=`y|rQhb=+XL`7`enumY-R0 zB1YiovDB@-*D=;(jm>z(iixlaO!Q!jx>d1#4caKJ`tPo3v4_886P?obbK)9^&oQV%d&^U57a zjWF0V-`Rt2v?-Z29p42>9ab-t+x@%IDMIZ=$pZIupw3wU_jbS;S#_WL04e0|cH@z( z0ZF3U+bDUUhgkm00S>b%MIhA#ZTu*%fO=@ zyU8JQtpsEZSjJXUajrb2^LP&$RzlH9ZCB)hss^>fG-+XG#XlQ7m*6vr>XQy~`^n-x7FBuVjgn!!W%Ih^vo0X3$)27o(nB2vq1`4T37pk<2%HTS-a3a56{_Tto0KvJY+>nXki#hO){ z*KOHx10kfxqHQkW;k^!&O&#EUK$sN6&}z01U}1_&1DqriL?Ge#Xq^gt)KhUcp-T60 zkJ03BZ2SZ=^h~$N2p>I4b!Ic=XMh?n<${d((Lb-H+rjiN04c-R_~fBdiG2wP<4clj zCmLTRjs5(9D#X_)S$c%;z~o-0RNtU+m&;cfe2YlOT40yh>`!Py5~6e$q>n_m)Y31@ z?+0`^J~Mx?l;%HnKu;(U?k7MxUUiiN&cEW~E#zl%6{!gJ;I7Xzk<{s zRc;`ELnX8F=q1MQ9axv^=6@tS9}^{D9doqRjrIRO5JM0mmjX&7TQrUXBs==!$?-Bj zIv$j=meZ!OC3<0&eIydNVi2urdN>hPlYG;corFlE-%xVb$;g!=HZNYM0Mf*CkLqwL zIz4jy5Eu31Q|%_;Y0#C1T%_tEkU)~I<0Ik-GU-m3)fDwiK+=ts<5}p`hI6oeBL}tB z*&yW{nLlixoYTX*$EzIYqE)Hg3nhY}3iZYgp|9-wfc+<}$e=5k1C zxqG}G<-G!3RcgKjuI#~=>ah*Qyb2Pg{lhp?Xf+fLFhoH1`IhV%cZ}eM_I#<=Zgf7L~*CD*b_ghsgUKL*hcPv ztVjT*>~5mTHemXMf=;vYX_mP=plJk=YwYdpsckO%LoIQ0k60(Wxs6B&>ES3QoqUo+ zdQyw-pDD&|fT5txx!mpO6w44DA&k|L)F?2;!T?VOI0)8mV@Yec0V45<9+$ZWv0C|+3%BtX@9%D1DVKwIx#G>vk6JkjJI$=I2bCo+GVL;u@U?*M-zpH~gnaK>V z^4;CRRea}oj-`ggJwUl1q#~*X`d(yexR3iyG6_1R-QmK9;@{ta1J2j2)(-%N6=tR^ zqbijLJH}&Bt!E-W1ginySq8F6PsKrNE#{AOV5T0HB$@z9l3BpS$NW}CPk}XasmGDw z`s|(qUK1yXK+@rv@#}J0?nzMC(mZjv;3=1p)VTKf%)498#3R>}LRWkL2;}Ur@3l?94AeMc_ahFxRfzLfr5>oS&K1ZEH*rIe_V_ z*5T%h=?_SXva5Mnqk@+0F@JAWTf2tj;b)4^%7l2V499^IXWKaST0JGBsg8#Z1IxaY z*wG`}E=Gzz5tJHUmmQ?6PJ*R|9tbKq@nk^CSO*)mML7kMs+2v?a6{u%U@>B9vdkw> zLnZV1<-eM5^ym}<1Xx%*d>0aOr>SuWQRo3A*aslYK6KiF-FQW?d5)_X1hIa7Ln!(SU62N zZ!w?=>7l4Is?D^=Rj}l>%`WypO&nMM8PQ@>qV6>iV_{AoTkWTEZn$9+p~UYnVLf*k zq>?`)E~|-mzS0h(@5#62mrAO= z7ZEltF8@`5??a~=bz)UI-_mE@50$u)vH1q_1}f|#{I<9H9_+DNPv(`eD*q5PHEJp@ zG6!IoN$L)`4yWLc09A8aExV8Uos>6~L83GsgQR?p7BJ=U9-=)%ZH0NFhgh?x#QY~a z&C`wVPj%X9j=DUJR;nzK)w7=opmLimlKAy(2kOeCOrJ{|cknwCyUr_8U9 z@FPfaTQy4WO$zBj+Od@aeF7Ou={e?Fe&zpZ4@MelGt_60w9~@e!f?6i^NwvFnObzx zuF_w?!WTkl68jQl0I^r~{VPPu=+LrVsQ)^jy;iRSeS=7Ww_8GuzHb2kLy{k7HP13fB$I$@`f4v({)kBRh>J{An{M(aU~-{xui5V7+vZ29*PkFA=SAIL}#+&YyISyciK2C`L&%* z9UEF>J8{B;<2qdyF2oUZs#vaI+R^+8pj4o8(26GlQnXz&OyD3V^;qrPunc`q?t!?X zX>P|(>46;dWtKP894oEATsfNWXCSTvEf%4iL{v9=jQkQn<`Obo@th z2q-lyjbt5s33n?n3j3`#-_A(*Z35p0UKwa5IG0lDcGxhA7p7_wAML=LSzYUl^;qSa zh%0on!vsuManWA)-GfM}NXh$V>R#I39!GEwvet4l1q(~f{c@g0ryo06&zn&WK@@MMc@9}Zq}GbTYOUJf4p`D2 zpPXK5N}f9t$9D0NWySm4FG8!b#8J_6D%9*{r31#b(uwnAokv!Z}YvNNt zjmdvQ6yQ&z!yTHz`MKq1BVs%QPT6bqZZ~Tn#_hkoaUC(n@1euj)jzrufOcals(3FV zhBn&o*rjHumwE)YV|8HmG9c;i;ZV7{?<+ml?x_);E;aV6JrD)RfjW43t*3MF=wIgb z*CT-R&57|Q$#i-n|FtBUo`elnGt_vqCsBK8#eEB)>_&hL-bRGowUHtXmXh( zxqJv&nNKMQ_eY)aQIFe>ZylErY+%D=P&U=%nx2@0W~xL&4Ma7knkTx?5b1R{)I9z< zQn^iP``R1kU!c=-EFf;ZG&RbXz?9F1kEWS4(-Fr3=2EH^NLZCaccb7NP^!9{&n&*# zaQR!vu}8LxtpWZMVBm7IuXVwLfhsQl z?1MqP$396{_@$?#84c=RJIzh7@4ul_KgU?6cCrj4wYk=gr)}{5=z(TAcWWw^|9gd3 z_3$4*?#(p`Fq%4Yp*t+)m7&`GICv(?Qsf`sqpmgCwyWOMEx@50P$-qg;Y3J^VWptK z(qJcn!Xt)7Sa33W7?5?mMb*+%;dD>$bmY?!%ATfzIt`LeFkh40={=2g)+3BR1CUC@ zGH^u@JhKNhgVpSQ7NBNrQV}%^BB^@IoQM;0v9>OT^tnB5-MY1=pVtBJ+Wd>e&QAn8 zhPG|H04eQ*&86&xJ@9q{C=Ol(2(vhsnJT}D7k6ZTsoeFKOCafhBNOHNu7tHqJJ!yH zn>2VCOds@+H^HW-QldvKaaTan2y0j_>gTIrX~Q+`GR|6bsa^-|j1yUWqU24wPPFgDFW8?gqI1lN#P_B*MfSb-_P z@;|r3fGsFpf?GgN;hI1LkZAc%sjj#!-_^#bs_#1hNpjB39)@-T?SzHDZuz%^mzyD( zlXf++%u94?dka)u=2xEJy%n7aWOVuI6^Dhl^~C1v5vxz$o@iwM)y)CZC_3GE+DVoG zV}Q)F?p7|2*W^|3L{I7Z8#ZsgaSKtV$K1@-g3-JeklGkDywO#(DHsOv_fs8p8WkoV zt|@djr(|B}(Pl@es+%PDB1|0?5m`)L0>lAP zTXrdo+bxJ1N-z7AEOswHZ@kO(6_B#KeXM#U8RRgjdu_X{0$zjY0;K+0H;n&aPu4Bez1roWX$s>HQpA@#4b{Qo_^` zN4>WC5wO+_n=9fAV#tp@eht-6An8KxMbxVQX@HsiuG+V$;WI!gNBfFvHHCc+ljtb# zTy!xZ^6tr(h~z-5o1U|{e+5ZVrx}gtr&Z0bd$1DxOBeJFL_6tqTh|d>P%%Cnhrdqc`Q2B zps8q2Ym-x8Vb_+CI;$b8K$00v&q9A!@dR*c=P6{O3NkgCTmEZph)(LjZga4)axx$_ zVyh^?DLp_5NyhN0fMjInQG1elE1D(-EFD5y#F3V`uJ>oP*FZ2NtZj=lY#`{0|H5I?#E5^z}XCQ&D)H4~lqHTF4pZ z9obP`08ie0U8&)PXqk}12p$(9!faQB=J~8p`inbOo~2YtbuWRX0k+Z<7jh{i$uf>n zrOVJM(dy+l=rKT-gVGqQ>J0Y^WUVqpQq+}+&ulYJzpm=>OHtgs>|6~}(y9uP1(6a= z*K@U+ZZ%|R+&vt`(#HVg=PJciWxpPo61jYNtUL(}6`dITUVNkHi$iEj_vK0HyM)>y^Qs$P|B$kf8n zQnx^okKtb?ceetFV5{mB$j^-XYc~;8ddMXkUfP3Ez{=RC@@bd3#$c)JcDr0s3Of8) zSX!7JuSIJQNUAj_nHcw?hS}0OGb}t)z!d7*ao5+#DIM^v-)m;BS%7A8*+YjqfRN$@ z=P{aS9#x~HPTCChMdUEFn`4GDQ8@%t%I3bf__l-&qgGMemq>mGMEa{|$`#k02%~~k zFuBC`z=i6d=XJe1(36sqEMz{`T zo(16J?yBW;J@PKRg+lczX-$H+R&-VOFdGPKW0UGc?e+kG1gu|rQ=vl z>K@Ch`MhtJcbf?uD8;K+JINb8tes~Kj@JQcm}Z5qsoqFzJIUn$JJ6JrTfbt?yMW~0L{WO3_j(Z5HR@>OeLxa7 zRKk%DdMvL9wMVc&?1=fPT^joclK#M5yPQ4_U1Cj}vp(tHYhEB`pi?x*H?;}=43LIt zj}JFN|8rQFp_3gRo`dg=CPoX-t_wKJIG>p`L7hj^8ca7btR^WOg}=B+qSYc`>6*Q zwIi*$;AcphYuNEOk0HN6!^1s%$`L})!zpNe_5VPiS_AE~=)- zb3tiO#`aVx$n@Qb!|g=ie1Hjrj8qET3sB*hjK(KgWiRYec*m^i_@YE&%^xm7Imm58*7i)Az; zif~njroAuS?lxTAAr0VMQK)M`H97906Cj$PaH2%jT?Wb8d>lMftnabiN{$|R14tRj zs0PZ$gkFBW`K;cAN}bDb5n%+K#%C;64vX81zFVPqO%z^Ax7n6N^u2YXgb`F2wTjVv zwbjm!STOd_7=AZH!kjuGw1p}D-vUhTF8g8Dt?0C=T}yT1+j=^40yW z(H^2y8RZLS3=&DT9_aL}(tbN?+q{V$vZUtSLhga|o?dcIa|g5+nnHQqQI1pSG#YLg z5jxj&Pio}^Z?+@Obp<1;^kjCoqmOxXGOIHNTxq9Ei%|XNVC_Q>`K^&Lb;pe)6_iF( zDO27Z2rW*lzo&ZUoyZh1o)GUshq-l&TyL)>^zOuw+^Tw(;~wNN8%@ra`5q+-hyZwt z!1wt%jHZQld;k6(yq0`6#l)2kv2iBifgS{A?)$kW-aZUU%8Lt!s*61W zNN=gjv{jBrlM2tQvE6zMo$5%`@nKuU9|vN=sHLLfJke8`TNrD|laT7=+^&&W`e%18 zTJicc?mml35!W!f_W8LEY@2CMYrFtRpVA&>AI)uCmEuKs>OVKL zXi0ggM_gC8ga|DiaK*p$rmp~od8zJYH1F)M!fK8fE1~%{#4txx-lbAF0!l6vZMxs< z=x}gkn)x>5jUMS*vt3h8ya_6H{7ZGlw|WeN#wL;Y0#WB?FVIZij{>lSKD8S59h83A zZu-5OFJhKz_`MwOi#2&v;U6WP}ta7Ivq;x~Y_md9^P>45>?!qPxQ-Fh5`m;xHIA1$TZ z+(9@h{L4IJO^!Pu*!T?&+I=K9)17i*vr1moaN6Po&?ouZI z(gSRF<6Lcj1!!-ApPK!Kz_0n-Kl;6g-8Ew9Q<4BuE$^1L0Y)@=Z$)V^S=T05Sg4GdxlBF*B)re-=G9ad12L?}3+LwWQ|g-=Wpb@7;3f>5%lla0mOJZT#Ms{iJ;rn)Y_!0i$E*=y(X)RJH5quCQ$@E%o=VM^Utp_E`>>QYxUF1 zdU*QS5=GEy7)Ft7T2%Im1YtelVjTL)9;Af9$RZ$ZJ>L#DuTFTSJ&;%x#d z4_h)U*@DnmV;0J-en!7VlsH(^dn{JKX{%92ExN!CfXPV}Hkadro&Ea;{&jTUn*k~E zGPfUIVIq-$)M&A$uUq|={p4b0e;Xn#RL6Xkf~Z}=oDufkm6j&tt%}_PvXYuNwbOu zJ^(TRCdZlwhk4Y%i?X|3M5e4%OuS=7nRh5r+WY4ukRE0EpUo+Egq$c7Dn+^z8RqR~ zUeWYlcY#tUs#lrZjaC9)|7r%iCtqD1$>VYNqLrxB3HA9tWEypk7f{(M)b^Ri1f22a zG;{fHI@$wCN2^XYRpEm@#P)h{UYv&@;Z|KjGpjrdNLei>IRkj4r^1V$#(T71lLY zf|o0zNKd5Bb>#7EPozm+<*u1T(i6FfJrNBG+Gw~|_!s?54|k@i)9&c2UfB^e~dX!F{91Yt;wj#C7_?ss_7PLfTdWDnR%Qf!}T zPkJDuu&zBDE^ooo-wsYPyfN38O!_u7tRdnFbrhY(UNyZmvPZGr>G8^?EA@A?t9}=n zDl7fG$%|M58qC$2RlRLENdWub_aVhogC?W=8QFgGU^)K#utQ}BKU><$k3ee8H#hO5 zCt)2gh0-U0uz_-#H>eWQK81zBH`Vm|88Tg=cD3_FT@%jdJt3-w(kXob(4PpE)o;H< z4cv91rHoO@C_T!Wye<1RAUr$R-g*B9U2|~F(ckvKM2?!ZzUu(BL9MUf_t^6zhtNNu zHG7@~`w@{UY%1CHr$lzWbk0={ljF~T@ECV%7_Hby{NjVw{Vxm!e}$%%7$ezjS_Xdu ztxWR-M(1dl@H=p&7gSUJ(c`W6q&9Un;pG2a=|1$V^vN+mIu@$%QjeNC;aOW<-Cz-k`TNBH*x+XWctd;bW;wW3`mF6-`nBtDIHn0%R;Kto(fTl z<$taQJq?k%IP%A`)6t6Hx@5b%c1AwO3{UVg^VwXsuHGy^3z_^qZCn%A*?=sU;+p{N z|Jvkx4&3nHD#*EhrrvhdZe7asJdjKc0R4)MNl0gIP3dt#k3b@uZ;Qi)pj7kV;km=L z3%Lj~93e4aV; zN*HnlI;FpE-CnD887!j!CzMFeG>zbpRTRJ_;O)L>5DNu75T(|X) zeA@8&b9+8=Eu{pb2-C#BtyOF+A86yTWdf15FT=dLwXz4IbFJS*4Cx<7s9$TRGL^WV zWY>MC5fYuLt}*L(%1@Kjx}L-j0EhlkZq!$b?i!{$&6)2)B3k$eyyw)5CXxQa(-)Eg9_;<8I(kc^0{K zmF6Bu%E3iTZM5#~0Ewjf`+b0vKZ0{w{C;SPTh9hJr%VrkQhARHP)*fI$%8%eO_Td3 z`AelOC$K;xr?pw8g1e88?kVH>nL8qi1U#m_2V@ZY7P!}0$@pv3E zl)xT84_ZFav3l`0=N(V>q%0G)5z?aqvyLD&meT(PXiDu6wywLp2uR&IOl+22FF}&|!W^07&CqkkcMKabUgd+TiZQi5r>WSC_N@3UqE>+$a^gvtPu4+s4g`n_=)Go+H=%FLzCB2J#DmLZI z&#TfUkcc)O_u)yMU{|Z&r9GvY1Iz!ON(G$~5q08u{_-9(U4Aepy8=9LjrOwAx)Nf- zX}9pM@>>a=|Ns4;c9D;+MrR$Wkymcxbk1vlL+f*A)ehlTgE9+pEk=6j(aPPd#lM!K z^+1DS`MIVU+khIF%G?A~H})jfmN>I1p?L{EsHL{_k9+EvZYy%=Y%Fj{ENJ~=p{-;) zdRW>9q6#t<#)oFDcykZXyu{psRR7T`_^tUpQV%TN=6CA8a=N4vw*xadcm~G?wrpZX zVJXe^t$U22Q?=m0SmV%=Rd2IH#@tbf6<;bXI2r^AJ2I!It6eA}S46S0~#>@DM2dYou)&NUWtdU+O9C zo+=-pq?aDhBxc3N$=d$h2@XHXOx~QWCGUa_J1^pf*XG=!@PmrQhoP6!ShtRI4`>(y zw#(Eo_jZ7%uv$Rx1E_+hvFd8@{itx|7VM;7>GXP+wuvn0G@65hW@jqULrG#cO{5|} zj2ak8CFAoW9oRM5Jexk+6Itz?j;LP@cnp}FH?{}YA5X0Ex19GZp8$jvwe&IR)T~d! zQsY`nn#SZQP~;E(otSz4wfQ1>8k%yq%Pp=!qs#DGnWdrQ9S}kWmb;Fu>JKO>ZWpCPoM#$h|C0>r@o1nXuS@l=e~ss z=Sn4E5+TljQcn(CICrbwaTJz`XKk6|zk^Ik_mr78iKZvR;XlI{(0d^HaFkdVci%^) z6t1~hxd!_dYDg#-7rnvtUGH}nWCP{wQ zfo6@Yi<28l-mKdxc!70wiP4g=#<5R z7(YYP?l$YCAFP$}7vRdUm~WTG$TG07q%?Et_*(~da4xRP{r+cCbpVaI(*FaPif^j6 zJ?8&gVYNHM!mv$&tPHn_7;GE|O7`B>q*Zj&b=MMF{0_%#@8&(?(eyT# zCW1+0b?wbBL*n|5vH@@ggi7TGJNT4%R*q@p5~GuU?HbouGpqSM-PKcBN#<7nRyM=Cd#c6B)#s{q_dvo2A59Xux2Le1U~ZzD zKy3PU?V*+Q#Me#DtHcB7;;O|VdJv%o?Jl(ze+W5DL1ln%j(ZPxY`;59hJf~Xq+{ab znQH3z_0f(|D(XyMd4GltU70g?nUf#usoI8@>ko4ZEbTHfp?f@mjNoS+(zcjSPlD3q zH<`g?c?yt%E1YkwW>5Ddd$aaD10bZl4ns)KqEk0lGTibjUG_Oxx{1TrIq_f0AoKz- z?ChFsl11X0Jbh^kN1)Jt~o&34|?Xg$##$QLqL}8iPAG>XIAUs zW(9rZ2Lq~}kdp6XRD^UbLvbOWKn6jypwqH^3Q8;S2CBGnX3)=IVgJUw=J9#YXDwAj zv&I*oFnMr%$@b_=bn0+ZouYq*%(wZYHFM+FNx-_vCJ_x9v*99|06DT285L?uZX8 znP55mtHrUPLF%4d$t|YiU}1B?Lq0Y69}h`g4;@}%K|BGi(>O`hOHM>&C7rQ<;11q; zz)4UwD}_b@Cno~~TPYzugTMyOVnb}6JyC#H(a{GZ0VZmJ&Ss%iFeSor24QaWjAE>{2}i@}%e$_`A< zw(aCqfUulBsZ3XcRMykQW?rfaGUB7ySxwd-r4QHDqz&lQa2=0^@*v;TQ|xQA{bux< zl4>?Ge9J_(1sWmNOW^#^$grl6t?*RDuBd#FYqr`B%tzS$+Bwz^NZ8upxS#6MQ|w=| z#Z}O5NII5_7iCRjwKfVlf3|{e>taOYkx1mqJf?c zJ-Rj!X3!DUOgXdh43uaNsH2S67w7$-)?HZr&&$ohaS;?rx=BA(>*#V%WYfOSE}I?$ zGKif`RUckKMHYJxTORN1>FG7Krn9twQs{P!lp*78$eKKw&j%si(^H8o(A402A--b* zs+frPq0%Fk#>{T~O-uWr&%pEj&9lD$05Y;??=JoEK|sE~cT$W7{5%B7*Kt_SnkwaC z7`d$5c|C2W7qN@!kkB6O87gp3O^8$(80P+c{ZV63`ACJ6Dy8=Eo@e)@WwbemJOLYK z56v;|9GBVX$)5GVl51%AdkUgPRNc0Dcp8}+@j0rC8P9ZJo#8FRvw&2n3e9Zu94w1) zo~!Tos9*4dnl9J%^cQ<7H1#w$mmMih2Axv3+t4q$;82e;ztzjxu_Uq; zF?=o>xo*R+gxL2Ki@E@O#gQrhWz;E1dpX*R>|`@J~6E;Si^(18kR z2lx<>s_1-e)%vI-D1c@N0BL*un5bRz z2!>Bu4IGQ2D!9x>p+Tma&as^fQEMRiytrBAwyC1u!y^3~r`u(+A9^AlKr^}a_aiKP z(ePC6Cv=M5;c`_?-akXqW}<@S`pz#P?AQ&D)B*diy^KAMET}m7*&7+{KD7O9VCVQ$d9EJwKdni$;(pP{|E4b=3zTj3HBYEDGskg&u*LvnlBM84^y8TvvYe0% z6eq_-C4dtF;e5Sk1KZa3B#`R1rmQ3@SC8ff~^J_mckVAS=gvpcwV#i`99 zOC|LNn3gpU+KARLKNl8>@*=Al^E`l_W>`>f{2wuG9xtx~HkXc=m)m{p3wr@#+gAY> zr2r2(aBk_z9Xia^TzLsZdlSlq7hdRy2pQ(F)GS>-a#_zcG0bq6Ln3|`&A5!~8CRqr zf|#sj_e!L>YxT&yQFawV(^S;*CfKXdQ6bB&-~pz3J-yTnN==ehBej>b)}zDU`fWGS zX^{D__<3v;2GAxDiB-&#g?5#5GazDhUf`0(-&A1>tZ9-J%4I7el~l+<=hn3@ZU$^eq4l$;3u$@qZ=* z4`Oq*SsAywXpP%?Cg-rV0lpoO56`vp`cX74iRS{XHHK0v-b+}XK!m3{!l=$MnV-!W zwA=lNl;o5L3)5&Nt%ytL*O~q+C6z8Y*J%xk`FZp(Ky~ukIWIyYp5oM zs7S*ZbLlNBJ@w97>+bBo?;me(husChorAvv+Le}q&iCq7yfT*E)3a=kl6G&hXb-P@ z8)EmNBU2gbVb`HY-47=up%Ikw03u7$!pdH+L)3w##(EH}GIL8#oCxkAq)p2q^YO#} z%^3HBmmU}If=8gkI-&Pe^m$$WQDDk0tCAoGPChl^pTXLFe6KysWBwl+fi_E1K}Sw5 z4wsSe2|)Vp+KCP=1r}LsU>PZ;=qX4>!G>{ngNo&+LF8X2Ia=cxRQPjfQl|MDq0a*I zu>~unk3H8@(H(>?@Ng!R3ou{1MW?KyU+l;PH~QK~yae&F=?c3|O$jC1aXC!Ag6fl6 z9fFbit1wNlZu^ECX())ufC8wn*U|Z)7h5>o(NTJeh1F;EmLth-t7+1F6On#5U)Jll zdTzbC$@^_cS}bu6oQG)PcaqKm+8ze-m3JZG!}SvdzlSCsw~Y+onkL={M9R8l43Qsz zQaPSH41T5ie+XM!1uDdd0Pr$@1WoB%m&)PgV>A)0EWY#4)DlFhymxYzOlc;)5ZXca zp8E`%W;9P~`F3IOb6`r|zf=!Le}UG&4%F$(m;O%^@9kbgC!)iX0lC#Ie6h{0&C5d)Y)C z0U^TEhITUd2U=JC`x{Lo6@hOMM=6YDRX7$B{`9_*&vAehuztKA@ID^B)(hAiDyHBG zNn+37(4CM^L=QdKn`ouIoYXV9Zb#2EBv0;%myJMFx!kW?$zDKAGyZo9;j(G9Kuvr4CB%ivLSwJ-RvTiZ4q@d=6ySJiPT?6nXv%DUukFO7H0p1Lwkf2ll3V51J z6Pr55Jm!$R8e%gn9ImsF6Ui0;Ne@m#gS+fjpym;(y{3uns7Q@p<3UFN^b$}e8{2Th zC+hP~Xqd=*DzBN&cEi$HM#gmGJxCpCwq32bxtFry@^D>csvC*7bky#tA4{TBT=dC^Zj=x0M)3AfMI+J-WH*MDKn9vr9cgBw_rbwTBR|F@CqP=(%t3Uk|=()%DfpLWrt`D#1_NtK*Q zmb1TH5BFR<+dZ8}&|$Aq3~n2b_CyElFX=1j8akZzihL}j)?2rGH;n~}tqNK015f0~ z<|~eT5*d+=vyOOHhN=PzTg;eVVH&Yvej28;j5J@2XAtWAPfMEMS^p2ic&~WsG!%ep z*Ua2jsu$4tfP=icCrvv6Wgr`U%ud6(@k`(|)y|FA(os6OspgMYki|iBfO-{?uiAyx z?EM;mn1;8BD5TY^Uhk=0cjxh_7DG4(($v?oc+peP1jJZINAW-D+jNvl{5~p-kB+qWQa=EsU)32JfAN}D^uQ03 zO&i{b`Un*vGLhE(WZDTR+(+W92FF~a>HXbaC2~w5Vx#%PQ*A(JHm^r>dRuM|+L&SpTPX z3^`4`I1Z8wu6H>k!rAdXQLXg#LgNV#jB`cvi4*(J(}Dri0(cT+XiihOh2&&F1Y47` zZUQ?6HuSuvY@LeMOe3WRo#y{^Evr|lqGe>m`swhntK4=db_OIRk5wcWUMDmY81AST ziaM)jnVUT@yC3ss_be>DxT!&SPES>V^5>~)=R#74Lx<-o!0mZG+epQYYu*j#_iTo; zo4_;_$gnLd71%P~^w0}?Y5Uj$%~TfwBIX0r71WX(F9v14tZmfr!tEu%NQsF{qD#?w zi7@lcGWJNvK1Gf6yI zF=6KXZ`RzlgIeO>7`^DAI%lg!`ud`uhI-Ulq;^_{gsa^>tl%B6aK)W|5}PZ4)USL& z^c;qjp3fK+Gpp3AyI?8(h89?mngR*OgND-S3Qs~mIZ9i4nO4yG^7VCuMmYgwOqGuh zMXkIHXer>DFs4c6LH}C-tjO&tWK_Orjkbk&7#*I<%vfFmk0kHm)xWW%_&?p+GgCB@ z{ItC)^O*l582YyNSW88D9H!ANczAyT5nfvWZb}ItpAz)j3vzUlUItIIu_aOR=p-<# z@2%1IjQ^E4*5d0wi%3I0`Q$*P*5@yod;!b{p=WmlR)07Gq?= zP2XBzUWTZri}Y=;{0frD>H;JM{?(q`6(1q#=_QZ|(eVX7U+=WDSiir4&PUrz6V`vW z6PPl6bnA7r5>#YiQEz^&Z$Tn1(pmi<9qe?#9knqF^gBJzS`fH*dy*UXIliQp0MZec zor?3ZrJEdu>KLQ;E+6!4-sP&*{zE`!h&pH%da3pn>hV!eIO<^~g?$WA@fP>GGJb+i zHMs0JnWvp}WNWQ>Wcyi1DnxPh&d(tc&!$@c+dk$CSbEy*0R?~AlkBS9Pm62uRmZ&5 z;QgwaAijoSX!S33a|eUppwmh8{W3V&muaAHdsdI%EiSe2^54O9E`3!w|3F0gA{3Om z{5^omKwrpVXXb|=ptuw_A>szxF~F>Nujf`3)3(#X!-l zmmAKQjzfi&ZA%Mv?fm!-I1eZ#{{+C=SP^|{ygV0AOc}cE`gODyR672`a;d8)_aaJz zHC9dmWKH2WQn3JQyqyY6xwfe@(>xTZF|dfPDKWL&oeolXT+Vc*Gtd~G5gIS$oC#2$ ziPdMy>T*_+PMHrBhiy=`A7M9%^Tj=OM%EE{~wTGX}4&$ z1Zb_XQujf(c3^L=JZ}dWZ)PRc-hoIZub=S%O|{=nQ2N$r3&*n?9q#s8xoWoA(-HG_ z{AznKwdORX_7;%Okc-dU+J7%WHb!qdT1Y)Err6sdC0*8+3Wqe>69{MWe2vgCNCdaw zvsj$~WWKC(ikcxj!DO&Z!czs8jg7|r=*&hFtIyIN7qac1PI;y#-J;gbnVyeAVO-B8 z0b#nYQQP}@K-z^{n1hmbA7>G$UE=zs89q#CeU{uX2v;t9IrnUAY z>YY7-Yn{!({w_#5_Q+o0tQ1o-+uhJq&V?mXxd$Do)W+18?(M+Hs9VCc6@aGTBqsU& z{ns7d_t0S<0HnMXzQ**Fp1_sFT4f(f_N5jT?ctt!vDpV7L8k+mc1t^^tn?)1Z9-c? z8)(kaYC?YumAQc9GgSo{?p*>b#psC+Y+Z6%NnHWt3w15JT`qVEl#xJh@Pv6;u%3pc z8V-^Ss%Ow?0Wkzy5dUW(_;B;I0`)$JA{6(=bdVQ%;spyvb*&d6`9%5U2>L{HFTwJO zt!*`Xxzk+GRqd6YXO9baY{eSmRaolhrdyf1UhA2bY$)g~o!&D$ZL)g<9r^4S!RC>k zzhY?-$D4rEYhiSx9Z_O83m;7dO;~@wrvlY}h=^!fe6E$!Za#vA>&4Zl=_klA=`LYgk3Z>|>|GaW zT4ekwtQusjJumkeD$?CHRT0fUM~6*DDW|f=;}@U|Ke~atVQt)e+0)rWj5v>HP60*e zQ#G4VPXOVE4NkOd3Q9+)UOe3CCJ5gNjrh%`$E{!LEGEk-vcwb zuUBr=W2A*t&c?}%fjJ_n)igCaT#YGEW3S6@->99^yYmk!Htbx**LpjN7D02#}4 ze%eV-zt43^x(QnKv@2p0B2}6lq9D>qVEN+K@qKmMbW1Oxb_-MzbOc*|YAtTbc2HVp z^>1|{m}UY=$zv>`W8Mv*n)FmPC(mJSH$)q=X_n%=r~hu{Xu*7LhD5x3#)ZD94#R8$ z41)$kIdk0F^NmlhK3_56ZtMBP4qY4Rw*!4lLzVq^6qQ<7*=F@33JNH)zoG3ECPJ4f zwOI)!(fP3VPK%TMy$lL^-6&x^0THihS=-Jae9`Wy=F7RB-8+A^ILsf-zWRIxb9S@? zO5<(((>i(xGW8dD(ukU`$@&gp*mO*di(rTE*|P42 zq;*Ee*L;BQIhv|oD8kIWkbG!;^I^NMrevo0KkV0>e3D#L`4Il zBpDi+N*?N&4#xWXFd$8_a6n+_Qd%AX4a41Y+U3puXwSvNsK)7^0YqgJ*J7SMhD?

WF_$EfZyrd)fbCz8wo#uBaoh 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

v!{1$1$_fLt#Z)Z+}tyFb;xBvlYoZ0 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