diff --git a/.github/workflows/deploy-documentation.yml b/.github/workflows/deploy-documentation.yml index eef8e80..94a8eb5 100644 --- a/.github/workflows/deploy-documentation.yml +++ b/.github/workflows/deploy-documentation.yml @@ -23,6 +23,6 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - python -m pip install .[docs] + python -m pip install --group docs - name: Deploy docs run: mkdocs gh-deploy --force diff --git a/climanet/dataset.py b/climanet/dataset.py index c9babdd..17ef9f5 100644 --- a/climanet/dataset.py +++ b/climanet/dataset.py @@ -1,3 +1,5 @@ +import numpy as np +from .utils import add_month_day_dims import xarray as xr import torch from torch.utils.data import Dataset @@ -17,38 +19,54 @@ def __init__( patch_size: Tuple[int, int] = (16, 16), overlap: int = 0, ): - self.daily_da = daily_da - self.monthly_da = monthly_da - self.land_mask = land_mask - self.time_dim = time_dim self.spatial_dims = spatial_dims self.patch_size = patch_size self.overlap = overlap - # Group daily data - # Create "YYYY-MM" string labels - daily_labels = self.daily_da[time_dim].dt.strftime("%Y-%m") - monthly_labels = self.monthly_da[time_dim].dt.strftime("%Y-%m") + # Check that the input data has the expected dimensions + if time_dim not in daily_da.dims or time_dim not in monthly_da.dims: + raise ValueError(f"Time dimension '{time_dim}' not found in input data") + for dim in spatial_dims: + if dim not in daily_da.dims or dim not in monthly_da.dims: + raise ValueError(f"Spatial dimension '{dim}' not found in input data") + + # Reshape daily → (M, T=31, H, W), monthly → (M, H, W), + # and get padded_days_mask → (M, T=31) + daily_mt, monthly_m, padded_days_mask = add_month_day_dims( + daily_da, monthly_da, time_dim=time_dim + ) + + # Convert to numpy once — all __getitem__ calls use these + self.daily_np = daily_mt.to_numpy().copy() # (M, T=31, H, W) float + self.monthly_np = monthly_m.to_numpy().copy() # (M, H, W) float + self.padded_mask_np = padded_days_mask.to_numpy().copy() # (M, T=31) bool + + if land_mask is not None: + lm = land_mask.to_numpy().copy() + if lm.ndim == 3: + lm = lm.squeeze(0) # (1, H, W) → (H, W) + self.land_mask_np = lm + else: + self.land_mask_np = None + + # Precompute the NaN mask before filling NaNs + # daily_mask: True where NaN (i.e. missing ocean data, not land) + self.daily_nan_mask = np.isnan(self.daily_np) # (M, T=31, H, W) - # Group daily indices by month label - daily_groups = daily_labels.groupby(daily_labels).groups + # Fill NaNs with 0 in-place + np.nan_to_num(self.daily_np, copy=False, nan=0.0) - self.month_to_days = {} - for month_idx, period in enumerate(monthly_labels.values): - self.month_to_days[month_idx] = daily_groups.get(period, []) - if len(self.month_to_days[month_idx]) == 0: - raise ValueError(f"No daily data found for month index {month_idx}") + # Precompute padded_days_mask as a tensor (same for all patches) + self.padded_days_tensor = torch.from_numpy(self.padded_mask_np).bool() # Precompute lazy index mapping for patches - dim_y, dim_x = self.spatial_dims self.stride = self.patch_size[0] - self.overlap - self.n_i = ( - self.daily_da.sizes[dim_y] - self.patch_size[0] - ) // self.stride + 1 # number of horizontal patches - self.n_j = ( - self.daily_da.sizes[dim_x] - self.patch_size[1] - ) // self.stride + 1 # number of vertical patches - self.total_len = len(self.monthly_da[time_dim]) * self.n_i * self.n_j + H, W = self.daily_np.shape[2], self.daily_np.shape[3] + self.n_i = (H - self.patch_size[0]) // self.stride + 1 + self.n_j = (W - self.patch_size[1]) // self.stride + 1 + + # Total length is only spatial patches (all months included in each sample) + self.total_len = self.n_i * self.n_j def __len__(self): return self.total_len @@ -58,63 +76,44 @@ def __getitem__(self, idx): if idx < 0 or idx >= self.total_len: raise IndexError("Index out of range") - dim_y, dim_x = self.spatial_dims - per_t = self.n_i * self.n_j - t, rem = divmod(idx, per_t) - i_idx, j_idx = divmod(rem, self.n_j) + i_idx, j_idx = divmod(idx, self.n_j) i = i_idx * self.stride j = j_idx * self.stride - - # Extract spatial patch - y_slice = slice(i, i + self.patch_size[0]) - x_slice = slice(j, j + self.patch_size[1]) - - # Get daily data (all days in month) - # Assuming monthly timestamp corresponds to days in that month - daily_patch = self.daily_da.isel( - { - self.time_dim: self.month_to_days[t], - dim_y: y_slice, - dim_x: x_slice, - } - ).to_numpy() # shape: (T, H, W) - - # Add channel dim → (C=1, T, H, W) - daily_patch = torch.from_numpy(daily_patch).float().unsqueeze(0) - - # Get monthly target - monthly_patch = self.monthly_da.isel( - { - self.time_dim: t, - dim_y: y_slice, - dim_x: x_slice, - } - ).to_numpy() - monthly_patch = torch.from_numpy(monthly_patch).float() - - if self.land_mask is not None: - land_mask_patch = self.land_mask.isel( - {dim_y: y_slice, dim_x: x_slice} - ).to_numpy() - land_mask_patch = torch.from_numpy(land_mask_patch).bool() # (H,W) + ph, pw = self.patch_size + + # Extract spatial patch via numpy slicing — faster than xarray indexing + daily_patch = self.daily_np[:, :, i : i + ph, j : j + pw] # (M, T, H, W) + monthly_patch = self.monthly_np[:, i : i + ph, j : j + pw] # (M, H, W) + daily_nan_mask = self.daily_nan_mask[ + :, :, i : i + ph, j : j + pw + ] # (M, T, H, W) + + if self.land_mask_np is not None: + land_patch = self.land_mask_np[i : i + ph, j : j + pw] # (H, W) + land_tensor = torch.from_numpy(land_patch.copy()).bool() else: - # No land mask → all ocean (False) - land_mask_patch = torch.zeros( - self.patch_size[0], self.patch_size[1], dtype=torch.bool - ) - - daily_mask_patch = torch.isnan(daily_patch) & (~land_mask_patch) - - # Replace NaNs in daily data with zeros (after creating mask) - daily_patch = torch.nan_to_num(daily_patch, nan=0.0) + land_tensor = torch.zeros(ph, pw, dtype=torch.bool) + + # Convert to tensors (from_numpy is zero-copy on contiguous arrays) + # (1, M, T, H, W) + daily_tensor = torch.from_numpy(daily_patch).float().unsqueeze(0) + # (M, H, W) + monthly_tensor = torch.from_numpy(monthly_patch).float() + # (1, M, T, H, W) + daily_nan_mask = torch.from_numpy(daily_nan_mask).unsqueeze(0) + + # daily_mask: NaN locations that are NOT land + # Reshape land_tensor for broadcasting: (H, W) → (1, 1, 1, H, W) + daily_mask_tensor = daily_nan_mask & ( + ~land_tensor.unsqueeze(0).unsqueeze(0).unsqueeze(0) + ) # Convert to tensors - sample = { - "daily_patch": daily_patch, # (C=1, T, H, W) - "monthly_patch": monthly_patch, # (H, W) - "daily_mask_patch": daily_mask_patch, # (C=1, T, H, W) - "land_mask_patch": land_mask_patch.squeeze(), # (H,W) - "coords": (t, i, j), + return { + "daily_patch": daily_tensor, # (C=1, M, T=31, H, W) + "monthly_patch": monthly_tensor, # (M, H, W) + "daily_mask_patch": daily_mask_tensor, # (C=1, M, T=31, H, W) + "land_mask_patch": land_tensor, # (H,W) True=Land + "padded_days_mask": self.padded_days_tensor, # (M, T=31) True=padded + "coords": (i, j), } - - return sample diff --git a/climanet/st_encoder_decoder.py b/climanet/st_encoder_decoder.py index e695eb1..21f4dc3 100644 --- a/climanet/st_encoder_decoder.py +++ b/climanet/st_encoder_decoder.py @@ -123,53 +123,109 @@ def forward(self, T): class TemporalAttentionAggregator(nn.Module): """Temporal attention-based aggregator. - This module aggregates temporal tokens into a single token per spatial patch - by computing learned attention weights over the temporal dimension. Temporal - positional encodings are added before computing the attention weights. Then, - temporal attention weights are calculated by applying `nn.Sequential` to get - a scalar score. - - For each spatial location, a weighted sum over time is performed to - produce one aggregated token. + This module aggregates temporal information for each spatial patch by + applying attention across the temporal dimension. It consists of two main + steps: + 1. Day attention: For each month, it computes attention weights across the + temporal tokens (days) and performs a weighted sum to get one token per + spatial location for each month. + 2. Cross-month mixing: After temporal aggregation, it applies a Transformer + encoder layer to mix information across months at each spatial location. + + For each spatial location, the day attention allows the model to learn which + days are most important for predicting the monthly average, while the + cross-month mixing allows the model to learn interactions between different + months. """ - def __init__(self, embed_dim=128, max_T=31): + def __init__(self, embed_dim=128, max_days=31, max_months=12): """Initialize the temporal attention aggregator. Args: embed_dim: Dimension of the embedding. The default is 128. Many vision transformers use embedding dimensions that are multiples of 64 (e.g., 64, 128, 256). This can be tuned. - max_T: Maximum length of the temporal dimension to precompute - encodings for. Default is 31, which is sufficient for a month of - daily data. + max_days: Maximum length of the temporal dimension to precompute + encodings for. Default is 31, which is sufficient for a month of + daily data. + max_months: Maximum number of months (temporal patches) to precompute + encodings for. Default is 12, which is sufficient for a year of monthly data. """ super().__init__() - self.pos = TemporalPositionalEncoding(embed_dim, max_len=max_T) - self.scorer = nn.Sequential( + + # Positional encodings for days and months + self.pos_days = TemporalPositionalEncoding(embed_dim, max_len=max_days) + self.pos_months = TemporalPositionalEncoding(embed_dim, max_len=max_months) + + # Day scorer (within each month) + self.day_scorer = nn.Sequential( nn.LayerNorm(embed_dim), # normalizing features nn.Linear(embed_dim, embed_dim), # learns temporal feature transformation nn.GELU(), # adds non-linearity to capture complex temporal patterns nn.Linear(embed_dim, 1), # project to a single score ) - def forward(self, x, T, H, W): + # Cross month mixing + self.month_ln = nn.LayerNorm(embed_dim) + self.month_attn = nn.MultiheadAttention( + embed_dim=embed_dim, + num_heads=4, + dropout=0.0, + batch_first=True, + ) + self.month_ffn = nn.Sequential( + nn.LayerNorm(embed_dim), + nn.Linear( + embed_dim, 4 * embed_dim + ), # 4 is a common factor in transformer feedforward layers + nn.GELU(), + nn.Linear(4 * embed_dim, embed_dim), + ) + + def forward(self, x, M, T, H, W, padded_days_mask=None): """ Args: - x: (B, T*H*W, C) containing spatio-temporal tokens - T: number of temporal tokens per spatial location (here days) - H: spatial height after patching - W: spatial width after patching + x: (B, M*T*H*W, C) containing spatio-temporal tokens, where C is the embedding dimension. + M: number of months + T: number of temporal tokens per month after temporal patching (Tp) + H: spatial height after spatial patching + W: spatial width after spatial patching + padded_days_mask: Optional boolean tensor of shape (B, M, T), bool, + True indicating which day tokens are padded (because some months + have fewer days). This is used to mask out padded tokens in attention computation. Returns: - Tensor of shape (B, H*W, C) with one temporally aggregated token - per spatial location + Tensor of shape (B, M*H*W, C) with one temporally aggregated, where C is the embedding dimension. """ - seq = rearrange(x, "b (t h w) c -> b (h w) t c", t=T, h=H, w=W) - pe = self.pos(T).to(seq.device).to(seq.dtype) - seq = seq + pe.unsqueeze(0).unsqueeze(0) - weights = torch.softmax(self.scorer(seq).squeeze(-1), dim=-1) - out = (seq * weights.unsqueeze(-1)).sum(dim=2) - return out + seq = rearrange(x, "b (m t h w) c -> b (h w) m t c", m=M, t=T, h=H, w=W) + + pe_days = self.pos_days(T).to(seq.device).to(seq.dtype) # (T, C) + pe_months = self.pos_months(M).to(seq.device).to(seq.dtype) # (M, C) + + seq = seq + pe_days[None, None, None, :, :] # add day PE + seq = seq + pe_months[None, None, :, None, :] # add month PE + + # Day attention per month + day_logits = self.day_scorer(seq).squeeze(-1) # (B, HW, M, T) + + # padded_days_mask is (B, M, T) true=padded, -> (B, HW, M, T) + if padded_days_mask is not None: + pad = padded_days_mask[:, None, :, :].expand(x.shape[0], H * W, M, T) + day_logits = day_logits.masked_fill(pad, float("-inf")) + + day_w = torch.softmax(day_logits, dim=-1) + month_tokens = (seq * day_w.unsqueeze(-1)).sum(dim=3) # (B, HW, M, C) + + # Cross-month attention at each spatial location + z = rearrange(month_tokens, "b s m c -> (b s) m c") + z_ln = self.month_ln(z) + attn_out, _ = self.month_attn(z_ln, z_ln, z_ln, need_weights=False) + z = z + attn_out + z = z + self.month_ffn(z) + + # Back to flattened tokens with month kept + z = rearrange(z, "(b s) m c -> b s m c", b=x.shape[0], s=H * W) + out = rearrange(z, "b (h w) m c -> b (m h w) c", h=H, w=W) + return out # (B, M*H*W, C) C: embedding dimension class MonthlyConvDecoder(nn.Module): @@ -178,11 +234,14 @@ class MonthlyConvDecoder(nn.Module): The MonthlyConvDecoder converts latent patch tokens back to pixel space: - Applies a 1*1 convolution to mix features on the patch grid. - Uses a transposed convolution (deconvolution) to upsample tokens to the original spatial resolution. + - Applies a convolutional refinement block to smooth patch boundaries. - Applies a small convolutional head to produce the final single-channel output. - Optionally masks out land regions using a boolean mask. """ - def __init__(self, embed_dim=128, patch_h=4, patch_w=4, hidden=128, overlap=1): + def __init__( + self, embed_dim=128, patch_h=4, patch_w=4, hidden=128, overlap=1, num_months=12 + ): """ Args: embed_dim: Dimension of the patch embedding.The default is 128. @@ -194,6 +253,7 @@ def __init__(self, embed_dim=128, patch_h=4, patch_w=4, hidden=128, overlap=1): The default is 128, which can be tuned. overlap: Overlap size for deconvolution. It creates smooth blending between adjacent upsampled patches. Default is 1, no overlap at edges. + num_months: Number of months. Default is 12. """ super().__init__() self.patch_h = patch_h @@ -229,56 +289,68 @@ def __init__(self, embed_dim=128, patch_h=4, patch_w=4, hidden=128, overlap=1): # common choice for spatial convolutions; it's the smallest kernel that # captures spatial context in all directions in_channels, out_channels = hidden // 2, hidden // 2 - self.head = nn.Sequential( - nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False), + + # Refinement block: a small conv layers to smooth patch boundaries + self.refine = nn.Sequential( + nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), + nn.BatchNorm2d(out_channels), + nn.GELU(), + nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1), nn.BatchNorm2d(out_channels), nn.GELU(), - nn.Conv2d(out_channels, 1, kernel_size=1), ) + # Final conv head to map to single-channel output + self.head = nn.Conv2d(out_channels, 1, kernel_size=1) + # Learnable scale and bias (mean and std) to improve predictions - self.scale = nn.Parameter(torch.ones(1)) - self.bias = nn.Parameter(torch.zeros(1)) + self.scale = nn.Parameter(torch.ones(num_months)) + self.bias = nn.Parameter(torch.zeros(num_months)) - def forward(self, latent, out_H, out_W, land_mask=None): + def forward(self, latent, M, out_H, out_W, land_mask=None): """Reconstruct 2D maps from latent patch tokens. Args: - latent: Tensor of shape (B, H'*W', C), where H'*W' = out_H//patch_h * out_W//patch_w + latent: Tensor of shape (B, M*Hp*Wp, C) where C is the embedding dimension. + M: Number of months (temporal patches) out_H: Target output height (must be divisible by patch_h) out_W: Target output width (must be divisible by patch_w) land_mask: Optional boolean tensor of shape (out_H, out_W). Values set to True will be masked out (set to 0) in the output (only ocean pixels exist). Returns: - Tensor of shape (B, out_H, out_W) representing the monthly SST. + Tensor of shape (B, M, out_H, out_W) representing the monthly variable e.g. SST. """ - B, HW, C = latent.shape + B, MHW, C = latent.shape Hp = out_H // self.patch_h Wp = out_W // self.patch_w - assert Hp * Wp == HW, f"Token count mismatch: HW={HW}, Hp={Hp}, Wp={Wp}" + assert MHW == M * Hp * Wp, f"Token mismatch: got {MHW}, expected {M * Hp * Wp}" # transforms the latent tensor from sequence format to image format for - # convolution operations - out = ( - latent.view(B, Hp, Wp, C).permute(0, 3, 1, 2).contiguous() - ) # (B, C, Hp, Wp) + # convolution operations; (B, M*Hp*Wp, C) -> (B*M, C, Hp, Wp) + out = latent.view(B, M, Hp, Wp, C).permute(0, 1, 4, 2, 3).contiguous() + out = out.view(B * M, C, Hp, Wp) # Apply 1x1 convolution to mix features - out = self.proj(out) # (B, hidden, Hp, Wp) + out = self.proj(out) # (B*M, hidden, Hp, Wp) # Use transposed convolution to upsample - out = self.deconv(out) # (B, hidden//2, H, W) + out = self.deconv(out) # (B*M, hidden//2, H, W) + + # Refinement CNN to smooth boundaries + out = self.refine(out) # (B*M, hidden//2, H, W) # Apply final conv head to get single channel output - out = self.head(out) # (B, 1, H, W) + out = self.head(out) # (B*M, 1, H, W) - # Apply scale and bias - out = out * self.scale + self.bias - out = out.squeeze(1) # (B, H, W) + # Apply scale and bias per month to improve predictions; reshape to (B*M, 1, 1, 1) for broadcasting + scale = self.scale[:M].unsqueeze(0).expand(B, M).reshape(B * M, 1, 1, 1) + bias = self.bias[:M].unsqueeze(0).expand(B, M).reshape(B * M, 1, 1, 1) + out = out * scale + bias + out = out.view(B, M, out_H, out_W) # (B, M, H, W) # Mask out land areas if land_mask is provided if land_mask is not None: - out = out.masked_fill(land_mask.bool().unsqueeze(0), 0.0) - return out + out = out.masked_fill(land_mask.bool()[None, None, :, :], 0.0) + return out # (B, M, out_H, out_W) class SpatialPositionalEncoding2D(nn.Module): @@ -407,7 +479,7 @@ class SpatioTemporalModel(nn.Module): Processes daily data in a video-style format with shape (B, C, T, H, W): B: batch size C: number of channels (e.g., 1 for SST, can include additional channels like masks) - T: temporal dimension (number of days) + T: temporal dimension (number of days, e.g., 31 for a month) H: spatial height W: spatial width @@ -418,7 +490,7 @@ class SpatioTemporalModel(nn.Module): 4. Decode aggregated tokens into a full-resolution 2D map using MonthlyConvDecoder. Output: - - Reconstructed monthly SST map of shape (B, H, W) + - Reconstructed monthly (SST) map of shape (B, M, H, W) """ def __init__( @@ -426,7 +498,8 @@ def __init__( in_chans=1, embed_dim=128, patch_size=(1, 4, 4), - max_T=64, + max_days=31, + max_months=12, hidden=128, overlap=1, max_H=1024, @@ -440,20 +513,22 @@ def __init__( in_chans: Number of input channels (e.g., 1 for SST, additional channels possible) embed_dim: Dimension of the patch embedding patch_size: Tuple of (T, H, W) patch sizes for temporal and spatial patching - max_T: Maximum temporal length for temporal positional encoding + max_days: Maximum number of days for temporal positional encoding + max_months: Maximum number of months for temporal positional encoding hidden: Hidden dimension used in the decoder overlap: Overlap for deconvolution in the decoder max_H: Maximum spatial height for 2D positional encoding max_W: Maximum spatial width for 2D positional encoding spatial_depth: Number of layers in the spatial Transformer spatial_heads: Number of attention heads in the spatial Transformer - """ super().__init__() self.encoder = VideoEncoder( in_chans=in_chans, embed_dim=embed_dim, patch_size=patch_size ) - self.temporal = TemporalAttentionAggregator(embed_dim=embed_dim, max_T=max_T) + self.temporal = TemporalAttentionAggregator( + embed_dim=embed_dim, max_days=max_days, max_months=max_months + ) self.spatial_pe = SpatialPositionalEncoding2D( embed_dim=embed_dim, max_H=max_H, max_W=max_W ) @@ -466,78 +541,78 @@ def __init__( patch_w=patch_size[2], hidden=hidden, overlap=overlap, + num_months=max_months, ) self.patch_size = patch_size - def forward(self, daily_data, daily_mask, land_mask_patch): + def forward(self, daily_data, daily_mask, land_mask_patch, padded_days_mask=None): """Forward pass of the Spatio-Temporal model. Args: - daily_data: Tensor of shape (B, C, T, H, W) containing daily data + daily_data: Tensor of shape (B, C, M, T, H, W) containing daily + data, where C is the number of channels (e.g., 1 for SST) daily_mask: Boolean tensor of same shape as daily_data indicating missing values land_mask_patch: Boolean tensor of shape (H, W) to mask land areas in the output - + padded_days_mask: Optional boolean tensor of shape (B, M, T) indicating which day tokens are padded + (True for padded tokens). Used to mask out padded tokens in temporal attention. Returns: - monthly_pred: Tensor of shape (B, H, W) representing the reconstructed monthly map + monthly_pred: Tensor of shape (B, M, H, W) representing the reconstructed monthly map """ - B, C, T, H, W = daily_data.shape + B, C, M, T, H, W = daily_data.shape - # Step 1: Encode spatio-temporal patches - latent = self.encoder(daily_data, daily_mask) # (B, T'*H'*W', C) Tp = T // self.patch_size[0] Hp = H // self.patch_size[1] Wp = W // self.patch_size[2] + Np = Tp * Hp * Wp + + # check shape and patch compatibility + assert daily_mask.shape == daily_data.shape, ( + "daily_mask must have the same shape as daily_data" + ) + assert H % self.patch_size[1] == 0 and W % self.patch_size[2] == 0, ( + "H and W must be divisible by patch size" + ) + assert T % self.patch_size[0] == 0, "T must be divisible by patch size" + + # Step 1: Encode spatio-temporal patches + # each month independently by folding M into batch + daily_data_reshaped = daily_data.reshape(B * M, C, T, H, W) + daily_mask_reshaped = daily_mask.reshape(B * M, C, T, H, W) + latent = self.encoder( + daily_data_reshaped, daily_mask_reshaped + ) # (B*M, N_patches, embed_dim) # Step 2: Aggregate temporal information for each spatial patch - agg_latent = self.temporal(latent, Tp, Hp, Wp) + # latent -> (B, M*Np, embed_dim) to match the aggregator input x: (B, M*Tp*Hp*Wp, embed_dim) + latent = latent.reshape(B, M * Np, -1) + + if padded_days_mask is not None and self.patch_size[0] > 1: + B, M, T_days = padded_days_mask.shape + if T_days % self.patch_size[0] != 0: + raise ValueError( + f"T_days={T_days} must be divisible by patch_size[0]={self.patch_size[0]}" + ) + padded_days_mask = padded_days_mask.view( + B, M, T_days // self.patch_size[0], self.patch_size[0] + ).all(dim=-1) # (B, M, Tp) + + agg_latent = self.temporal( + latent, M, Tp, Hp, Wp, padded_days_mask=padded_days_mask + ) # (B, M*Hp*Wp, embed_dim) # Step 3: Add spatial positional encodings and mix spatial features + E = agg_latent.shape[-1] + agg_latent = agg_latent.view(B, M, Hp * Wp, E) pe = ( self.spatial_pe(Hp, Wp).to(agg_latent.device).to(agg_latent.dtype) - ) # (Hp*Wp, C) - x = agg_latent + pe.unsqueeze(0) + ) # (Hp*Wp, E) + x = agg_latent + pe[None, None, :, :] # Step 4: Spatial mixing with Transformer - x = self.spatial_tr(x) # (B, Hp*Wp, C) + x = x.view(B * M, Hp * Wp, E) + x = self.spatial_tr(x) # (B*M, Hp*Wp, E) + x = x.view(B, M * Hp * Wp, E) # back to (B, M*Hp*Wp, E) # Step 5: Decode to full-resolution 2D map - monthly_pred = self.decoder(x, H, W, land_mask_patch) + monthly_pred = self.decoder(x, M, H, W, land_mask_patch) # (B, M, H, W) return monthly_pred - - -def make_daily_mask(daily_ts, land_mask): - """mask True only for missing ocean pixels - - daily_ts: (T,H,W) float tensor - land_mask: (H,W) or (1,H,W) bool, True=land - """ - isnan = torch.isnan(daily_ts) - - # normalize land_mask to (H,W) and broadcast to (T,H,W) - land2d = land_mask.squeeze(0) if land_mask.dim() == 3 else land_mask - land2d = land2d.bool() - land3d = land2d.unsqueeze(0).expand(daily_ts.size(0), -1, -1) - - mask = isnan & (~land3d) # True only at ocean-missing - return mask - - -def pred_to_numpy(pred, orig_H=None, orig_W=None, land_mask=None): - """ - pred: (B,H_pad,W_pad) or (B, H, W) torch tensor - orig_H/W: original sizes before padding (optional) - land_mask: (H_pad,W_pad) or (H,W) bool; if given, land will be set to NaN - returns: (H,W) numpy array - """ - # crop to original size if provided - if orig_H is not None and orig_W is not None: - pred = pred[..., :orig_H, :orig_W] - if land_mask is not None: - land_mask = land_mask[..., :orig_H, :orig_W] - - # set land to NaN (broadcast mask across batch) - if land_mask is not None: - pred = pred.clone().to(torch.float32) - pred[:, land_mask.bool()] = float("nan") - - return pred.detach().cpu().numpy() diff --git a/climanet/utils.py b/climanet/utils.py index a957d4f..558b0bb 100644 --- a/climanet/utils.py +++ b/climanet/utils.py @@ -1,5 +1,8 @@ +from typing import Tuple + import numpy as np import xarray as xr +import torch def regrid_to_boundary_centered_grid( da: xr.DataArray, @@ -71,4 +74,77 @@ def regrid_to_boundary_centered_grid( ) print(f"Regridding complete. New dimensions: {da_regridded.dims}") - return da_regridded \ No newline at end of file + return da_regridded + + +def add_month_day_dims( + daily_ts: xr.DataArray, # (time, H, W) daily + monthly_ts: xr.DataArray, # (time, H, W) monthly + time_dim: str = "time", + spatial_dims: Tuple[str, str] = ("lat", "lon") +): + """ Reshape daily and monthly data to have explicit month (M) and day (T) dimensions. + + Here we assume maximum 31 days in a month, and invalid day entries will be + padded with NaN. + + Returns + ------- + daily_m : xr.DataArray - dims: (M, T, H, W) + monthly_m : xr.DataArray - dims: (M, H, W) + padded_days_mask : xr.DataArray - dims: (M, T=31), bool, True where day is padded + """ + # Month key as integer YYYYMM + dkey = daily_ts[time_dim].dt.year * 100 + daily_ts[time_dim].dt.month + mkey = monthly_ts[time_dim].dt.year * 100 + monthly_ts[time_dim].dt.month + + # Unique month keys preserving order + _, idx = np.unique(dkey.values, return_index=True) + month_keys = dkey.values[np.sort(idx)] + + # Add M (month key) and T (day of month) coordinates to daily data + daily_indexed = ( + daily_ts + .assign_coords(M=(time_dim, dkey.values), T=(time_dim, daily_ts[time_dim].dt.day.values)) + .set_index({time_dim: ("M", "T")}) + .unstack(time_dim) + .reindex(T=np.arange(1, 32), M=month_keys) + ) + # Force dim order: (M, T, H, W) (and keep any other non-time dims after M,T) + other_dims = [d for d in daily_ts.dims if d != time_dim] # e.g. ["H", "W"] + daily_indexed = daily_indexed.transpose("M", "T", *other_dims) + + # Build padded days mask from daily_indexed (NaN locations) + padded_days_mask = ~daily_indexed.notnull().any(dim=spatial_dims) + + # Align monthly data to same month keys/order + monthly_m = ( + monthly_ts + .assign_coords(M=(time_dim, mkey.values)) + .swap_dims({time_dim: "M"}) + .drop_vars(time_dim) + .sel(M=month_keys) + ) + + return daily_indexed, monthly_m, padded_days_mask + + +def pred_to_numpy(pred, orig_H=None, orig_W=None, land_mask=None): + """ + pred: (B, M, H_pad,W_pad) or (B, H, W) torch tensor + orig_H/W: original sizes before padding (optional) + land_mask: (H_pad,W_pad) or (H,W) bool; if given, land will be set to NaN + returns: (H,W) numpy array + """ + # crop to original size if provided + if orig_H is not None and orig_W is not None: + pred = pred[..., :orig_H, :orig_W] + if land_mask is not None: + land_mask = land_mask[..., :orig_H, :orig_W] + + # set land to NaN (broadcast mask across batch) + if land_mask is not None: + pred = pred.clone().to(torch.float32) + pred[:, :, land_mask.bool()] = float("nan") + + return pred.detach().cpu().numpy() diff --git a/docs/code_math_description.md b/docs/code_math_description.md index 9e67433..c4eeb7b 100644 --- a/docs/code_math_description.md +++ b/docs/code_math_description.md @@ -111,9 +111,8 @@ This is a temporal attention pooling over sequences of tokens. For each spatial patch (h, w): - Collect its T temporal tokens: each spatial patch (h, w) has T temporal tokens -- Add temporal positional encoding -- Compute a learned scalar score per time step: the model learns which time - steps are important for this patch +- Add temporal positional encoding for days within a month and for months within a year. +- Compute a learned scalar score per time step - Apply softmax over time: it ensures the weights form a probability distribution over time. - Compute a weighted temporal sum: output is a temporal summary vector for each @@ -121,14 +120,14 @@ For each spatial patch (h, w): **Detailed process:** -We start with: `x ∈ ℝ^{B × (T·H·W) × C}`, where `B` = batch size, `T` = number -of temporal tokens per spatial patch, `H`, `W` = number of spatial patches along -height and width, `C` = embedding dimension. We can reshape it to group by -spatial patch where each spatial patch has its temporal sequence of length `T`. +We start with: `x ∈ ℝ^{B × (M.T·H·W) × C}`, where `B` = batch size, `M`= number +of months, `T` = number of temporal tokens per spatial patch, `H`, `W` = number +of spatial patches along height and width, `C` = embedding dimension. We can +reshape it to group by spatial patch where each spatial patch has its temporal +sequence of length `T`. Then we add temporal positional encoding `pe` from `TemporalPositionalEncoding`. -Add it to each temporal token `seq = seq + pe`. This injects time information -into each patch’s token sequence. +Add it to each temporal token `seq = seq + pe`. This injects time information (for days and for months) into each patch’s token sequence. Then we compute temporal attention weights by applying `nn.Sequential` to get a scalar score, see @@ -145,11 +144,17 @@ Here the explanation over each module in the sequential is as follows: see [torch.nn](https://docs.pytorch.org/docs/stable/nn.html) for more details on each module. -Then, we convert scores into attention weights using softmax over time that -represents importance of each temporal token for this patch. +We apply the mask `padded_days_mask` where padded days (beyond the actual number +of days in a month) are masked out. This ensures that the model does not attend +to padded tokens that do not correspond to real data.Then, we convert scores +into attention weights using softmax over time that represents importance of +each temporal token for this patch. Then we aggregate temporal tokens by +weighted sum over the temporal dimension. Result is one token per spatial patch. -Then we aggregate temporal tokens by weighted sum over the temporal dimension. -Result is one token per spatial patch. +Then we apply cross month mixing using `nn.MultiheadAttention`. This allows +tokens from different months to attend to each other, which can capture seasonal patterns. The attention is computed across the temporal dimension for each spatial patch. See [torch.nn.MultiheadAttention](https://docs.pytorch.org/docs/stable/generated/torch.nn.MultiheadAttention.html#multiheadattention) for details on how multi-head attention works. + +Then we apply `nn.Sequential` again to the output of attention to get a final scalar score for each time step. The explanation for each module is the same as before: LayerNorm, Linear, GELU, Linear to 1 scalar. This gives us a score for each time step in the temporal sequence of each spatial patch. ## 4. Spatial Positional Encoding (class `SpatialPositionalEncoding2D`) @@ -205,6 +210,7 @@ a container that repeats the same transformer block `depth` times. - Reshape latent tokens - Apply 1x1 convolution to mix features - Use transposed convolution to upsample to original spatial size +- Applies a convolutional refinement block to smooth patch boundaries. - Apply convolutional head for final output - Optionally mask out land regions - Add scale and bias to output @@ -223,21 +229,27 @@ original pixel grid. It converts the low-resolution patch grid back to the original image resolution. The padding is set to the overlap, which allows for smooth upsampling and some overlap between patches. -Finally, using `nn.Sequential`, we convert the upsampled features into a single-channel output. This processing block contains: +Then we apply a convolutional refinement block to smooth out any artifacts from +the deconvolution. Deconvolution can sometimes produce blocky outputs, so this +refinement helps to smooth patch boundaries and improve spatial coherence. This +block consists of a `nn.Sequential`. This processing block contains: -- `Conv2d`: 3×3 Convolution with padding=1 to refines spatial details after upsampling. +- `Conv2d`: Convolution to mix features and reduce artifacts. - `BatchNorm2d`: Normalizes the features to stabilize training. - `GELU`: Non-linear activation to allow complex feature interactions. -- `Conv2d(1×1)`: Final 1×1 convolution to reduce channels to 1, producing the final output map. +- `Conv2d(1×1)`: Final 1×1 convolution for deeper feature refinement. +- `BatchNorm2d`: Re-normalizes the features to stabilize training. +- `GELU`: Another non-linear activation to allow complex feature interactions. -A single `Conv2d(64, 1, kernel_size=1)` could work, but the extra layers provide: +A single `Conv2d(..., 1, kernel_size=1)` could work, but the extra layers provide: - Spatial refinement after deconvolution (which can produce artifacts) - Non-linearity for more expressive power - Better gradient flow during training -Then we apply scale, bias, and (optional) land mask to get the final output (he -reconstructed 2D map (e.g., SST) for each batch). +Finally, we apply a small convolutional head to produce the final single-channel +output. Then we apply scale, bias, and (optional) land mask to get the final +output (he reconstructed 2D map (e.g., SST) for each batch). ## References diff --git a/notebooks/example.ipynb b/notebooks/example.ipynb index bfdbb2c..83494a1 100644 --- a/notebooks/example.ipynb +++ b/notebooks/example.ipynb @@ -2,26 +2,18 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "11ad68b2-7502-4dc4-8b78-d0a4fb53255d", "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "import xarray as xr\n", - "\n", - "import sys\n", - "\n", - "sys.path.append(str(Path(\"../src\").resolve()))\n", - "\n", "import torch\n", "import torch.nn.functional\n", "from torch.utils.data import DataLoader\n", - "from climanet.st_encoder_decoder import (\n", - " SpatioTemporalModel,\n", - " pred_to_numpy,\n", - ")\n", - "\n", + "from climanet.st_encoder_decoder import SpatioTemporalModel\n", + "from climanet.utils import pred_to_numpy, add_month_day_dims\n", "from climanet import STDataset" ] }, @@ -42,16 +34,15 @@ "source": [ "data_folder = Path(\"../../data/output/\")\n", "\n", - "file_name = data_folder / \"202001_day_ERA5_masked_ts.nc\"\n", - "daily_data = xr.open_dataset(file_name)\n", + "file_names = [data_folder / \"202001_day_ERA5_masked_ts.nc\", data_folder / \"202002_day_ERA5_masked_ts.nc\"]\n", + "daily_data = xr.open_mfdataset(file_names)\n", "\n", - "file_name = data_folder / \"202001_mon_ERA5_full_ts.nc\"\n", - "monthly_data = xr.open_dataset(file_name)\n", + "file_names = [data_folder / \"202001_mon_ERA5_full_ts.nc\", data_folder / \"202002_mon_ERA5_full_ts.nc\"]\n", + "monthly_data = xr.open_mfdataset(file_names)\n", "\n", - "# downloded from era5 and regridded using the function `regrid_to_boundary_centered_grid`\n", - "# land 1, ocean 0\n", - "file_name = data_folder / \"era5_lsm_bool.nc\"\n", - "lsm_mask = xr.open_dataset(file_name)" + "file_name = data_folder / \"era5_lsm_bool.nc\" # downloded from era5 and regridded using the function `regrid_to_boundary_centered_grid`\n", + "lsm_mask = xr.open_dataset(file_name)\n", + "lsm_mask = lsm_mask.rename({'latitude': 'lat', 'longitude': 'lon'})" ] }, { @@ -65,1298 +56,62 @@ { "cell_type": "code", "execution_count": 3, - "id": "a9e054ab-995f-4483-a47b-84df84e6961e", + "id": "82bc2879-b788-492e-a0c0-53a35896a9d8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(60, 160, 400) (2, 160, 400)\n" + ] + } + ], "source": [ "# coordinates of subset\n", - "lon_subset = slice(-50, -30)\n", - "lat_subset = slice(-40, -20)\n", + "lon_subset = slice(-50, 50)\n", + "lat_subset = slice(-20, 20)\n", "\n", "daily_subset = daily_data.sel(lon=lon_subset, lat=lat_subset)\n", "monthly_subset = monthly_data.sel(lon=lon_subset, lat=lat_subset)\n", - "lsm_subset = lsm_mask.sel(longitude=lon_subset, latitude=lat_subset)\n", - "# rename dimensions to match the expected names in the dataset\n", - "lsm_subset = lsm_subset.rename({\"longitude\": \"lon\", \"latitude\": \"lat\"})" + "lsm_subset = lsm_mask.sel(lon=lon_subset, lat=lat_subset) # True=Land\n", + "\n", + "print(daily_subset[\"ts\"].shape, monthly_subset[\"ts\"].shape)" ] }, { "cell_type": "code", "execution_count": 4, - "id": "ac735a7d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset> Size: 795kB\n",
-       "Dimensions:    (time: 31, bnds: 2, lat: 80, lon: 80)\n",
-       "Coordinates:\n",
-       "  * time       (time) datetime64[ns] 248B 2020-01-01T11:30:00 ... 2020-01-31T...\n",
-       "  * lat        (lat) float32 320B -39.88 -39.62 -39.38 ... -20.62 -20.38 -20.12\n",
-       "  * lon        (lon) float32 320B -49.88 -49.62 -49.38 ... -30.62 -30.38 -30.12\n",
-       "Dimensions without coordinates: bnds\n",
-       "Data variables:\n",
-       "    time_bnds  (time, bnds) datetime64[ns] 496B ...\n",
-       "    ts         (time, lat, lon) float32 794kB ...\n",
-       "Attributes:\n",
-       "    CDI:          Climate Data Interface version 2.2.4 (https://mpimet.mpg.de...\n",
-       "    Conventions:  CF-1.6\n",
-       "    history:      Fri Oct 31 09:28:31 2025: cdo daymean 202001_ERA5_masked_ts...\n",
-       "    frequency:    day\n",
-       "    CDO:          Climate Data Operators version 2.2.2 (https://mpimet.mpg.de...
" - ], - "text/plain": [ - " Size: 795kB\n", - "Dimensions: (time: 31, bnds: 2, lat: 80, lon: 80)\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 248B 2020-01-01T11:30:00 ... 2020-01-31T...\n", - " * lat (lat) float32 320B -39.88 -39.62 -39.38 ... -20.62 -20.38 -20.12\n", - " * lon (lon) float32 320B -49.88 -49.62 -49.38 ... -30.62 -30.38 -30.12\n", - "Dimensions without coordinates: bnds\n", - "Data variables:\n", - " time_bnds (time, bnds) datetime64[ns] 496B ...\n", - " ts (time, lat, lon) float32 794kB ...\n", - "Attributes:\n", - " CDI: Climate Data Interface version 2.2.4 (https://mpimet.mpg.de...\n", - " Conventions: CF-1.6\n", - " history: Fri Oct 31 09:28:31 2025: cdo daymean 202001_ERA5_masked_ts...\n", - " frequency: day\n", - " CDO: Climate Data Operators version 2.2.2 (https://mpimet.mpg.de..." - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "daily_subset" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "da7ffd93", + "id": "d70ba708-843c-42c2-9d44-3bd60bb3b13b", "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset> Size: 26kB\n",
-       "Dimensions:    (time: 1, bnds: 2, lat: 80, lon: 80)\n",
-       "Coordinates:\n",
-       "  * time       (time) datetime64[ns] 8B 2020-01-16T11:30:00\n",
-       "  * lat        (lat) float32 320B -39.88 -39.62 -39.38 ... -20.62 -20.38 -20.12\n",
-       "  * lon        (lon) float32 320B -49.88 -49.62 -49.38 ... -30.62 -30.38 -30.12\n",
-       "Dimensions without coordinates: bnds\n",
-       "Data variables:\n",
-       "    time_bnds  (time, bnds) datetime64[ns] 16B ...\n",
-       "    ts         (time, lat, lon) float32 26kB ...\n",
-       "Attributes:\n",
-       "    CDI:          Climate Data Interface version 2.2.4 (https://mpimet.mpg.de...\n",
-       "    Conventions:  CF-1.6\n",
-       "    history:      Fri Oct 31 09:31:04 2025: cdo timmean 202001_ERA5_full_ts.n...\n",
-       "    CDO:          Climate Data Operators version 2.2.2 (https://mpimet.mpg.de...
" - ], - "text/plain": [ - " Size: 26kB\n", - "Dimensions: (time: 1, bnds: 2, lat: 80, lon: 80)\n", - "Coordinates:\n", - " * time (time) datetime64[ns] 8B 2020-01-16T11:30:00\n", - " * lat (lat) float32 320B -39.88 -39.62 -39.38 ... -20.62 -20.38 -20.12\n", - " * lon (lon) float32 320B -49.88 -49.62 -49.38 ... -30.62 -30.38 -30.12\n", - "Dimensions without coordinates: bnds\n", - "Data variables:\n", - " time_bnds (time, bnds) datetime64[ns] 16B ...\n", - " ts (time, lat, lon) float32 26kB ...\n", - "Attributes:\n", - " CDI: Climate Data Interface version 2.2.4 (https://mpimet.mpg.de...\n", - " Conventions: CF-1.6\n", - " history: Fri Oct 31 09:31:04 2025: cdo timmean 202001_ERA5_full_ts.n...\n", - " CDO: Climate Data Operators version 2.2.2 (https://mpimet.mpg.de..." - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: [299.8475 300.13306], std: [1.9400501 2.0374947]\n" + ] } ], "source": [ - "monthly_subset" + "# create monthly mean to predict mean and std per month\n", + "daily_subset_averaged = daily_subset[\"ts\"].resample(time=\"MS\").mean(skipna=True)\n", + "mean = daily_subset_averaged.mean(dim=[\"lat\", \"lon\"], skipna=True).values\n", + "std = daily_subset_averaged.std(dim=[\"lat\", \"lon\"], skipna=True).values\n", + "print(f'mean: {mean}, std: {std}')" ] }, { "cell_type": "markdown", - "id": "68bfea61-8b90-42c6-b59a-2a11841b1ff2", + "id": "11a1c896-a876-40bc-8f0a-9e7373d734b1", "metadata": {}, "source": [ - "## Create the model" + "## Create dataset" ] }, { "cell_type": "code", "execution_count": 6, - "id": "7ab48e70-d84a-4907-8fa6-1a7cd6658c3e", - "metadata": {}, - "outputs": [], - "source": [ - "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", - "model = SpatioTemporalModel(embed_dim=128, patch_size=(1, 16, 16), overlap=2).to(device)\n", - "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n", - "decoder = model.decoder\n", - "\n", - "with torch.no_grad():\n", - " decoder.bias.fill_(monthly_subset[\"ts\"].values.mean())\n", - " decoder.scale.fill_(\n", - " monthly_subset[\"ts\"].values.std() + 1e-6\n", - " ) # small epsilon to avoid zero" - ] - }, - { - "cell_type": "code", - "execution_count": 7, "id": "31646135", "metadata": {}, "outputs": [], @@ -1365,8 +120,7 @@ " daily_da=daily_subset[\"ts\"],\n", " monthly_da=monthly_subset[\"ts\"],\n", " land_mask=lsm_subset[\"lsm\"],\n", - " patch_size=(16, 16),\n", - " overlap=2,\n", + " patch_size=(80, 80),\n", ")" ] }, @@ -1378,21 +132,48 @@ "## Train the model" ] }, + { + "cell_type": "code", + "execution_count": 7, + "id": "91459025-ab92-45d9-9e94-d091fe09698e", + "metadata": {}, + "outputs": [], + "source": [ + "# create the model\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "model = SpatioTemporalModel(embed_dim=128, patch_size=(1, 2, 2), overlap=2, max_months=2).to(device)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n", + "decoder = model.decoder\n", + "\n", + "with torch.no_grad():\n", + " decoder.bias.copy_(torch.from_numpy(mean))\n", + " decoder.scale.copy_(torch.from_numpy(std) + 1e-6) # small epsilon to avoid zero" + ] + }, { "cell_type": "code", "execution_count": 8, - "id": "d366da78-bb5d-4bcc-8ca9-59866a410dd8", + "id": "3bfbc09b-0b0b-431f-b185-f89a2adc3c72", "metadata": {}, "outputs": [], "source": [ + "# create dataloader\n", "dataloader = DataLoader(\n", " dataset,\n", - " batch_size=16,\n", + " batch_size=1,\n", " shuffle=True,\n", " pin_memory=False,\n", ")" ] }, + { + "cell_type": "markdown", + "id": "945ec311-53b3-4cac-a1e3-d16f4508e7a7", + "metadata": {}, + "source": [ + "### Start training loop" + ] + }, { "cell_type": "code", "execution_count": 9, @@ -1403,11 +184,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "The loss is 30.19863510131836 at epoch 0\n", - "The loss is 6.372329235076904 at epoch 20\n", - "No improvement for 10 epochs, stopping early at epoch 29.\n", + "The loss is 1.3227499723434448 at epoch 0\n", + "The loss is 0.25537195801734924 at epoch 20\n", + "No improvement for 10 epochs, stopping early at epoch 21.\n", "training done!\n", - "10.819591522216797\n" + "1.358122706413269\n" ] } ], @@ -1428,17 +209,21 @@ " daily_mask = batch[\"daily_mask_patch\"]\n", " monthly_target = batch[\"monthly_patch\"]\n", " land_mask = batch[\"land_mask_patch\"][0, ...] # same for all batches\n", + " padded_days_mask = batch[\"padded_days_mask\"]\n", "\n", " # Batch prediction\n", - " pred = model(daily_batch, daily_mask, land_mask)\n", - " # Compute loss\n", - " ocean = ~land_mask\n", - " ocean_broadcasted = ocean.unsqueeze(0) # [1,H,W]\n", + " pred = model(daily_batch, daily_mask, land_mask, padded_days_mask)\n", + " \n", + " # Mask out land pixels\n", + " ocean = (~land_mask).to(pred.device) # (H, W) bool\n", + " ocean = ocean[None, None, :, :] # (1, 1, H, W) broadcast over (B, M)\n", + " \n", + " loss = torch.nn.functional.l1_loss(pred, monthly_target, reduction=\"none\") * ocean\n", + " \n", + " # Normalize per month (avoid division by zero)\n", + " loss_per_month = loss.sum(dim=(-2, -1)) / ocean.sum(dim=(-2, -1))\n", + " loss = loss_per_month.mean()\n", "\n", - " loss = torch.nn.functional.l1_loss(\n", - " pred * ocean, monthly_target * ocean, reduction=\"sum\"\n", - " ) # For SST there is only one channel\n", - " loss = loss / ocean_broadcasted.sum()\n", " loss.backward()\n", " optimizer.step()\n", "\n", @@ -1478,7 +263,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "torch.Size([1, 1, 31, 80, 80]) torch.Size([1, 1, 31, 80, 80]) torch.Size([1, 80, 80]) torch.Size([80, 80])\n" + "torch.Size([1, 1, 2, 31, 160, 400]) torch.Size([1, 1, 2, 31, 160, 400]) torch.Size([1, 2, 160, 400]) torch.Size([160, 400]) torch.Size([1, 2, 31])\n" ] } ], @@ -1495,12 +280,12 @@ " pin_memory=False,\n", ")\n", "full_batch = next(iter(dataloader_pred))\n", - "\n", "daily_batch = full_batch[\"daily_patch\"]\n", "daily_mask = full_batch[\"daily_mask_patch\"]\n", "monthly_target = full_batch[\"monthly_patch\"]\n", "land_mask = full_batch[\"land_mask_patch\"][0, ...] # same for all batches\n", - "print(daily_batch.shape, daily_mask.shape, monthly_target.shape, land_mask.shape)" + "padded_days_mask = full_batch[\"padded_days_mask\"]\n", + "print(daily_batch.shape, daily_mask.shape, monthly_target.shape, land_mask.shape, padded_days_mask.shape)" ] }, { @@ -1508,13 +293,22 @@ "execution_count": 11, "id": "15d5fbee", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 160, 400)\n" + ] + } + ], "source": [ "model.eval()\n", "with torch.no_grad():\n", - " pred = model(daily_batch, daily_mask, land_mask)\n", + " pred = model(daily_batch, daily_mask, land_mask, padded_days_mask)\n", "\n", - "monthly_prediction = pred_to_numpy(pred, land_mask=land_mask)" + "monthly_prediction = pred_to_numpy(pred, land_mask=land_mask)[0]\n", + "print(monthly_prediction.shape)" ] }, { @@ -1539,7 +333,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 13, @@ -1548,7 +342,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1558,7 +352,7 @@ } ], "source": [ - "monthly_subset[\"ts_pred\"].plot()" + "monthly_subset[\"ts_pred\"].isel(time=0).plot()" ] }, { @@ -1570,7 +364,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 14, @@ -1579,7 +373,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1590,28 +384,40 @@ ], "source": [ "# original target\n", - "monthly_subset[\"ts\"].where(~lsm_subset[\"lsm\"].values).plot()" + "monthly_subset[\"ts\"].where(~lsm_subset[\"lsm\"].values).isel(time=0).plot()" ] }, { "cell_type": "code", "execution_count": 15, - "id": "ea56d33c-fd54-4353-bd88-06990ed9641c", + "id": "7d621ae6-52d8-476b-95b4-205bc05589e3", + "metadata": {}, + "outputs": [], + "source": [ + "# Error\n", + "target = monthly_subset[\"ts\"].where(~lsm_subset[\"lsm\"].values)\n", + "err = target - monthly_subset[\"ts_pred\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "6e18ddd5-81b2-4583-8a35-e9af7978bdf5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkUAAAHHCAYAAACx7iyPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA7VFJREFUeJzsnXd8HMX5/z8ze3eSbMuyDa640jGYZsDYJIBphlBCIAmhBNNJMNWUQALYVBMg1AQcILSEFggt+SV8YwihOhBTAgQwYAguWK5IsmVLutud3x+zMzszu3vSqVs879frXqOdnZ2d3VvdzT3zeZ6HCSEECIIgCIIgvuHwrh4AQRAEQRBEd4AmRQRBEARBEKBJEUEQBEEQBACaFBEEQRAEQQCgSRFBEARBEAQAmhQRBEEQBEEAoEkRQRAEQRAEAJoUEQRBEARBAKBJEUEQBEEQBACaFBGdwOjRo3HCCSd09TAIgiAIoig0KSLahddffx0zZ85ETU1NVw+lU/n3v/+NM888E9tuuy169+6NkSNH4oc//CE++eSTxPYfffQRDjzwQPTp0wcDBgzAj3/8Y6xYscJq8/HHH+Oiiy7CjjvuiMrKSgwdOhQHH3ww5s2bl9jnkiVL8MMf/hD9+vVD37598d3vfheff/55i68hCAJcf/31GDNmDMrLy7H99tvjkUceibV78803ccYZZ2D8+PHIZrNgjLX4HIprrrkGhx12GAYPHgzGGGbOnFm0/WOPPYaJEyeid+/e6NevHyZNmoR//OMfAIC9994bjLFmX+ocf//733HyySdju+22g+d5GD16dLuN0+Xaa6/F7rvvjoEDB6K8vBxbbLEFzj333Nh7DbT8/hfj2Wefxc4774zy8nKMHDkSM2bMQKFQiLWrqanBaaedhoEDB6J3796YPHky3n777ZLORRA9GkEQ7cANN9wgAIgvvvgitq+hoUE0NTV1/qA6gSOPPFIMGTJEnHXWWeLuu+8WV111lRg8eLDo3bu3eP/99622ixYtEhtvvLHYbLPNxK233iquueYa0b9/f7HDDjuIxsZG3e78888X/fr1EyeffLL47W9/K66//nqx2WabCc/zxJw5c6w+16xZI7bYYgsxaNAg8ctf/lLcdNNNYsSIEWL48OFi5cqVLbqGiy++WAAQp556qrjrrrvEwQcfLACIRx55xGo3Y8YMkc1mxfjx48WWW24pWvPxAUAMGTJETJkyRQAQM2bMSG07Y8YMwRgTP/jBD8Ts2bPF7bffLk4//XTx4IMPCiGE+Pvf/y5+//vf69fZZ58tAIif//znVv1//vMfIYQQU6dOFeXl5WLSpEli+PDhYtSoUe0yziSOOOIIcfrpp4ubb75Z3HPPPeL8888Xffv2FZtvvrlYu3at1bal9z+Nv/71r4IxJiZPnizuuusucdZZZwnOufjJT35itfN9X0yaNEn07t1bzJw5U/z6178WY8eOFZWVleKTTz4p6foIoqdCkyKiXSg2KerJvPbaa9aERgghPvnkE1FWViaOPfZYq/6nP/2pqKioEF9++aWumzNnjgAgfvvb3+q6efPmiTVr1ljHrly5UgwcOFDsscceVv0vf/lLAUC8+eabuu6jjz4SnueJSy65pNnxL168WGSzWTFt2jRdFwSB+Pa3vy2GDx8uCoWCrq+urhbr1q0TQggxbdq0Vk2K1POxYsWKopONuXPnCsaYuOmmm1rc9+OPPy4AiBdffDFx/5IlS/Tk/OCDDy46KWrpOEvhiSeeiE12Srn/aYwdO1bssMMOIp/P67pf/OIXgjEmPvroI1332GOPCQDi8ccf13XLly8X/fr1E0cffXRbL48gegS0fEa0mZkzZ+LCCy8EAIwZM0YvW/zvf/8DENcU3X///WCM4dVXX8XZZ5+NgQMHol+/fjj99NPR1NSEmpoaHH/88ejfvz/69++Piy66CEII65xBEOCWW27Btttui/LycgwePBinn346vv766866bADApEmTkMvlrLotttgC2267LT766COr/k9/+hMOOeQQjBw5Utftt99+2HLLLfHHP/5R140fPx59+vSxjt1oo43w7W9/O9bnE088gV133RW77rqrrtt6662x7777Wn2m8cwzzyCfz+OMM87QdYwx/PSnP8XixYsxd+5cXT948GBUVFQ022cxii1Zmdxyyy0YMmQIzjnnHAghsHbt2jadFwCGDRuGbDbborYtHee6devw8ccfY+XKlS3u01xiLuX+19bW4uOPP0Ztba2u+/DDD/Hhhx/itNNOQyaT0fVnnHEGhBB44okndN0TTzyBwYMH44gjjtB1AwcOxA9/+EM888wzaGxsbNE1E0RPhiZFRJs54ogjcPTRRwMAbr75Zvz+97/H73//ewwcOLDocWeddRY+/fRTXHHFFTjssMNw11134bLLLsOhhx4K3/dx7bXX4lvf+hZuuOEG/P73v7eOPf3003HhhRdijz32wK233ooTTzwRDz30EKZMmYJ8Pl/0vI2NjVi5cmWLXq1BCIFly5Zh44031nVLlizB8uXLscsuu8Ta77bbbnjnnXea7be6utrqMwgCvPfee6l9LliwAGvWrCna5zvvvIPevXtjm222iR2v9ncFL7zwAnbddVfcdtttGDhwoNZW/frXv+6S8aTx5ptvYptttkkclxACK1euRHV1NV555RWcffbZ8DwPe++9t25Tyv1/6qmnsM022+Cpp56yjgcQewaGDRuG4cOHW8e/88472HnnncG5/bG/2267Yd26dak6OIL4JpFpvglBFGf77bfHzjvvjEceeQSHH354i39lDx48GH/961/BGMMZZ5yBzz77DDfccANOP/103HnnnQCA0047DaNHj8a9996L448/HgDw6quv4p577sFDDz2EY445Rvc3efJkHHjggXj88cetepdHHnkEJ554YovG6FqoWsJDDz2EJUuW4Morr9R1S5cuBQAMHTo01n7o0KFYvXo1GhsbUVZWltjnK6+8grlz5+LSSy/VdeqYtD4B4KuvvsJWW22VOtalS5dqMXHa8Z3N119/jZUrV+K1117DP/7xD8yYMQMjR47Efffdh7POOgvZbBann356p4+rVJYtW2a9N8OHD8fDDz+MrbfeWte19f4391yZxy9duhR77rlnYjt1rnHjxjV3WQTRo6FJEdFlnHzyydaXwYQJEzB37lycfPLJus7zPOyyyy546623dN3jjz+Oqqoq7L///pY1Ry07vfjii0UnRVOmTMGcOXPa+WokH3/8MaZNm4aJEydi6tSpun79+vUAkDjpKS8v122S9i9fvhzHHHMMxowZg4suuqjkPouRds6WHt8RqKWyVatW4dFHH8VRRx0FAPj+97+PcePG4eqrr+42k6K99947deI8YMAAzJkzBw0NDXjnnXfw5JNPxpYBS7n/J5xwQiy0RXPPQF1dXavORRDfVGhSRHQZprYGAKqqqgAAI0aMiNWbWqFPP/0UtbW1GDRoUGK/y5cvL3reoUOHJv6ybivV1dU4+OCDUVVVhSeeeAKe5+l9SouTpNtoaGiw2pjU19fjkEMOwZo1a/Dqq69aWqNS+qyurrb2V1VVoaKiAhUVFSWPqTnSztVSVNtsNovvf//7up5zjqOOOgozZszAwoULY89PdyOXy2G//fYDABxyyCHYd999sccee2DQoEE45JBDAKDN97+5Z8A8viPea4LoadCkiOgyzElDc/Xmr/EgCDBo0CA89NBDicc3p2Vav369JVYtxpAhQ1rUrra2FgcddBBqamrwyiuvYNiwYdZ+NQlTyx0mS5cuxYABA2K/4puamnDEEUfgvffew//93/9hu+22s/arY9L6BKDH4U4C77vvPpxwwgkYOnQoXnzxRQghLKude3wppJ2rpQwYMADl5eXo169f7FlQE+Gvv/6620+KXCZNmoShQ4fioYce0pOitt5/87lyf0wsXbpUa5NU25Y8KwTxTYYmRUS70JpAfq1ls802w/PPP4899tijVb9uH3vssXbVFDU0NODQQw/FJ598gueffx5jx46Ntdlkk00wcODAxACMb775JnbccUerLggCHH/88XjhhRfwxz/+EXvttVfsOM45xo0bl9jnG2+8gU033RSVlZUAEFsu3HbbbQEAO+64I+655x589NFH1rjfeOMNvb9U0s7VUjjn2HHHHfHvf/8bTU1Nlnef0sg0N/HtrjQ0NFgT8rbef7V/3rx51gToq6++wuLFi3HaaadZbV955RUEQWCJrd944w306tULW265ZVsujSB6BOR9RrQLvXv3BoBOiWj9wx/+EL7v46qrrortKxQKzY5BaYpa8moO3/dx1FFHYe7cuXj88ccxceLE1LZHHnkk/vKXv2DRokW67oUXXsAnn3yCH/zgB1bbs846C4899hjuuOMOy4Xa5fvf/z7+/e9/WxOj+fPn4x//+IfV53777We9lIXhu9/9LrLZLO644w7dVgiB2bNnY5NNNsGkSZOavQcuaecqhaOOOgq+7+OBBx7QdQ0NDXjooYcwduzYbmPVSHLJr6+vx7p162Jt//SnP+Hrr7+2PMVKuf9JLvnbbrsttt56a9x1113wfV/X33nnnWCMWcuP3//+97Fs2TI8+eSTum7lypV4/PHHceihh6aK/AnimwRZioh2Yfz48QCAX/ziF/jRj36EbDaLQw89VE+W2pO99toLp59+OmbNmoV3330XBxxwALLZLD799FM8/vjjuPXWW60vA5f21BSdf/75ePbZZ3HooYdi9erV+MMf/mDtP+644/TfP//5z/H4449j8uTJOOecc7B27VrccMMNGDdunGW5uuWWW3DHHXdg4sSJ6NWrV6zP733ve/q+nnHGGbj77rtx8MEH44ILLkA2m8VNN92EwYMH4/zzz292/MOHD8e5556LG264Afl8HrvuuiuefvppvPLKK3jooYes5asvv/xSh0ZQk7Crr74aADBq1Cj8+Mc/bvZ8v//97/Hll1/qScPLL7+s+/jxj3+MUaNGAZAhF+655x5MmzYNn3zyCUaOHKmP/fOf/9zseZJ477338OyzzwIAPvvsM9TW1upz77DDDjj00ENLHuebb76JyZMnY8aMGToVyKeffor99tsPRx11FLbeemtwzjFv3jz84Q9/wOjRo3HOOefo85Ry/5966imceOKJseXIG264AYcddhgOOOAA/OhHP8IHH3yAX//61zjllFMsV//vf//72H333XHiiSfiww8/xMYbb4w77rgDvu/jiiuuaNU9JYgeR5eEjCR6JFdddZXYZJNNBOfcim49atQoMXXqVN3uvvvuEwDEv//9b+v4GTNmCABixYoVVv3UqVNF7969Y+e76667xPjx40VFRYWorKwU48aNExdddJH46quv2v3a0thrr70EgNSXywcffCAOOOAA0atXL9GvXz9x7LHHiurqaqvN1KlTi/bpRg1ftGiR+P73vy/69u0r+vTpIw455BDx6aeftvgafN8X1157rRg1apTI5XJi2223FX/4wx9i7V588cXUMe21115tvl9uJOply5aJqVOnigEDBoiysjIxYcIE8dxzz6X23VxEa/XcJb3M57OUcap7Yka8XrFihTjttNPE1ltvLXr37i1yuZzYYostxLnnnht7toVo+f1X47/vvvti+5566imx4447irKyMjF8+HBx6aWXJqbWWb16tTj55JPFRhttJHr16iX22muv2P8hQXyTYUK0IhALQRAEQRBED4M0RQRBEARBEKBJEUEQBEEQBACaFBEEQRAEQQDYgCZFs2bNwq677orKykoMGjQIhx9+OObPn2+1aWhowLRp07DRRhuhT58+OPLII7Fs2bIuGjFBEARBEBsSG8yk6KWXXsK0adPwr3/9C3PmzEE+n8cBBxyA+vp63ea8887Dn//8Zzz++ON46aWX8NVXXxWN8UIQBEEQBKHYYL3PVqxYgUGDBuGll17CnnvuidraWgwcOBAPP/ywjlHz8ccfY5tttsHcuXOx++67d/GICYIgCILozmywwRtVVNcBAwYAAN566y3k83mdgBEAtt56a4wcObLopKixsdFKkhgEAVavXo2NNtqoU1NXEARBEBsWQgisWbMGw4YNs1KntDcNDQ1oampql75yuRzKy8vbpa+eyAY5KQqCAOeeey722GMPnSSzuroauVwO/fr1s9oOHjw4lrXbZNasWRTNlSAIgmg1ixYtwvDhwzuk74aGBmxU0Qfr4DffuAUMGTIEX3zxBU2MUtggJ0XTpk3DBx98gFdffbXNfV1yySWYPn263q6trcXIkSNx3z/eRt++fWMJQX0BeCwq84EAZwx5P4DHGfxAtg/C41Q7IGqr9gW6rdofWPXqXyAQ9nG+EAgCoc8VlYDH7dLcr68hiM7vC4GmgmzYWLCvIR92ED+P2u9b240FWTYVAj0+EY5VCAE/PE/g29evEIEA48wq1Q0KhEAhH0AIAREA3GNQP8yaGgMEhQC+L/f7eR9+oYBCQz1E4OuXi1/Iy3356BeYED78pkbk19fDz6+HCHz03ng4Fj7989jxBEG0jY+X1QEA1MesxwHGAM6YjB8efnZutnEllqxei00G9OmagaZQV1eHESNG6MTLHUFTUxPWwcfx2AS5NsqAmxDgweolaGpqoklRChvcpOjMM8/EX/7yF7z88svWzHzIkCFoampCTU2NZS1atmwZhgwZktpfWVlZYiLE8t59kOuV/g+oJipZIb/8vfC/mot4O4UXRBMlc5+a5GScevXm+EYffiCAQMADwMP+VJkN25ilHwi97Rvt/HDSwgI5WfEDAeYFCGBMVjxhT6jCSZsXHs8DgUIQTdC4F54vKydGGciJjpoUeervAHqyhLCNQv0dCAEWpX0CKwTgLIBfEAAT4TjDY3gAHz4CBAiEQIAmCOGDeTmA+frFuOxQlV4ZEBSa4Geb9KRJ+D5YphwsU4ZC03r4jetR84/rQBBE+1PVABTC3ysBBDzG4HGAh7MhpWD4Os/Qv38V+vZt/1yK7UFnSC1y4MixNi7RbZAK4s5lg/E+E0LgzDPPxFNPPYV//OMfGDNmjLV//PjxyGazeOGFF3Td/PnzsXDhwqKZywmCIAiiu+Mx1i4vojgbjKVo2rRpePjhh/HMM8+gsrJS64SqqqpQUVGBqqoqnHzyyZg+fToGDBiAvn374qyzzsLEiRPJ84wgCILYoOEskmK0ug+ArEXNsMFMiu68804AwN57723V33fffTjhhBMAADfffDM45zjyyCPR2NiIKVOm4I477mjV+bKcoTwjDWmcRbqfSDOEUOcj2+aNpSxbWxSujwPIM91JeBZZ7wuBbCgC4pzpZSEA4Xa07JblkfYoSeujzu2WJn4gkMtwrSXKcDkOLwjHY/zXmP0A3NgGmgo+PM4sLZIqcxkuz8sZCoUAAEPA5BJb4Mttv6C0U3IcppZIaahUyTgDCxi8DOAXZFvfD+T+QqTFMvVDjHtg3ENQaNJLZqqeZ3Ly+nIV4E3rERSaEAS+XHoLfPBMFlnOIfz2ETcSBBGnd4ajiQv4gdJfMjDjy199dnpMfqGvXrMOAyp7dd2AiR7PBjMpakk4pfLycvzmN7/Bb37zm04YEUEQBEF0Du2x/OWBls+aY4PRFHUFpoWFs9B8yRk8zvQvmGi/rPOU1cVop+uMQ3whxcTa6mNM+jhn+mVuq+PVP4Z5Lrc0x67qzWtSViJ3f1OCx5ltLYqfL5PQv3kcM65DiGjby4Slx+X1Zbi0CKn2hrVItudgjOnjOGPww/EKIWT/CV5mpsBaWYmY58ErqwDP5pCp6AMvVwEvkwPP5GR9+HemrAK9Jp4d65MgiLZTkeUo8zgyHMh5UmTtWolIBiPxWPu8iOLQpIggCIIgCAIb0PJZV5D1pLnStAppnUvoe6+0RK7bu27Po/b50I0d4OBCIAgALgxriPkrKdQSWZoiHlqX/ABZMK0xCoQAvMja5GqJTA2Rx5kuzXYZzuBzhhw4fBHXBmmNUIjcLwfbVPDhhW75jaF7f+y4UFuUyXrS7d4DfD9AJqfiEYXX6zErjlFG3YcMR1AIwHioIcoBfkFanXxf1vuFAJlcGfxCAYL7CPJNYJ7h1x+iLEaMe8jkslLDlMkhKDTByzdJfVGmCX5B6osKjetb/xARBJHKRoY+qLq2Hn5gSyWUq7thjEZt/XpU9a7otDF2F2j5rHOgSRFBEARBdHPaY/kr/hORcKHlM4IgCIIgCJClqChytSju9WZGojZxU3yY7X0h95spPvxmHOo4T/9ZoITa5jhUlGpzLGa9uV8JrVVdIYj6Mo81l9ySrtU3wgMUnP7dJTxmXE8QCDAWCa+FsVSoltA8j0u3e3MJLe/Lfnx5f/zQfd9HKLQWLHLD9+wI1rGI1kq4nZUCb9/ZDwCFsOz9rfNQ/+rNqe8HQRCtZ3ltPXKcoVEIBGB6CU0I+TkRGOmVeAs8kXsitHzWOdCkiCAIgiC6OTJSXNv7IIpDk6IUGGPIapf6KMmqSRZMx2EMhECWs9BqwxA4P2aUwBqQiVaz3NMibTNIYdZxRwcAX4kNlTibeaH1SeYP40K5/Av4XKQGbQSgrT5KAG0KrxsLgRRas8hqVMzNXx7vhYJqAIUACAXdZv+qvUL1o4M6BgIsXCznnnKvD/PBcQ4RAJ4nfz1msp4O1ljI+/AyHH4hgAeOgIdBHhkD573gFwrwMhkwzuC5bx6g6wMhrVCM+fAyvVFoyoN5HvzG9cj2rkKhoR6Z8u6Zc4kgegKDquz/r6U19WHgW2mx9zgQAMiG299EsTVZijoH0hQRBEEQBEGALEVFUVqdwA8DBQbJ7bTVxkkFovbJvmytUSBEtEbOIutQpDOKNEeuDiltW+mB0rRFatt0x3c1Q/o4YR9fLGWIwuMMBafftNQjTaF7vaUlCkvGGASMbQ6IQLnnhtYgIa08hcDohzEEHMjkPAQFhkxWaoNUyTPcSiWig0QisjrJMhOm+siBcw9erlynBSEIomNZWlNvfA7JuoIPrUH02DczfRd5n3UONCkiCIIgiG6OnBS1dfmMaA6aFKVgJ4RVmh2pGVIlEFp8wMDDQIb5IJDeU+FPGbWGy4PIkuSmCHG91ZQ1hRtJZQGpLVK6orAnezvU3jShuJXGLCtyntYAoRAgk/NkgleE7TyWqC2Kl55lBSrLcBTC4Ivas805b5o1CwAKBWUlEjK4I4fWGAW+tPIUwvepkPfBuWcHeyyTjzbjCDVG8Q+TIBAQQoSaJQ4fMrikCgKZD3yZ/iNXgWxFn7RHhSCIdmRov96orq2HEPKzzxcCHNB6TcbkF9eadetR2eubpSsiOh6aFBEEQRBEN4eWzzoHmhQRBEEQRDeHvM86B5oUFcF1w5diamEtd5ku+Ulia9Pd3g3WmLRspupV/i9TbG0GfDRd8pXY2gy8aIqtATtYoxtUUaHc8i1BtB/E2rn9mCXAkcvY+9USmiu0dvtx3fj9QMAvBGChO75nCLMLebnUVcj7esmLK7d9j8v2Hrfc7gFogXVQCMJ+outSQm0vwxH4ARj3IAJf3u+wJAii89AOH0pwHS6hFSA/D9atb0CvivKuGyDR46BJEUEQBEF0c3g7LJ9RDJ7moUlRClnOY0JrIG7d4SwSQ/MgCriodL2BYGEAskg4HfXlnpPFXPd5mBrEY8wQWstfS7KB6igUQnvSuuMGSzStMHHrTkSvUHitrDsVXG5rwbVrvg3/y8x+mgqRpUeWATwnTIBrFcplODzOkDH6+fNpE7Hfr1+Fi18IkAHgFyLrj2kNMlFBGz1IK1MQjpdxBj+0VgWGe74HBsEERNaDX/B0yhCvjASdBNFZ5HgUnsQPBMBk8EaOcHIQ/r8GQqBh/Xrw+lXIbTy8y8bbGdDyWedAE0eCIAiCIAjQpCgVj8Nyu88HQfLLF/qldT2htijQSWCjZLCyL/nyBWIvE3WML4B8IFDww/MF4XjCbbk/gC8EmvwAfiDQVEguXS1RcuqOeEqOaG0/ObgjEMXQyIUWNtmfExSyyPkznOkAkH8+bSIA4PkzvwURSLd8bVXKeeAeRybH4XkcXoaDZzgyWU9ue1ymZ1FWonA8ZkJaYZyXc+myn8lFfTEuE8v6TevhNzVg+VPTU58VgiDalwGVvXSKjwDy80+Efwfq8zAQ6NOrAuUVFWjqtVFXD7nDUd5nbX0RxaHlM4IgCILo5pBLfudAkyKCIAiC6OaQpqhzoElRCpxJsTUgl9JUxGozz5jHmCW0BmQ7jwP5cC0synovxdayTXqEaUl4Lh4ujfkym3yeCXAhkA9zsQVMIAu53/M48mEE6qSI1orm8pFZAuhQcG1FuDYEyX4gkPO4XkoDgJxasmJS8F2Ry4T9yqUyFenaHI/HGcpCoXUu48EP8tZ78cLZ38a+t70i+w+XwirKM2hs8vHPn+2Fb9/wonTHDwB4gDDGw8IPkUzWg+8HyHBPC7PVEprprg8gFGBnUMhLN3wvRy6/BNHZ5DwmZQZhNIxACGSNSYH5udaHIlsT7QRNigiCIAiim+OhHZbPvomZdEuEJkUpBGY2et8WXUdtkp8wPzD+FpElyfxlU0xwrPpW7vnW34Z1wze2fQEdJNJ2j08Ovgg0bzUCYOUts8rQUpbm/g8AOUgrUi7D0VQAgEAHcwSgyyivGkdTwUdFLoMj730DfiDw9Cm7A5DWIgD4zuzXw/4CZFTIBK7ypAEiiKxDgLQaKStSJsvl/iys40QAFPI+fAQ6qKOXiYTaFf2HxO4dQRAdS2WvClQC+HLVWozZuBKfLl8DAQGPyc+7ti4lbWjwdlg+c/NuEnHI+4wgCIIgCAJkKUqFs2hWnaQpSj8u0gUFQljHmXESi834VTZo6eYPAFxrh6IAjgAXTGaPF1JbpI4LwlQYeV9qfsxUHW62e1UPSKuSshLp0nDjt7Ldh5qiiqztz6D6N7VDkRWKI5cxwwIE8Di3jlPz9MryLJoKvrYYKSpyni5V/Uvn743Jt7yMwA/k/TDaMxXUMhMFu2ScgTEGLyN1RYW8D99ngC/3iUCAMSZThOQqsOSR01LfK4IgOpZRG/UBAGwxqBKfrVgDQIAJQDBpRWIMGDmgT9cOshNoF+8zMhQ1C02KCIIgCKKb0y7eZ7R81iy0fEYQBEEQBAGyFKWSJrROb+9mkbfr8zGhc3p/qqmKfm1GtlZiazdHmhI++0IunQHSVBoIWMJpIHnpLE1w3Vy2+6Q8ZhljCa0xXIrzApYQLsCzxmMLvX2dC02dN+Ms/Zl50gCAexyFvK8F1GYJ2EtjPAwF4IfHAdLvV6g8aGHJOIU7I4jughnOgzEZ5fqbYv2g5bPOgSZFBEEQBNHNoeWzzoEmRUVIElorpHCaaWuNetiURUkZGKQrPpB1FirNvk0XftW3H/af5VHbvB/I/gyxtTxnFCQyiyi7dMAEOJd52bystCKpgJTZUKDtc5Fq9VGCa5UzzbUamcTd65kO1ugHApmcZ1mZ4NnWN3WcElJHViMOPwiQ0+14KNCW+4958N9Y1+SjojyjrWHCCEuQ8ewb72WjPGiqjQhznwEAN9z8AaDPxhuDIIjuwdaD+wIAPl5WZ3xuCny2Yg02H1jZZeMieg40KSIIgiCIbg5nrM1xhihOUfPQpKgI+SCQFiDDSmSm+fDDwIomrtXHPUbpfvQ+KzCk6sPWIWltU4KuSJ/XkSi5wR0Bac1yLVymFcg8d5rmyLQemaVJMU2S7scPrHthpgzxmAw1oMIJ+IHbX5R+panga2tULsPRGNhhCQBpFXLHZY4VGQ7uyWCNfvgGyqCOAmUV2fgbShBEl6I+G4UAth9W1cWj6RyYx/RnWav7oElRs9CkiCAIgiC6OdyLlvlb3QdNipqFXPIJgiAIgiCwgU2KXn75ZRx66KEYNmwYGGN4+umnrf0nnHCCjERsvA488MBWny/LObIes15lmbCOc+slRdFyX3mGx44py3D0ynooy/DY/izn8BgLo2hHmeOz7svj+m/VZ1nCuTyGsB1H1jO35Uttc8aQ81R2ejuytBpDLsxeX5HzUstchluvtP4A6abvcaYjYSuPCmvpDHLpLJfh6FOWsfq6/5idcf8xOwMA7j9mZ1TkMqjIZVBZnkFFzkNZzkMmw5ELy7JwfBVOGXuVZeBl5Pso1JJhIcB/rvtOq58fgiA6hlzoW84Y8P7SWnxYXdfFI+oEPA7Wxhe80r7yR48eHftOZYxh2rRpie3vv//+WNvy8vL2uPpOY4NaPquvr8cOO+yAk046CUcccURimwMPPBD33Xef3i4rK+us4REEQRBEh8A4A2tjoCGV9qil/Pvf/4bv+3r7gw8+wP77748f/OAHqcf07dsX8+fPj865gS3ZbVCTooMOOggHHXRQ0TZlZWUYMqTtWc3dpVsrUGJgCJlN0bQQsbZRf3aHZnBH2U8kao6E2enjM4M3KjE15wwFledMibZT+lLHSiFzJLRuKgQx4XVasEbTfd8VMCv3eFewXTDOo8bnsVB4zRnW52XQRk8wVGYyKAQCTYUA9x+zM07747u6f2UtUhat6L7awnHVBoAer5uXLZfh8HMefD9AocmHCATyjT4+/c330t8AgiC6hOW19eBgAOT/OWcMY4f2xfzlddhqUN+uHl6PYuDAgdb2ddddh8022wx77bVX6jGMsXb5Du4qNqjls5bwz3/+E4MGDcJWW22Fn/70p1i1alXR9o2Njairq7NeBEEQBNGd4B5rlxeA2HdeY2Njs+dvamrCH/7wB5x00klFrT9r167FqFGjMGLECHz3u9/Ff//733a7B53BBmUpao4DDzwQRxxxBMaMGYMFCxbg5z//OQ466CDMnTsXnpecrmHWrFm44oorYvWcSY2O9A6XupcAMqw896T7PA/iLu5JuFYieYy0MnlgRj9hWo4wA33cWiW1QMpKpNN/GP1zL+wLoQWJc+QRaH9/lfpCusOHbu9h6g3lbg/AsgopTGuQa31xrUZJVqSmQqBTduj94bVqTZFOUSLLm767nT7/XT/c0bof5zz1fqRNMixGfiBQMKxFKl0IIDVN5vhVm4qcJy1MhQC+H+CDGw9JfT8Jgug6BlX1hl9TD5aXludAyGCOAPDp8jXYYlDPDOLIOAfjbbNjsPB7asSIEVb9jBkzMHPmzKLHPv3006ipqcEJJ5yQ2marrbbCvffei+233x61tbW48cYbMWnSJPz3v//F8OHD2zT2zqJHTYp+9KMf6b/HjRuH7bffHpttthn++c9/Yt9990085pJLLsH06dP1dl1dXeyBIQiCIIiewqJFi9C3b7TU2BLt7e9+9zscdNBBGDZsWGqbiRMnYuLEiXp70qRJ2GabbfDb3/4WV111VdsG3Un0qEmRy6abboqNN94Yn332WeqkqKysLPGBUNYdIWS6DGUIkhaaeBDHYpheVWrb7KeYpsjV1RXTGZnHquCO+SDSGHkMMuUHszVHppXI1AK5WiFl3VG4+10rk9mfKk0tj3meJiPqpekRd+nfPtLH5zIcTYVAW4HM83gBs6xFhVA7ZI4rl/HCFCEyVYhLn/IM/EBAJATgJAii+zC0X28AwBcr16ApiD6f44m3ew7m8ler+wiF1n379rUmRc3x5Zdf4vnnn8eTTz5Z0vmy2Sx22mknfPbZZyUd15X0OE2RyeLFi7Fq1SoMHTq0q4dCEARBEK2GeaxdXq3hvvvuw6BBg3DwwQeXdJzv+3j//fc3qO/gDcpStHbtWmvG+cUXX+Ddd9/FgAEDMGDAAFxxxRU48sgjMWTIECxYsAAXXXQRNt98c0yZMqULR00QBEEQGyZBEOC+++7D1KlTkcnYU4bjjz8em2yyCWbNmgUAuPLKK7H77rtj8803R01NDW644QZ8+eWXOOWUU7pi6K1ig5oUzZs3D5MnT9bbSgs0depU3HnnnXjvvffwwAMPoKamBsOGDcMBBxyAq666qlWxirIes5a8VHgHFgZYVFZaHuZFMwXXrvCaMwaP23nRZN+BkVdNRHEAAnVctPQDyKWmrMdCgTWi81kmY4Z8IKSpVQh4jIdLZ7JNFnLJzBRiByISPivBcRotyXPm1jcVAt2vFy59KcG1al/Bw/1ZKYquyNnCeDcYpLofqlRu/BW5TCw/m8e5sbTGw2PUfhj9BSjLcKziDBOvfQFzf5685EoQRPegqszD+oJAox+En68Ci1evxfABfTr0vO8uqUHeF1i3dk2HnsdEWnraKLRG6dqA559/HgsXLsRJJ50U27dw4UJwQ/z99ddf49RTT0V1dTX69++P8ePH4/XXX8fYsWPbNO7OZIOaFO29994QRfQ7//d//9eJoyEIgiCIzqE9NUWlcMABB6R+7/7zn/+0tm+++WbcfPPNrRlat2GDmhR1NgGiB8F8JpLE1kmlQgqpmVUfCIG8ny6y1u1CRbSyCqlt0y0/8biEoI2qD5WdnnMG35eWLSW4TgrWqEjbn2Ytct3y/TAQo7IelWU4Gg03/V6hdUilCgHSg0AmjS/ncfhMWadYUeuVGTZAUZHLYn2Tj4qch3VZjvGXPYe3rmp9mhiCIDqWAZW9sHrNOjT68nN268GdE7xxXd5vvlE7wxgDa2NCWBa07fhvAj1aaE0QBEEQBNFSyFKUAmOwNEUirBMi0hUB0vKShalzkaVruXEDOMo6WZ8PgjDoIpBlTOuVTCuH1DFFfWQB5P1AB3M0z8lDzZEvgLJMaGEK5LZrLcp6zNIWZTOyhJL0eLblK8nq4tYDiAV9BKC1Rcq93gwO6R6v2qdZo5S7vbIyqb8B6Y6vgjqq8+tAjp687iSNkseiBLhehiNbRv8eBNHdGVDZCwMqgfnLOz4bwbtLatBQCJANdTT5Dj9jBPc4eBs1RVyQHaQ56FOfIAiCILo5bXGp130IWj5rDpo2EgRBEARBgCxFRXEF92oZSRgZ6n3HwzGKUJ3uJZck0g70EphqYwuLlbu+6y7vLp3pfGhuvYpoHQhrCS3vB1pwrZbiVKnaZzlHPgj0kpvnCLPVeWNLaWE7ldfMdPtPi5ytyvVNvrVftTeF2WYJREt2FcY4mgoB/EBgXZMvl9FEwniZvWQHSFFjJuth8i0v48Vz90x9LwmC6B5sNahjRNbvLqlJlEU09znf3pClqHOgSRFBEARBdHNIU9Q50KQoBQ5mBfZT2etVLjRlXeAsEmADQN6PxNNJaDG0Ya0B4jnOpLVGWNYZs172xUJRdZT1nnuh9YfBqs96MlijsgKp82dDK042HEA2PE+Z3i8F3QiFhVxfdzh+z7YGecb+aLxqO0DO42jyAx2cMWb5CkXRrju/yntWFtYnZb1X+dLU36aVyQ+EzpkmD4A+ziTnc2Q4Qy4cH1mJCGLD4r2varH9sKo29fHZijXwhUBTaHLP6g9ohrwR5yTJgYbYsKFJEUEQBEF0d9ph+Qy0fNYsNCkqgjIqKCuQCuboB3ZKj0hXI9vlg0AHeHTTe5haItcKlERSQMikYI95Q9tjnyfqi3P5K8fUFrlaIUBadwAg63HkfWlNUhehtEaWtUm58+tSWaeku79q72qRklJ2AMlBIs2gj4B0u1dWopxTJoUNcK1HZjsziKMfCDTlMmgMz0cQxIZFqVaitxbVaEuQm6aJMwbOGMyP6KzHjMC7nacp4oyBt/EziSxbzUMLjARBEARBECBLEUEQBEF0e5jH254QNiA7SHPQpCiFKGo1ACaXrLhgCCCXX4RAzKVbrjIJADyMUo1QrByZZj0w+IEhRPaYXmYDYJtuA6aX38xlOGniDZf3wroshxZaR+cRzQqus46A2mNymY0zBo/JpTS9NCdjEehxq5sTBHKJTZVAJNhWQmx5HEsXaCfkJQPiwmtTgJ30ciNpK4F2Rc6LoloniLLdpTYAWN9UaO3jQxBEN+ezFWvQWBDIZRg4ws929bnMuLWtPm85Cz+HPQDgKLRV41MC7ZIQlnKfNQtNigiCIAiim9MucYpoUtQsNCkqQprQWjj18eMcEbShdlZCPoVpJTKP0aLt8NggTMpsBntUgRplvX28dMtnlnBQWn3kL46CH2gBtDkuX0RCs8itHsiHfwcQWuznOdagbIJbvrJSyV9dkUBbCbxl/9yyHrnCamXFUa80q5JZugJtU2CtLESqzHIuLWTZyEqkBN0EQfRMGgsicp4RQoupeZjLUpfGPCJwPmfd4L3Ehg9NigiCIAiim0Oaos6BJkUpcCYtOEJKYbSmCAi3YQTwCtej1S+LrCfXblXKDx4GClRaH/s8dkoMVSo9ktleaZGk9UXWmdohM4WH0vao47NMuasLrXsKDI2Q0hx5TJ4jG2preJgKpCzDUfADcBZln5fXGo0vCIS+R3p8Yb9lGU8GtNTZ6rnTT6hJQjiObGjVCdv5jlnOTYMSc7MPj1OaJdfS5HGGnMfltXqRtUhprNyQAQRBbHh8vKwOfoDICmRogxiT2sdAyNi0qj4Q0We/smarAL0BRFgyAML6/OtouId20BS102B6MDRtJAiCIAiCAFmKCIIgCKLbwzgDa6P1uq3HfxOgSVERtMDaEFqrpTK1nxlLae4SDxAti6kI19Y+bgqcVWRqlT3ebhvPziz/zjuRpnWkaj8SGGe9KNI0wABuLLXpsdv519TSXRAKn/OBQMaJbK1MxzofmsfgFyIBt94PKRjPco7GUDFunk8Jt2UE7SCMhC3rAxUCAHY0V1VvhgtwlyDVUlivrKfr835gCcVV6AEAyHgcGQBVyKKpl7zOi/78X1x/6Lax95UgiO6P6SzDnKUzz8hZqcOdQO5X7WWd0OFYuhLO2yEhrE+LQ81Bd4ggCIIgCAJkKSqK+qUQ/aJgWnynBNgKFehLldIYEYqew8zKnEWu+qbAGrDd102hNSB/xaggjxHSWpT1uBWkMco7FgZl9Ox8Zl44LhWUUVljkqw2ZuiA8tDNPcu9UEAe3RvVLhAyH1kgRMytvywjwwCUZeTxXAgpzHbc+9V+z4vc/c1+VHBJQFqLfBHmmguiMSlhtcfk/eCMoSLrhWPNFBVQK8tRv4qsdum/7sVPcfHkLVKPIQiie6KM21x/lkeBdsN4slbIFeUsowwyocw6/PyRn9Ei7KcJwsqJ1tG0S5yiThSGb6jQpIggCIIgujnt4pLfxuO/CdCkqAiupkitM/tCWG74rqbIzZxsWnjMwI7c0MAoLZGrPVLtVBDHpOCNbpDGKCu9o90xUojo0rAWccOa5AdCW5mUdclMIcITgiia2ih1Pt2fgKFJCq1hxnmVBijpelwrkbJ6IbR2eYyjAdLdPx+63avgi74ItUgFoFeWI+txlGc4OIuCRvpCIO8b15P1tNWp0QsoszRBbKB4jAHc/jx23fMBJOqFGCLLMWMMQghkQp1iLsewuqGAbYdUdeTwiS6AJkUEQRAE0c1hnIPxNlqK2nj8NwGaFBEEQRBEN4d77eB9RstnzUKTohSky2aUs8uMbK2E1maOnCAU3QmB2PJP1gujpgaRIDmel4xHy248LrBWpcobxqVtV0dkVZGrVYRr2T4h4moAnadMJV4LROhuD+hI1mqJSrvb626iPGq+iITcamlNXl90OvP4QAh4GR660YfXG/6PqojSHmPhspqs95ylq6i/cJxeFJagAQG8gMGH0HnNPCaX6AIm0FiQS2HlGbmEljV+NamwCUAYPsCT41nHg9hyKEEQGwZ9clzmOAsF0urTxOPyMzzDVVT86HOFMaAiw7XsIOtJ+cKAyt5W3wP7AnV1dZ12LWgHTRFoUtQsdIcIgiAIgiBAlqKi+I7lI01orTIsK4OCFO3apewnsjjoII06y73dRomtVZkktDaFgknZ4z1uWmmg+/d0EDMlcA7d+BOsRCqPmtmvDrKohc5SSM2ZtNK47d3jpHhR/jpTQnN1nsAIKmkGbwTCYI5h+9j4BJAVQJ4J5DyOJj/QwRmVkJsLhkY/QLkfIM8ZyjwGj9sCdD8Ayjyg0ffBWRZZz9eWKIIgNiyGVPXG8tp6NPnyM8r8DNYhV9TnnfH3wL69OnuozcJ4O3ifkaaoWWhSRBAEQRDdHBJadw40KUpBWYWEYZHRrpyGlgiItEeqfVa5rofPn57cB5E+xrROKHzTrd55dqVWyAzyGNYry5Wh7QGAbIZrK4zZTllxslzpcuQYykLXU6XVUWSZ3a/uPxyg/pWlstWzSJukrlMdp6w6PHSjV+70KiUIZwzZTDjejKxPWuD1RaRR0mk6MrJhIERojfKQ9ZjWKumglKFVzHwfvPDFGAAveg/LPIFeWQ/r8j5eWrASg/vkEAhg7JC+eGtRDcaP6BcfHEEQ3YpBVb1Rs3Yd8qGeUmqJ5OfGgMruZxEiuhaaFBEEQRBEN0cGb/Ta2IffTqPpudCkqAhKSmJajQBYWiJlJZLtI12KkTtVHmNoh1QqD1WfaDUqkhA2uR/TQwyWlUhtKzzOEPgi8vZiyvoTtTc1S1luJ1qV/aqgk0L3Gd4crSEK7x4AO1GtQmmHtJWIR9akvB/ooJFKs6Tug6c82QyPkSwHkLGDP2Y5Q8bjUYoTw1pkEmkLwnFBWpMynCEbSG+1hkKANY0+OGN4d0kNPA6891Utth9GwdsIorvTr08vrG9oQGMhgC+AjTZACxFFtO4c6A4RBEEQBEGALEUEQRAE0e3hnIO3USjd1uO/CWxQd+jll1/GoYceimHDhoExhqefftraL4TA5ZdfjqFDh6KiogL77bcfPv3001afT62yuKmvzGCNaulMBW0E4ktnsi87G7wqVQBBrtzHjT7UC4iEyOol83cpIbFcevLC7Szn0X6PacGxfMm2ZRmOsgxHr6yH8gxHZZlnBTWM+mP6PMml8/IYOJNLVR6PxlumgkN6XNd7DCjLyHOVZ2ResrKMJ9tnPCNPWdR/maeui0ci67DfMk9eT68sR5+ch7LwesrD6+yT81BVlkFlmYdeWU/eX6bGK//OcYYMB8o8hpzHUBEeX5nLoFfWQ0VWbldkOXplOT5fuabVzxdBEJ1HRXk5+vXptUEunQHR8llbX6Uwc+ZMMMas19Zbb130mMcffxxbb701ysvLMW7cOPz1r39ty2V3OhvUpKi+vh477LADfvOb3yTuv/7663Hbbbdh9uzZeOONN9C7d29MmTIFDQ0NnTxSgiAIgmg/umJSBADbbrstli5dql+vvvpqatvXX38dRx99NE4++WS88847OPzww3H44Yfjgw8+aMuldyob1PLZQQcdhIMOOihxnxACt9xyCy699FJ897vfBQA8+OCDGDx4MJ5++mn86Ec/KulcgbCDNgKRwNq0DjGVUd4JACj7iMTNrlA5SXCtjk2yNJn1bmmmE3H3m3gcQBAGLAxLQFqrzPFwD2gs2OEB0s4PJ3WJ8Y7IcSMSXqtgjyrIoxl8EYC2+kRhB8KgkpnoOPM8ZgYTJexWVibTXb8sI61pvbLSCpXLyBD/ylrHmLT+cS24ZuAAspACcQ8MeWYI1ZV1Kex/aU09hvazUwAQBEH0BDKZDIYMGdKitrfeeisOPPBAXHjhhQCAq666CnPmzMGvf/1rzJ49uyOH2W5sUJaiYnzxxReorq7Gfvvtp+uqqqowYcIEzJ07N/W4xsZG1NXVWS+CIAiC6E4wxnUAx1a/wjhy7ndeY2Nj6nk//fRTDBs2DJtuuimOPfZYLFy4MLXt3Llzre9gAJgyZUrR7+DuxgZlKSpGdXU1AGDw4MFW/eDBg/W+JGbNmoUrrrgiVs+ZHbSxuQSwJq4Fx9zvaoq0dYalBHx0yOogitBlIASyKmhiJkzdkbHHlA37KwuP97JOv+G1ZcMgkerJUOlA3POp9Bh620pIa96MsH8VTFKl/giDN2YZjwWN5KErvjW+lJysfmCHGpBjFlqrpfRUSjvl8WSNGGPyjMpKlPGi0g+ADBcwDH8ynEEYAI4xhhV168DZhunqSxBE96c9XfJHjBhh1c+YMQMzZ86MtZ8wYQLuv/9+bLXVVli6dCmuuOIKfPvb38YHH3yAysrKWPvq6uqSv4O7Gz1mUtRaLrnkEkyfPl1v19XVxR4YgiAIgugpLFq0CH379tXbZWVlie1Mucr222+PCRMmYNSoUfjjH/+Ik08+ucPH2RX0mEmRWvNctmwZhg4dquuXLVuGHXfcMfW4srKy1AeCIAiCILoD7Wkp6tu3rzUpain9+vXDlltuic8++yxx/5AhQ7Bs2TKrbtmyZS3WJHUHeoymaMyYMRgyZAheeOEFXVdXV4c33ngDEydObHW/nEWCaiWwVoJrXZ8QjdrjdrRqJaj23bYJQms/APK+Ldp2xdtmmebub0aqVu75HgdyGaaXq5LKrBflA1O5wZL6dbfNcALcONYMPxC57TMrP5p5D9UxUbgBrt3xzTIbuv2rZTNTbK2u2wvDF+QyDBkPVvgCjzG9dKaQ72kUAVuGC5Cu+b2yHGUZhrIMQ8ZjMn8Sl9G0PeYu+BEEQbQf3OPt8moLa9euxYIFCyzDg8nEiROt72AAmDNnTpu+gzubDcpStHbtWmuG+sUXX+Ddd9/FgAEDMHLkSJx77rm4+uqrscUWW2DMmDG47LLLMGzYMBx++OFdN2iCIAiC2AC54IILcOihh2LUqFH46quvMGPGDHieh6OPPhoAcPzxx2OTTTbBrFmzAADnnHMO9tprL/zqV7/CwQcfjEcffRTz5s3DXXfd1ZWXURIb1KRo3rx5mDx5st5WWqCpU6fi/vvvx0UXXYT6+nqcdtppqKmpwbe+9S0899xzKC8vL/lcypIQQIRWH1lnCq6j/cwSXGvxsxI1g4EHth3BdjtPEFojsrqo0hRsKzd6JShWferxK3f7UIDthe+0towo9/fw2lSJ0DJWpvKIBXFrkBq3ugduqYTe0grm2k9UXjKg0Q/AA3n/PERu7qbFSY0f+p5H15sPpPnMlzdfCrgNsbZywy/PcuS8yEIk+wmtbcbwOJP3Rh2rhdfWJTAEQoaAYCzax8I6giCIjoBxBtbGiNSMl2bPXrx4MY4++misWrUKAwcOxLe+9S3861//wsCBAwEACxcutKJkT5o0CQ8//DAuvfRS/PznP8cWW2yBp59+Gtttt12bxt2ZMEGf5BZ1dXWoqqrC258tRp/KvgggvY7cmEUKM2aRVZ+S4FXVW3GNnCWxNFwvNjfpa9KkSNWpXe5ykfKwU6W6Fl8IueznxEtqyTjdGExJx/uBnBQlTWTcZTgT83rzQYC8L8KxoqRJUdJ1qElRlodLYyxpUoTESZGq69eHvM8I4puC+r6ora1tlUanlHMsuPanqCxvm/51TUMjNvv5nR063g2dDcpS1FWoSYMfRO75QKQt8kXknm+66ZuaIpNiE6LUIIl6LGHww1jW+oisp6xOUQgBwM4Gb45VbasSDAiCcOIVxIM3utfmhh6IstQ7Weu9yF0/zwJ4XGafV/dY3Y+YRsnQCJnjKPM8AD7gQ1+vHwitJSrL8NAl39Y2eQwIEFn+1H2VQRyNCaRhNZL3MWzMAMHsX2x+ICAYQ83adRtsFm6CIIhvOjQpIgiCIIhuTnt6nxHp0KSIIAiCILo5KqJ1W/sgikOTojRYmBNLMCCMZqyWVfQyFKIcWirCtbXfWP7hLIr8bOp0moto7WqDktzvTQ2O7pdH7uac2ZoiAGBqCc3WMUNALgtmuRxnLhMuBxricfM6zHEpDZAZYRt66c4eY1Z4yPtGyILA1viorPVu30owrpf64IGzANwX4ZJdFFagV9ZDLnSdzxrRp+VR6nqFXkrjUFGqQzf78G/GABb4YCIARAAwLv9WffAMMowjAJP3MyiuuSIIgigV5nngntd8w2b6IIrToknRzjvvXFKnjDE8++yz2GSTTVo1KIIgCIIgiM6mRZOid999F+effz769OnTbFshBK677rqiCeY2FISwS7M+SXCdVgJAwIQlXA58eawptOaMIe8nZ6XP+5GVxhVaayuTI6h2yyTBtel5xpUAGTKLvcel4JoxKSQ2BdVJ4zSvQ53HtLCZ5/chkMsweAGXnmjwZTZ6P25lUdYlsx9lmfM44HEOj0UBMrNcCqxdK5ESnpvvna9DLUihNmNSiA1IG5eyEsk3Xl2kH0bt9KXVyM8D3ANnHGAeMmShJgiinSFNUefQ4uWzCy+8EIMGDWpR21/96letHhBBEARBEDY0KeocWjQp+uKLL3Swppbw4YcfYtiwYa0eVLfAdFlnyuojUWoS7X4P2/VdaXmU5YYzgInwbx72pdzyffu0aZoiM22IQlmLXHd4ayyOvokbVhChxobIOuIxhI7nTJbKCsSjUAMAdGBKHi5RqzJJu2SdV+0XLAwaycCZgMe90EpkB0ZS6ULcfrWmypO6riyPYkZ5oQYpijekAkOqMbBIS6SsR9zQFBmWJSZEpCUSQluLWBBEliMAQmTAuAfOATBatycIgtgQadGkaNSoUSV1SlnmCYIgCKL9YLwdvM/aePw3gVZ5n9XU1ODNN9/E8uXLEQT2L/vjjz++XQZGEARBEISEls86h5InRX/+859x7LHHYu3atejbt692cQbkskSPmRQZyz1qicyHLQJOElybUZKBaNlIucX7gSFkZpF7vrsU1tLSPA6BDB+gc7K5y3rO0lm0hGb3yxCJrhlgCa5j12yFE0iOoB1bOguvn7NI6KwjXofLjEmpRFL7DZf2Mmppjxt5y2AKtY37wBg8SAG5wguPi/KZuQr7cOlMLacFBb2LMQ4heDhOcsknCILYECl52nj++efjpJNOwtq1a1FTU4Ovv/5av1avXt0RYyQIgiCIbzSMM20tavWrxISw30RKthQtWbIEZ599Nnr16tm5nVTeKwAyF5iQFp40wTUAyyU+yToChNnoEQU/VMERPS5d01XW+2JZ6FUZS5ZqJFDlYdZ5xqLxmK09wyokj436VQYSFtqTlOA6ENA2kIBFouak0rx+18JjWpu0mF3lLQvzpen+eNSHeV9jffPoGjmLAjV6XOUzk3XuZ4LnMR2OQCV4VQEbYQZsDHywoBCJq/2CFcxRBAFYJhe+2R4a1q9HeUUFCIIg2gPSFHUOJd+hKVOmYN68eR0xFoIgCIIgiC6jRZaiZ599Vv998MEH48ILL8SHH36IcePGIZvNWm0PO+yw9h1hF2O6rvst0BY5xhsdaBCIpwcBFxA+Cy1RUlOT9+1giABiQRLN0jqX446fhseZts64YzavhRuu68ptX42LK+2PE6hS9gvrehPvVRBtBxA6OKRvhCvQbv+OlcgNhaCDVCJuJZL7mWX583hkHZLvR1gq65k7bmUxCjVEzC/oenkRvtQ1FZqktghAee/Kou8BQRBEKTDugfE2pvlo4/HfBFo0KTr88MNjdVdeeWWsjjEG3/dj9QRBEARBtAHuRQHh2tLHBs706dNLPubSSy/FgAEDWtS2RZMi1+3+mwBDpMGJdDdxbZFyXlIWEFdLo4I4upoeMMAXDNwD8kpLg8g6Ah5ZozhjVpBEld5C7zd6NsegtDGm1kaOy74404NQhFatQFm+oPRV0rqixqV1R6HFSF2jee3qbyCuzzI92NQ1AlFQSCjrkLqH3OnT9UCDbSUy74EK3KjqldXLPK8aZ0ZdnAhCDZGQZVAAgiC0GPm2JxoAIQKZgVoEgJdBY53UGpVV9gNBED2TJavXdt7JOJevtvaxgXPLLbdg4sSJyOVyLWr/6quv4swzz2zfSZHJgw8+iKOOOgplZWVWfVNTEx599NGe45JPEARBEES346mnnmpx2rHKytKkDCVPG0888UTU1tbG6tesWYMTTzyx1O4IgiAIgmgG5nnt8trQue+++1BVVdXi9r/97W8xePDgFrcv2VIkhLCWWxSLFy8uaaAbCjpHmd6WgmsgWjoDkgXWJmp5R7WVXQr4kMEG84EAF1JobC4/me1N934lbHbPrdzwzXpzaUnWR27zSnCsSt+9pjC4ogwSqXqLXPMZi5bTYnnPjCWuQIRC7YS4hkq87l6ncsvPqnABPD5es51nnE/2i+R6ZueL0/dJZb1XQRlVrjMRREtn6oVo6Uzfr6AggxgEvox26WXQVLMcwsvRMhpB9EAagoQPtI6CNEUAgKlTp6JQKDTb7sMPP8TYsWNxzDHHlNR/iydFO+20ExhjYIxh3333RSYTHer7Pr744gsceOCBJZ2cIAiCIAiiFI499lg89thjqfs//PBD7LPPPqiuri657xZPipQH2rvvvospU6agT58+el8ul8Po0aNx5JFHljyA7orKzq7+VoEOBUIhsWAAF/AD2yJiWm1MkbNKORHtDIW/Qqb4AKQ1hgnp1h4wYVubnL6zjpUDSLbQmOc2BciRNcYpQ3d1D9IqqA7I6KCOOrIjBKKAlS5urXmeMECBtg6p/oFIB+gGbHStXZ57n2ELxrVbviOwVmJzj7EojUfgpO8QgS2w9gtadA1hWIzM61XWI79JVogA8PMAY2CsAU35dYCXQ65q48T7RRDEhsX85XWde0LO28FStOELrQFg7ty5+MlPfoLZs2fH9n300UfYZ599MGnSpFb13eJJ0YwZM+D7PkaPHo0DDjgAQ4cObdUJCYIgCIIoDYpoHfF///d/2HPPPTFgwABce+21uv7jjz/GPvvsg9133x2PP/54q/ou6Q55nofTTz8dDQ0NrTrZhozWnxh1hiHF0LG4uqE4WtMTtvMM6wU33M9Vig6d6iJ8qW2PMZnOI3yp9tywrtjXoM4PfX6zjLeTFiZTm8MZk5YnxuS4gcTStbQBdioRda/U9Xhcaoc8xpDRpTyn6i+mlWK2lUjfH+c9ia4rfG+EkFYiQxtkWX9MLZHjmm+3Sy9VShDm52Xwx0ITkG9A09elm3MJguhefL5yjfx8p9zPXcI222yDv/71r/j1r3+NG2+8EYCcEE2ePBm77rornnjiCXitFJWXLLTebrvt8Pnnn2PMmDGtOiFBEARBECXC2kFozTZ8obVi1113xdNPP41DDjkEa9euxd13343x48fjiSeesDTPpVKyLe3qq6/GBRdcgL/85S9YunQp6urqrBdBEARBEO2M8j5r66sHsc8+++Dhhx/GNddcgx133BFPPfVUi4M6plHydOo73/kOAJnjzIqEHLrq96Q0H6aLuMoFJl25gQB2ZGvTjV4tDzFLIMys5ZwgbMuFQMDk0pEptGaeEQYALCYsBuLLQ3o/7OjVWmjsLJsxxnTeLy4iAXWAUBAdqsqV8BoAPENobV6rW8prtOu5MWh1vQhsMTUQjzJtjlcY5zdDC6hrVe2SolgzhtiyGdxlsyAv9+nlLyOqtbt0piJYp9Qr134WFCAY1+duWrkYItcLZX1bFmGVIIjuhelgQ3Q+/fv3j4UGeuWVV2LxiFavXl1y3yVPil588cWST0IQBEEQROshoXXELbfc0mF9lzwp2muvvTpiHN0S00oEQAdxVPG6VABF38gU7zE7U7wpEHZRwRI5ZK4xTzn9syinmDkG041eOvGn9RsJudV50q8xCsbJGIMQYU43mBYyI2iiCt4YHpcWzFMIdS/sdsoi5UOFC4iPO8lCpK4jCMXZdvDGsFThBJh9nCWOZwzMFUeqN9gNyigCaeGBH1p6QitQUIisREzFEOC29YgZFxYKuQXPAH4A5mXBGtcC6DmWosb6NfB5FnkjmJ0w/l/Ue5XzOHpVlHfFEAmi3QggUh1pOgwK3qiZOnVqh/XdKjVSTU0Nfve73+Gjjz4CAGy77bY46aSTemREa4IgCILocihOUadQ8h2aN28eNttsM9x8881YvXo1Vq9ejZtuugmbbbYZ3n777Y4YY5cRc/020klwx5VelUDoMg+7XrnRm27zsi0LgwxK3VCGS5f0bPhSbumqzBru8B6PXtzcDvvxOEPGU2OAdq9XkckBQ3/Dle6IaVd88x6YoQfM9lEZhhJw9kd6puh8KqiicsGP3PAjF3z7+owwBGGZ1fclvE4uwwFkOYx7Yqf2AKADNrIUd3pLZ6RSe6S1V1ahpG1VZ6YFUS79fh7w88gv+wL55f9D0+qvSnswuxFr163H2nXrEXhZMAaUcfnKeQxlGY6cx1Ge4fp9ygcCNWvXdfWwCaJNqBAoqeZ6osMYMGAAVq5c2eL2I0eOxJdfftni9iVbis477zwcdthhuPvuu7XbW6FQwCmnnIJzzz0XL7/8cqldEgRBEARRhPZI6NoTEsLW1NTgb3/7W4tXplatWlWSA1jJk6J58+ZZEyIAyGQyuOiii7DLLruU2h1BEARBEM3BeduXv3rI8lm30hT17dsXCxcuxNZbb23VL1q0CJWVle02sK6GIS5yVpnV/TAPGqDEvxHuco3poh47hyNkNoXIgXYxZ7HQAEldui7pqg5IXyNV5wWi0toPW3BdrDTHAUT15rmTBNueERJWjdvj8ngvvLdqHGZpXWe47fFQKK6WPfV5owEqobVgXLvMJwmsXQTPyLxmSQJrE3cJTXdguOqrKgAskHnWmlYuRm7j4fHjujFr1q3XS8QskL/E9HIjwnsMAIwb77lAPgBWrVmHjSp7ddXQCYLYQAmChM/XdqTkSdFRRx2Fk08+GTfeeKNOuPbaa6/hwgsvxNFHH93uAyQIgiCIbzzkfdYplGxLu/HGG3HEEUfg+OOPx+jRozF69GiccMIJ+P73v49f/vKXHTHGFjNz5kwt5FUv16JVCkqcbLp8K+G0ytjOEAmvdVZ6QzQd5TKzX3ERdyRQ9kIBMgsFyNwZiwqEaJZJwuR4fZIAWQV7tF9mfjZ3vKo0x+W+VL26PlcoHbteY9wc8t4pAXpiaQizXeG30j+q/Gta4C4EWODLXGc6631x4XVMSA3ErUOK5varAJA6MGSTLlmhEfkVC5OP6wY0rKtHY/0aNK6tlWX9GmQRgAsf3M9H9zTw9cvNFcfU/0f4HhHEhsjnK9dYuSo7C8a9dnm1lFmzZmHXXXdFZWUlBg0ahMMPPxzz588vesz9998f+w4uL9+wQnCUbCnK5XK49dZbMWvWLCxYsAAAsNlmm6FXr+5hCt92223x/PPP6+225EAhCIIgiG8iL730EqZNm4Zdd90VhUIBP//5z3HAAQfgww8/RO/evVOP69u3rzV5Sopj151p9YyhV69eGDduXHuOpV3IZDIYMmRIm/tJ0rGYK5nSUiLf7CAMVBgIoTPBu7oeUwtjkqYRAmytkYvp4p42/jSkssMYQ1o7I+gijKCO8XsRD9IojMhmSce52iNzzFawRjd4pBEIULUxU3nIOqYDbbYUrTGyNEMy4KKs96TBw9QiAfGgjTwjLUHuPtV30jFhnwJAfvn/kB00uqSxdySNa2vl+EQQWtYCyNCbANPXw+wAmEk6KwC+IVzjDFi9Zh0GkK6I2IBYvHqt1l92evBG1g5C6zQrdgLPPfectX3//fdj0KBBeOutt7Dnnnumn4KxdvkO7ipKnhTV19fjuuuuwwsvvIDly5fHRE+ff/55uw2uNXz66acYNmwYysvLMXHiRMyaNQsjR47s0jERBEEQRFsodfkrrQ8AseTtZWVlKCsrK3psbW0tABknqBhr167FqFGjEAQBdt55Z1x77bXYdttt2zDqzqXkSdEpp5yCl156CT/+8Y8xdOjQbmUamzBhAu6//35stdVWWLp0Ka644gp8+9vfxgcffJDqGdfY2IjGxka97T4sBEEQBNGTGDFihLU9Y8YMzJw5M7V9EAQ499xzsccee2C77bZLbbfVVlvh3nvvxfbbb4/a2lrtkPXf//4Xw4d3jHftggULcN9992HBggW49dZbMWjQIPztb3/DyJEjWzUZY0KUZgTs168f/t//+3/YY489Sj5ZZ1NTU4NRo0bhpptuwsknn5zYZubMmbjiiiti9R/97ytU9u1r1SXdKtc50M1K7y4JmX2U4liY9C65LvFJy09A64KuqtMlueq3lrRHLW28ZsiAJNTSmRRbx3PMMXNJB46YWi8FGfV6n9EuCAzX/eRjdF60pD5MkupMc3b4t/ByyA4ek37hKTSsqzcicgsp5DaX+tQ5eAYiPFdZ3/ivvsa1tVIoXSxatzt2B8G43M+YzPnGOARjeglNQL63Vb0rSr5OgugqFq5ei4LxobRu7RqMG7MJamtr0df5vmgv6urqUFVVhVUvP4G+fdK1PC3qa209Ntrz+1i0aJE13uYsRT/96U/xt7/9Da+++mpJk5t8Po9tttkGRx99NK666qo2jT2Jl156CQcddBD22GMPvPzyy/joo4+w6aab4rrrrsO8efPwxBNPlNxnyQuU/fv3b9Z81l3o168fttxyS3z22WepbS655BLU1tbq16JFizpxhARBEATRAlTwxra+IMXQ5qvYhOjMM8/EX/7yF7z44oslW3uy2Sx22mmnot/BbeHiiy/G1VdfjTlz5iCXy+n6ffbZB//6179a1WfJk6KrrroKl19+Odat6/75i9auXYsFCxZg6NChqW3KyspiDwhgu6erbSAucFY3MHJdtwXWCtdKEuj64qWJ6xav/jYtRMpKlYRZL5opU49LGJh7j9LO7947c7xKKG2GB0DC32aZdq2sOeNn2v4kkTBXFg8VS8CTVo/Q2iK4XIHW28xoH1pIYq765n6zPhwD85tQWPopmlYuLn4dIQ3r16NxTQ1YodF4NWhLF4IAzC/IstAE5BvAmtaBNa1D08rFaKpZrvtqrFsN5ufDkAVBZGlKC2xZJOClrBeWW75yRFDuzGvWrW/RNRJEV/PlKmklUp9TnY1K89HWV0sRQuDMM8/EU089hX/84x8YM6Z067Xv+3j//feLfge3hffffx/f+973YvWDBg0qKT+aScmaol/96ldYsGABBg8ejNGjRyObzVr7uzIp7AUXXIBDDz0Uo0aNwldffYUZM2bA8zwKKkkQBEEQJTBt2jQ8/PDDeOaZZ1BZWYnq6moAQFVVFSoq5LL38ccfj0022QSzZs0CAFx55ZXYfffdsfnmm6OmpgY33HADvvzyS5xyyikdMsZ+/fph6dKlsQnbO++8g0022aRVfZY8KTr88MNbdaLOYPHixTj66KOxatUqDBw4EN/61rfwr3/9CwMHDiy5LxXwD7CDN+qdRuk5xwFxfQ+cbZXOQ/3kUGk9dHoP96cISynDPj3YmhzPsaqodjzFAT+wh2Ppeqx+0kIAGO2YUQqjLxEezxCm23COLSba1++BUUbnYjo4Y6T5Ma7b1RKFf8d0QG4ZJO03O3Zc7M1zmceYOFah1FIE4E31yFcvALwsRK4XclUb60Mb1tVLi1BQAE86ZxBYFhpzbMwdVz6QVinO47+AzXACrrYo7VpDjZXQx/sqwgHAODIMEAzwIEMnrF23Hn16FdcWKZ0TkKyDIoiOZGlNPRgDMoxZOs5MZzoadXJE6zvvvBMAsPfee1v19913H0444QQAwMKFC8GNMAFff/01Tj31VFRXV6N///4YP348Xn/9dYwdO7Zt407hRz/6EX72s5/h8ccfB2MMQRDgtddewwUXXIDjjz++VX2WLLRuKY888ggOO+ywokGeuiNK1PbJwiShdfPHNzcpivqKL6eZ8XxKoZiw2p0Upb3daYLm1jwc5mQoNilKqG/JpCiJYpMiazylTIp0u2hSZE0uii29uedK2F8SanmumUlR4uQkYVJU9DxpMVASYioVbaO2YYitAYB71rYIv1xUPCmaFBHdmaU19cgrJwFjUrRuzRpsM3pYpwitV//7b+0itB6w60EdOt7OpKmpCdOmTcP9998P3/eRyWTg+z6OOeYY3H///fBKWC5UdFi459NPPx0TJkzApptu2lGnIAiCIAjiG4gQAtXV1bjttttw+eWX4/3338fatWux0047YYsttmh1vx02KeogA1SnYQqotRUn/HWQlCE+LdpzcxSzDJkRov0worRbD6QLm4sJntX740aITmwP20U/KbK0285chlPtPZZ8fJoFKy2itXk+ebw5CHspS1iWjvANCy0OmmLLQua2+8a7UZzD82lrUTHrStK5E5aoVKRr1rAGTX6TFmlzc6yhVUgY54ktkaWNHQCgrEqGhQeQlqNi42tJdFyjPQu3ZZRwH+AevNBitG59A3pVyBxJjWtqIDJl+vrlNfp6u7FuNVmLiE6lyRcxOQUgczV2FoxzsDZGtG7r8d0JIQQ233xz/Pe//8UWW2wRi73UWnrOHSIIgiCIngrzIl1Ra1+sjZqkbgTnHFtssQVWrVrVrv1SttQieI6Q2kNoASsidlbt0qwvWtBsCK4ZY7p0H1nVzjPMIZzBMo+42hz3WMvSEraOQgoILcBOsti4AmxX8GyNyTivaclyj+MMsetMEnCbgm1TOB5dbxSw0RZZG+Ji5VKurEPK4lBM5AzENTnqvgR+ZHVKOK6oeDuJJHd9J2iiEi2zQpPW/yRpl+xzJ1hqzXgPVlt1/vAaVL2vrE+qbULJeer1MdOCxjOA8KXQPrR4sbB/lUOtYf162ZeXle+bes/MQJleDmWV/RLPRxDtTc3adajPC2S4/EzzOJNW7/Df1Uv43CI6j+uuuw4XXngh7rzzzqKRtkuBJkUEQRAE0d1hrGVL1s310YM4/vjjsW7dOuywww7I5XI6VIBi9erVJfdJk6IU0jK1F8sIb1pHlIVFWVBcDY5pkTGPN89t4lpeAFvD447dSiciojIpi31i+hJjvC1Jt+FenwqsWEx71Fyp2rrHRucIy+aCMZoWhwRLTOI254Bf5PiUjPepmiLjGNUmlh5EnYNnYu3N/Uqbk/gBaQrdUnRPiWM3j0c0fqbc8Y3zC56JNExBEPdaS7h+FhRCa5Gh6+Kertf3w0ypYvYV9hdky/Vm0+qvwApNyA4aHb8PBNEOrG0yLLGM6c8zrTntzDmG6c3Zlj56ELfccku799lhk6JRo0bFAjsSBEEQBEG0B1OnTm33PkueFC1atAiMMZ0D5c0338TDDz+MsWPH4rTTTtPtPvjgg/YbZRdgpp6IBUJU1iAwS9+jtw1cvY+2HBUJFJ/466MZDZFpRVLaoaR+XE2Rbu9onfQ1hzabYr+IVFJWd/zmvZP1pf2scp2kSkr4qnB1KcLRCrkJUw1NkRvXKFYW81hLid2jT5P2iy3BqhQ7PinuktV5mnaoGR1VLNeL0k/59vMX3j9Vo0+R9iPUsBbpKhZZ4lQ9U9eT9n4yjoryyFLEfOe9I4h2ZGlNvQ7YmxR/zkxB1BnoNEJt7KMnsXDhwqL7R44cWXKfJU+KjjnmGJx22mn48Y9/jOrqauy///7Ydttt8dBDD6G6uhqXX355yYMgCIIgCKIItHwWY/To0UWD/vq+n7ovjZInRR988AF22203AMAf//hHbLfddnjttdfw97//HT/5yU9oUkQQBEEQ7Y2Ze6otffQg3nnnHWs7n8/jnXfewU033YRrrrmmVX2WPCnK5/MoK5OB1Z5//nkcdthhAICtt94aS5cubdUguiNmDi83YKC7YOGKiWOi6iJtdRtDAK0WJsxlKFeAbOKKwpPGliT0dkXhaSSJyluKmc5DnkvoZTQ3lqAbEJOZG+G2YCxx2SzRLGx12kwgQtWfEg9HF59+PCBjfySJmQEpLLZuZLwPYdab7awyZQyxMVpvcNHzuvfOFHy7wm59jWb/pimfh/csdXzx89uBNZ17iISls7BUgRubalfqNvkVC5EdWLqZnCDSWLx6rfW5qv0DEC2hNfe5SXQ8O+ywQ6xul112wbBhw3DDDTfgiCOOKLnPkm1p2267LWbPno1XXnkFc+bMwYEHHggA+Oqrr7DRRhuVPACCIAiCIJqB8/Z5fQPYaqut8O9//7tVx5ZsKfrlL3+J733ve7jhhhswdepUPVN79tln9bJaT4AxhmyoElYZ183UGEA8kKErpta6bKPfpOz14Qnt0jguLShj0j43S71ZWu1bakZ1xpUm4LbHyyyLkD0+FrMEMSFCN3PoEkAoijb6N6wMar+1LwnXspXkCm+Kq5EStNFta/bv9JUqZkwSXrtWFX1BhpVIlWkCa1NY7YzTvBaRtA+wBNC63hR6mwErjXHEhNZpAm6Fcu8PS30eP4gHpHQteErcHRSkK75fMH6+l64bIIg0qmvjAmuFZ1iPpI9N5y1HkdA6Tl1dnbUthMDSpUsxc+bMVuc/K3lStPfee2PlypWoq6tD//79df1pp52GXr16tWoQBEEQBEEQpdCvX7/YxFQIgREjRuDRRx9tVZ+tilMkhMBbb72FBQsW4JhjjkFlZSVyuVyPmhRFFpZIyeMLe78vbL2PSVp9sbbN4Wp6iiVkbQtuP23pV1mMTMuRvgS1rTRGrmZINTOsLzGLUDGNkPpn0XqY8FeSaS0yPTrUjyjftOjA9jlPFEA18+urmHhKaYXSjjOv0bqWhH5TiFnGVDBF8x4kBZFU2h8VTFJpi7iX3K/Rf0u1RZa7fprOyyQwrUnh8+NRPDSifVhaU2/pmd2k374Q8ZRLnQV5n8V48cUXrW3OOQYOHIjNN98cmUzrwjCWfNSXX36JAw88EAsXLkRjYyP2339/VFZW4pe//CUaGxsxe/bsVg2EIAiCIIgUaFIUgzGGSZMmxSZAhUIBL7/8Mvbcc8+S+yz5Dp1zzjnYZZdd8PXXX1t5Rr73ve/hhRdeKHkABEEQBEEQpTJ58uTE/Ga1tbWYPHlyq/os2VL0yiuv4PXXX0cul7PqR48ejSVLlrRqEN0RtXTGGOBBLv+oDMkqyrMSTbuZ5O0+kvsPnKW4JPdOLdg2xH1JQmz3nEllWvsk1HJXUr8tiVDNmCFIhLyHqrTaJSyXNZvt3sTM01UsyrMIHWmThNlmGSQsBbkXllQ2d0ySELolxzrC5lg/RQTWgCGkdkMXpLm9Jw3BWtJKFlpbedAA6PeEQ4vXwROWxNKWypKW8gJHOK6eE+4BGfuziCBaw4q6ddbnG4DYh6YXRrL2mPxc7szVM7IUxUnKCQoAq1atQu/evVvVZ8mToiAIEqNELl68GJWVla0aBEEQBEEQ6QjG2sH7rFOncR2Gij/EGMMJJ5ygYycCMor1e++9h0mTJrWq75Lv8AEHHGBlpmWMYe3atZgxYwa+853vtGoQ3RXTWuJxZll+3Nmp6/LuBnNMIsmdPqleCJEaNDGWrgqRBYczFhNIu+2LCajNfpIIhIhZlKIxx/8WwvnbEFqbL/WLyHJBTSqNttYvIDfyq7XPcDU3Xzyj43gIZr/AuBQbu8foF5MWC3Ve9QoFybH62DUkWKCs+gT3fLO0rju6FyKlTM2rZo3LDM7o2aWz3wriaJYmrhUuSLEONWc1sq5XnifXb1B6G4JoASvq1um/zc/2wNjWZfi3zH3WMyYZGxpVVVWoqqqCEAKVlZV6u6qqCkOGDMFpp52GP/zhD63qu2RL0a9+9StMmTIFY8eORUNDA4455hh8+umn2HjjjfHII4+0ahAEQRAEQRSBls809913HwAp27ngggtavVSWRMmTouHDh+M///kPHn30Ubz33ntYu3YtTj75ZBx77LGW8LonoC0lEICQ1iIhoO1rKh1HLIijkVnezSCvMNsyxmLZ6NWxSSTphJQGyh27F+qD0rRG7nEALA0Q1ylH0n8RJWWZYAxWcEbhlKpekZa+wz6RY9HQBycEVEzbL4LktCDN6WqKUSxYY1rbpGPS3OrTri92nfHjY9acsD+z3gzWGLOkqX6VlsjoJ/b+BGHgSz+s9539xnaiBsksTQ2S6jccuxUwk3mxayaIllJbvx5+IOAxaTVnyrrOpH5UPV1qpQBAaCFSFqNOHKxrAW9tHz2IGTNmtHufrXLkz2QyOO6449p7LARBEARBJEGWokSeeOIJ/PGPf8TChQvR1NRk7Xv77bdL7q9Vd+j3v/89vvWtb2HYsGH48ssvAQA333wznnnmmdZ0RxAEQRAEURK33XYbTjzxRAwePBjvvPMOdtttN2y00Ub4/PPPcdBBB7Wqz5InRXfeeSemT5+Ogw46CF9//bX2ROvfv78lwO4pmEs6TAhwyIimSnSd5HLPGEtc+mou+qkr6CtGkmBaCZ9NAbQqiwmsXcF0keDIsX4DIRJF1YAtpHZLJbTW4mpE267QWoRCZ6s0/k4UPrvCZu7ZAmFHSG29vIx8OYkUBeMQXia5TBBku+JswTPhdSaJvU2xdnPi8hRhtiX2dq5JH2/cCxWZ2r23etyuYDwatyVEd0hbbowt2QGppVpayw0YFhduG++puqcEUQor6tZh1Zp1KBheMK60wAs/3918lUx//sej73ck7v9da189iTvuuAN33XUXbr/9duRyOVx00UWYM2cOzj77bNTW1raqz5Lv0O233467774bv/jFL6wokrvssgvef//9Vg2CIAiCIIgiMB77oVbyq4dNihYuXKhd7ysqKrBmzRoAwI9//ONWO36VfIe++OIL7LTTTrH6srIy1NfXt2oQ3RGPh+JnlZ07zNDNggK48OFxFrMYuS+PM2sbCW1VG7MEImuRezxgW3vcXzdppAmszZdrYJHjsF8eDwXYKe76lthaiPQXs/e3BiYCW+xbTHDdXLb7luC6nDsWDOFYUsy/U93jFWnbacLsmLXIbZ+236hXedcSrVPmAxfEz1+EtPdEW4OCgv6fSqwPCvK99QtoWrkYzC/o/0M3rkNu4+EtHhdBrG9owOo1Mkgjg2EN4gweZ8h6ssyFZYZHJWPM+EwPg9G25nOEaDeGDBmiI1qPHDkS//rXvwDIeUpaGJvmKHlSNGbMGLz77rux+ueeew7bbLNNqwZBEARBEEQREqUCrXj1IPbZZx88++yzAIATTzwR5513Hvbff38cddRR+N73vteqPktekJ8+fTqmTZuGhoYGCCHw5ptv4pFHHsGsWbNwzz33tGoQ3RHLesF47BcBC3yAe+Bglm6HpZQoss9sA0RpP1pSJmWzV2UgRNHzqXG72etNF3vX1V61SwraqNz3kyRRMZd8p97sW3XAwO3j1HZYQnDLxZ4ButQ3xCyTst2re8943MKhPkBSMrvr/jiS693nJqEP4WhorA8tHrqtuyWQHFZA1fNM6GYfjp17iWMXXja6dypLvfWecfs85jiSrse4xbH3RG0npfZIu7cp40p9MAmiGdbnw+cU8t9DfY4qzO2kz1uEx3XJo9cek5oeNim66667EISfidOmTcNGG22E119/HYcddhhOP/30VvVZ8qTolFNOQUVFBS699FKsW7cOxxxzDIYNG4Zbb70VP/rRj1o1CIIgCIIgiJZSKBRw7bXX4qSTTsLw4XIZ/Uc/+lGb5yElTRsLhQIefPBB7Lfffvj000+xdu1aVFdXY/HixTj55JPbNBCCIAiCIFKg5TOLTCaD66+/HoVCQrLwtvRb6iB+8pOf4KOPPgIA9OrVC7169WrXAXU3BPfC5RuuM3Rry2kAMMa1WVW5muvd4YZq35I8OdGSFlpUmv2bf7ekLCqSDoXQiRGpWbRU5o47DbVEllYmjaGYS390AEfxMycNJlo6U30AxjJnkrA46QOlOXF0S9qopaKY23m47YX7vYzVTiT9ngkCCC8jS6P/pIjVql4Lv1Nc22NLdK4HS5EP2VR3+6Qy7b5Y7cz3jJbOiJZTW78eQgi9FKazECjHlrCd+5noZisAjM9GALGo7h0IJYSNs+++++Kll17C6NGj263PkpfPdtttN7zzzjsYNWpUuw2CIAiCIAiiFA466CBcfPHFeP/99zF+/PhYDrTDDjus5D5LnhSdccYZOP/887F48eLEQWy//fYlD6I7IhhDQcj1RQEmS+baRwAWFPTsnUEJS0N39bC1aUUJhAAP85GlWY44Y/DDfGVCHwfrV06SQNsav7G/JULrQIiYUDot6KI5bNdCZPZTyq9519Dk3qek+6YyujEVXFAYAmyrc1vca4mQLXGvEpy3QGCdJqJWm4awWCRYPyzhcdo9UUJjrqxEmfRzigDIZKJSCZT9grYeJQq3zX6SyiSSrDkK49ZZhyQJrZXgOxSGCy/6OGJ+IWE8RhiBEsMEEN9c1qxbr92zLcG0ym+mre/250uawwlTufc6+/kjoXWMM844AwBw0003xfYxxnRw6VIoeVKkRExnn322dXIhRKsHQRAEQRBEEcwAcm3powcRBOk/KltLyZOiL774ot0H0R2pKC+P1ptT1o+1xsj99R6+lNXItMCo7PNeysPphdYYtV9ZYty17WLaoECIFmuLFElWq0TXeedXFDfG6VqNTBf/NFSbJE2SlUrE2TbHrWP5QZnQHItWmEmdwdEO6Qt1tUBOBnZV8mxoscmG7Tzb/d7YFmF+bcGyjrXDi/aHWrViCC8X09zErC7q/Oa2sio5WqRYaR5v/hItNq5W/tpM0xSZ/z+5AcP03/kVCxMscizZUkcQCaxvaJDWIC6tQln1eIf7TasQoL4Q9QdK+GwqPWnUr/rs79RnkCxFRWloaEB5eXmb+yn5Do0aNaroqzvwm9/8BqNHj0Z5eTkmTJiAN998s6uHRBAEQRAbHKV+nz7++OPYeuutUV5ejnHjxuGvf/1rh43N931cddVV2GSTTdCnTx98/vnnAIDLLrsMv/vd71rVZ8mWIhU90oUxhvLycmy++eYYM2ZMqwbTHjz22GOYPn06Zs+ejQkTJuCWW27BlClTMH/+fAwaNKikvirKy9Gwfr0RMJBrDVFME6IXn0PvNK2VEBAxu0x67DlzDVuh1rrdbbO+OQ1OsQCTrrZIWamUlkhZjEzPhTQLT5pWqbnx+IZmyr4fwlqelf1G2oB8IGKJdpkI+3X60tYwZTkKtUhJQSXtQUQWGDcIZVpZrK3ZZ9LzFH++POsXqbZChdYm64GxdFPKs83QGLn1pqbH1UBZ9zRlfMl3LPq5FWqXzKCOMU1RirYqTYMEZiTyJYgU1q1vsD4fzOCLctu2Ern/m/p/yfgf1fuBsE3Jvq+tpj0SupZ6fKnfp6+//jqOPvpozJo1C4cccggefvhhHH744Xj77bex3XbbtWnsSVxzzTV44IEHcP311+PUU0/V9dtttx1uueWWVoUKYqLEBCGcc/0lZXVkfHF961vfwtNPP43+/fuXPKC2MmHCBOy666749a9/DUCuOY4YMQJnnXUWLr744maPr6urQ1VVFWpra9G3b99oUqSW0NwvsSCMkWAp8Ww358BYPisWKdrsxpx0NDcpamkJpAuvzX49Z5ahvtDdcarxWfUJ/bVkPK2dFLkRaZFwXeZ9s9oZH4bde1KEdDN9sUmROfaOmhQVc7MHEiNxW+NyhNbm8lnTysWJ7WF8OVDuMyINd1KkKHlSlPasM466mq8xaPgo/X3REajvpGXV1W0+R11dHQYPGdLi8Zb6fXrUUUehvr4ef/nLX3Td7rvvjh133BGzZ89u09iT2HzzzfHb3/4W++67LyorK/Gf//wHm266KT7++GNMnDgRX3/9dcl9ljztnDNnDnbddVfMmTMHtbW1qK2txZw5czBhwgT85S9/wcsvv4xVq1bhggsuKHkwbaWpqQlvvfUW9ttvP13HOcd+++2HuXPnJh7T2NiIuro660UQBEEQPRX3O6+xsTHWpjXfp3PnzrXaA8CUKVNS27eVJUuWYPPNN4/VB0GAfD7fqj5LXj4755xzcNddd2HSpEm6bt9990V5eTlOO+00/Pe//8Utt9yCk046qVUDagsrV66E7/sYPHiwVT948GB8/PHHicfMmjULV1xxRWqf5RUV1nbDunqdj8myEpklbLMrZzxaigoDf8kltvj5dL3h1q8E2iZulvqWlm5ASVeobf5tWk5iomtDaG1ai8xRusJoVfpGe9MyFOjbaN8YP9yhwjQqy5uq900BpHUtVjc6zEF0ISr8QRR6wYUxuUyljTEiEnS7ZayflLaMIRJce1kdHBQIzduh9cRaWjKtN66buhpoeJfCU4f14fEqOKMjpFbWTOv87rnc/U4ZW+Iyj3WDUlr3P/o/AQDmF9C0crG2LCVaocz+i/VNfKORAmuBLI+s3zG3eoSu9VpQbeCIqOMyCQEIX+bA7CRk8Ma2eY+p40eMGGHVz5gxAzNnzrTqWvN9Wl1dndi+urq6TeNOY+zYsXjllVdieuYnnngCO+20U6v6LHlStGDBgkSzW9++fbXIaYsttsDKlStbNaDO5pJLLsH06dP1dl1dXeyBIQiCIIiuRIi2S5jU8YsWLbK+x8vKytrWcRdx+eWXY+rUqViyZAmCIMCTTz6J+fPn48EHH7SW8Eqh5EnR+PHjceGFF+LBBx/EwIEDAQArVqzARRddhF133RUA8Omnn3bJxGLjjTeG53lYtmyZVb9s2TIMGTIk8ZiysrKSHwjh5XQgQw4hf+mavyRUyUJrEc8AzIOpzWlp1niF+oHgapJKKRWudcfVBbUk+KKrKdI2sgStD3P2y+MjrVDScbqdcby2KiXcH91OCHjh8cLVEiRok5TmQJWxcQunTLieJOF3km5LOH3KMUhLlflLVlumzNLUOxjBHNOF/9EDI0wrTpJVx31QuGe0a+bBC3xt1QJzBNOmlskJ6qjfmgRRqwq+qa/L1TyFQR5FtmenGOqu+P97FyJbBogAvLEeQc0KZMYf3NXD0qxdt17/rTSMcSsRimuGLItnwrPfnNavm9O3b99mNUWt+T4dMmRISe3byne/+138+c9/xpVXXonevXvj8ssvx84774w///nP2H///VvVZ8n259/97nf44osvMHz4cGy++ebYfPPNMXz4cPzvf//DPffcAwBYu3YtLr300lYNqC3kcjmMHz8eL7zwgq4LggAvvPACJk6c2OnjIQiCIIj2QMWCa+urpbTm+3TixIlWe0DqkDvy+/fb3/425syZg+XLl2PdunV49dVXccABB7S6v5ItRVtttRU+/PBD/P3vf8cnn3yi6/bff3/wcI3/8MMPb/WA2sr06dMxdepU7LLLLthtt91wyy23oL6+HieeeGK79F/eq3fqvsY1NfIPbUaR681MBFE8QMhfxW6pUG7kTAAqAKQVNCzcdkuVuFWVSe0EYzo4ZEuS06aRZCVSlpCkhLXmv6FlBbI86qI2gXO92kCEuEcZnP3m8WY/nEXnU6UvpPXID4RVuscpzzi3dM9jljpJsDN29xrUL1k/iH7RyjHahrooeKYdrDGm7dE3ztUcecmlbu9YB10PNFWvrUjJ7Yp6pKWR0l7r3pxf9KaHGtG5+IvehyjrjSBbAebnEQBgveMi3a6iafVX4BUDAET6zWa1Q0iod7VC6rM8aKFXaAcQXkmb+yiF5r5Pjz/+eGyyySaYNWsWAKk53muvvfCrX/0KBx98MB599FHMmzcPd911VxtHXpx58+bpRPVjx47F+PHjW91XyZMiQCrQDzzwQOy9994oKyuzxK1dzVFHHYUVK1bg8ssvR3V1NXbccUc899xzMfEXQRAEQRDpNPd9unDhQm0MAYBJkybh4YcfxqWXXoqf//zn2GKLLfD00093SIwiAFi8eDGOPvpovPbaa+jXrx8AoKamBpMmTcKjjz6K4cNLD9lRcpyiIAhwzTXXYPbs2Vi2bBk++eQTbLrpprjsssswevToVgVL6k64cYpKQVuKXLgXTwrqlkmUEGgrTaPktgFaLtZLm+sWsxS1hEDYViJ3X+x85piSxuNsJ7VxPdF0W0NnZOqNzOOS9E5JMZWaO1+SpUi2TU4Q7N7/2PvqPDdpv4JLJsH7zNpn1jn6DD0O82WSFK+oJeNQp2OcYhN1If6i9yEy5dpSxPLrwNauhrf1t7t6aACkpagQsxQh3SJULP5XQjtXf1RX8zUGjt6yU+IULfyqfeIUjRzW8jhF3Z0DDzwQNTU1eOCBB7DVVlsBAObPn48TTzwRffv2xXPPPVdynyVriq6++mrcf//9uP7665HL5XT9dtttpzVF31TKKvuhrLKfXGJgzFBHt/LLqbnAeEY7lblZZ3BOaKcDUBYx7Fn5xgSs5RyzdAXWvq4vXio3+rT9+pKMUi+jOPVmafYjwvGY5mZfyH1p4zFLIUS0xJaw3yzdJTlzshc7l7qHcMcW3fNACPiqDOR7oMoA0iVXhSQQ3AMYlyUAwTNW1Fsp8OfFS8BekjOPV9tOe7UtX+Fzzrh87o3jYLZT/XOuXel1OydMgJvjSY/Hy5Abfhfhf/wKACAor4LfeyOI8koEFVVS7N67X9cOzkBNiBSCMUs4bQUmTXKOsT70nOVcc0KUNunvQNTnUltfPYmXXnoJd955p54QAVLOc/vtt+Pll19uVZ8lf8I8+OCDuOuuu3DsscfC8yJdwg477JAau4AgCIIgiNYTiPZ59SRGjBiRGKTR930MG9Y67WHJk6KOiCDZ0yjrXYmyPlUo61MFiABlfarAgkL0Cn9hMBHo7dSX0R5A9KtFhQEw6q3+jNL8VcOEABMCHPKlf+iHL5XiwwyBb7mzaiF1uD98eY7AWrmlu/WmO3xayZk8zixNa5FbsiL9AfHlNXf5yxVWm+NMK9V9UqW73xRbq1LdC2a8zGtR99TT98gugei9sFLPKAF2wi9aN3WHafq3gkImCKbN9kn9WMe5cR+SUM+qu4SWcH53OU6wMFVIEKBp9VfFz0O0P737obD4vxCZaHVABd30RozrqlFpGutWo2H9ev25JkOlyOCK+vMwfCHw5UuIsAyAwI/2J33eJn3udrKliIhzww034KyzzsK8efN03bx583DOOefgxhtvbFWfJQutOyKCJEEQBEEQxelhhp42c8IJJ2DdunWYMGECMhk5nSkUCshkMjjppJOszBqrV69uUZ8lT4o6IoJkT6asb7jGrX9FK9/89F/iaUk3m2uXROJ+JziZFVRSwLIOxVzDmxFZuwlai4mwk0TOSaUiLahjkkQqSRTtsah9mmg6ECqQYvFxuVamJLG2ew7Xpd+6F8Y9NcukZLo6bqJKGaLeQ+6BGcEUE606LXmGHCcAYSSOjSVyDYOTsqAgNUUBAMaiII1JFiAvA+EXdDqP3MbDkV+xUI4jHK8uzXEZiWWJzsUbMQ6FpZ8i138IGutWg/l5QATIDh7T1UMDAPjZXrHgjPrZiWmHnIChzudji5Iepwm3O5D2WP7qactnt9xyS7v3WfKkqCMiSBIEQRAEQZTC1KlT273PVsUpUhEkCYIgCILoeNrDe6yneZ8pli9fjuXLlyNwLMnbb799yX21alJEtIJQCK3ckHVm8HA3c8yxVilCJ2wRFG+XgBLTqv36X0Ifh3B/uMcQWFulioEULqlxvUQkrOvwEpaFVCkQLRspt3JToMyZfeJAREtsrmjZXfYyTysQLZW5x5mibDj7GWN6/B6Pzm+O0zMONsfgtks6hxqTuYxnkhSnSIgoL5qVH81d1jQjXqcsC6TFNYotnaWVCcLsRMF1MVQ/xlJY08rFUnie9Mwb9fCjsmnlYopX1In4X/4HDEC+egG88P3IDN2iawcV0rRyMXjvjcI4F84zJAJr2Uw/Syonn/p8DD+PFbHPVbMMgnh9JxBAiy/a1EdP4q233sLUqVPx0UcfxSZ8jDH4vp9yZDotmhT179+/xVGrWypmIgiCIAiCaC0nnXQSttxyS/zud7/D4MGD2yW7RosmRaaYadWqVbj66qsxZcoUneRt7ty5+L//+z9cdtllbR5QT0VkysDyYfZmEUBHQwjfw2ICa4u0SNhpkbFTXLGLCa9jXRiRspW4V+XqAhATAwNxS0iS4LpYdOgkAbOqT4tOrcfrnK+lQu+0cfHwepX1KGncxYTWSfcgqUwSVMu+7dLMk2aJ4h1rUUxgHQqxwbi8H84zI7hnvdfC+IBRQm41Dm3QU8+xemajA8I+M9FzzLj8hc4zYRlaiziPhNlGP6U6FRAdyPo6MM6RHbVDV48khqioks+smWvSamBbyy2rT9LnaVK9enYZh2Vv6cTlKDOuZFv66El8/vnn+NOf/pQYJqi1tGhSZIqZjjzySFx55ZU488wzdd3ZZ5+NX//613j++edx3nnntdvgCIIgCIIg77Mk9t13X/znP/9p10lRybnP+vTpg3fffTc2iM8++ww77rgj1q5d226D6wrakvusOZpqlgMAcv0GobFudVyHkfQLuLk1a1MLlPRWxhJoJeeTKrbfbmv3V8rTEyQ0TnOpN1387fM1f8K0XGUmSTnOgOatS2nnSepLnwvufmbdizQtUSmWYCsvWhGLoYX7SxjJ76+rK0s8b6oGQ9haDjfonSOMTHVxTrBmUh40omFdvX6GE5+9cDvVSuSSYmVKDDwqAtTV1WHjLXbolNxnH/3vK1S28Rxr6uqwzehhPSb32cqVKzF16lTstttu2G677ZDNZq39hx12WMl9liy03mijjfDMM8/g/PPPt+qfeeYZbLTRRiUPgCAIgiCI4pD3WZy5c+fitddew9/+9rfYvg4VWptcccUVOOWUU/DPf/4TEyZMAAC88cYbeO6553D33XeXPACCIAiCIIpD3mdxzjrrLBx33HG47LLLMHjw4Hbps+RJ0QknnIBtttkGt912G5588kkAwDbbbINXX31VT5KIZHL9Bum/daRrAI31a+QfqcI/Y4kiFLtGrs1e1C5pvcWNTtxcFOMkkpYuzGUVY+UuLQpzS4TYJmppKknA7AqjXZKWzqzI1tzur9jSWbF+1H55PwzBNmOJQmp5ruL3xhVYJ0UXTyyR4JafsDRmCqnj7vUsdl61Ld+j8LqSzhsKrpWAO3JxDgDmWUJqLbQGouyLjuDaxRVeK5pqVyJXtXHyQUSPpXFNDUSmTDsHuJ9vLsJ8Jt3QEmnC6qTSjKreyYJ/gXYQWrfLSLoPq1atwnnnndduEyKglXGKJkyYgIceeqjdBkEQBEEQBFEKRxxxBF588UVsttlm7dZniyZFdXV1JYmy1qxZg8rKylYP6ptGWe/4vWqqXRnLNQVAZnVmXP50LmbdUTgCw7Sgj8Jtn9SPE+SRGeYiZTXSGd4Rueu7ZSBELEO8iw54GKWtBxAP+mgN0bDWKGuQOj7Lo/xn6nhTEO2OR1l4koJAJlmNYsEnnb64cZ+80Brk3hvPVWir49W5IaS1xr4l0moDZout3aCKiETRLOHnpuV+X8Qq5Y4nsT/zF3tzv7wV3P7VXcz1Xj+zjAN+U2IboufS9HU1kOsdWTyBBKG/iNcp0tzwVZlU70fBHbsicCMgrfBJziql9tGT2HLLLXHJJZfg1Vdfxbhx42JC67PPPrvkPlscvHHp0qUYNGhQ840BbLLJJnj33Xex6aabljwggiAIgiBsBNq+/NWzpkTAPffcgz59+uCll17CSy+9ZO1jjHXcpEgIoU/eEvL5fMkDIWya00koHZIKjqfXzFv4yzw1SGSx4wH715lBWvqJ5jRFrraomIbHCoRYRGtULKu92d48X1JARRhlmpbI7DfQ1rHoWFufJGCEN4zdGxUg0tX0yGsLrWQiOk7Vu8EbW1O67yFQJEhk0vmUBROw9B1qWz6bobbItCKpZ9YMjKe0RW5wR1dzFO5v+roawstZOj2i59Gwrh55cHjl/cAY4s+e/vwr8tWvtUGZ5M85pXez+gsALyOtRZxH6WYoiGiX88UXX7R7ny2aFI0cObIkz7IhQ4bEzFgEQRAEQbQOCt6YTlNTE7744gtsttlmyGTaltK1RUf/73//a9NJCIIgCIJoA6Lt3mc9bf1s3bp1OOuss/DAAw8AAD755BNsuummOOuss7DJJpvg4osvLrlPsv9toJT1rkRZ70qwQiN0xNYk9/qk0ojwWjQbdOJxtriWCSFfCeJfIFloDSQLm+X+5kuV0V6eh+k6IBIrmyVnUjDNWbRtZq5X5y8WydpdwlN9uONxl85U3+aSV9Rnyr1JElKL+D1VJEWcjrnfIy60ZoFv7dfCaRYKwjnTf6v9TAhdmv3IkyYLUGPPJmCHgjBL0+U5rVSobb8A1rROR4wneiaCe/BY+EwGvvw8CnwwEUTu9rq+IOuLCaktB5ZCcukKrd1nkOhSLrnkEvznP//BP//5T5SXl+v6/fbbD4899lir+mybnYkgCIIgiA4ngEDQRlNPW4/vbjz99NN47LHHsPvuu1ta0W233RYLFixoVZ9kKdrAKes7ABACgnH54nKeq8rYL3HGgbAtAKuMCa6TyhDTIiFYekZ3hRJYm0Jrt3Qd0tPc9RWm8LrZ4Iqwt1XpqwCEiLaT2iWV5kvo64vGFBdri2ZLIeL30A879QNhueXqe6nGBGZtx94jYxuADnyntmPHm0JvEc97JhvFrUDNWoXCAKTCeSYta1EppaLQhKbalfExEj0CHQ0ktEwm5jrTz7jzbKjPPfNzMS2Io9o2y4RnTjBue5V0MOqzoa2vnsSKFSsSveLr6+sTw7a0BJoUEQRBEASxwbHLLrvg//2//6e31UTonnvuwcSJE1vVJy2f9QDKKvsBABrX1lpWoGLWnlRNkSJNW6SPt39ypGmKVLPmgje6JRK2zTMW0xy57vuqH5HSPq1f0ypULDyACt5oHm+O2Q45EFl50jRFgO3+nrRfbScFVXR/IBVzxzf3cwggtJyZpRxQACbcflugQ7NuRmD5/FvHJwXCM7RETATy8IRSd0/BHHssa9etlxq3UENkBWYUAhBK15bwbCV87smNBO1lEAVpBGAFbQQAZgZxDAqdanoh77M41157LQ466CB8+OGHKBQKuPXWW/Hhhx/i9ddfj8UtaimtshS98sorOO644zBx4kQsWbIEAPD73/8er776aqsGQRAEQRBEOrR8Fudb3/oW3n33XRQKBYwbNw5///vfMWjQIMydOxfjx49vVZ8lT4r+9Kc/YcqUKaioqMA777yDxsZGAEBtbS2uvfbaVg2CaB/K+lTJPxiH4J6tMUrQEKnSfKVZl8p79Q6tULZORWHqUJL+AV0djD6uhNK2uKSXrpUnEEAhEAiE0uVEpdvO3C+vJ9LzqFIIUbRdkm5JJFxTcxoj1bfSEfmiuKYorVRaoaTSfB/VtluvcX5xW7qNlliNjMB6SUk7Y7j6jRSsfWEwR6Lnoa1EyttRlQrXaggU//xLSunBHO9HnvDMm5bNTkz1oYTWbX31NDbbbDPcfffdePPNN/Hhhx/iD3/4A8aNG9fq/kqeFF199dWYPXs27r77bitA4x577IG333671QMhCIIgCIJoKZ7nYfnyeCiOVatWwfO8VvVZsqZo/vz52HPPPWP1VVVVqKmpadUgCIIgCIJIpz2Wv3ra8plIuaDGxkbkcrlW9VnypGjIkCH47LPPMHr0aKv+1VdfpQSw3YCy3pVorFsN5mW1qdc1HQNxgbXel2QWZhwN69eH7YXRR+Sm3Zz3oyu01n2EpddCAXYxwbRbulns5TjtErDFh83lUTNJy7Om+nTH5F6zbGfnhEsrzeOKCbPl2NNLsx2HgIAhvHbbWz758bxmMaG1DuJolIzZ9eZzlbQMERjPpZ+wNCHCxb+kAKSIlkWavq5Grv+Q+PHEBkfT6q+QKa+KhM0ikI4AodjeIiG/I5DgWKIE1UqYr4MyhvuVoNq3n9fomY+cFDoLc+m8LX30BG677TYA8nPazcvq+z5efvllbL311q3qu+RJ0amnnopzzjkH9957Lxhj+OqrrzB37lxccMEFuOyyy1o1CIIgCIIgiJZw8803A5A/TGfPnm0tleVyOYwePRqzZ89uVd8lT4ouvvhiBEGAfffdF+vWrcOee+6JsrIyXHDBBTjrrLNaNQiifSnrOwCNa2oAj8dD2rMwmYMpMDRxgpilZVRX+/Tfzg8QNwN8Uqkwt5WgurnfM2lu8qr0A2m1UaUZXDHtOJmh3j6zzBQfla6QG8Ler0r33B5niS79DIAfWsjca08LLaDam/cuLZt90nshx8jgCykqVKXbToDFrEtMCCPoIwcLChA8I395J51cl7ZrdOzZS3geYwFFXZxjXDF2U+1K5Ko2Tj+e2CAQud6R6z3iIn9r2/m8U8+QW0pBdUGWfsFKLxNz5489u6JLhNZ+ivG01D56Al988QUAYPLkyXjyySfRv3//duu75EkRYwy/+MUvcOGFF+Kzzz7D2rVrMXbsWMt8RRAEQRBE+0HLZ3FefPHFdu+z1RGtc7kcxo4di912240mRN2Qssp+4E31YIVGO2Fic79sUoI0Nrd27mqK0gITulYiIK6bacm/bZqGSPYX1wYpVKLYxCCOhibIPE+a+380/qjUCWGNvhhjqX24bvppaUZgtEvSJOn9joFGXkNxi52raUoLIgkYqUDcdAruL2kg0gwZv6pjSTrVyy/oII0qOJ/UkATOy/mVbqhPkwKQUtqPdBZdenJXD6FZGtbVh1YdXyZ5DZ8JqwT0c5P0OWdpi/wmaSHym+TxhSZ5nF+w+o/p5AI/etaE/ZwSPYsWWYqOOOKIFnf45JNPtnowbWX06NH48ssvrbpZs2bh4osv7qIREQRBEETbUbHK2tpHR/C///0PV111Ff7xj3+guroaw4YNw3HHHYdf/OIXRb3A9t5771jk6dNPP73VeqD2oEWToqqqKv23EAJPPfUUqqqqsMsuuwAA3nrrLdTU1JQ0eeoorrzySpx66ql6u7KysgtHQxAEQRBtRwaYbeukqJ0G4/Dxxx8jCAL89re/xeabb44PPvgAp556Kurr63HjjTcWPfbUU0/FlVdeqbd79erVMYNsIS2aFN13333675/97Gf44Q9/aCm+fd/HGWecgb59+3bMKEugsrISQ4aQKy4A5PrJ7MFNq78CvJwUGno5IIx2rZc8EgSFaQLrJDGvubyiaG6ZxhQVFxMZJ5VyHMnu8M0JqpME02n7zXH6rsDawDpeGMtboplziWTXf1OgnbStzgk9NmEtqenTO/c0H15bWhmNyxZya2G2UwowcBXlPAAQCq/lG+BbQuhYBGzAXnIzH0VT2NqS5Qn9IBr9Gsc3rqnR+QGJCD9faL5RF1PeqzcASMcRl8TPrRRhtWqvyiCIC6p1vykfcuqZdvsicOCBB+LAAw/U25tuuinmz5+PO++8s9lJUa9evbrVd3bJQut7770Xr776quUC53kepk+fjkmTJuGGG25o1wGWynXXXYerrroKI0eOxDHHHIPzzjsPmUz6ZTY2NupUJQBQV1fXGcMkCIIgiBbTnt5n7vdcWVkZysrK2ta5Q21tLQYMGNBsu4ceegh/+MMfMGTIEBx66KG47LLLSrIW1dTU4M0338Ty5csRBPYNOv7440sed8mTokKhgI8//hhbbbWVVa/MZ13J2WefjZ133hkDBgzA66+/jksuuQRLly7FTTfdlHrMrFmzcMUVV3TiKDuf3IBhifVaxJjgdpomsG4uMKCiOYE1K1IKpAdhjMYRWYXcEinHp9WnWaPc8ZhWKhNl8TEtQOo8SjitLEiqNF36VanE3knX5IrA3XO5Auy0e1osZ5yJ6s8VYMeE2KElETBdmQ2htTkeV2Bttklyh7YGZMQFMO9/GMgv0XVanTcooGFdvbY6EJJsr/KuHkJRmlYuRm7j4XIjQbSvS+O9Z2YJI0ijLh2BtH5WfadfJJa6P7NtJ9Ge3mcjRoyw6mfMmIGZM2e2qW+Tzz77DLfffnuzVqJjjjkGo0aNwrBhw/Dee+/hZz/7GebPn99ibfKf//xnHHvssVi7di369u1rfUYyxjpnUnTiiSfi5JNPxoIFC7DbbrsBAN544w1cd911OPHEE0seQHNcfPHF+OUvf1m0zUcffYStt94a06dP13Xbb789crkcTj/9dMyaNSt1FnzJJZdYx9XV1cUeGIIgCILoSvx2EFqr4xctWmTJXdK+H0v5/lUsWbIEBx54IH7wgx9Y+t4kTjvtNP33uHHjMHToUOy7775YsGABNttss2av5/zzz8dJJ52Ea6+9tt20SEykJQ9JIQgC3Hjjjbj11luxdOlSAMDQoUNxzjnn4Pzzz291ErY0VqxYgVWrVhVts+mmmyYq3P/73/9iu+22S7RspVFXV4eqqirU1tZ2C41UR7O+oSGyBjWjKWJCIHAC+hULGAgU1w61VFMExDVEadqf1paKpHGo8wMqCUBcQwVEhgxlqwiMv9P0T0kaoZaMNRYEMqUf9xqK3TsgCmCpgk16rLlxhOcNz2ZpioCYpihR32GWptbDrHdJegOUVs7LAIzrDOlgHOAeynqT08WGhBl8s7FutXSnB2zrospinxK8MdYexjMaCzSaoH9zdHG6Xfh3XV0dNhq7e4d+X6jvpGffXoDebXQcql+zBoftvFmLx1vq9+9XX32FvffeG7vvvjvuv/9+cB633BYdX309+vTpg+eeew5Tpkxptn3v3r3x/vvvt2uKsZItRZxzXHTRRbjooov0umRHTh4GDhyIgQMHturYd999F5xzDBo0qJ1HRRAEQRCdR4C2e4+VuuBXyvfvkiVLMHnyZIwfPx733XdfyRMiQH5nA9LQ0hKmTJmCefPmde2kyKQ7WVLmzp2LN954A5MnT0ZlZSXmzp2L8847D8cdd1y7hgAnCIIgiM7GDwT8Ns6K2np8GkuWLMHee++NUaNG4cYbb8SKFSv0PuVZtmTJEuy777548MEHsdtuu2HBggV4+OGH8Z3vfAcbbbQR3nvvPZx33nnYc889sf3227fovAcffDAuvPBCfPjhhxg3bhyy2ay1/7DDDiv5WkqeFI0ZMyYW9dfk888/L3kQ7UFZWRkeffRRzJw5E42NjRgzZgzOO+88Sy9ExIllQtdCxbjQWjAWiXdTBNex/ltQuppGIC6IdiNUu8LolvSbVrrjNZeJzPMLIWSOMLhLhTLNnLLG+4YmWP8yC4/1jdKut5fA3GU83xmsElireqbuCVjs+Ng1sPgvTt3eCWlgLpW591QJsTljxjKrErs6ynsASRGni9KSpTPVJnx25TUYgmvGAcbi4QAIAED9I1ej99GXdvUwEslVbYzG+jWAn48iTbvOPGpbvb3qeQjzmels92lOAPr/xxZum9uxZV/juSyam+8bxJw5c/DZZ5/hs88+w/Dhw6196jMln89j/vz5WLduHQCZFeP555/HLbfcgvr6eowYMQJHHnkkLr205c+j0iyZcY4UjDH4vl/ytZQ8KTr33HOt7Xw+j3feeQfPPfccLrzwwpIH0F7svPPO+Ne//tVl5ycIgiCIjkK0g/dZiRLiFnPCCSfghBNOKNpm9OjR1vlHjBgRi2ZdKh3h8V7ypOicc85JrP/Nb36DefPmtXlAROcSgIEjElInCa2B4sJqK76ZshwgWUANZzvJDb5YsEZXJKxc3JsTaiuSxM5JGex9EW8v71d4Xud/UW+nmKE4A9RvlryzrxCOAULAY7bVSI1BX6tjoYqE1vLHcobL85g53lTwR3XvzHum+tHnCksPAr6Q/fgi/p6Y4QB8IZDR1iLIX9b6bnGrXy24BmwxrL5RgIDMWM4AWzSrSu4Zx6VYgMLcVCJsQ7/okxFdHEalOaJnKSIpOGPS21vUSmRaxYOC7Cco6HrBM+nOAc74OgtfxC3GremDKE6bNEUmBx10EC655BIr+jVBEARBEER7cdttt+G0005DeXk5brvttqJtzz777JL7b7dJ0RNPPNGi6JVE94ILI3S9Qcwd37AGAcmlEFGQRtfNHUW2i2Wd1+Mx9DBAspYoSUdjnTclMKJpSTFLANqK5GqKlIZIjTMt+GPaNSaFGFBWGY9F+/XxCPVKQXQ8IK1O6t3zwpNnHLd6V0tUPOQAKxrQMvG9Ce+hx1n0S9u0FjWnLdI3xa43U9HoO2FqhfSdAaIM5r4O4Ce8AEy14xkA5JLv0ufYy7t6CEWxgiWa9Y6bfKJejfHE0BDmtq4PCvFtM21NN7A0tmfwxg2Zm2++GcceeyzKy8tx8803p7ZjjHXOpGinnXaKmfarq6uxYsUK3HHHHSUPgCAIgiCI4nRn77PO5Isvvkj8u70oeVL03e9+15oUcc4xcOBA7L333lZUS4IgCIIgiI7igw8+wHbbbZe47+mnn8bhhx9ecp8lT4raMz8K0fWU9+qN9Q0NcoVDub0bAusATC+PmBnSXczcWEBc8KyWV5IE1GY7N0qz6y3hZqOPnSe2HAS95KVKud8RigcisfSFfZw6Vp1TncvMcabOay43umMw3fLVuYJAwFPLdsy+BiHk+YQQeltlsy8A8BiD7wvkPHkTPc4Q+NFyoxobgyGQDmwBNwB44XV56r0IBddJ0cTl2GxBt1xC8+QzBBju+bCX1pSoVWHm4FM3zBDDCjeKsVkiZVkkCOTd4xzwm9BUsxy5fhTIdUOirE8VGtfUxJb4YwLotEjWhmdCokDbyJeW2g+Q7BTQyWEeaPkszpQpU/Dqq69izJgxVv2f/vQnHH/88aivry+5z5LfVc/zsHz58lj9qlWr2j3FB0EQBEEQkfdZW189iVNOOQX77bcfqqurdd1jjz2G448/Hvfff3+r+ix5UpQW56CxsTEx/xjR/WGBbwVfFI4lyBRQu9nugejXhx9aB1wRrxL7uiJd00qkStOykfSsuQJr83hl+ShmJeJIDiegrlP2Y5dmDjMOeQxjciwel9dmBpdUmLfR7cMsPWZvR+L1uEUuumZhicsDEVq2AtvyZvZjitBNK5G6dj0uR8wu9zv3NuE9FJD9CmE8Q0xFtUzJIaVK9XKF1G7Jk8sk12gWFOTLly8UmtJu5zeadY9f39VDSKWxbnX0bBgZ7nUwR21B9ENzqm+I7tV2/DgloG6RtUkEgHm+LhJdK0tRW189iSuuuALf+c53sN9++2H16tV4+OGHceKJJ+LBBx/ED37wg1b12eLlM+X6xhjDPffcgz59+uh9vu/j5ZdfJk0RQRAEQRCdxu23345jjz0Wu+++O5YsWYJHHnkE3/3ud1vdX4snRcr1TQiB2bNnW0tluVwOo0ePxuzZs1s9EKLrYCJAIKL3s1i2e6VjUWWSa7cbZLGYi7erCcoHLc8YDxiWkXBbOJaSvJDWHK350ccpi0k0brOfQihH8H0n071p/QnNYtaxQoT6H/sXGWcMPmzrkUJpegJITY8QQMCg3wSlJ1IaJNPKY6X0CP/whQy+mA+ke73qx9UkBcbYPc70+ZWmSGmQXIcVdd58EGmfzKCTAgIeGMA9MD8Mthj4tqbI/WVu3ayMowtRQRvT6qW2SHgZxDKhW/1y0hUl0OsHF2H9s7eh4rDS3Zc7mrK+A6S1SD0jIkg29brZ7p3gjBrnmbOeRUAHbUzVGKVZMDuBIBAI2ug91tbjuwPPPvtsrO6II47AK6+8gqOPPhqMMd2mQ3OfKde3yZMn48knn6QkqwRBEATRSQTtoAnqAXOioh5l9957L+69914A6LzcZy+++GLJJyG6N6zQCJ7LQDCml+IB20oE2JYJta0w9T9JWiGz9J1thastUrvTrES6PSLLhxtokBs/IM3zxBLKpiR8VRYcrq5La4ciC5L2wFLXzQAdulBE3npJnmim55erKQIMDzYRteeMwQ+tMwB0/55xnGn1se6Jc+8AaSViDJbnG2DrtvR4YPdnJqZlkN5qCHVnXpiI1fylLsxf2K7VR9Un7TdLs53C8ERL7T8IAA6yFiXQHa1EChZqepiyEgGG5dEQxZnPhxmE0dSrGak8dN/GsxTTuzntEy2bRKfSEfnOTFo0KZo+fTquuuoq9O7du9ms8zfddFO7DIwgCIIgCAm55HcOLZoUvfPOO8jn8wCAt99+u6hXDEEQBEEQ7YsvhNYVtqWPnsDcuXOxatUqHHLIIbruwQcfxIwZM1BfX4/DDz8ct99+O8rKykruu0WTInPJ7J///GfJJyG6N7mqjXUAx6Tgi4AtoLayxhuCaXOJy82sDqM/0yXcXUZSy0UqaCIQuZS7wRkDpOcCM/tNQrUzgy3KftQ47WCVSiQdBCJ0y2fWeaMlvOj+RQElw1xwIso6z4xrsc4BERN3KzF3EI7LXc70w6UqvRSncrhBxO696kfBEQmr9Xusto33VB0vzxsJwNV1eMw+kcdZuJ9L8arOIYVIcK3qnSUzLXY1cZfY3P1OMEernenOrwTbRAz/gxfgbbdvVw/Dounr6uj9M/OYuQJo7ukHNTG7fZJQ2qhXz5wVWNQU96vSfPZoGa3LuPLKK7H33nvrSdH777+Pk08+GSeccAK22WYb3HDDDRg2bFirgk2X/K6edNJJWLNmTay+vr4eJ510UskDIAiCIAiiOMr7rK2vnsC7776LffeNJvCPPvooJkyYgLvvvhvTp0/Hbbfdhj/+8Y+t6rvkSdEDDzyA9evXx+rXr1+PBx98sFWDILqWpprlYGHwPy0KdtqYaR6SgiqaFgUlxgWSrUSu6NcMIGiWkfXGsUoZlgprP6Ljkh7sYvtdkbMZrNKs98JAjW5gRN0PY/o+mKEF9D5DWK375NE50q7dHCPgBGdEFLwRznF+IKTXivFh6DEGDiDLGTzOkOWyLsMZPBYXWptXGL/38XG6sIRf6K4rtOwkdKFOshKZpZm5PAgi61AY3M+yECgBrghkAEe/AAQFNK6tTR3vN5XuZiUCgFz/Icj1GwRWaIIKusicEgAQ+NF7bwZ31PudbPfO/lgwRzc4ZJLYv5ODOPpoh4jWnTrijuPrr7/G4MGD9fZLL72Egw46SG/vuuuuWLRoUav6bvGkqK6uDrW1tRBCYM2aNairq9Ovr7/+Gn/9618xaBB5dBAEQRAE0XEMHjxYhwlqamrC22+/jd13313vX7NmDbLZbKv6bvHier9+/XQ6gy233DK2nzGGK664olWDILqYoCDdyg1NjKndMa1DblDGJN2Jmx7CTSYKJGl47PYQdvBFGO7ychxh6VguFEoD5MZ185vZnxasUo5H6nTs+yOPGbNxJT5bsSY2lsjyFOmU3HNZJjaj9CHPqWxPfiDCVBpyf14I7fqvk9gaxwVBIC1dhlmHsehe6iS9kOEEfDDLsqdQ703BCIwpu4veK5U/hYfpXLzw+hhnQKgdijREHiCE1m9YGiJTU5Sa5NPUh0gtEfMLdqoP3S7ht7EIIn0KscEQsyACUWLXUPNjWSBN61CKliixPq2d+yyqvjsJ8j6L+M53voOLL74Yv/zlL/H000+jV69e+Pa3v633v/fee9hss81a1XeLJ0UvvvgihBDYZ5998Kc//QkDBgzQ+3K5HEaNGoVhw4a1ahAEQRAEQaRD3mcRV111FY444gjstdde6NOnDx544AEr9+q9996LAw44oFV9t3hStNdeewGQka1HjBgBzlu88kYQBEEQRBsIAmFpA1vbR09g4403xssvv4za2lr06dPHSjsGAI8//riVn7UUSvZNHTVqFABg3bp1WLhwIZqa7MzT22+/fasGQnQhjBtRlZXAWG4HenkmjPjsCKhNMa4SWAfW8hEzxLn20pncL1d3zMjSCjMitRlZWruiB/EI1G6/8rzxelPsnBbB21waVC7npru/Oi8E8PnKNfq+KPf8SJyt7pktqFZu6yaBXoKKRN4KFcla3zPY/cE4j9mPEnInhThQkbkt8bhxDxRu3jUzyjcLlwStiNpCufmH/cXyncmdScsezF0G0eLXIHKrB+x6QIts5T4hl85EAB0GIHyaRYDk3GhE9yXFHV+5zycKpVV797iW1ie1A8gVvxtRVVWVWG+uZJVKyZOiFStW4MQTT8Tf/va3xP2tyTVCEARBEEQ6fjtYitp6/DeBkqe85557LmpqavDGG2+goqICzz33HB544AFsscUWidlrie6PX9FPingNobX7v6MsAm4eM1cjHHebjywL6iXr7TLtuMilXLY1Ax4GkNvCcDkPrOPkGnxgvHR9+AFTMNqJsD91PjMBo+onHx6XD48tBEK6uqrxBWFbCJ1HzhcIgznaonA1FnX+vOorHIvZXgg1hqh/VRaCcDuQ58orQbZxL9Q4fIFwzOoeQJ/TvCd+YG+LsF/Vv7oHgfsei4RnAgwIgziKsAQgA+4xFpYcwsvKNl5WtwcQ/TL3nG0jKKNg3M6rZpL0y76T3amJ1tG0cjGaVi42TLvJQumYyN4s1XFpZVo79QKigJ9mnfl3J+A7/5etfRHFKdlS9I9//APPPPMMdtllF3DOMWrUKOy///7o27cvZs2ahYMPPrgjxkkQBEEQBNGhlDzNra+v1/GI+vfvjxUrVgAAxo0bh7fffrt9R0d0OI31UgujMqW7GdfdIIVan+LoZaIAhVH7tMCD5nFeqGvxuDw2CmSYoEVyrEqynTovSyzdoJImatt3+jXd9LXWCUozFfXPwv55OH6mNToMHAwel/Uek+3MII0svFZTN2RqehhsDZKql/cyqo/SnEBbp5Ku0XTFTQryKI+Pv5TlLK+tTZFFTR1n3js1zug9U1Yk45c+YFuBGJfWIutiWbortFmmpfZIIgzkGAsaSXRrZCBG9cAlPANmsEZnfyzrfUtLwLYSOVYpZfXszJQxftAe1qJOG+4GS8mfDFtttRXmz58PANhhhx3w29/+FkuWLMHs2bMxdOjQdh8gQRAEQXzToeWzzqHkae4555yDpUuXAgBmzJiBAw88EA899BByuRzuv//+9h4fQRAEQRBEp1DypOi4447Tf48fPx5ffvklPv74Y4wcORIbb7xxuw6O6Hh8ng2XO+ylKBXJ2cx2D8QjWvvCXqJyBdOm+zpgiIwRudmb9fo8KuqyGpcIM8GHDaIlr8j13MQdTxrqsHzCuhMHiyJn6/7U+W3RtLxW179eLUmGfTjqdL18F9jHCiGPExD6vVHXYi6TqW0V2ZoxQDCpdFbLeGYIAj8MqRAEoTs+wvfad/OmuUtsSogdndtjLLwnAgBDJjyPgIyMrQbs8ehZApPjAfPAwojWdqbzaJmCBYUw/kJYHxSi0j3Oi44TvuGizTggWOyiRCcLZLsb6/50I3odeUFXD6NF5DYejvyKhdCfFC2NNG3k2NPbzR1vtBPu0pkuPedZSggB30GQ91nn0OYF0V69emHnnXduj7EQBEEQBJEABW/sHFo0KZo+fXqLO7zppptaPRii83EztmvLQrjfY4ZQWdhWIlOA7AZvVEJpTwV9hB1k0WO2FcljtlXKCo6IKFAgnH7cQIWqdMcjx29bQNT1mlafaHwMAdT4bRG0aYUyLTE8tEoEiCw3yiIDwBJVqzFGlrDk9yfJ4sUR5WBT5wogwEWYx8yx8pjX5odxEyNLX5TbzTwfjGcAiKxZfhAdl2EyK5u8B/IEAWTeM98YuAoMGVgWLSatRVxajSIBdrhtDT4l0B6Q6J6PILDzqQH2GwUgV/XNtWpvKFYiTRi4UQf0BKJnQFkE3WCcrti+ueCNhuWwuHXJ+RD5BlsceyotmhS98847LeqMud84BEEQBEG0GRVLrK19EMVp0aToxRdf7OhxEF3A+oYGyzripsoAbCuRynKfpCWKXLRtLVFqFntha4rMoIzmfnk+pjVI+njnw0EHKnTc993r8oVhWQlL2V/YXltS5HUWhNTbBEHkCq+wdEDOD1MfhiZLu9A7uicRBWRUWiEe3lVP/UhN+J2h9ES+CIMqiiC8R9E5vXDbtBopLZHpwa4saR5PfgaUxUwFpgSkhsljDIVAIMNl6TGGICz9cPxqHICIQjDwyHomAG0V0ilJlBXJvHjzF7vSFrlu9a7GyC9Iy4J547TJjqOxbjXK+rY+FQDRiTAWvvfqmSmiKUrQp7VIQ8QzyA4eAwDIVy+IQkQAoUna1hKZx3YWpCnqHDovyAJBEARBEK2CJkWdAy2IEgRBEARBYAOaFF1zzTWYNGkSevXqhX79+iW2WbhwIQ4++GD06tULgwYNwoUXXohCgbJhJ7FufYO17QquAVdQzCyhtWoWiYjV8fIPzyg5jMjVYWkKqM3zysjazFhuYfo4PS5hi5aV0Nsdj4o0rfq3RMlhS45ISO1GsjbHZUaRdiNXczB4obu5eW1pqHMlEVvOczXHRqmvwQhJ4LYLRPQC7MjUUb41gSZfiqgLfpT3DYiW6HQ08fDeqf5l7rionSwFCmF/Tb7MndYU5k0rBAJ538ivJqDztOkI3oHKbi/ioleekX+rMs3VuhhBYIuwiW5NdtBowM/DikaeJLY3SRJWp+Q/U89YftkX8f6S/vHMf95O1NGqXIttfXUUo0ePBmPMel133XVFj2loaMC0adOw0UYboU+fPjjyyCOxbNmyDhtjS9hgls+amprwgx/8ABMnTsTvfve72H7f93HwwQdjyJAheP3117F06VIcf/zxyGazuPbaa7tgxARBEATRPmwIy2dXXnklTj31VL1dWVlZtP15552H//f//h8ef/xxVFVV4cwzz8QRRxyB1157rUPHWYwNZlJ0xRVXAEBq1Oy///3v+PDDD/H8889j8ODB2HHHHXHVVVfhZz/7GWbOnIlcLteJo+3++ELAM2SorsjWdbOPstBH+61tQ2CtOzRKM2ijeZzajg6z+4kCD8YF06ofJfw2zwPY7bVYWFliIPR+ZemwL4xZrvIiFEmbvwtda4/5eWPvE1YQR/O8kdjazEukhMpMW9xUKjDzWnQgSS2ADrS1JetFY42sRvKPBiMBkhnKABDIeqHgmTMtEo+sV9G9A+T4lJu/zP0mDAuhvA4toOYMHMKw/Kl2Aj6gz2t9IHEPEAyCZY1f/I5nQOADylVbCbEZj0yQfmC7cus3iyzIGxyMQ3DPfs+BdCtQEcG1lXtPeVckmW9dLxRd8siKSWgqKysxZMiQFrWtra3F7373Ozz88MPYZ599AAD33XcfttlmG/zrX//C7rvv3pFDTaXHvKtz587FuHHjMHjwYF03ZcoU1NXV4b///W/qcY2Njairq7NeBEEQBNGdUMEb2/Lq6OCN1113HTbaaCPstNNOuOGGG4rKV9566y3k83nst99+um7rrbfGyJEjMXfu3A4dZzE2GEtRc1RXV1sTIgB6u7q6OvW4WbNmaSvUN4Gm1V/B7zVA/1IHknQowtLoCEhtjwyqKJys8bZJVgVddEsVrFGdR7mAy/NF49PnEcIK3uj+UPOYTB+hgktGQSPjP+zM2BxucEZlDXK1RlpLxIqnCrGCNxrbAWw3e1UHRLoqM40JBwN4ZC3yw4wCvogCSJrX4lqJAqM+cm9n1nsqtULCuh9mKAOPMeR9+d5EoRAiixpnDHk/tGIFkOP1AY8LbdUSXLnly3uXVyEcjIifGY/pEA8CkV5MWavMLPbWL3qE7tjql72qF4Y1yAnkl2QlYiKA8Ato+roauf4t+1VLNM+6x69Hrx9c1CF9Z4dsBiB0lw+x3nMgriFSJFiRmJsCJPw/0LoiE8uELvSz19m6NN/5321tHwBiP/7LyspQVlbWpr7PPvts7LzzzhgwYABef/11XHLJJVi6dGlqQOfq6mrkcrmYRnjw4MFFv7M7mi61FF188cUxYZb7+vjjjzt0DJdccglqa2v1a9GiRR16PoIgCILoSkaMGIGqqir9mjVrVmK7Ur6jp0+fjr333hvbb789fvKTn+BXv/oVbr/9djQ2NnbmpbWZLrUUnX/++TjhhBOKttl0001b1NeQIUPw5ptvWnVKxV5sjbM9ZsgbEuvL+sMLTR9pKTIAW1MEGN5HjvRGa43CbS31UPtTtEORd1V0PAeQF5EFRR4v7AB87vldK1domVFBGl3vKWgNUqRJUm2Uh5puB6YTxfot+IFmJmCVKTHkQU1hKQMXMggRXZFqp6w46po9xtBYkBofANqiJQSQDweTD6MwuslwpcWF67uU94WlW3Lb+0IgyznyKmikD2S5PN5NTQIA+YLsS72pfl5qgjzGUJbhYEwgyyPvQxXsUYTBHn31Zgv1lAFSsiXAOIPwsmHCWLnP+HEe5ngxrT8BwDztqcb8pkhHou6wlwFTwRzDeiYCCBGgcW0tyvpUFXtbiRbSUVYik+yQzZBf/j+5EfgynUsQvbdq27UgiiTrEJBsWjb3A4gSwbbQu7GDaE+h9aJFi9C3b19dn/Yd2Jbv6AkTJqBQKOB///sfttpqq9j+IUOGoKmpCTU1NZa1aNmyZS3WJXUEXTopGjhwIAYOHNgufU2cOBHXXHMNli9fjkGDBgEA5syZg759+2Ls2LHtcg6CIAiC6Arac1LUt29fa1KURlu+o999911wzvX3scv48eORzWbxwgsv4MgjjwQAzJ8/HwsXLsTEiRNbdc72YIPRFC1cuBCrV6/GwoUL4fs+3n33XQDA5ptvjj59+uCAAw7A2LFj8eMf/xjXX389qqurcemll2LatGnfKEsQQRAEQXQmc+fOxRtvvIHJkyejsrISc+fOxXnnnYfjjjsO/fv3BwAsWbIE++67Lx588EHstttuqKqqwsknn4zp06djwIAB6Nu3L8466yxMnDixyzzPgA1oUnT55ZfjgQce0Ns77bQTAJmXbe+994bnefjLX/6Cn/70p5g4cSJ69+6NqVOn4sorr+yqIXcrmlZ/haby/vBYFPgwSZwLREtT5m8Snb1eCZqhRMJqqSqe1d4UWCcJr+XqiRRWq0xDHhCKcENrtjEGc0lPC8BDoTXCcakwA54KyogoB5gav8ISeLPI9VzvD7cTPXITgjrq+xQONiZMdtAibyZF1gjke5Dl3HCTj8eH87hcElNic/O9U9ei8AO5PJb3RUxkbaKW4vKBWjoL86kJYfWXD8L6ANZ15X35JjYWAmS9MKAlD5c/WbRSZpayXiBAmFPPk6XHmbV0Jq8jvB/ck0trcISuhqu0tbzB7QB9FkGQ7IZNdH+c99pcFjWXvsxnJLZ0phsxu3Rxl9KssvOen+4cp6isrAyPPvooZs6cicbGRowZMwbnnXcepk+frtvk83nMnz8f69at03U333wzOOc48sgj0djYiClTpuCOO+7okDG2FCYEfSqY1NXVoaqqCrW1tS0yL24oqEkREJ8UqTp3UuQi4+oII9qxKqNJke4PyZMhs12S95msF5H3ljHGpElRku4p6ican9qfNCkyk8QmUfKkyNApmZMipSkyYw9FmqdI72NqvDwuPfLMsQThJMe+tmjsWc71sX4gJzLNTYpMspzrsQJInBQlTfaUrijrMd2Huk41SfIYQ4YzmRRWe+zJCOZZTyaCda9XXR9nYdRwIaCjG5sTICGknsSs18Gd7C9PQH5JirI+KKvs1+w9IboP+eX/M7zBikQnN70YzYmN9XcLJkJmfw51dXXYeIsdOvT7Qn0n/fCuF5Gr6NOmvprWr8UfT5vc477f2pMNxlJEtJ6G9esRVAyQYlTILxh3YqEEzb5hDTIRxsQCsCdEatv0XFXCalXmjXqzf3dOrgXaQdRvmlt8UtBGM5WHqldBEuU47I70hMSZELmWEGuMhhXH4+GXtTrOEEPng0C2DeTefBCmPQknLP+/vTMPk6JI8/83Mquqm+a+hkMaEXAB74NFAUdxRWHcccBxdB0PZBZxUVTE8aew44UXiveyzoiuA+ri47U6M84h4qrosOh6DIoOoLhyqKByNT0cXVUZ7++PyIiMjMrqbuymu7p9P89TT5KZkZGRUdVF1Pt+3/fVix87VL5woRr/0tb9uoJpeyEVSGWtycloAZWzfmUWE9frfnJBYATetgDbThIJKMG16g9Ie5EwPCABpAAZlkDR8yTDVbEMQmsQWeVfPDV3GV8JspMWu3kpzYIp5fkAeTGRLbTVkKRaHGmEB0Dtx/5f85pPNMs0AOGpL60wiaP+nMSE1Ai/35LKwACFlsWkMjHOosr8JcYW4k33+ZGNYCna13mKWgOtJnkjwzAMwzBMQ2BLUSunauduVRhVxF1k+leP64ZytUNRUsR4QVizRVxL5LqZNK6mxyRvDDVFGh9hSLqnEw9SbFxJ/dlJG3XCQm0t0rodk4DQsSJF/cUtJ1G5i7jVyPfUD1T7OhttedLJE4HI/RRZlwrfp8Cx1gBa2xPt69D6pPD9uPXK6tetblFER2af1+4xZW2SSHtebA7s5JBB+JnQ49BJJ7V7j0JLEKSIzWHeWK2sArk+kJehtciMJ+6ytT8EAoCvw/f1MRGao2qzAJiHVa6XPbt3o7xNm8I3hSlNilhqtFVIW4xqLcNhud/q3LoJQPVnqYmVJ4EkeCWqKWpN8KKIYRiGYUqcvAREAxc1efYW1wm7zxiGYRiGYcCWou8EApHbxPZC2JFYrncikKo2VWC5OZLaJUWSqVpX+jjF2gVU+0rc7k+Jj53+TYX2MNzeOW5bubXAOsldZtcOU//WJ6OaXza6nQyi8HUAyMnIRZYUCZb4jEFyDTP97+h9kaYemSQlsN6Tl7H3CEAohFZ+wrQnIIOoj3jkWfTsnjVee06iMHyEwmkPOanGod2GsWzgkiKXG7TbUWW2hjWOtA8EAZAJt7a7E1rITTDfSL712Qys5xWhi1AHBvjh580XKqmD58fdZCa7scyrTNeIC7BJeOw6a0Fkt34Jod1iFBQKqEPXmamV9s16lXIdKIw6sz//xdytttCaVHZ0SBnKD5q49hm7z5oEXhQxDMMwTInDi6Kmgd1nrZi/7dptBNauINgTydd4Ivzl7elcOnEhtHDbCQEPVuV3K1+Pvh6IPmh6axcUtPft/rwwf40n4uJhLZhW1+l+4/tmvGGOHF2XLMonFImSvTC3jt7q474X5t4Jt3oe7Zfv3hDRfKc9L/ZKeh+AyKpmn3fF2FpgbeN7wrzsOY/XK7PaCyedgIheAKx6ZeF+OAhXKJ72vDC1gBpD0v3cFAMmr5LUFia1zUnVLifVKxuEteDCVAoFNfeIQKTa5MP26iWRk4Q8AVL4oFQZ4PkgPw3yUqGVCFZIdpFEfkyDWPmzH+3T/kUQ5qGSQWI+KjdnEaUy8dxVbtJF0ubkoHCr+7VzIUkJeJ6yGAmPPz+tELYUMQzDMEyJw5aipoEXRa2UKBRfWUhsbVCxsPukpIrFtEQaVzNUcL1ppzM46/IWBR0V7OokkzpDNKBDwpWFwY8KwRdkx66Plsje1z8M7a2tLdIJC3XJDE1On3c0SLGweGsAhRXuwzbWxPqegOcketQJGHOBRECRNSeyLInQsqL0USazdmiBkRQlfguMBilutYoScqr+dcmNnIyH3UdWICAXWmjSXqTv0uMKQIAPE9ZfkyelNaJ46gajDxNRB+Xh1i4joz87+jOgPrNqHL4HeOFziXDrixR8X0DISMQkgmykE/EzgOdzSH4jIpLyTTQi6e59VUZrEWbqLKL90WQ690R+d5WyGnopdS7IFZbucFM2CM/JLSKj4wAyXXoju/XL4hmx9wGcvLFpYNsfwzAMwzAM2FLEMAzDMCVPIKnBeYrYfVY3vChqpWihsi0s1tmHbfGqK4wulsFaZ7zWGKF2GLav3RsF16Mw43UStgCbKLwhoozLOhO1O16Y66J+dIZrL6wbJkVUD81kvPaVq8mHyt5sC5xt11pS1uckD0FSDTEdpq+3djZpl9gxqR5QC6N9REJqT0TvhO060+ddN2jkLlQuJb0F4i44tx6a26925dnndfoCXYPODqN3+wuIVB01XUg2QGxLAvAhkJcqHUAWQMqPwqajsHy91W5N1USnevDD9z4N1SdBhet7flgnDRlTLw0Ah+Q3Ip9c/BMM/o/fNM3NimWkDslv/AQAkOp1IFK9B8XO5TZ9Gq+Zl3C9Du3XX3pCyrA9gfzw89LEQmsiAjVwUcP13+uGF0UMwzAMU+JISQ3WBLGmqG54UdSKscWsMkx2p605OhFefYXWkQhX17giY9WRSBI6Fwqt1flQ/Iy4zJd0aH6suj2ZqvNa2KufB7CtS/ZzRuO076sF00lC6yB8uQkKdQV7jV1vTBOFq7sWoLiVSV+jhdZuMkUtoFZ96jQBHtKeMAkidaJEJXxWdcnUlmJWGk2g5zC8Tgbqnrp9ICOLkJ20MRKfxy1fLjltrQkk0r4X+2wZS54UobAbqAkCeEKgJrTM1ZgPFVDm+4APCBLISiWwt61PxoKI+GdRzUuUDiIDnQaCILUoXBBSnoDvp+GRBPlp9Q55KXi53QDaFk4es9fk92Sb7mZCwHwDOMkW9afWDc+Hc1zXSEvauuf1fipMCgkoETdVVe2Tx2OaD14UMQzDMEyJo3N0NbQPpnZ4UdQK2bV7D1I6YrVAN6L2dQg3UFjyw0brRYwFALB+sVOBtUZrclxNkYtWxljSJHU/q4EITT95rRECYuYlkfBvbe3SOh7bikRkVXi3Kr7r+VHzoqw5vmXlcSvSA1H/tgUlyZriVpTXuh6tDQqKfEeZpIcJ5m4d/m5rdrT1SFJheHza96yQfNvaEo1fX2ePOWoHY0XS2FYuvTX3t0RXRlOktUD6/qH1yJ23gAiQ2tIDBKGeCdZ7aadqMKkXyH4v4/MlrP51WDZ5qVBLxFaixmLI/N813c2KaYrCRItaM5bf+El0zioFonVGWntkW4Ps/swnp4jVKdOlV8OfpZ6QbARNEbvP6oRD8hmGYRiGYcCWIoZhGIYpeVho3TTwoqiVsWv3njDZq4AgggxrfrmV0fc2k7XJhmy5ogAgcO5Pbj+IXB76evu+cXGugBTxvoLQPaLdL67QuthzFAit9fidTNYaO7O1zlqtRc329TWOGT0XZmF2w901dl4QV1ytBdBaEK2/sGQofM4FMswoHZ9jO8wesLNt6zGF8xNOlC0yz1lfrHkAnifgSWGE12r8Uf/2mAHUKugGgLKUjyAvkfYEpBdlH3ffo7QnkMurMH01PomclcU7k1LjUPuR2xKIMpXrzNaBjNy2gQAgSYXzI+5KU/PlgYSH9hyG37IxfnGnqn1tuG40+7jbj91fXf02EXbptob0wdQOu88YhmEYhmHAlqJWxe49e+BRACD6teOBQIgqmesfzn4oxHaTNrpou4GxhIgoGWNSIIMQ2pqgxLU+QlGtTvLo3C+psruNJwAiAXik7icKz0f1w3QtLZWs0RZaFxNYa+ykjUHYTgahRUPXAAtqD4FPQluObHG1mVmjQlcP5vlaxB2F5Ot9PUcynIRCETjMvhGDW9YrbVXyQsW6lATPc+eg+ENF97NE6SJeLw1AgXVLWxJzWhDuiNNzUsIXAjX56MOU9gUkeShLeciH72GAKOzeJkrmCMCj0JIZb+SFn3VJQDYgdO9QUfQ5mRZCgtDaFkkL+5y5Jm75yX+5uui52FZ4SPU6sFGH/23g6LOmgRdFDMMwDFPisKaoaeBFUSugaudueAJIeSLyl4dbCQEls4j/Qtd/GoVlIaJf1sJpp/oLr6f4cSKVzBFFNEqBjMKo9fU62aKuwG4PzA63tn/cuNebceikj27odx1aIpNU0U7mKKOkjrrSvB0iL8PjsQGHJhFPRlYU1X/8vkkao8KyH2rmtdXFvZer9ckHkabIF0DOPJssuI/WSunJVOVICNITCEjGrD9a5+Q+A6DLmChNkkphEGqLfBEmY/SQC6J0AJ4Q2JMPjGbJnad4egGBijQQ5JTmCAB8L9JumffOSkPge0IlilQmAmUt8wgeCZOEMiuJ9QKtAeGpPxEZFGp/XL2QqzUK942VyG5fRFsk06w/+y7BiyKGYRiGKXE4T1HTwIsihmEYhil1GmFRlCgcZWLwoqgVkPFV+D1kUFDHxxMeCCrU2hYcJwmubeGzPq9daCZ8HnGhtb5Oi1ujjNmha8vykWmhNoUdJ4XTx1x5iP6AtedPF06P1Vuz6qUBhRXabYG1jV3BXuOFbpcoN4AalI8wRF5Es5NYWb4OAXaS8FqNwWrjhJG7LiO7nUkZQJHw2bPOuxmz7fHbSEnwfBG54Jwvz6S6b/pNtO+jXWk1kOHcqHpnBe5MUKJrECCkSWCPAMpTnhFix94PMxcqHYERsHthyggSyMvIAaw/s9mA3WethiSBtXPcbG23mutqSxJj29fIPDLd+uy759gLJJH6nm9gH0zt8HcEwzAMwzAM2FLUKrB/PeiaPyQ8VTE6tGBoYbItTgUiQbVrUUgSWgvLqhIlziNT50yEYfdacK3uS5CILAS22Fr3A+v+WZ3A0P1BY+3bFiLbOqT7M/XLPLcqPcWsO0B03sYVWdv9u8kc7VpegEq8aONeHzuXKLJGofUkFHG7YfRaBG2PTYe3q+SPhdaeIBRPe54w2xygkijmZaytGmMU8WJ3J0XYh67pFiab9DyBGqnqn6m0AqG1xgnj9wWQy1Ns3xy3MoKmPQ85UBimrwTa9nuXDs1qZfDVfaxPrSSCT5FlbneecFDPDgXzzbQsyE8BUkLIPADPTnIRNihiBbKtRfq8l0oWaofnU/sN2bcPsxcQNYKmiC1FdcKLIoZhGIYpcVho3TTwoqgVIGS+MOwUobWH1L76/VyoLfKNJiayBhGRE5qttnbVe1dL5G5j58OQaf0jRWgNEAq1Qa5WydU6AVFaAI+EkrWEuhwiwPMRVmovnqzRtSq5W8iwzIaU8HwRWiQ85AIZS+YYOFv13I5eRzuoE0p1FNP32G1cK00QFCaOtN9LY7XRWhzrvGkfWokAZW1K+16sfRJFNU+OLktrinKBDOcMYcJPbeUS8eextjrVgU6Q6QXqExJP7hhZ8TwBBGGpkBoEKIMPTyg9mBAEIgGySoK0y7BaoDWQ6dIbuW/Wx4651e2LJm50/y3zye1kvjC8n/lOwIsihmEYhilxpAREg5M3NtJgWjG8KGoFUOgX1xFnACJrkVCRaXorEyKn1H5cIxRIimmNTBJGigLK7OMScdV+jqJINVf3A0TaIjKWgmQtkS7d4R4vpivSGiUdlRTTxljnTaJArTnSup0AxhKh7q8tIOrCnIwKuar2ZiAKL36dW4ZDY66v5UtOW08Cq63WALnYSRZrwmfPIblvNwmj1hIltbfvDyC0QoWFXLVVKLR65WT0Hup+074arx++iWk7ks7VEjmlUAJJKCfPjDNJf6XewwDlKQ9KfOUDPiCkinizk422SfmJ88G0PMhPQeSzYRgsTMRtrQVi3eSOtqYoqSBsicFlPpqG0nvnGYZhGIZhmgG2FDEMwzBMiaPTJzW0D6Z2Woyl6NZbb8WIESNQUVGBTp06JbYRQhS8nnzyyaYdaBNTvWs3hMyH4alKcCisBGQ6XN+40ISuNh4XBkdJF0V8q5M5OskJfU9dEx0XTruwXyB2T30/AX09THshon495z7uy/fCPhF/prCwfIHrTOOeLxBGQ5+Pz4cJMfeUWD0KOffC+4bHPRHb18/si+TEjp4nTJh9QdV6/Uyi2PmEJIxEBVv35YrO7VeuDtFBQMluwWLuwVygxOK5QCIg5eLTL3U/MtsgvH9OStTkJXJSH4fZuvdLeo8lEfJhf/lAuWCzAYUJHZlWgf6cEqnvPB1sYgul7USM4XEh89H3o9uuhMPxAZiCsA19MbXTYhZF2WwWZ555Ji6++OJa282fPx8bN240r/HjxzfNABmGYRhmH6FD8hv62he89tpriUYJIQTefvvtoteNGjWqoP2UKVP2yRjrS4txn82aNQsAsGDBglrbderUCT179myCEZUOZCcg01hCayBM3ojCUhgBKUG1W2LDTraoBdgAYsJVc6swjF8dL/zlrttLolgySLsft1QHEB+P25e+xhVZR4kM4/PhCqzddvbz20Jqg4wsG/b82Fs/DNcHEFpGCpMz2oJocyx6iIJn1ckTk8p15CyrTUAUKwESf/Z4qRD3uL0FgMCjWDkS9xmBQotiUn/ZQKo5QSS0tr9x7CSSQCS0lkSQXvQeaIuZvp+0pstOkbBHJ58MRfO2lS0nJQ7r3TFxfpgWiJ+Kh9PbwmqrRAeskkf2FkBiYIrepvoc3FRP0ioYMWIENm7cGDt23XXX4b//+78xdOjQWq+dPHkybrrpJrNfUVGxT8ZYX1rMoqi+TJ06FRdeeCH69++PKVOm4Gc/+5lx6SRRU1ODmpoas79jx46mGCbDMAzD1JtSTt6YyWRixohcLoff/va3uOyyy2r9/xdQi6BSMmS0GPdZfbjpppvw9NNPY/HixTjjjDNwySWXYO7cubVeM3v2bHTs2NG8Kisrm2i0jUP7ijbGT270REDkQ9eaIlEYGu8WhgUiLY1bGNb3lGnTQ6QT0u2UxkedN9uwrd5qzY9O3+c72iDVTiDlCbNva4xsbZHvha/wPiK8v+/BlH1Ie15Mw5T24+ejshPxZJP6uZM0Q2nfQ5l1XB+zNUa2XkdbOJKO2xTTNdloTZIvomdw+9E6pmLWnKSta/FKvHcRq1AgCdm8NP9O6k+fs9MK2GgrmK0pirRHFNMWSVLapFwgo/51WL9UaRT25CV25SSqawLsygWozuaxKxegY1m6zjlmWgbZzZ+rcHwZRFoiewtEW8sqpLexUkhAQRh+qteBTfcwe0GSPvDbvAD1499+2YaBxuB3v/sdtmzZgp/97Gd1tl24cCG6deuGQw45BDNnzsSuXbsadSx7S7MuimbMmFHUD6lfq1atqnd/1113HUaOHIkjjzwS11xzDa6++mrceeedtV4zc+ZMVFVVmdeGDRsa+lgMwzAMU7JUVlbGjAGzZ89u1P4feeQRjBkzBn369Km13TnnnIP//M//xKuvvoqZM2fi8ccfx3nnndeoY9lbmtV99vOf/xwTJ06stU3//v2/df/HHHMMbr75ZtTU1KCsrCyxTVlZWdFzDMMwDFMKNKb7bMOGDejQISqOXOz/wBkzZuCOO+6otc+VK1di8ODBZv/zzz/HokWL8PTTT9c5nosuusj8+9BDD0WvXr1w0kkn4dNPP8WAAQPqvH5f0KyLou7du6N79+77rP/ly5ejc+fOrX7RI33lGtCustg5iAKBNRDWRXO26ny09cJsw3Zma525mki5vVRdsUKBtka7TYoJrTV6fMWE14FMbq/F1m7Ve1donQuiOmj2PLiZtM31YUMZhIJ0J0N1dL+wQy+exdpkd7bcPEnh4xrbrVRUiI0wg3M+ytZtC6wLhM55WeDS0scBxM4nCa4BFOwn3SeQhEzKS+xPt8+kPARKtg9Pu7z0nMuE8aQFcgEASEhSqQ7yiNISpMN06Z6vM2wDuXz8PUlLD75QLrUTBnQrmHOmheJ5hV8IQCzs3naNxT69bsZqu12qDOnufffZsBsKUSMsisLvkg4dOsQWRcX4NoaL+fPno2vXrvjRj3601+M75phjAABr1qz5bi6K9ob169dj69atWL9+PYIgwPLlywEAAwcORLt27fDCCy/gq6++wrHHHovy8nIsXrwYt912G6666qrmHTjDMAzDtED21nBBRJg/fz4mTJiAdHrvdXz6//VevXrt9bWNRYtZFF1//fV49NFHzf6RRx4JAHj11VcxatQopNNpPPDAA5g+fTqICAMHDsQ999yDyZMnN9eQmwxtSBBAPDRfePBAoDDBIVFhtXjXWqStPqqqvappZYeraxGaSbroRVXtdd00omir65/pRIvaWuQLx1oVWg48AQiK0ghAKGuQLyLrlDlOgA8R9qfSC5SlVD2zMt83ld8DIni+et60H1aUhwitXKqivP3cgVSV4208635eKOoNCEinhBH76rlVlh0Vkm8mTKpBu9XsbauRDk+364EFFE9E6aYUsLGtNACUdcYJo0+y7gCFKQbs9sXuU+y+Sf0ZK5CnU0HoaSkUZgNANpDI+J7K0aetQmFYv+fp6wk1eRV/nwsia5wO9QeAHFDwXjItGxHko2KFbnJGkoCUEJDKouSE48fqm3kpkJ8BlbVFptP3mvGJ6gfJhidf3FfRZ5pXXnkFn332GS688MKCc1988QVOOukkPPbYYxg2bBg+/fRTPPHEEzj11FPRtWtXfPDBB5g+fTqOP/54HHbYYft0nLXRYhZFCxYsqDVH0dixYzF27NimGxDDMAzDNBEtoSDsI488ghEjRsQ0RppcLofVq1eb6LJMJoOXX34Z9913H3bu3InKykqcccYZuPbaa/fpGOuixSyKmOL8LRsg5QkVdi58ZR0SwpT2AGwNUGRpsJM3aitNlFQxrrUxW8Q1RW7eQWP5sLRE6nykZUramvINWvOTkMxRkrogdgzJ95GOJcbVArnaIvsHVFKiQ53UUV/jlpuIaYZkXFOUVO0eiKrLG21NPq6TcOfUToqo9+3t/zthIADgziVrEq08Waf/JCuRa/UpZmVK0gwlaZiS+5Wx98Ydh7kfETyKTJQBEeB5yOUl0p5AjaVJktacZwOJtmkfuZQPADj/qOYzxTONS7Zqs7KICwEhLasPorB7AMpKJCXIT8WTN/oZpR36Xr/mGH6r54knnih6rl+/frFFWWVlJZYsWdIUw9oreFHEMAzDMCVOKSdvbE3woohhGIZhShwpKbnu0d72wdQKL4paAdmATE0y4QPCExAyCOv+qD8CJWiOsh17iDI6B6EbxxZa69TsHqhAaK2F0zY6fF+ft9tpgbd2adli4eh46ErTYf4QocBaGBeZ0Szb96Uo9bZurx4x7F+KRFea1t76EECga2jJAhG0vdVeNUkCacTdadFcqoGmKfq3ByUENqLuUFCd9uNbfX0xobXvh2OpI4weSK535gqhaxNaF4TTF3GpFbtfMReadrFlUl7svO4vqc6ajQ7fDwIyLrNsIJHNRy/fE8hmJDqUF6ZmYFou2e1fA2Ema7fKvRZYR3700KUWqMzWQubgH3BUcwy70SAZgLTAvAF9MLXDYRkMwzAMwzBgS1GL5/82VwNQFgXylbWlDIAn/AJrDhAJpBsitI73E7cuGVGwJXy2Q8j1/ZKSJxIVCqdzFLeAuCJrN5giKVRd30cSIZBITOJoLBDOuNR1oVDascbY97KfN7DE1XaFe30PI7QOwpQHMj5nRqRt3c5N0pi0vfW/P0601iTOh3VtQdi8YxUy1pdwq48nWYdsa4/bXzYvjdUpqX3SGH2h5j/tzDGgBNWBJOzOBsjmJar35E1fnSrSyOYldmcDPP3BlzjrsN5F54IpfWqqt6saj+ELQDy8XmNHf5gvqSBK0tiCYUtR08CLIoZhGIYpcUjKRlgUsTu5LnhR1MIRUL/a7RyBAYXV55OsJiL6pU8Eo/H5NpoinbQRiJI3uufNfcJtPIw/0ux4Ql3nQ9QraSMQ6olE3Lqk72PwCJCRNaNYEse0r5I+usktbStXpCnS8yHMvGiNkSSdxFECEMgJQgpAPpDwfQ85GWmD0o5uyQMStUWaYpoiIK79Me1r0R65ep26tEO1aYzcfmzrUzHNkJseoBh6frT1TFvM3Je2FmUDZZ3avisHANi6swa3/GBIve7FlC4itwsin4UIcrFkjTE9EZBQLyiIEjcyTD3gRRHDMAzDlDgUBKCggZaiBl7/XYAXRQzDMAxT4hA1gqaIeFFUF7woauHkQ+GwdncFRNCeiXTo3hCOC8p1YQFRZmlbaC2EqFVorY/bdc+0QNm1YhdYtUnVQNNuEXM8IZO13pduH5bQ2gi3nb95W0jt1hADIsG1roPmCrWNOJp0u/C68Hxg9QXEM1sX3IviqQlcUbctuJahwDvq17pHEReV65KqS5jttrPD812BtL2/OxvUKrROEmZraksfkNRfJuUhG74Henz2NpCEmjAUf3cuCOdFwvc8VO/JYUvVHjAtl5odWyGyu0IXWRB3nQFWHTOVwTr2JWfVR6PU3hcnZb6b8KKIYRiGYUocjj5rGnhR1AoIS0KFlejtMProl7cdnm8bQ7TlQlerj5IoiljV+CihoFDh+lZVey3MJqLiyR0RT+roIS7w1r/9bKG1HrcerxCOFUlGQmvTXxhur7f6+dKeFwq640JqLbg27YQXsyLZySUDInh+Ul200EonKRKk6+SUofg6EAJeGKKf9j21RbxavBZS62SPrtDaTuKYRWGdMVsAXVvYe7Eweleorc+7228Tjl/bdUlbPc7dWW39US9tJaoJrUQ6LF9ZjaRpl5cB/rYnj507agreL6b0yVZtBoIsvCBvLEQiTNRoW4pMvTNXaB0KrEES5KWQ6nNwEz9B48OLoqaBJfkMwzAMwzBgS1GLJyBCLnSlZ3wRhrUDeamsGsp6kVxaw9XQaGsRYGmEtOYHkXYIiKxBgfmBFh230e59U00ekZ5II6lQUxR1EO+rmK7I1QjlAkevk/C82mpkH9fXxXVC+hgScct9aE2QCtGPJ3K07xG/JtIVuUkcbe1RkmXFtc7UVrqjrtIgdn95SUh5omCbZPVJKhniaouSkjjWZkXSmiG9zdth+ETW+SB2Xo9j184ssrvzyW8aU5LU7NgKkd+jynMEKq2CsMLvEwkCJ2ljPKnjvirvUbOzGtmqLfuk7yTYUtQ08KKIYRiGYUocTt7YNPCiqIWjND7qR1IggXToEFWlNJQupVg0lBtpZaQ6tkZIa4bC874Xao0QWodC7Y6tKYoh4skcle5JOE3UDQhKU2Rbg2IRcwifB5FVyFdXR8kiU/oHY6gRCpMz6ue1C7wChdFgJrmjpS3ywuSPtlXHt7RJdqFY1T5K4pgLJDwB5CTghfqllB0FF45NF7bNQRYkcbQte36oqwq8ZO0OUJi0Uc1V8aSMxbQ+qXDfthLZ54sld3S3SZFsbgRbUntd4NW1ENnttJVIR6AFkpDPS0hJyOcksjVsKSp1slWbVWHXIA9PKg2R0Q/ZZTx0okYb/QfkLha09ii0Nu0Lytq2R/WWr/dZ/y5SBoXP+W36YGqFNUUMwzAMwzBgSxHDMAzDlDysKWoaeFHUSshJUmHwUiDtEQKoEPAAwoS9axdYsS0QT1KoXWew2gXGtUWQiOqfuaJdjZvssVi7SODtHNfXWa4+2+tHFE/i6CZzBArD823Xl+0Ss6+xxdBuO3c80nk2W1wN2FXvQwFz+JDOLSyXGsXO2wko7fvUx2VV1/kkYXZNkSSONZarrizloSYvUVZHGgC7/5q8RCrsR2/19bbw2k7OmJeE3bkgcfy6nXav1WSD0G0WgCSQ3Z0DFVPHMyVBtmozkNsTS84opOXydNxlJLyEMHy1FWH4vXG7CQ/w913Sxpqd1eoeTQQvipoGdp8xDMMwDMOALUUtlo3bd4Zi2OiYnfTQrq5g/1a2rULuVlKUjFFVm48LrYEooaAfnhCeEiinfKc6fdifEWSHgmstDE9KJqmTL9rjMOOxxNn6NkIoC5EglcTRDtNPCy9K6gjVry3AtsXLuSAerh8QIZ0SsXB+PxRsp31RYM0ygmxbcB1IY5HyPSW41sJp1bf647OtQ74QSnDthWJvaItUfIw6yWNtyRGTkjnWZ5sNrTj5IsJse5ty9m2SkjECyqqjt254f9J1xSyLtnUr5QlkAQhPgAIJkkA+F/0iHjL9d1h5748S+2Gah+y2TUCQNwkWVbSITA6/tyxBACILEWD+6JOu01al/Ocf7ZvkjbrsSFMRBCCvgZYeLghbJ7woYhiGYZgSh6jh0WdcELZueFHUQskGSkOkf6VTGH6v0eH4FJplzL513rXGAFHSRpOMUWuGKNIU1VbaI7L6IBwXFW2XVJg2Gkc8OaRLlLRR3yee+FH/29Ybxa63kjUWJFB09EX2GAJZmMrATe6oQsejBI4utt7IPa7vn5TMUR+vzZqSlNSxLuuLbXXJO9cVK+hqW5NsbY8+HnuuWjRHZVZpEfd++SLj1mH4ttYJAIK8RJCXyOcCBIFEPqeO79i0qWCumWbG1gbZekF9XGuDbOx9uwAsPJAO3dcanzCHB3kplQiSYeoJL4oYhmEYpsQhKRtuKeLkjXXCiyKGYRiGKXGoEZI3cvRZ3fCiqIXiC+W+Mgjl1vJDl5o+I0LXmeeE5Wsvhe0602iXl74PEYWZsSMXnBfdAJKAdHieQKGgWgu/hXG1AXHhtR63LcBWPYTHCbUKrwkw1eshlOA68XmcudPTRoQwg3XkInPro6ljUcZroLB/N+N15AESkJ52zSHWpqBemhBIQYXrG8E1ACkIXlg3zRdqsrTQWpNUx0xTl+Ba1yHTmabt65JcZ/ZWC6Vtd5l2ZdljShJS6+Ou4Dpp/Pb1tuvMvp/eN1rcfPSLONWmHQ646Fl89tBPEueIaVqyW79ULi1HqGzcaW6Yu+02k6EoO0kwLJyoE+Gp8P78vnGfmazbTKuCF0UMwzAMU+Io91nDFmHsPqsbXhS1UHKSkPaUBUaHm2sLiP17W1t9bGsRUCiwLhBWh7/QybGOFLteUpTQUfWH+HXkCLid56FQfGz3X2xrG3IkKCbItoXX+nwS+n52XbTAEji72MkdAxklhDTjsMXRlpDaTdCorifrmnhYfm1ia1tobVtL3L7rElYXCpej5IrF+nWr2yf1o2vCBUTwZdzqpM9HExb1q61FNVY6gJSTxBEAdmfzps6Za/UKJKnPmGUsCPISwhNIZcpQU70dfSc+jvULzi94NqbpyG7+3ArDt5Iuhm+cFlqTsCokahG1/R+6G63h5vgQApBBPNljI1JTvb1JEzcC7D5rKnhRxDAMwzAlDi+KmgZeFLVQPFPlXe2r6vOOzijWPvp3MSuR3S7qN7LuuFaign4hCpI1mt9SOi2AJ+JJHfW1AirRYmgtckuTxDBJEkNtEYURumFLncTSPl+QBkCEcyai5IyejM+dqy3yzZyH2iE/audDIB0meFTXqSf3HO2QL0SkW5JqVnVSR3jqKlXmQ8SSNXpEMPkI6/iBWlvJDa0x0thWJ126o5hGydYUxSxSdpoA/W55ybokex5talyrkGUR0zqiGksn5GqNAMD3Q2uDBIJAIl3mww/0s3bCnqotGHrDIrwza0ztE8g0OvkvV6vweG1dcRI1CjtBo7bu1Gbh0X+b7lYjgwKLVGNi9ESsKWp18KKIYRiGYUocKQMIthTtc3hRxDAMwzAlDgUSEA1cFBXLhssYeFHUQglC4bIgO/xduaQoVgUeJpweiATPkdg3PI5IoG3C3sP+JEWCYe3yCijuWjP3g24X3T923hV2W+1tobXrOrMF1HYm7Oi+ZPWTILS2O7buB8SzVBcTWidmoJaF5wM9X5KMkNq9PumcK7K2x2ILrbNBoRg6KWO03SZruZ1cl1O9MmA7Amq9nw0il1d96qqZ+4OQ8b3IPRbEXWfZfBDLlO2G3btj1+2ktFJJ+B4oRfCtb7gg3xE1uzm7cVOjXWcG1+VkudQKxMt2pmovPBcEyUJr40pLqJ/GMPWEF0UMwzAMU+Jw7bOmoWljCr8la9euxaRJk3DAAQegTZs2GDBgAG644QZks9lYuw8++ADf//73UV5ejsrKSsyZM6eZRrxv+WxztRLsIgyzN1aRcOtYaYjIvCIrhk62WChkNuH7jsDatQrZ+/oXugct+I6EzO7LbQ/otgK+9fKESkIpEF3rW6WN7JcHAQ/C3FMby/Rx+2XfD1B9euH90p4XG4NGn7fxi/z1JGiLC65Vzxpvo/fNuPQ8eFFb3xOxFwAjnLZFzfZ5t338GeJtUgn92/MQOFas2uqrBVKGImlZYL3S6Q+05Wt3No9sPjCi6l3ZADV5iV3ZIBRbS/Oy+7KtYF44XuFBheKnffi+h3SZj0xZCmVtyrBjcxX+ftZLhW8Qs08wViL1ppjjiWHytVmJABO2H+UeccLwSULIvHnZQuhg1RuN9kzqfk0vsiYZNMqLqZ0WYSlatWoVpJSYN28eBg4ciA8//BCTJ0/Gzp07cddddwEAduzYgVNOOQWjR4/Ggw8+iBUrVuCf//mf0alTJ1x00UXN/AQMwzAMw5Q6LWJRNHbsWIwdO9bs9+/fH6tXr8avfvUrsyhauHAhstksfv3rXyOTyeDggw/G8uXLcc8997S6RRFBW0iipIxAqJMRgBfqVbQ1hpBcKkNdEyVV1JYBgbjWSCdmBKIw+1i4vdNPbSSlAdAkyQOSSCrlEY2jsL/Y/e2w/b3A1RTVlrgxOlZ4vZu4MdZngv6oLoppeOzz0ZjjY6jreDSuwvB+INLyBEWy5Mbb6zZerPSIDrm375+3xpOkdcqHSRlJEkSSWQ7KaqTvKEgYI4TMZfHNhm2J1zCNR/7L1QBJkJ9RuSuEF3P9UD0SH+rwfNhbG+fvxA7xN294eJ1IpRv0PMkDbIbkjQ0VWrOlqE5ahPssiaqqKnTp0sXsL1u2DMcffzwymYw5NmbMGKxevRrbtvGXIMMwDNNyYfdZ09AiLEUua9aswdy5c42VCAA2bdqEAw44INauR48e5lznzp0T+6qpqUFNTY3Zr6qqAqDccaVKdXU1Upbmxf6xrJM4qn9H5/fGUuRSH0uRvl9SVJnbl76vOWadL4w6i+ua3H5iFwIFFpu6LEV2BFrUNxX8271fUUtReCwfyHpbinT0mXTGZO4Vns+F95F1RJ9l88mWH2npeeLP4lhirH0V+VaHpaiItkJKQuAJswUAX/+6tixFucC1FKkmuVA/JJ3x2Z9ZO1kphXOTzwWQgfo3SYIMJIJsgCCbhczuhhBU0n/frYF89d9CS1G60FJUTy2OcKPJZF5Zg7Rl0rUUyTCyUCZEpwHwGvE9z+6oBgBUV/8tHMpemp6/DUGuSNGiveuDqZ1mXRTNmDEDd9xxR61tVq5cicGDB5v9L774AmPHjsWZZ56JyZMnN3gMs2fPxqxZswqOV1ZWNrhvhmFKk46P/3NzD4FpRVRXV6Njx477pO9MJoOePXti01+fbpT+evbsGfOoMHEENckSN5lvvvkGW7ZsqbVN//79zRv45ZdfYtSoUTj22GOxYMECeF5kq5gwYQJ27NiB3/zmN+bYq6++in/4h3/A1q1b620pklJi69at6Nq1a9GSGc3Fjh07UFlZiQ0bNqBDhw7NPZwWB8/ft4fn7tvDc9cwSnn+iAjV1dXo3bt37P+jxmbPnj0F0dbflkwmg/Ly8kbpqzXSrJai7t27o3v37vVq+8UXX+DEE0/E0Ucfjfnz5xd8AIcPH45f/OIXyOVySKeVqG7x4sUYNGhQ0QURAJSVlaGsrCx2rFOnTnv3IE1Mhw4dSu7LoSXB8/ft4bn79vDcNYxSnb99ZSGyKS8v54VME9EihNZffPEFRo0ahb59++Kuu+7CN998g02bNmHTpk2mzTnnnINMJoNJkybho48+wlNPPYX7778fV155ZTOOnGEYhmGYlkKLEFovXrwYa9aswZo1a9CnT5/YOe3969ixI1566SVMnToVRx99NLp164brr7++1YXjMwzDMAyzb2gRi6KJEydi4sSJdbY77LDD8MYbjZy5tIQoKyvDDTfcUODuY+oHz9+3h+fu28Nz1zB4/pimpFmF1gzDMAzDMKVCi9AUMQzDMAzD7Gt4UcQwDMMwDANeFDEMwzAMwwDgRRHDMAzDMAwAXhS1OGpqanDEEUdACIHly5fHzn3wwQf4/ve/j/LyclRWVmLOnDnNM8gSY+3atZg0aRIOOOAAtGnTBgMGDMANN9xQkCGW5684DzzwAPr164fy8nIcc8wx+N///d/mHlLJMXv2bPz93/892rdvj+9973sYP348Vq9eHWuzZ88eTJ06FV27dkW7du1wxhln4KuvvmqmEZcut99+O4QQuOKKK8wxnjumKeBFUQvj6quvRu/evQuO79ixA6eccgr2339/vPvuu7jzzjtx44034qGHHmqGUZYWq1atgpQS8+bNw0cffYR7770XDz74IP71X//VtOH5K85TTz2FK6+8EjfccAPee+89HH744RgzZgy+/vrr5h5aSbFkyRJMnToVb775JhYvXoxcLodTTjkFO3fuNG2mT5+OF154Ac888wyWLFmCL7/8Ej/+8Y+bcdSlx9tvv4158+bhsMMOix3nuWOaBGJaDH/84x9p8ODB9NFHHxEA+stf/mLO/fKXv6TOnTtTTU2NOXbNNdfQoEGDmmGkpc+cOXPogAMOMPs8f8UZNmwYTZ061ewHQUC9e/em2bNnN+OoSp+vv/6aANCSJUuIiGj79u2UTqfpmWeeMW1WrlxJAGjZsmXNNcySorq6mg488EBavHgxnXDCCTRt2jQi4rljmg62FLUQvvrqK0yePBmPP/44KioqCs4vW7YMxx9/fKz68ZgxY7B69Wps27atKYfaIqiqqkKXLl3MPs9fMtlsFu+++y5Gjx5tjnmeh9GjR2PZsmXNOLLSp6qqCgDM5+zdd99FLpeLzeXgwYPRt29fnsuQqVOn4h//8R9jcwTw3DFNBy+KWgBEhIkTJ2LKlCkYOnRoYptNmzahR48esWN6364RxwBr1qzB3Llz8S//8i/mGM9fMps3b0YQBIlz812el7qQUuKKK67AyJEjccghhwBQn6NMJlNQcJrnUvHkk0/ivffew+zZswvO8dwxTQUvipqRGTNmQAhR62vVqlWYO3cuqqurMXPmzOYecklR3/mz+eKLLzB27FiceeaZmDx5cjONnGntTJ06FR9++CGefPLJ5h5Ki2DDhg2YNm0aFi5cyNXgmWalRdQ+a638/Oc/r7OmW//+/fHKK69g2bJlBbV/hg4dinPPPRePPvooevbsWRCJofd79uzZqOMuFeo7f5ovv/wSJ554IkaMGFEgoP4uzl996NatG3zfT5yb7/K81Mall16K3//+93j99ddjBax79uyJbDaL7du3xywePJfKPfb111/jqKOOMseCIMDrr7+Of//3f8eiRYt47pimoblFTUzdrFu3jlasWGFeixYtIgD07LPP0oYNG4goEgpns1lz3cyZM1koHPL555/TgQceSGeffTbl8/mC8zx/xRk2bBhdeumlZj8IAtpvv/1YaO0gpaSpU6dS79696eOPPy44r8XCzz77rDm2atUqFgsT0Y4dO2LfcStWrKChQ4fSeeedRytWrOC5Y5oMXhS1QD777LOC6LPt27dTjx496Pzzz6cPP/yQnnzySaqoqKB58+Y130BLhM8//5wGDhxIJ510En3++ee0ceNG89Lw/BXnySefpLKyMlqwYAH99a9/pYsuuog6depEmzZtau6hlRQXX3wxdezYkV577bXYZ2zXrl2mzZQpU6hv3770yiuv0DvvvEPDhw+n4cOHN+OoSxc7+oyI545pGnhR1AJJWhQREb3//vt03HHHUVlZGe233350++23N88AS4z58+cTgMSXDc9fcebOnUt9+/alTCZDw4YNozfffLO5h1RyFPuMzZ8/37TZvXs3XXLJJdS5c2eqqKig008/PbY4ZyLcRRHPHdMUCCKiJvfZMQzDMAzDlBgcfcYwDMMwDANeFDEMwzAMwwDgRRHDMAzDMAwAXhQxDMMwDMMA4EURwzAMwzAMAF4UMQzDMAzDAOBFEcMwDMMwDABeFDGtkFGjRuGKK65oVfedOHEixo8f36A++vXrZwrlbt++vWi7BQsWFFQjZxqPiRMnmvfhN7/5TXMPh2EYC14UMUwj8dxzz+Hmm282+/369cN9993XfANK4KabbsLGjRvRsWPH5h5Kq+e1115LXIDef//92LhxY/MMimGYWkk19wAYprXQpUuX5h5CnbRv375kqorncjmk0+nmHkaT07FjR16UMkyJwpYiptWzbds2TJgwAZ07d0ZFRQV+8IMf4JNPPjHntbto0aJFGDJkCNq1a4exY8fGfs3n83lcfvnl6NSpE7p27YprrrkGF1xwQcylZbvPRo0ahXXr1mH69OnGVQIAN954I4444ojY+O677z7069fP7AdBgCuvvNLc6+qrr4ZbjUdKidmzZ+OAAw5AmzZtcPjhh+PZZ5/9VvOzYMEC9O3bFxUVFTj99NOxZcuWgja//e1vcdRRR6G8vBz9+/fHrFmzkM/nzflVq1bhuOOOQ3l5OQ466CC8/PLLMffQ2rVrIYTAU089hRNOOAHl5eVYuHAhAOA//uM/MGTIEJSXl2Pw4MH45S9/Gbv3hg0bcNZZZ6FTp07o0qULxo0bh7Vr15rzr732GoYNG4a2bduiU6dOGDlyJNatW1evZ6/rue655x4ceuihaNu2LSorK3HJJZfgb3/7mzm/bt06nHbaaejcuTPatm2Lgw8+GH/84x+xdu1anHjiiQCAzp07QwiBiRMn1mtMDMM0H7woYlo9EydOxDvvvIPf/e53WLZsGYgIp556KnK5nGmza9cu3HXXXXj88cfx+uuvY/369bjqqqvM+TvuuAMLFy7E/PnzsXTpUuzYsaNWPchzzz2HPn36GHfV3rhL7r77bixYsAC//vWv8ec//xlbt27F888/H2sze/ZsPPbYY3jwwQfx0UcfYfr06TjvvPOwZMmS+k8MgLfeeguTJk3CpZdeiuXLl+PEE0/ELbfcEmvzxhtvYMKECZg2bRr++te/Yt68eViwYAFuvfVWAGoRN378eFRUVOCtt97CQw89hF/84heJ95sxYwamTZuGlStXYsyYMVi4cCGuv/563HrrrVi5ciVuu+02XHfddXj00UcBKGvSmDFj0L59e7zxxhtYunSpWbRms1nk83mMHz8eJ5xwAj744AMsW7YMF110kVmE1kZdzwUAnufh3/7t3/DRRx/h0UcfxSuvvIKrr77anJ86dSpqamrw+uuvY8WKFbjjjjvQrl07VFZW4r/+678AAKtXr8bGjRtx//3379V7wzBMM9C89WgZpvGxq2t//PHHBICWLl1qzm/evJnatGlDTz/9NBERzZ8/nwDQmjVrTJsHHniAevToYfZ79OhBd955p9nP5/PUt29fGjduXOJ9iYj2339/uvfee2Nju+GGG+jwww+PHbv33ntp//33N/u9evWiOXPmmP1cLkd9+vQx99qzZw9VVFTQ//zP/8T6mTRpEv30pz8tOi9J4/npT39Kp556auzYP/3TP1HHjh3N/kknnUS33XZbrM3jjz9OvXr1IiKiP/3pT5RKpWIVyxcvXkwA6Pnnnycios8++4wA0H333RfrZ8CAAfTEE0/Ejt188800fPhwc59BgwaRlNKcr6mpoTZt2tCiRYtoy5YtBIBee+21os9djLqeK4lnnnmGunbtavYPPfRQuvHGGxPbvvrqqwSAtm3blnjenh+GYUoD1hQxrZqVK1cilUrhmGOOMce6du2KQYMGYeXKleZYRUUFBgwYYPZ79eqFr7/+GgBQVVWFr776CsOGDTPnfd/H0UcfDSllo463qqoKGzdujI03lUph6NChxoW2Zs0a7Nq1CyeffHLs2mw2iyOPPHKv7rdy5UqcfvrpsWPDhw/Hiy++aPbff/99LF26NGZBCYIAe/bswa5du7B69WpUVlbGtEr2XNkMHTrU/Hvnzp349NNPMWnSJEyePNkcz+fzRnPz/vvvY82aNWjfvn2snz179uDTTz/FKaecgokTJ2LMmDE4+eSTMXr0aJx11lno1atXnc9e13NVVFTg5ZdfxuzZs7Fq1Srs2LED+Xw+dv7yyy/HxRdfjJdeegmjR4/GGWecgcMOO6zOezMMU5rwoohhgALBrxCiQMfTGHieV9Cv7carD1rT8oc//AH77bdf7FxZWVnDBljkfrNmzcKPf/zjgnPl5eV71Vfbtm1j/QLAww8/HFsEAmrRqdscffTRRn9k0717dwDA/Pnzcfnll+PFF1/EU089hWuvvRaLFy/Gscce26DnWrt2LX74wx/i4osvxq233oouXbrgz3/+MyZNmoRsNouKigpceOGFGDNmDP7whz/gpZdewuzZs3H33Xfjsssu26t5YRimNOBFEdOqGTJkCPL5PN566y2MGDECALBlyxasXr0aBx10UL366NixI3r06IG3334bxx9/PABlUXjvvfcKRNM2mUwGQRDEjnXv3h2bNm0CERndy/Lly2P36tWrF9566y1zr3w+j3fffRdHHXUUAOCggw5CWVkZ1q9fjxNOOKFez1CMIUOG4K233oode/PNN2P7Rx11FFavXo2BAwcm9jFo0CBs2LABX331FXr06AEAePvtt+u8d48ePdC7d2/83//9H84999zENkcddRSeeuopfO9730OHDh2K9nXkkUfiyCOPxMyZMzF8+HA88cQTdS6K6nqud999F1JK3H333fA8Jb98+umnC9pVVlZiypQpmDJlCmbOnImHH34Yl112GTKZDAAUfAYYhildeFHEtGoOPPBAjBs3DpMnT8a8efPQvn17zJgxA/vttx/GjRtX734uu+wyzJ49GwMHDsTgwYMxd+5cbNu2rVZBb79+/fD666/j7LPPRllZGbp164ZRo0bhm2++wZw5c/CTn/wEL774Iv70pz/F/sOfNm0abr/9dhx44IEYPHgw7rnnnlium/bt2+Oqq67C9OnTIaXEcccdh6qqKixduhQdOnTABRdcUO/nuvzyyzFy5EjcddddGDduHBYtWhRznQHA9ddfjx/+8Ifo27cvfvKTn8DzPLz//vv48MMPccstt+Dkk0/GgAEDcMEFF2DOnDmorq7GtddeCwB1Cp5nzZqFyy+/HB07dsTYsWNRU1ODd955B9u2bcOVV16Jc889F3feeSfGjRuHm266CX369MG6devw3HPP4eqrr0Yul8NDDz2EH/3oR+jduzdWr16NTz75BBMmTKjz2et6roEDByKXy2Hu3Lk47bTTsHTpUjz44IOxPq644gr84Ac/wN/93d9h27ZtePXVVzFkyBAAwP777w8hBH7/+9/j1FNPRZs2bdCuXbt6vzcMwzQDzStpYpjGxxU8b926lc4//3zq2LEjtWnThsaMGUMff/yxOT9//vyYsJiI6Pnnnyf7zyOXy9Gll15KHTp0oM6dO9M111xDZ555Jp199tlF77ts2TI67LDDqKysLNbXr371K6qsrKS2bdvShAkT6NZbb40JrXO5HE2bNo06dOhAnTp1oiuvvJImTJgQE3VLKem+++6jQYMGUTqdpu7du9OYMWNoyZIlReclSWhNRPTII49Qnz59qE2bNnTaaafRXXfdVTAfL774Io0YMYLatGlDHTp0oGHDhtFDDz1kzq9cuZJGjhxJmUyGBg8eTC+88AIBoBdffJGIIqH1X/7yl4L7L1y4kI444gjKZDLUuXNnOv744+m5554z5zdu3EgTJkygbt26UVlZGfXv358mT55MVVVVtGnTJho/fjz16tWLMpkM7b///nT99ddTEARF52Fvnuuee+6hXr16mc/NY489FhNPX3rppTRgwAAqKyuj7t270/nnn0+bN2821990003Us2dPEkLQBRdcELs3WGjNMCWHINoHwgmGaeVIKTFkyBCcddZZsSzWpUy/fv1wxRVXNEkJlKVLl+K4447DmjVrYgJ2JkIIgeeff77B5VsYhmk8OE8Rw9SDdevW4eGHH8bHH3+MFStW4OKLL8Znn32Gc845p7mHtldcc801aNeuHaqqqhq13+effx6LFy/G2rVr8fLLL+Oiiy7CyJEjeUGUwJQpU9iNxjAlCluKGKYebNiwAWeffTY+/PBDEBEOOeQQ3H777UYM3RJYt26diXTr37+/EQ83Bo899hhuueUWrF+/Ht26dcPo0aNx9913o2vXro12j73l4IMPLprZet68eUXF3fuar7/+Gjt27ACgUj/YEXkMwzQvvChiGKZVYi8CXXr06FGQ+4hhGIYXRQzDMAzDMGBNEcMwDMMwDABeFDEMwzAMwwDgRRHDMAzDMAwAXhQxDMMwDMMA4EURwzAMwzAMAF4UMQzDMAzDAOBFEcMwDMMwDABeFDEMwzAMwwAA/j+f2SUkcyR8nAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -1621,50 +427,52 @@ } ], "source": [ - "# Mean Absolute Error\n", - "target = monthly_subset[\"ts\"].where(~lsm_subset[\"lsm\"].values)\n", - "rmae = abs(target - monthly_subset[\"ts_pred\"]) / target.std(skipna=True)\n", - "rmae.plot()" - ] - }, - { - "cell_type": "markdown", - "id": "fa9467ce", - "metadata": {}, - "source": [ - "## Save the output" + "err.isel(time=0).plot()" ] }, { "cell_type": "code", - "execution_count": 16, - "id": "8367e4a7", + "execution_count": 17, + "id": "ea56d33c-fd54-4353-bd88-06990ed9641c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Save the trained model\n", - "model_save_path = Path(\"./models/spatio_temporal_model.pth\")\n", - "model_save_path.parent.mkdir(parents=True, exist_ok=True)\n", - "torch.save(model.state_dict(), model_save_path)" + "err.isel(time=1).plot()" ] }, { "cell_type": "code", - "execution_count": 17, - "id": "c2524855", + "execution_count": null, + "id": "bf3c8bea-c519-4a8f-a8a0-e25af79bac39", "metadata": {}, "outputs": [], - "source": [ - "# Save the xr.Dataset with predictions\n", - "predictions_save_path = Path(\"./predicted_data/predictions.nc\")\n", - "predictions_save_path.parent.mkdir(parents=True, exist_ok=True)\n", - "monthly_subset.to_netcdf(predictions_save_path)" - ] + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "ClimaNet", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1678,7 +486,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.0" + "version": "3.11.14" } }, "nbformat": 4, diff --git a/tests/test_dataset.py b/tests/test_dataset.py index c9cd895..76db999 100644 --- a/tests/test_dataset.py +++ b/tests/test_dataset.py @@ -61,10 +61,10 @@ def test_len_and_shapes(): assert len(dataset) == 4 sample = dataset[0] - assert sample["coords"] == (0, 0, 0) - assert sample["daily_patch"].shape == (1, 6, 2, 2) - assert sample["monthly_patch"].shape == (2, 2) - assert sample["daily_mask_patch"].shape == (1, 6, 2, 2) + assert sample["coords"] == (0, 0) + assert sample["daily_patch"].shape == (1, 1, 31, 2, 2) + assert sample["monthly_patch"].shape == (1, 2, 2) + assert sample["daily_mask_patch"].shape == (1, 1, 31, 2, 2) assert sample["daily_patch"].dtype == torch.float32 assert sample["monthly_patch"].dtype == torch.float32 assert sample["daily_mask_patch"].dtype == torch.bool @@ -98,7 +98,7 @@ def test_index_mapping_and_mask_values(): ) sample = dataset[3] - assert sample["coords"] == (0, 2, 2) + assert sample["coords"] == (2, 2) expected_mask = land_mask.isel(lat=slice(2, 4), lon=slice(2, 4)).to_numpy() assert torch.equal(sample["land_mask_patch"], torch.from_numpy(expected_mask))