From 7aead2f8ac8abe3effd7baf6da39b6d70b61f5e4 Mon Sep 17 00:00:00 2001 From: Jeff Shen Date: Mon, 7 Apr 2025 14:12:34 -0400 Subject: [PATCH 1/4] add util to move pytree to device --- aion/utils.py | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 aion/utils.py diff --git a/aion/utils.py b/aion/utils.py new file mode 100644 index 0000000..d7921cd --- /dev/null +++ b/aion/utils.py @@ -0,0 +1,10 @@ +import torch + + +def to(x, device='cuda'): + def _move(x): + if isinstance(x, torch.Tensor): + return x.to(device) + return x + + return torch.utils._pytree.tree_map(_move, x) From e6b01a6c4f09478ec753cfa1a0a6e08cb2014481 Mon Sep 17 00:00:00 2001 From: Jeff Shen Date: Mon, 7 Apr 2025 14:12:48 -0400 Subject: [PATCH 2/4] add intro notebook --- examples/getting_started.ipynb | 1625 ++++++++++++++++++++++++++++++++ 1 file changed, 1625 insertions(+) create mode 100644 examples/getting_started.ipynb diff --git a/examples/getting_started.ipynb b/examples/getting_started.ipynb new file mode 100644 index 0000000..9c82a01 --- /dev/null +++ b/examples/getting_started.ipynb @@ -0,0 +1,1625 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3c0bc240-a054-47f3-bc6c-d6caada072d8", + "metadata": {}, + "source": [ + "# An Introduction to AION\n", + "\n", + "Jeff Shen ()\n", + "\n", + "7 April 2025" + ] + }, + { + "cell_type": "markdown", + "id": "c703c9f2-c38f-4644-b606-f1471656d6dd", + "metadata": {}, + "source": [ + "
\n", + "
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "071e0751-def6-4e53-a013-f320084d0f9d", + "metadata": {}, + "source": [ + "## First, an overview. \n", + "\n", + "AION consists of _tokenizers_ and a transformer encoder-decoder processor. The tokenizers are responsible for converting pixel-level data (images, spectra, ...) into _tokens_ which are standardized in format. The transformer is then responsible for modelling all the joint and conditional distributions of these tokens. Any input tokens will go through the encoder part and end up as _embeddings_ (some useful representation of the input data), which go into the decoder along with specified output modalities, to produce output tokens. " + ] + }, + { + "cell_type": "markdown", + "id": "af318246-a71b-470d-9d14-7ccb7eb48739", + "metadata": {}, + "source": [ + "### There are a few common things that you might want to do with AION. \n", + "\n", + "Here I will demonstrate:\n", + "- model loading\n", + "- tokenization\n", + "- sampling\n", + "- embedding-based adaptation" + ] + }, + { + "cell_type": "markdown", + "id": "6d8490ef-fe9c-4dd0-92f9-8262ac210be3", + "metadata": {}, + "source": [ + "
\n", + "
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "32d32f07-716f-4095-a332-f2a8e042f597", + "metadata": {}, + "source": [ + "## Model loading" + ] + }, + { + "cell_type": "markdown", + "id": "ede15a09-b090-4079-931b-36df079b7074", + "metadata": {}, + "source": [ + "You will need to install the `AION` package from https://github.com/PolymathicAI/AION." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dec3946f-5148-4d27-a439-d96f0a6f96ee", + "metadata": {}, + "outputs": [], + "source": [ + "from aion import AION" + ] + }, + { + "cell_type": "markdown", + "id": "25e15614-85c6-4a61-885a-bf3ddaf297b9", + "metadata": {}, + "source": [ + "Let's load the pretrained model. \n", + "\n", + "__Note__: this only loads the transformer, NOT the tokenizers." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c9792b75-9cb1-49fa-b4ca-1841f65f9785", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading weights from local directory\n" + ] + } + ], + "source": [ + "model = AION.from_pretrained('/mnt/ceph/users/polymathic/aion/dec24/base')" + ] + }, + { + "cell_type": "markdown", + "id": "6e7077f6-c57a-417b-81d4-4cc474a4a8d7", + "metadata": {}, + "source": [ + "### AION transformer\n", + "\n", + "Now, we have access to the transformer model.\n", + "\n", + "There are a few parts to this: the encoder embeddings, encoder, decoder embeddings, and decoder.\n", + "\n", + "The encoder embeddings are responsible for taking the tokens from ints to vectors in a high dimensional space. The encoder processes these vectors and turns them into useful representations. From there, the decoder takes those input representations and gives you representations for the modalities you want. The decoder embeddings then turn those back into ints that you can decode back to pixel-level data. Let's look at some of these parts here." + ] + }, + { + "cell_type": "markdown", + "id": "fde12d34-d9c8-4434-afb4-26a7649ac103", + "metadata": {}, + "source": [ + "Below are all the modalities that AION understands (i.e., is pretrained with):" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6b741b09-d068-40c5-b23d-14c8bc56f57d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "odict_keys(['catalog', 'tok_a_g', 'tok_a_i', 'tok_a_r', 'tok_a_y', 'tok_a_z', 'tok_dec', 'tok_ebv', 'tok_flux_bp_gaia', 'tok_flux_g', 'tok_flux_g_gaia', 'tok_flux_i', 'tok_flux_r', 'tok_flux_rp_gaia', 'tok_flux_w1', 'tok_flux_w2', 'tok_flux_w3', 'tok_flux_w4', 'tok_flux_z', 'tok_image', 'tok_image_hsc', 'tok_mag_g', 'tok_mag_i', 'tok_mag_r', 'tok_mag_y', 'tok_mag_z', 'tok_parallax', 'tok_ra', 'tok_segmap', 'tok_shape11', 'tok_shape12', 'tok_shape22', 'tok_shape_e1', 'tok_shape_e2', 'tok_shape_r', 'tok_spectrum_desi', 'tok_spectrum_sdss', 'tok_xp_bp', 'tok_xp_rp', 'tok_z'])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.encoder_embeddings.keys()" + ] + }, + { + "cell_type": "markdown", + "id": "96968480-e4b1-46f5-aac2-7d7fe4a5cd33", + "metadata": {}, + "source": [ + "And let's take a quick look at the components of the decoder:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "93157a3d-bc8a-4cf5-955c-71ac8245a3ce", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "ModuleList(\n", + " (0-11): 12 x DecoderBlock(\n", + " (norm1): LayerNorm()\n", + " (self_attn): NormAttention(\n", + " (qkv): Linear(in_features=768, out_features=2304, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=768, out_features=768, bias=False)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (q_norm): LayerNorm()\n", + " (k_norm): LayerNorm()\n", + " )\n", + " (cross_attn): NormCrossAttention(\n", + " (q): Linear(in_features=768, out_features=768, bias=False)\n", + " (kv): Linear(in_features=768, out_features=1536, bias=False)\n", + " (attn_drop): Dropout(p=0.0, inplace=False)\n", + " (proj): Linear(in_features=768, out_features=768, bias=False)\n", + " (proj_drop): Dropout(p=0.0, inplace=False)\n", + " (q_norm): LayerNorm()\n", + " (k_norm): LayerNorm()\n", + " )\n", + " (query_norm): LayerNorm()\n", + " (context_norm): LayerNorm()\n", + " (drop_path): Identity()\n", + " (norm2): LayerNorm()\n", + " (mlp): GatedMlp(\n", + " (fc1): Linear(in_features=768, out_features=2048, bias=False)\n", + " (act): SiLU()\n", + " (fc2): Linear(in_features=2048, out_features=768, bias=False)\n", + " (fc3): Linear(in_features=768, out_features=2048, bias=False)\n", + " )\n", + " )\n", + ")" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.decoder" + ] + }, + { + "cell_type": "markdown", + "id": "7e7be0d1-5dc8-41e4-90d1-67db930c4ac1", + "metadata": {}, + "source": [ + "### Model freezing" + ] + }, + { + "cell_type": "markdown", + "id": "69d2c3c5-a04a-4fca-b04e-498ec5631eb8", + "metadata": {}, + "source": [ + "Here I will not be doing any fine tuning of the actual transformer. So I will freeze all the components. I will also put the model on GPU." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9398e0f0-bed3-4bfb-9424-355aded7e6f8", + "metadata": {}, + "outputs": [], + "source": [ + "model.freeze_encoder(freeze_embeddings=True)\n", + "model.freeze_decoder(freeze_embeddings=True)\n", + "\n", + "model = model.cuda().eval()" + ] + }, + { + "cell_type": "markdown", + "id": "bb9f33ee-7752-45af-bd9c-b40af384067f", + "metadata": {}, + "source": [ + "## Tokenizer loading\n", + "\n", + "_If you are only working at the token level, you can skip this step._\n", + "\n", + "We also need to load the tokenizers to work with raw pixel-level data. For this demo, I will use spectra, and so I will load the spectrum tokenizer. In general, you will need to load the tokenizer for each of the modalities you want to work with. \n", + "\n", + "### TODO: make tokenizer loading easier (I don't want to have to hunt for the path)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cc2a13e8-5c91-4acf-853b-665e78e591b7", + "metadata": {}, + "outputs": [], + "source": [ + "from aion.tokenizers import load_tokenizer\n", + "from aion.utils import to" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a1280b27-ffad-406b-a383-35ea66f2a339", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/home/jshen/miniconda3/envs/mmoma/lib/python3.10/site-packages/torch/package/package_importer.py:235: UserWarning: TypedStorage is deprecated. It will be removed in the future and UntypedStorage will be the only storage class. This should only matter to you if you are using storages directly. To access UntypedStorage directly, use tensor.untyped_storage() instead of tensor.storage()\n", + " dtype = storage_type.dtype\n" + ] + } + ], + "source": [ + " # for DESI spectra\n", + "tokenizer_spec = load_tokenizer(\n", + " \"/mnt/ceph/users/polymathic/MMOMA/outputs/mmoma_codec_sdss+desi/6kzi0iz9/checkpoints/last.pt\", \n", + " device='cuda'\n", + ")\n", + "\n", + "# for Gaia XP spectra\n", + "tokenizer_bp = load_tokenizer(\n", + " \"/mnt/ceph/users/polymathic/mmoma/outputs/mmoma_codec_parallax_1024/bp_coefficients_codec.pt\",\n", + " device='cpu',\n", + ")\n", + "tokenizer_rp = load_tokenizer(\n", + " \"/mnt/ceph/users/polymathic/mmoma/outputs/mmoma_codec_parallax_1024/rp_coefficients_codec.pt\",\n", + " device='cpu'\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f167d06e-76ff-4e31-953b-0ca5c57c361f", + "metadata": {}, + "source": [ + "
\n", + "
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "461376a9-3214-4d41-885b-fea872e17328", + "metadata": {}, + "source": [ + "## Tokenization\n", + "\n", + "Since AION's transformer works at the token level, we need to give it inputs it understands. Here I will show how you can turn raw (pixel-level) data to tokens." + ] + }, + { + "cell_type": "markdown", + "id": "1d5e9e00-5afe-4791-b3b9-cd3e5f906f5f", + "metadata": {}, + "source": [ + "### Data loading\n", + "\n", + "Ok, let's get some data to play with. For this example I will use low-res spectra (in the form of basis coefficients) from _Gaia_ and medium-res spectra from DESI, but it doesn't matter where you get your data from, as long as it is formatted in the right way. I will not talk about that too much here because it is different for each modality; you will need to check the specifications of the tokenizers to how they need their inputs formatted." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "acb190fb-7f9e-4e39-ae8f-807efe17baf7", + "metadata": {}, + "outputs": [], + "source": [ + "from mmoma.datasets.astropile import CrossMatchedAstroPileLoader\n", + "from mmoma.datasets.preprocessing import PadSpectra\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "7f67952f-2fa6-49e3-a0df-0f541aaeeaf0", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "baf9ea88800f4218b8b2976c7eceaa08", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Resolving data files: 0%| | 0/61 [00:00\n", + "
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "0e42c677-76bf-48db-bcc0-dc94b375f489", + "metadata": {}, + "source": [ + "## Sampling\n", + "\n", + "Here I will demonstrate __sampling__. That is, given some input modality $x$ and some desired output modality $y$, I will draw samples from the conditional distribution $p(y|x)$.\n", + "\n", + "More concretely, I will demonstrate spectrum super-resolution: given (the basis coefficients of) a low-res spectrum from _Gaia_, I will generate (samples of) the corresponding high-res spectrum from DESI. You can use the same strategy to sample from modalities that AION understands, and can even do things like cross-modal generation (e.g., from an image to a spectrum).\n", + "\n", + "We first need to initialize a sampler object" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "5e7867e6-95ba-4aca-a2b3-80844433275f", + "metadata": {}, + "outputs": [], + "source": [ + "from aion.fourm.generate import GenerationSampler, build_chained_generation_schedules, init_empty_target_modality, init_full_input_modality\n", + "from aion.fourm.modality_info import MODALITY_INFO" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "e7f5b6c0-1583-466a-b256-2bbf68b81d47", + "metadata": {}, + "outputs": [], + "source": [ + "sampler = GenerationSampler(model)" + ] + }, + { + "cell_type": "markdown", + "id": "3224f4ff-0754-401f-98a7-052c896ddc03", + "metadata": {}, + "source": [ + "Then we set up the generation by specifying the input and output modalities. The modalities that the model understands are from the `model.encoder_embeddings.keys()` from above. We also need to specify how many tokens the target modality has. Since I am generating `tok_spectrum_desi`, if we remember from above, this has 273 tokens (the sequence length)." + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "912cd242-04cb-4394-8e72-8341cc9b7293", + "metadata": {}, + "outputs": [], + "source": [ + "input_mod = ['tok_xp_bp', 'tok_xp_bp']\n", + "target_mod = ['tok_spectrum_desi']\n", + "tokens_per_target = [273]" + ] + }, + { + "cell_type": "markdown", + "id": "d001f19d-16e3-420e-b466-d56447506173", + "metadata": {}, + "source": [ + "### Setting up the inputs\n", + "We then prepare the inputs into a dictionary where each modality gets a key, and the corresponding value contains another dictionary with the actual tokens, and an input and output mask." + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "id": "73df935c-831a-49f8-b3fe-58b3afaf3d4d", + "metadata": {}, + "outputs": [], + "source": [ + "device = 'cuda' # where to run the model\n", + "\n", + "prepared_input_tokens = dict(\n", + " tok_xp_bp=tok_bp,\n", + " tok_xp_rp=tok_rp,\n", + ")\n", + "\n", + "batched_sample = {\n", + " k: dict(\n", + " tensor=v.to(device).int(),\n", + " input_mask=torch.zeros_like(v, dtype=torch.bool, device=device), # False = used as input, True = ignored\n", + " target_mask=torch.ones_like(v, dtype=torch.bool, device=device), # False = predicted as target, True = ignored\n", + " ) for k, v in prepared_input_tokens.items()\n", + "}\n", + "\n", + "# Initialize input modalities\n", + "for im in input_mod:\n", + " batched_sample = init_full_input_modality(batched_sample, MODALITY_INFO, im, device)\n", + "\n", + "for tm, ntoks in zip(target_mod, tokens_per_target):\n", + " batched_sample = init_empty_target_modality(batched_sample, MODALITY_INFO, tm, batched_sample[im]['tensor'].shape[0], ntoks, device)" + ] + }, + { + "cell_type": "markdown", + "id": "bc79354f-625e-497f-af88-81436a9d69a6", + "metadata": {}, + "source": [ + "### Setting up the sampler\n", + "\n", + "We need to set up the sampling schedule so that the sampler knows how we want to generate the output tokens." + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "id": "84551162-b07d-4015-a918-0a55e992283c", + "metadata": {}, + "outputs": [], + "source": [ + "schedule = build_chained_generation_schedules(\n", + " cond_domains=input_mod, \n", + " target_domains=target_mod, \n", + " tokens_per_target=tokens_per_target, \n", + "\n", + " # for args below, you will need one list item per target modality. here that is just 1\n", + " \n", + " autoregression_schemes=['roar'], # roar, autoregressive, maskgit\n", + " decoding_steps=[50], # how many steps to decode all the tokens\n", + " token_decoding_schedules=['linear'], # constant, linear\n", + " temps=[0.4], # sampling temperature, higher=more diversity\n", + " temp_schedules=['constant'], # constant, linear\n", + " cfg_scales=[1.0], # for classifier free guidance\n", + " cfg_schedules=['constant'],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "e1ae32b0-da04-45d8-bde2-f7acb8fb9eeb", + "metadata": {}, + "source": [ + "Now we are ready to do actual sampling! Note that the sampler will overwrite the input dictionary." + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "id": "aecb6832-faac-4d4c-a83c-c76f58b72080", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "50it [00:04, 12.44it/s]\n" + ] + } + ], + "source": [ + "batched_sample = sampler.generate(batched_sample, schedule, verbose=True, seed=0)" + ] + }, + { + "cell_type": "markdown", + "id": "e29574fb-95ba-4372-99c9-e457ca5d765d", + "metadata": {}, + "source": [ + "### Decoding and checking\n", + "\n", + "Ok, now that we have our sampled tokens, we want to see what they look like. To do this, we will decode them back to pixel-level spectra and plot them. Again, we use the tokenizer for this." + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "id": "f55b244d-1e16-4e30-89ab-309aee269f5e", + "metadata": {}, + "outputs": [], + "source": [ + "out_tok = batched_sample['tok_spectrum_desi']['tensor'] # grab the actual output tokens that we sampled\n", + "\n", + "with torch.no_grad():\n", + " out_spec = to(tokenizer_spec.decode(out_tok, ctx=dict(spectrum=to(batch['desi_spectrum'], \"cuda\"))), \"cpu\") # decode" + ] + }, + { + "cell_type": "markdown", + "id": "c1821183-65d8-4c4f-bc1d-285feb6dfffd", + "metadata": {}, + "source": [ + "Now let's compare the sampled spectra to the real spectra!" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "id": "4277d4a8-f682-4f80-8fea-d6eeb9714d91", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Flux')" + ] + }, + "execution_count": 157, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ix = 0\n", + "mask = batch['desi_spectrum']['lambda'][ix] < 99999\n", + "plt.plot(batch['desi_spectrum']['lambda'][ix][mask], batch['desi_spectrum']['flux'][ix][mask], label='Truth')\n", + "plt.plot(batch['desi_spectrum']['lambda'][ix][mask], out_spec['spectrum']['flux'][ix][mask], label='Sampled')\n", + "plt.legend(fontsize=12)\n", + "plt.xlabel(\"Wavelength (Ã…)\")\n", + "plt.ylabel(\"Flux\")" + ] + }, + { + "cell_type": "markdown", + "id": "06b2d1f5-6f6a-4748-be8b-f2e7322382a8", + "metadata": {}, + "source": [ + "Congrats, you successfully super-resolved some spectra!" + ] + }, + { + "cell_type": "markdown", + "id": "9426122e-45c4-475c-a713-30e0c0d71148", + "metadata": {}, + "source": [ + "
\n", + "
\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "31a03412-c316-471a-ad77-4616158e1f36", + "metadata": {}, + "source": [ + "## Embedding-based adaptation\n", + "\n", + "Next, I will demonstrate how you can quickly AION to perform downstream tasks based on embeddings. Here I will demonstrate parameter regression for stars.\n", + "\n", + "The idea is that AION has been pretrained on vast amounts of data and has a good general understanding of stars. So, despite not being explicitly told anything about physical parameters, if we give it some input data, at the end of the encoder (we will not be using the decoder here), we will have some useful representation (embeddings) in which \"important\" information about stars is linearly accessible. We will take advantage of this fact to build a simple projection matrix to access this information and to tie it to some physical properties." + ] + }, + { + "cell_type": "markdown", + "id": "0206e165-5ea5-4a57-b9c3-1748af9baa4c", + "metadata": {}, + "source": [ + "### Data\n", + "\n", + "Here I will be using _Gaia_ XP coefficients again as the inputs, and as outputs some stellar parameters. Let's first get the data to train on. We will use the STARHORSE catalog which provides estimates for stellar parameters for APOGEE stars. Let's download it:" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "id": "6a2d799a-1431-44bc-a65a-91a720775597", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "04/07 13:10:05 [\u001b[1;32mNOTICE\u001b[0m] Downloading 1 item(s)\n", + "\u001b[35m[\u001b[0m#cc2e5e 275MiB/275MiB\u001b[36m(99%)\u001b[0m CN:1 DL:\u001b[32m27MiB\u001b[0m\u001b[35m]\u001b[0m\u001b[0m0m\u001b[35m]\u001b[0m\u001b[0mm\n", + "04/07 13:10:17 [\u001b[1;32mNOTICE\u001b[0m] Download complete: /mnt/ceph/users/jshen/programs/AION/examples/APOGEE_DR17_EDR3_STARHORSE_v2.fits\n", + "\n", + "Download Results:\n", + "gid |stat|avg speed |path/URI\n", + "======+====+===========+=======================================================\n", + "cc2e5e|\u001b[1;32mOK\u001b[0m | 24MiB/s|/mnt/ceph/users/jshen/programs/AION/examples/APOGEE_DR17_EDR3_STARHORSE_v2.fits\n", + "\n", + "Status Legend:\n", + "(OK):download completed.\n" + ] + } + ], + "source": [ + "!wget \"https://data.sdss.org/sas/dr17/env/APOGEE_STARHORSE/APOGEE_DR17_EDR3_STARHORSE_v2.fits\"" + ] + }, + { + "cell_type": "markdown", + "id": "0672ce54-a3c0-470c-92c1-a7c081e1fc24", + "metadata": {}, + "source": [ + "Now let's load the data and extract the IDs of the stars for cross matching with Gaia and also extract the target labels we want to predict. Here that will be median estimates for Teff, logg, and [M/H]." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d9bd208e-d5f3-45e1-84a4-e4d913f160f3", + "metadata": {}, + "outputs": [], + "source": [ + "from astropy.table import Table\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "6e898d37-f4af-4644-8789-8c0daf674d45", + "metadata": {}, + "outputs": [], + "source": [ + "t = Table.read(\"APOGEE_DR17_EDR3_STARHORSE_v2.fits\")" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "b311c888-dda5-4ea8-b23b-0cc77e7e4cdc", + "metadata": {}, + "outputs": [], + "source": [ + "starhorse_ids = np.array(t['EDR3_source_id']).astype(int)\n", + "targets = np.array(t[['teff50', 'logg50', 'met50']]).view(\"#sk-container-id-2 {\n", + " /* Definition of color scheme common for light and dark mode */\n", + " --sklearn-color-text: black;\n", + " --sklearn-color-line: gray;\n", + " /* Definition of color scheme for unfitted estimators */\n", + " --sklearn-color-unfitted-level-0: #fff5e6;\n", + " --sklearn-color-unfitted-level-1: #f6e4d2;\n", + " --sklearn-color-unfitted-level-2: #ffe0b3;\n", + " --sklearn-color-unfitted-level-3: chocolate;\n", + " /* Definition of color scheme for fitted estimators */\n", + " --sklearn-color-fitted-level-0: #f0f8ff;\n", + " --sklearn-color-fitted-level-1: #d4ebff;\n", + " --sklearn-color-fitted-level-2: #b3dbfd;\n", + " --sklearn-color-fitted-level-3: cornflowerblue;\n", + "\n", + " /* Specific color for light theme */\n", + " --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n", + " --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, white)));\n", + " --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n", + " --sklearn-color-icon: #696969;\n", + "\n", + " @media (prefers-color-scheme: dark) {\n", + " /* Redefinition of color scheme for dark theme */\n", + " --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n", + " --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, #111)));\n", + " --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n", + " --sklearn-color-icon: #878787;\n", + " }\n", + "}\n", + "\n", + "#sk-container-id-2 {\n", + " color: var(--sklearn-color-text);\n", + "}\n", + "\n", + "#sk-container-id-2 pre {\n", + " padding: 0;\n", + "}\n", + "\n", + "#sk-container-id-2 input.sk-hidden--visually {\n", + " border: 0;\n", + " clip: rect(1px 1px 1px 1px);\n", + " clip: rect(1px, 1px, 1px, 1px);\n", + " height: 1px;\n", + " margin: -1px;\n", + " overflow: hidden;\n", + " padding: 0;\n", + " position: absolute;\n", + " width: 1px;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-dashed-wrapped {\n", + " border: 1px dashed var(--sklearn-color-line);\n", + " margin: 0 0.4em 0.5em 0.4em;\n", + " box-sizing: border-box;\n", + " padding-bottom: 0.4em;\n", + " background-color: var(--sklearn-color-background);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-container {\n", + " /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n", + " but bootstrap.min.css set `[hidden] { display: none !important; }`\n", + " so we also need the `!important` here to be able to override the\n", + " default hidden behavior on the sphinx rendered scikit-learn.org.\n", + " See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n", + " display: inline-block !important;\n", + " position: relative;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-text-repr-fallback {\n", + " display: none;\n", + "}\n", + "\n", + "div.sk-parallel-item,\n", + "div.sk-serial,\n", + "div.sk-item {\n", + " /* draw centered vertical line to link estimators */\n", + " background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n", + " background-size: 2px 100%;\n", + " background-repeat: no-repeat;\n", + " background-position: center center;\n", + "}\n", + "\n", + "/* Parallel-specific style estimator block */\n", + "\n", + "#sk-container-id-2 div.sk-parallel-item::after {\n", + " content: \"\";\n", + " width: 100%;\n", + " border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n", + " flex-grow: 1;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-parallel {\n", + " display: flex;\n", + " align-items: stretch;\n", + " justify-content: center;\n", + " background-color: var(--sklearn-color-background);\n", + " position: relative;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-parallel-item {\n", + " display: flex;\n", + " flex-direction: column;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-parallel-item:first-child::after {\n", + " align-self: flex-end;\n", + " width: 50%;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-parallel-item:last-child::after {\n", + " align-self: flex-start;\n", + " width: 50%;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-parallel-item:only-child::after {\n", + " width: 0;\n", + "}\n", + "\n", + "/* Serial-specific style estimator block */\n", + "\n", + "#sk-container-id-2 div.sk-serial {\n", + " display: flex;\n", + " flex-direction: column;\n", + " align-items: center;\n", + " background-color: var(--sklearn-color-background);\n", + " padding-right: 1em;\n", + " padding-left: 1em;\n", + "}\n", + "\n", + "\n", + "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n", + "clickable and can be expanded/collapsed.\n", + "- Pipeline and ColumnTransformer use this feature and define the default style\n", + "- Estimators will overwrite some part of the style using the `sk-estimator` class\n", + "*/\n", + "\n", + "/* Pipeline and ColumnTransformer style (default) */\n", + "\n", + "#sk-container-id-2 div.sk-toggleable {\n", + " /* Default theme specific background. It is overwritten whether we have a\n", + " specific estimator or a Pipeline/ColumnTransformer */\n", + " background-color: var(--sklearn-color-background);\n", + "}\n", + "\n", + "/* Toggleable label */\n", + "#sk-container-id-2 label.sk-toggleable__label {\n", + " cursor: pointer;\n", + " display: block;\n", + " width: 100%;\n", + " margin-bottom: 0;\n", + " padding: 0.5em;\n", + " box-sizing: border-box;\n", + " text-align: center;\n", + "}\n", + "\n", + "#sk-container-id-2 label.sk-toggleable__label-arrow:before {\n", + " /* Arrow on the left of the label */\n", + " content: \"â–¸\";\n", + " float: left;\n", + " margin-right: 0.25em;\n", + " color: var(--sklearn-color-icon);\n", + "}\n", + "\n", + "#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {\n", + " color: var(--sklearn-color-text);\n", + "}\n", + "\n", + "/* Toggleable content - dropdown */\n", + "\n", + "#sk-container-id-2 div.sk-toggleable__content {\n", + " max-height: 0;\n", + " max-width: 0;\n", + " overflow: hidden;\n", + " text-align: left;\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-toggleable__content.fitted {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-toggleable__content pre {\n", + " margin: 0.2em;\n", + " border-radius: 0.25em;\n", + " color: var(--sklearn-color-text);\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-toggleable__content.fitted pre {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-fitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n", + " /* Expand drop-down */\n", + " max-height: 200px;\n", + " max-width: 100%;\n", + " overflow: auto;\n", + "}\n", + "\n", + "#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n", + " content: \"â–¾\";\n", + "}\n", + "\n", + "/* Pipeline/ColumnTransformer-specific style */\n", + "\n", + "#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " color: var(--sklearn-color-text);\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "/* Estimator-specific style */\n", + "\n", + "/* Colorize estimator box */\n", + "#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-label label.sk-toggleable__label,\n", + "#sk-container-id-2 div.sk-label label {\n", + " /* The background is the default theme color */\n", + " color: var(--sklearn-color-text-on-default-background);\n", + "}\n", + "\n", + "/* On hover, darken the color of the background */\n", + "#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {\n", + " color: var(--sklearn-color-text);\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "/* Label box, darken color on hover, fitted */\n", + "#sk-container-id-2 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n", + " color: var(--sklearn-color-text);\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "/* Estimator label */\n", + "\n", + "#sk-container-id-2 div.sk-label label {\n", + " font-family: monospace;\n", + " font-weight: bold;\n", + " display: inline-block;\n", + " line-height: 1.2em;\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-label-container {\n", + " text-align: center;\n", + "}\n", + "\n", + "/* Estimator-specific */\n", + "#sk-container-id-2 div.sk-estimator {\n", + " font-family: monospace;\n", + " border: 1px dotted var(--sklearn-color-border-box);\n", + " border-radius: 0.25em;\n", + " box-sizing: border-box;\n", + " margin-bottom: 0.5em;\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-estimator.fitted {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-0);\n", + "}\n", + "\n", + "/* on hover */\n", + "#sk-container-id-2 div.sk-estimator:hover {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-2 div.sk-estimator.fitted:hover {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n", + "\n", + "/* Common style for \"i\" and \"?\" */\n", + "\n", + ".sk-estimator-doc-link,\n", + "a:link.sk-estimator-doc-link,\n", + "a:visited.sk-estimator-doc-link {\n", + " float: right;\n", + " font-size: smaller;\n", + " line-height: 1em;\n", + " font-family: monospace;\n", + " background-color: var(--sklearn-color-background);\n", + " border-radius: 1em;\n", + " height: 1em;\n", + " width: 1em;\n", + " text-decoration: none !important;\n", + " margin-left: 1ex;\n", + " /* unfitted */\n", + " border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n", + " color: var(--sklearn-color-unfitted-level-1);\n", + "}\n", + "\n", + ".sk-estimator-doc-link.fitted,\n", + "a:link.sk-estimator-doc-link.fitted,\n", + "a:visited.sk-estimator-doc-link.fitted {\n", + " /* fitted */\n", + " border: var(--sklearn-color-fitted-level-1) 1pt solid;\n", + " color: var(--sklearn-color-fitted-level-1);\n", + "}\n", + "\n", + "/* On hover */\n", + "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n", + ".sk-estimator-doc-link:hover,\n", + "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n", + ".sk-estimator-doc-link:hover {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-3);\n", + " color: var(--sklearn-color-background);\n", + " text-decoration: none;\n", + "}\n", + "\n", + "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n", + ".sk-estimator-doc-link.fitted:hover,\n", + "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n", + ".sk-estimator-doc-link.fitted:hover {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-3);\n", + " color: var(--sklearn-color-background);\n", + " text-decoration: none;\n", + "}\n", + "\n", + "/* Span, style for the box shown on hovering the info icon */\n", + ".sk-estimator-doc-link span {\n", + " display: none;\n", + " z-index: 9999;\n", + " position: relative;\n", + " font-weight: normal;\n", + " right: .2ex;\n", + " padding: .5ex;\n", + " margin: .5ex;\n", + " width: min-content;\n", + " min-width: 20ex;\n", + " max-width: 50ex;\n", + " color: var(--sklearn-color-text);\n", + " box-shadow: 2pt 2pt 4pt #999;\n", + " /* unfitted */\n", + " background: var(--sklearn-color-unfitted-level-0);\n", + " border: .5pt solid var(--sklearn-color-unfitted-level-3);\n", + "}\n", + "\n", + ".sk-estimator-doc-link.fitted span {\n", + " /* fitted */\n", + " background: var(--sklearn-color-fitted-level-0);\n", + " border: var(--sklearn-color-fitted-level-3);\n", + "}\n", + "\n", + ".sk-estimator-doc-link:hover span {\n", + " display: block;\n", + "}\n", + "\n", + "/* \"?\"-specific style due to the `` HTML tag */\n", + "\n", + "#sk-container-id-2 a.estimator_doc_link {\n", + " float: right;\n", + " font-size: 1rem;\n", + " line-height: 1em;\n", + " font-family: monospace;\n", + " background-color: var(--sklearn-color-background);\n", + " border-radius: 1rem;\n", + " height: 1rem;\n", + " width: 1rem;\n", + " text-decoration: none;\n", + " /* unfitted */\n", + " color: var(--sklearn-color-unfitted-level-1);\n", + " border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n", + "}\n", + "\n", + "#sk-container-id-2 a.estimator_doc_link.fitted {\n", + " /* fitted */\n", + " border: var(--sklearn-color-fitted-level-1) 1pt solid;\n", + " color: var(--sklearn-color-fitted-level-1);\n", + "}\n", + "\n", + "/* On hover */\n", + "#sk-container-id-2 a.estimator_doc_link:hover {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-3);\n", + " color: var(--sklearn-color-background);\n", + " text-decoration: none;\n", + "}\n", + "\n", + "#sk-container-id-2 a.estimator_doc_link.fitted:hover {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-3);\n", + "}\n", + "" + ], + "text/plain": [ + "LinearRegression(n_jobs=-1)" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "adapter.fit(train_x, train_y)" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "aa90fa13-efbe-4412-9482-ea692ca10bf6", + "metadata": {}, + "outputs": [], + "source": [ + "pred_y = adapter.predict(test_x)" + ] + }, + { + "cell_type": "markdown", + "id": "1a8b9aa6-418d-4b44-8507-53ffa68cd00b", + "metadata": {}, + "source": [ + "### Check predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "id": "3eefb63f-b411-4cea-85b9-a2f93effa6b0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n", + "\n", + "titles = ['Teff', 'log g', '[M/H]']\n", + "\n", + "for i, j in enumerate(titles):\n", + " ax[i].scatter(test_y[:,i], pred_y[:,i], s=5)\n", + " ax[i].plot(test_y[:,i], test_y[:,i], 'r--')\n", + " ax[i].set_title(j)\n", + " ax[i].set_xlabel(\"Truth\")\n", + " ax[i].set_ylabel(\"Predicted\")\n", + " if i == 0:\n", + " ax[i].set_xscale(\"log\")\n", + " ax[i].set_yscale(\"log\")" + ] + }, + { + "cell_type": "markdown", + "id": "0fb7ac6b-7ddf-402f-b4e6-c3ca85b2849a", + "metadata": {}, + "source": [ + "Congrats, you have just done embedding-based adaptation!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "mmoma", + "language": "python", + "name": "mmoma" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 9e009928862dd311cea07be2a4963f50b37ee8cc Mon Sep 17 00:00:00 2001 From: Jeff Shen Date: Mon, 7 Apr 2025 14:22:22 -0400 Subject: [PATCH 3/4] minor tweaks --- examples/getting_started.ipynb | 121 ++++++++++++++++++++------------- 1 file changed, 72 insertions(+), 49 deletions(-) diff --git a/examples/getting_started.ipynb b/examples/getting_started.ipynb index 9c82a01..66ecc2a 100644 --- a/examples/getting_started.ipynb +++ b/examples/getting_started.ipynb @@ -79,6 +79,7 @@ "metadata": {}, "outputs": [], "source": [ + "import torch\n", "from aion import AION" ] }, @@ -351,7 +352,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "baf9ea88800f4218b8b2976c7eceaa08", + "model_id": "cf6ea30a80de4590bf50434d8ee73782", "version_major": 2, "version_minor": 0 }, @@ -365,7 +366,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cea6faea066a47f6a3d69cbf015c90d1", + "model_id": "95dae3088da740faa2ae252ac560d7a2", "version_major": 2, "version_minor": 0 }, @@ -461,7 +462,7 @@ }, { "cell_type": "code", - "execution_count": 97, + "execution_count": 12, "id": "8e020987-5880-4cbb-b47a-6fa7681c80ea", "metadata": {}, "outputs": [], @@ -480,17 +481,17 @@ }, { "cell_type": "code", - "execution_count": 98, + "execution_count": 13, "id": "3c0e347d-a227-4943-88c2-7a40c351f0fd", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(torch.Size([32, 273]), torch.Size([32, 55]), torch.Size([32, 55]))" + "(torch.Size([128, 273]), torch.Size([128, 55]), torch.Size([128, 55]))" ] }, - "execution_count": 98, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -535,7 +536,7 @@ }, { "cell_type": "code", - "execution_count": 107, + "execution_count": 14, "id": "5e7867e6-95ba-4aca-a2b3-80844433275f", "metadata": {}, "outputs": [], @@ -546,7 +547,7 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 15, "id": "e7f5b6c0-1583-466a-b256-2bbf68b81d47", "metadata": {}, "outputs": [], @@ -564,7 +565,7 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 16, "id": "912cd242-04cb-4394-8e72-8341cc9b7293", "metadata": {}, "outputs": [], @@ -585,7 +586,7 @@ }, { "cell_type": "code", - "execution_count": 151, + "execution_count": 17, "id": "73df935c-831a-49f8-b3fe-58b3afaf3d4d", "metadata": {}, "outputs": [], @@ -625,7 +626,7 @@ }, { "cell_type": "code", - "execution_count": 152, + "execution_count": 18, "id": "84551162-b07d-4015-a918-0a55e992283c", "metadata": {}, "outputs": [], @@ -638,7 +639,7 @@ " # for args below, you will need one list item per target modality. here that is just 1\n", " \n", " autoregression_schemes=['roar'], # roar, autoregressive, maskgit\n", - " decoding_steps=[50], # how many steps to decode all the tokens\n", + " decoding_steps=[25], # how many steps to decode all the tokens\n", " token_decoding_schedules=['linear'], # constant, linear\n", " temps=[0.4], # sampling temperature, higher=more diversity\n", " temp_schedules=['constant'], # constant, linear\n", @@ -657,7 +658,7 @@ }, { "cell_type": "code", - "execution_count": 153, + "execution_count": 19, "id": "aecb6832-faac-4d4c-a83c-c76f58b72080", "metadata": {}, "outputs": [ @@ -665,7 +666,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "50it [00:04, 12.44it/s]\n" + "25it [00:07, 3.37it/s]\n" ] } ], @@ -685,7 +686,7 @@ }, { "cell_type": "code", - "execution_count": 154, + "execution_count": 20, "id": "f55b244d-1e16-4e30-89ab-309aee269f5e", "metadata": {}, "outputs": [], @@ -706,7 +707,7 @@ }, { "cell_type": "code", - "execution_count": 157, + "execution_count": 21, "id": "4277d4a8-f682-4f80-8fea-d6eeb9714d91", "metadata": {}, "outputs": [ @@ -716,13 +717,13 @@ "Text(0, 0.5, 'Flux')" ] }, - "execution_count": 157, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAGyCAYAAADu9GDAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACafklEQVR4nOzddXQUVxsH4N+sJ4EkSBQCwd01uITixYpDgaIFirVAkQKFtkj5aIsUSgUqSEtLgaLFneAOwQkWAoQ4SVbu98c2m93srPvmfc7hsDtzZ+buZHbm3ascY4yBEEIIIYQAAASuzgAhhBBCiDuh4IgQQgghRAsFR4QQQgghWig4IoQQQgjRQsERIYQQQogWCo4IIYQQQrRQcEQIIYQQokXk6gy4A5VKhadPn6JgwYLgOM7V2SGEEEKIGRhjSE1NRXh4OAQC+5X3UHAE4OnTp4iIiHB1NgghhBBihUePHqF48eJ22x8FRwAKFiwIQH1y/f39XZwbQgghhJgjJSUFERERmue4vVBwBGiq0vz9/Sk4IoQQQjyMvZvEUINsQgghhBAtFBwRQgghhGih4IgQQgghRAsFR4QQQgghWig4IoQQQgjRQr3VCCGEuB2lUgm5XO7qbBAXEYvFEAqFLjs+BUeEEELcBmMM8fHxSEpKcnVWiIsFBgYiNDTUJTNXUHBECCHEbeQERsHBwfD19aUpnfIhxhgyMjKQkJAAAAgLC3N6Hig4IoQQ4haUSqUmMCpSpIirs0NcyMfHBwCQkJCA4OBgp1exUYNsQgghbiGnjZGvr6+Lc0LcQc514Iq2ZxQcEUIIcStUlUYA114HFBwRQgghhGih4Ig4lUKpcnUWCCGEEKMoOCJOs2j3TVSetQd3ElJdnRVCCMlXIiMj0alTJ1dnw2NQcESc5ttDd5GtVGHxnluuzgohhDgNx3Fm/Tt06JBNx7l+/TrmzJmDBw8e2CXf+Rl15SeEEEIc6Ndff9V5/8svv2Dv3r16yytVqmTTca5fv45PP/0ULVq0QGRkpE37yu8oOCKEEEIcaMCAATrvT506hb179+otzysjI4OGNXARqlYjTucNvXTfZCvR/dvj+GbfbVdnhRDiBVq0aIGqVavi3LlzaNasGXx9fTF9+nQA6mq5OXPm6G0TGRmJwYMHAwDWrl2Lnj17AgBatmxpsKru2LFjqF+/PmQyGUqXLo1ffvnFkR/LY1HJESFW+PPcI5yPS8L5uCSMjy7n6uwQ4rUYY3gjV7o6Gzp8xEKHjMHz6tUrtG/fHn369MGAAQMQEhJi9rbNmjXDuHHjsHTpUkyfPl1TRaddVXfnzh288847GDp0KAYNGoSffvoJgwcPRp06dVClShW7fx5PRsERIVbIUtCQBIQ4wxu5EpVn7XF1NnRcn9sWvhL7Pz7j4+OxatUqjBw50uJtS5cujaZNm2Lp0qVo06YNWrRooZcmNjYWR44cQdOmTQEAvXr1QkREBNasWYPFixfbmn2vQtVqhBBCiBuQSqUYMmSIw/ZfuXJlTWAEAEFBQahQoQLu3bvnsGN6Kio5IoQQ4rZ8xEJcn9vW1dnQ4SN2zCSoxYoVg0Qicci+AaBEiRJ6ywoVKoTXr1877JieioIj4nTe0CCbEOIcHMc5pArLHeXMRG8updKytliGZrZnjFm0n/yAqtUIIYQQN1aoUCEkJSXpLMvOzsazZ890ltGEvfZDwRHJd27Gp6DXqpOIuffK1VkhhBCTypQpgyNHjugsW716tV7JkZ+fHwDoBVLEcvmjrJIQLYN/OoP4lEz0Xn0KDxZ0dHV2CCHEqGHDhmHUqFHo0aMH2rRpg0uXLmHPnj0oWrSoTrqaNWtCKBRi4cKFSE5OhlQqRatWrRAcHOyinHsuKjkibi1TroRKZd/68ITUTJv3QcXXhBBnGT58OKZOnYojR47gww8/xP3797F3715NSVGO0NBQrFq1CgkJCRg6dCj69u2L69evuyjXns2lwdGRI0fQuXNnhIeHg+M4bNmyRbNOLpdj6tSpqFatGvz8/BAeHo53330XT58+1dlHYmIi+vfvD39/fwQGBmLo0KFIS0tz8ichluBgXmCR/EaOip/sxtBlWwF5noAmIxFQmW6MePVJMp4lv7Emm0ZRA0ZCiLWWL1+udw85dOgQrl69ypteIBBgwYIFePHiBdLT07F7926UKVMGDx48wNq1a3XSDhs2DHfv3oVCoQBjTDPe0YMHD7B9+3a9fR86dMjmCW+9kUuDo/T0dNSoUQMrVqzQW5eRkYHz58/jk08+wfnz57F582bExsbi7bff1knXv39/XLt2DXv37sX27dtx5MgRjBgxwlkfgTjQkVsvUJZ7jDWvBwHfNgAALNl7CwMXrQcWlcKTr1og8uMduPw4iXf7+y/T0WnZMUTNP+DEXBNCCPF0Lm1z1L59e7Rv3553XUBAAPbu3auzbPny5ahfvz7i4uJQokQJ3LhxA7t378aZM2dQt25dAMCyZcvQoUMHLF68GOHh4Q7/DMTO4k4B2WlA2WgAQDvBGfXy1w8AAEv338YE0V5ABBRLvQwAeHv5cd62Q4aCJnvQrlZ7lJiBiMI0OSQhhHgLj2pzlJycDI7jEBgYCAA4efIkAgMDNYERAERHR0MgECAmJsbgfrKyspCSkqLzj7iJn9oCv/UA0hKQmJ4NDvrVV3LmXv0I+v1wytVZIIQQYkceExxlZmZi6tSp6Nu3L/z9/QGo56HJ2wpfJBKhcOHCiI+PN7iv+fPnIyAgQPMvIiLCoXknZlLlzlf26PFDzN52DQKe4Ehp4rLdevEJeqw8gecptje8NsejRPu3abKXjGwFpv99BUdvv3B1VgghxGN4RHAkl8vRq1cvMMawcuVKm/c3bdo0JCcna/49evTIDrkkfG49T0X8lpnAsrrwh7qh/I4rz3DwZoJeWqZSaF5P3nQJAMBx+sGRykSDbuFf7+GzZyOxfOc5W7Jukel/X3HasSyx8tBdrI+Jw8AfT7s6K4QQ4jHcPjjKCYwePnyIvXv3akqNAHW3xYQE3YesQqFAYmIiQkNDDe5TKpXC399f5x+x3ZtsJU7efQWFMrcEqMNXBxB6cRnw6jYmiv5CBS4OADBk7RlNmqdJb9Bk4QHUmZc783ZShhwAIEO23nFUxi7b2F3oJDyFSoI4XJYNRwnuOf6SzAZu7rT14xm1PiYOT5NcW4KUpVDiZVqWzrLHr923VIsQQtyVWwdHOYHR7du3sW/fPhQpUkRnfVRUFJKSknDuXG4JwYEDB6BSqdCgQQNnZzffG/HrWfT9/hSWHbijWdZfuF/zeohoD/ZIP0Zt7hY2iD8DTn4LAOi07Bgev36DzKzcQGi39GOE4hVGiXS7nobhFboJj/FnIDMZ2NBHZ9Fi8SrUEdwGNvbVLHPUGEVKO4/HZKlWiw+j7mf78Ph1hkvzQQghns6lwVFaWhouXryIixcvAgDu37+PixcvIi4uDnK5HO+88w7Onj2LdevWQalUIj4+HvHx8cjOVj9EK1WqhHbt2mH48OE4ffo0jh8/jrFjx6JPnz7UU80Fjt5+CQBYF/MQYAw4+AUmiTbppftOsgRRwuvAnmkAgMT0bPggEz9LFuikOyX7QG/b3dKpqCJ4qHn/sWg9ynBPgLM/Abf36qUvjFS9ZY4ao0iUcA24tsUh+zbHk/9Krg7fovZFhBBiC5d2+zl79ixatmypeT9p0iQAwKBBgzBnzhxs27YNgHpIdG0HDx7UDGy1bt06jB07Fq1bt4ZAIECPHj2wdOlSp+Sf8GMMwKPTwOGFCOAppPGHVlVPajx6Cw9iofh70zveOxsBnG6pyCjRdnXpkv7YZk4lgRxhG9XDD0D6l2YoAkIIIZ7HpcFRixYtjP6KN+cXfuHChbF+/Xp7ZovYQ4bhSV2F0BrZ+sc2WCiOM2+fx7+2OBtMq/H2vJ+3onTFmupqNTuWHs0RrcVg0b+5C55ecJvgiEbyJoQQy7l1myPiycx8KCeZGRhZqTiXW8X0yf13MePvq3YNGMpxj3UDI8Dsj+4oM/6+iiyF6alVCCGE8KPgiDidiFOZTmQnPpxub7dI7pld9uuf/hDzRD+hk5BvAEgGPL8GzAkAbu6weN/2CN42xDg26CSE5B8cx2HOnDl229+hQ4fAcZxbz+lGwRGxikKpQmK6fjd74L+CEzetzimENN3ean8NA37tbnF+O557DwNF+zBetFl/5bW/gZWN1K839rNov1ceJ6PuZ/vw+xnbgpuUTIXpRIQQp7py5QreeecdlCxZEjKZDMWKFUObNm2wbNkyV2eN5EHBEbHK28uPo/a8vbj/Ml1vHWMMWQrnlQ5ZQgmBVpd7BlzZBNzdD7yItWg/vtmG21Qh4bru+8OL9NM8PAm8vK23ePzGC3iVno2pf9k2qKSbxqaE5FsnTpxA3bp1cenSJQwfPhzLly/HsGHDIBAI8M0337g6eyQP95qkysvsuvIM62Li8FXvmggqKHV1duzq+jP1fHQ7Lj/F2Fbl9NYfuBkP/imFXas09wyXWRkAQAhea5ZnZCugPXVscoYcX+27hW61iqFGRKDlBwqtDsSrJ8bFwc+BouWBcm2Acz8DodWAnzup181J1tlMYeVYSYdi9UccJ4S4j88//xwBAQE4c+aMZn7QHHkHMyauRyVHDvT+uvM4ducl5u+84eqs2MfdA8DhL80qlghMdM/pNL6WfKt5HSMbq3n99orjSH98Fdg6Fnj9EJ/vvI61Jx6gy4rj+jtJeWr6QFyer9amQcCe6eqxnXICIx7Mytbcg9ec0XnvoHEuCSFWunv3LqpUqaIXGAHQmSN0zZo1aNWqFYKDgyGVSlG5cmXeabMiIyPRqVMnHDp0CHXr1oWPjw+qVaumacezefNmVKtWDTKZDHXq1MGFCxd0th88eDAKFCiAe/fuoW3btvDz80N4eDjmzp1rVrvHJ0+e4L333kNISAikUimqVKmCn376SS/d48eP0bVrV/j5+SE4OBgTJ05EVlYWzx7dC5UcOcHrDP62OR7n127q/4uWAyAGYHi06ahnvzgpU5bbIZmGcfKxOsskUED6S3sgOwV4egGxyoX8G8fFAD+9Zfogzy7qLzu3Vn/ZrX+h2vUxfhd2wp6nEhRlBSDm/HCPhSM5Qw4/qRAioQBPkt5g8qZLeK9xKURXDjF5eKpWI8S9lCxZEidPnsTVq1dRtWpVg+lWrlyJKlWq4O2334ZIJMI///yD0aNHQ6VSYcyYMTpp79y5g379+mHkyJEYMGAAFi9ejM6dO2PVqlWYPn06Ro8eDUA92XqvXr0QGxsLgSD3h5tSqUS7du3QsGFDLFq0CLt378bs2bOhUCgwd+5cg3l8/vw5GjZsCI7jMHbsWAQFBWHXrl0YOnQoUlJSMGHCBADAmzdv0Lp1a8TFxWHcuHEIDw/Hr7/+igMHDthwJp2DgiNiuaQ4AGV0l726i/2SD/GdshP+hRnBgwtVETzEUvFynWU7pdOhmcbt+VWgqIGNY2yf+FjH+p4QAOiLb9BXkrs4MnM9asz9F1XC/bFjXFPM/PsKTtx9hRN3X+HBgo72zQMh7owxQO5mU+KIfS0unv3oo4/Qvn171KxZE/Xr10fTpk3RunVrtGzZEmKxWJPu8OHD8PHx0bwfO3Ys2rVrhyVLlugFR7GxsThx4gSioqIAAJUrV0bbtm0xfPhw3Lx5EyVKlAAAFCpUCCNHjsSRI0c0AygDQGZmJtq1a6cZOHn06NHo3LkzFi5ciHHjxqFoUf4b4YwZM6BUKnHlyhXNtF6jRo1C3759MWfOHIwcORI+Pj5YvXo1bt26hT/++AM9e/YEAAwfPhw1atSw6Ny5AgVHxAo8xRI7J6OM4BkWCb53++AIgM4UJKZM//sKPn27CsRCgX51mYNde6pu22WoZ6AhHAeoVAxbLppRBUiIO5NnAF+42XRQ058CEj+LNmnTpg1OnjyJ+fPnY8+ePTh58iQWLVqEoKAg/PDDD3j77bcBQCcwSk5OhlwuR/PmzbFnzx4kJycjICBAs75y5cqawAiAZk7RVq1aaQIj7eX37t3TCY4AdfCVI6ckaMeOHdi3bx/69NGdqxJQd7j566+/0KtXLzDG8PLlS826tm3bYuPGjTh//jwaN26MnTt3IiwsDO+8844mja+vL0aMGIEpU6ZYdP6cjdocOYHX1XDw1dkoMjUvyzLzAw93VV5+U/N6fUwcNp7+r2v91b+ccvyy3GNwUGGbZAYwJwCj0r/FCOE/kOG/uvr//gaGJrtlDDj78DXvOkKIa9SrVw+bN2/G69evcfr0aUybNg2pqal45513cP26upfr8ePHER0dDT8/PwQGBiIoKAjTp08HoA6WtGkHQAA0gVNERATv8tevde8JAoEApUuX1llWvnx5AMCDBw94P8OLFy+QlJSE1atXIygoSOffkCFDAOQ2MH/48CHKli2r1/yiQoUKBs6Q+6CSI2IFngeyVonKn+wjJ+bFMb5M/hB3uTk4z9Q3ioRU5zYg3C6ZgZ+U7VFdcB8A0P7NDrQXA0W5FCCpLvB1NZwN7Y3Bz3pgx7gmvPuQK91zOAVCLCL2VZfUuBOxr+k0RkgkEtSrVw/16tVD+fLlMWTIEGzatAkDBgxA69atUbFiRSxZsgQRERGQSCTYuXMnvvrqK6hUut9poVDIu39Dy+0xwGxOHgYMGIBBgwbxpqlevbrNx3E1Co6cQMWA1Ew5CsrEphO7EGMM5+OSUC6kAPyN5ZXnC5b0Ro5Ax2XNJZoIruK8srxLji3j5Bgt2qa3vLXgPPB1NQBA3fjfkZbVBd/vikEQkvDC6/4ChEBdR2xhFZYnqVu3LgDg2bNn+Oeff5CVlYVt27bplAodPHjQIcdWqVS4d++eprQIAG7dugVA3RuOT1BQEAoWLAilUonoaONzSJYsWRJXr6qnbNIuPYqNtWxcOVegajUnOHLrBarN+Rf3XqS5OitG7bwSjx4rT6DDN0dNpNQPjgKf802j4dmEeac5ubXHNRnRUkagO/2JEEp8dqcbzshGY6poA6py9zTr8l5vNAktIa5z8OBB3u/gzp07AairmnJKfLTTJScnY82aNQ7L1/LluZ1TGGNYvnw5xGIxWrduzZteKBSiR48e+Ouvv3D16lW99S9e5M5n2aFDBzx9+hR//vmnZllGRgZWr15tx0/gGFRy5ES/n32Eae0ruTobBu24oi66fvz6jfGE+eQhK0LuFByMAVjfy3WZMWCEMHfutvdF/+B90T8olfkbAGDudt2Rum88S0XlcH+n5o8QovbBBx8gIyMD3bp1Q8WKFZGdnY0TJ07g999/R2RkJIYMGYLnz59DIpGgc+fOGDlyJNLS0vD9998jODgYz57ZZ15IbTKZDLt378agQYPQoEED7Nq1Czt27MD06dMRFBRkcLsFCxbg4MGDaNCgAYYPH47KlSsjMTER58+fx759+5CYmAgAmpHA3333XZw7dw5hYWH49ddf4etrW7WkM1DJEbHcm9cYKfwHoXjl1YMNiqEEwOAP9y3xmyreqLesLPcUD16lQ67UDWLfyJXOyhav83GvcflxkkvzQIirLF68GC1btsTOnTsxadIkTJo0CadPn8bo0aMRExODwMBAVKhQAX/++Sc4jsNHH32EVatWYcSIERg/frxD8iQUCrF7927Ex8dj8uTJOHPmDGbPno158+YZ3S4kJASnT5/GkCFDsHnzZowdOxbffPMNEhMTsXBh7hhxvr6+2L9/P9566y0sW7YMn332GZo0aYJFi3imVHIzVHLk5cauPw8GYEW/2vbb6cnlmCYGBgj34R/stt9+3cwI0Q5UF9xDQ8EN/JHyrekN3IQAKhy9cB0HJXOwWdkUy5TdXZ0lpGbK0f3bEwCAO5+3h0hIv8tI/tKuXTu0a9fOZLrOnTujc+fOestzeoLlMNSbjK/qLjIy0mC1eunSpbFnj/EmA3zbBgcHY/ny5TrVcnxKlCiBrVu3mrVPd0J3KGdy8rXwOj0b2y8/w47Lz5CYno0shX1LDiIEL0wn8nANBeqpXxo80h8W313tkX6MqaINKCV4jg/Ff2qtMX4BKlXM4A3r8esMzN56FQ9f6U80bI6kDLnmtbXzxxFCiLNQcOTFVFoPuouPXqPCzN2Yv8u+87xx4PJFl/FsuWdNAdNTdETzuq9wPwCgx8qT2HrxCW/6bIUKzb88iP4/xPCuf2/tGfx88iH6rLa94b2b/2AkhBAKjpzKhe1zftx+GDsl0/Di6Fre9T8cvYedV+Kt2rehgQi9Sbk3l12dBavNF/+IVoLzAIDxGy9i+2X9MWMuxL3G49dvcOLuK53ljDFsufAEt56r2109S87U25YQQrwNBUdOZLIXmB2lZylw6l6i5v0Hmd+hsuAhlkhW8ab/bId1JUolXx4xnchB4lSGe1MQXT9JFqOT4CQAYOz6C3rrDYW3e67FY8LvF03u//bzVHz812U8fu1mc2ARQnitXbsWaWnu29nE1Sg4cqIdl+3fFZOPUsVQZfYejFl/XrPMl/EHZhfiXmPW1quoz93AVNEGSCDnTWdIh6sTbMmqTZR0+VpkuWSZ3rL0LAUO33phsGr00uNk3uV5dV1xHBvPPMKIX86ZTMu8b0IdQoiXod5qXmjfjed6y5iBOr1u//UgeiBTd918zQpgtVK/p4QxrurOr6LgyGKluae4x3In8Rz12zkcvf0S1YoF6KW99yINa48/MGu/6dnqxv7Xn6XwrvfmIR8IId6Hni5eKDVTob9Q++l0/lcg8T7vtpGcfmDlrig4stwB6UcYLdyieX/0tnpG7StP9EuIWv3vsFljI6Vm5pY2UhBE7MHdu3kT53DldUBPl3xCp+Ro21hgaU277ZuzQ0vz0yrLZ2lWubKFuwebIv7DYHAMAF/tvWXR/u4kWNZugZ57xBCxWD2nY0YGtV0juddBznXhTFStlk/wPY/OPEjkWWrNzm1/2g3NnowrsmEWbSOny9d6cSeR+eIOugmO4ivJSuxS1sP78okAgG/238bENoYn3P1m3228U7c4rj9NQdngAmYdjqMiJWIGoVCIwMBAJCQkAFCPsEzXTv7DGENGRgYSEhIQGBiomXPOmejpkk/w3V56rjqJokiGFLaN4cNg+zhHqbB8rh0Kjmyw5X3IAHwlUb9tLzwDc9vif7XvFr7al1u69PfoRprX5jzGqOCIGBMaGgoAmgCJ5F+BgYGa68HZ6OniYslv5PCXiVz26+is7H2D656nZCK4oNR03phrBoF8wEJQC3dccmxPc0cVjrIC/fGNtD2Q9QMAdMr6DMgyv6rMlmuXMYYbz1JRsogv/KR0OyLq6yksLAzBwcGQyy3rPUu8h1gsdkmJUQ66G7nQsdsvMeDHGPSpF4EFPao79Fh8vdWaCS4ZTL/14hOM33gRALD/w+YoE2Sk+kTF0wDcQc6ryqK2QB0QbVS0wnpFa2ySznXa8d3VNVVJVBE8NLj+tKqCyeAox3bpTODLzwCYN2XKrfhUk2m0r76v9t5CdKUQRJUpgv03EjDsl7MoXdQPBz5qYdbxSP4gFApd+nAk+Rs1yHahnKqJjWceOeFo+sHRL5KFPOnUvtwTq3k9+rfzBtMBgHh1M+uzZaGR2RM1r8+zcjjDKuJT+UCnHd9drVW2Nbq+n+igZTtUZKK38CBWir9CBS4OYihQgYsDX6XYlL9yRw83Z7D0H4/dR9/v1dOQbL2kDtjuvbRuzjZCCHEEKjnyQnzdHw2Nc2SOF2lZRtcLEp1XtfUChbBA3geZkGjaHK1Rtsds8a9Oy4M7UjH7/85ZKP4ewH/tkbREZq632zGoyzYhxB1RyZGbuPokGR2XHsWRW46Z6T4ty3lVX462Svk21irbuTobbsVUiBGjqmi3Y70r3GN0/eojd5H8xnRbEVU+mJOPEOKZKDhyE8N+PotrT1Pw7k+nbd4XXwNZc0uOygieQmCH3mfEeluUjUwnykPAGQ40nrAi+EPRwoYc6Zor/hm7JVMRCP62Rl/svImha3VLm/jabNeatxfbnTSlDiGEWIKCIzeRkmm/Xhk5VRVDhTvQU3gIANBcaN6s8g0EN3FcOg4AEMk9gz8c3xbk0X8TyP6jbOjwY3mCncoGFm/DGSg7ap31JVpmLbE1S3oqCh5hk2QuuDyBdM71cvbha5P7yFu69L9/Y5GcQb2TCCGuR8GRmxAJ7NuVvyiS8Yl4Hb4Ur0YYXlm0bRiXiO6KnTgk/RDnpKMcPg71W9nqhuEfyMfhoSrYYLoXTH/+r/xsq1J7fCH+4Og1K4hsiMEZKVmyVjnBE9yXDUBBqEexHS3cisuy4egkOAl/pIPFX7Fof8sO3MHMrVftnk9CCLEUBUduQiS0759ChNw2RnPEP1u8/Si5uoGzmDM9t5at3kCmec1X/bdI3gsz5O+hc9ZnDs+LK9xUReAZK6x5b24V6DR57ojihrZI/+/cGgqe7GGcaDMKIgNTxL8DAJZLluGodDy4VU2AuJj/jm/eZ7oQZ7rEiRBCHI2CIzdhr9KZI7deYPKfl3UmZS3M8c+U7g6uqCJ13vM9xDMhxTplNOJRxEm5cq5jqqromz3D4u3MmVsuCxJrsmSRcO6l3tQvAdx/c2PF7gQA+J1agtkiy4N0c6VmyvE8JdNh+yeE5C/Uld9N2Ot3fU6Dbu39Ca1oYK1deuHIPkUvqaoMgHVDLWhvY6pkyJElRx2FxjoRMEApR8GTCzFEBEigwP8UPZEIf7vmofqn/4Ix4OzMaBQtILXrvgkh+Q+VHLmQI9vyaO87Z0RpS/jhjf0yY8TvypY67x35EHdnusGo6SsjifnplA5yYPhXWUcnTQaTaq13DdW1rcC8opr3/UX7cUg6EQVg31nXc4ZL6vbtcbvulxCSP1Fw5GTZitxSHEeGAfYMMhzxYD2jKo8p8uHYrarn8GO5O5bnr/WIBZm1nUqn5Aj4QtFP836G/D00zfraPhm0gSDpgd4yf+4NrsqGge8bwBigVDGceZCITLlSaznDxUdJJnuzPUp8g0eJ9g28CCH5DwVHTvb90Xu8y+0dFJQxcx4tV5kpfw9/KFvCXp/8pirCLvtxBQ5Mp7QomfmZtY3KSLXan8pmeIUAg+sNmSwfYVY6e+gq4C/lWXHwDnquOonR684jISUTH/91Gd8euouuK46j1f8OmdyvXEnjdBFCbEPBkZMdv/NS89oRpST+SMfbguNYL/nCbvsswewfaBn67NZ2OX8DT29nYlm1GgfjbY7y7sPc4GiTsoXesk/kg83a1lJfS75FJ8FJnWUcB6w5fh8AcOBmAup/sR8bzzzSzPX3Kj3bIXkhhBBtFBx5mVXir7BUssKu+/xbNQ5QuPdDKe9ghJ4kbyBjfuNs3XRKI19nc/Y4X96Xd3m81jAD9rZcsgwAMFy4HbskHyNcFY/XNBAkIcTFXBocHTlyBJ07d0Z4eDg4jsOWLVt01jPGMGvWLISFhcHHxwfR0dG4ffu2TprExET0798f/v7+CAwMxNChQ5GWlubET+EYjDEorKgeaCS87oDcADg03+pN1ytamk5kI09vq2TO/KsHlDWNrn/EgrFTWR+bFM2QDbHOOlMlR32zZ+A7ZWcAwAllZYu2tdUDWT/MEK9HJUEcPnzzjcn0c/+5jhepxidDBoA91+LRZcVx3H/p+FHeCSHexaXBUXp6OmrUqIEVK/hLOhYtWoSlS5di1apViImJgZ+fH9q2bYvMzNzxTPr3749r165h79692L59O44cOYIRI5zXbsJa+288NzrFwpj151Hv8312nVbEJpf/sHrTs6oKessMPW6tfRB7ei83y4dO0E1VmnsGgMNo+QRMVozSS23o/KQwXygZh0uqMppld1m4waPeU4WalTtrNRDcxANZP1Tk4gym+en4fXy46ZLB9TmfdOSv53DpURI+MpKWEEL4uHSco/bt26N9+/a86xhj+PrrrzFz5kx06dIFAPDLL78gJCQEW7ZsQZ8+fXDjxg3s3r0bZ86cQd26dQEAy5YtQ4cOHbB48WKEhxu+ybtScoYcQ38+azTNzivxAIDdV+PRq64bNDbm7BtH27ukx5uCI3POTt4UFbhHJtLzn59aWd9BBKXRwSJdUSq3W/ox+mdPw3FVNd71Vx4nmb2vlDdu8gODEOIx3LbN0f379xEfH4/o6GjNsoCAADRo0AAnT6obcZ48eRKBgYGawAgAoqOjIRAIEBMTY3DfWVlZSElJ0fnnTKZKg64+SXZSTsyn4ptW3QE8PcixRt6u/NYMCPmz8i2rjq2EUC8w0j5++UzdUa2d+fdZJ5mP3sKDAACBkTZlzESdZP67ogghtnLb4Cg+Xl1yEhISorM8JCREsy4+Ph7BwboTlYpEIhQuXFiThs/8+fMREBCg+RcR4bySGXNijE7Ljjk+IxZKzHD8HGuA57cdspatI5IbqwoDLAtqtFOq2y65LrxYKP4eD2T9cE82AA9k/TR5Sc/SHgPJ+D4YY8iUK7H8wG3cjHffqXQIIe7DbYMjR5o2bRqSk5M1/x49Ml4lYU/mNLzV5i5VAsmZzgmO3MUGJzQiz5H3kmDg0CFLfygGvhKl3lmfYHT2ONxlxYwew5Kg05qSK2d5+7+u/9lKFYb9fAbJb+T65y/Pgrsv0rHswG0s/vcW2n19VLM8KSMbT5OcMxI8IcSzuG1wFBqqbvj5/PlzneXPnz/XrAsNDUVCQoLOeoVCgcTERE0aPlKpFP7+/jr/3NVnO264OgtO5S7Vas4OEPKWHF1nkUbT55ynGFYJO1UNTe7fspKjvGMkuY+lkuX4QfwlqnAPsO9GAr7aewsZ2QqT211+rF9VXXPuXjRacACv0kz3fCOE5C9uGxyVKlUKoaGh2L9/v2ZZSkoKYmJiEBUVBQCIiopCUlISzp07p0lz4MABqFQqNGjQwOl5NoeTmu7Ynb2DBUMPa2smyQXsnz9nB0fa58MRx7Yl6DyoqokHqhBsVTZyi0ApWngBO6TTAQAbTtxCjTm7TW5zMz5V83redt3hLmKfp+ZNTgjJ51waHKWlpeHixYu4ePEiAHUj7IsXLyIuLg4cx2HChAn47LPPsG3bNly5cgXvvvsuwsPD0bVrVwBApUqV0K5dOwwfPhynT5/G8ePHMXbsWPTp08dte6rFOXDepyyF51d9CeH5nyHHCxZgOhGsGwTS0mBHYENwlAUJWmb/D+PlY63ehyMEIhWxssG4JxuAABgf20x7XKQfj903a/8XHyVh+YHbNB0JIfmQS4Ojs2fPolatWqhVqxYAYNKkSahVqxZmzZoFAJgyZQo++OADjBgxAvXq1UNaWhp2794NmUym2ce6detQsWJFtG7dGh06dECTJk2wevVql3weczxKfIPN5584ZN9bL7r3fGrmuKIqDQDIZGITKR3LnFDiT2Uzh+fDXmypVlMvM/9W8bm8n96y1llfmr29uS7KRmpeX5KNwHDh9v/eWRYILtodi0SeaUm6rjiOxf/eQrkZu6BUuUd1LyHEOVwaHLVo0QKMMb1/a9euBQBwHIe5c+ciPj4emZmZ2LdvH8qXL6+zj8KFC2P9+vVITU1FcnIyfvrpJxQoUMAFn8Z83x25q7fMHtVtGVmm2164C0NTXXwkH4UfFO3RMdt+c8NZqn3WfIjMKMHKclAAZ85j2NjlIhPrn1tjXeHzusFKGDmu6dyJeI6VBcPn6iWzT5u/GeL12C/5EMI0y34kXHyUhGaLDhpNs/WiY37QEELck0sHgcyvMrL1H7yW9mLzZHGqINxixXnXvUAgPlMMdHKOdN1gJZFpZFDEHKo8IUoK84E/l9v7ydo50ozJZkJIOKXRAMZfJkamXLeR8TNWxOxj/KlshoJ4g9M8I5ubgy+AUjIhb9q+2TMwRrgFTYTXrDpWXmUEz4Bf6qNn4T+hDjPNO7dpWQq8yVbCR8Kfz+cp1GibkPzEbRtkE/diSyPhvNuOkH8ISwICW3uwxbNCFm9jTnCk/bm2KxuiZtb3Ousd0fOuU/YXWK9ohTHZ4wym4Thg3yTdKr/tqoZYquiKwdlTTB6DQYCflO1xlZW2Ob+5++R3UlXFIY28NyW+g89FP1m0zfOUTHRdcRxf7rmpt27h7ptQKFU4+yART6j7PyFej4Ij4nB5S1gsqeKxhzfMdKCjz/QjOztPwavKgq/TX8omFucIAG6xCExXDEM8DJcEceBQJki3aplBgCWKXjikqmnVcXP3bU7Ap5/G2Llx1PAN/UX7ESW4Zvb11mLxIVx8lIQVB/WrvQFg8/kneGfVSTRecMCe2SSEuCEKjtyEu3fxLyewvs2F/rg5lj0M8wYh7kKulS9LH+8fykdbva0pHKdur+dOjH1GAee4OuUNks9xTzYAzQWXEI6XABhkyEKv704a3e4WT/f+83GGJ4o2x4m7L7Hi4B2oqHE3IW6PgiPicJYER91q5Y70/JW8By6oymKTsrlmWfXiAVjatxa+fKe61ce3F0v2O0U+HL8q1PMEHlHyT6aal9xAOx3PZPhcWRIsb1E2suroP0sW4oRsHBaIvscl6XDEPzA+uOpbXx3RW3b6fqJVx87R7/sYfLknFjuuPLNpP4QQx3PPn+T5kD0aZIe9MjzZrivlDSIMjbkzKKokbjzL/cX+jbIHvlH20EmzbWxudVSHamGQK1VYfuAOcNqOGYZ5pTmWTBb7h7Il/kBLfKHohzeQmpWHhlnLUZJ7js3SOWalz+HIMiNr9p3AAu0WoNq6lz6iQwCAEcLtmKkYatG2916m23h0NUeOdUYIsQ8qOfIiNe9+6+os8GLgsFNZX/PeUElBIT8JTj/Q/3XeuGwRfPRWeeyZoNvI2E8qQqCvBDM7VUaAjzXtigyzz6Nc/3O+gUxv7ydUVXTeD2kcCQB4hQCcZ7lDV5hbU+ZOVWqXVKVNNgK3pA2avdonDRDtRwnuuemEBtDAkIR4NwqOvMizVPeYpDavo6qqmCofoXn/0sDI0cUL+fIu9xELMbZVOVQILWjwGEKB+wQEOUyNSt0gczn6ZU/HUZVuFWFkET/e9CIjnzHEX780qmZEoOlMOsBr5P6dumR/huss0ujI59ZOGaPtU7nlwz8ckU60+nit/3eYd7k5o9S7UexKCDGAgiM38YpnhF5LZbhhbFQhcy1SUACp8EW/7OkYnT0OTxCkWX9kckv8OrQ+xrYsq9PeyJ6sq9IxXUKhO1ms/jFMlXI8R2GcUFUFoBtQKEX8QaIxfhL9GvKfh+SW1hWQOq8GPUZVCcsVXTA+O7fROV8AtEdZF4D5U5s8VAUbPKfmDL3AZ6hwJx7I+uGBrB/qcvpd+A3hqxpbtv82KszcjR2Xn+HqE/2Jbl3lTkIqfjv1EAoq7SLEbNTmyIs0El43ncjJsrQeWjmBgLYSRXxRoogvmpYL0ltnGfv2ADKn+sZU0GVJSJYNMepmrgQDME3I/6A3djyBVqlSTslEgK/9R/DmzOhZlsp8sVjRW2dZ3uDlkSoIH8pHATC/Wm22YhDeER7lXWftaOWfiH/TvP5TOhdvZS3Eh6JN+F7RAWdZRYv29b+9twAAY9afBwDsGt8UlcLsM/q3LaKXqBuXM8YwMCrStZkhxENQyRHxAM6vh7DHEU0FWIMbReq8f4kAvEIAShaxvOSImWjRb2o9AKuOm9eH2aPwAoF6yxPhj0/kgzXv35NPRhrUx5shz20YvVdZx+C+X7IA3GehvOsUdvqd9690KtoKz+JP6VxU4h4aTavdJZ/v/Brq3ca54HoGgAtxSS45LiGeiIIj4hQRhX30ltm3Gs22B87w7ElIZAUwMPvj//ZmWUkUX2pT1UVFC+iXEK0aUAe1S1g+orc2a9q0/DioLraMbmzTcZWMw18qw5Px/qp8CxUz16BR5lLc1po+5orWSNzXWEmD2zMI8K3ibQPrTMtilgVQu6TTMEi4x+D6bZfUc7gdik1Azbl79fNkRkB6MDYBt3nGVCKEuBYFR8QpihbQbzD8Ve+azs+IAXtVdVE76ztN4+grqlImt8n76LNHFcpblUMMNi6PheHAAQAmt1XPhfZFN/PGUdLWulIICvnZ1uPPnBHCMyHFUxQ1uJ4xw5GdChzeQIYNipa86wdlT8VH8pE6y/5U5gZrE+Wj8b2ig8k8avtU/DPKcY8RLTiHYOgOAnkjPgUAMHjNGSS/0W/wdyD2hdF9T9t8BUPWnEEbnjGVHIGGniTEfBQceaBvD93BwB9jkK3wjAaWeauPLOWI3j0PVcE4oyqfZ2nugf5RRWGqfDhWKzoa3IepBtl3/GoDAF4Y6J3HcRyaluMPFHZPaKp53THrc3yj6I4f0N1gXj56qwLGtCyL2M/a2aH9lnXyThNjDWPtqpT/3a6OqviDv8OqGvhTa8BQAFCw3FucECqr8rhXOgU/SP6H07IxaMDlDh558u4ro9sducUfHOVczxtOx5l1fE/5nhPiTSg48kCLdsfi6O2X6LPa+BQIhF8K80Xz7K/whhkejJFBgN+VLRGrijB7v3mrUdaFfIQv5b3QLXuuwfS/vFcfW8bkVmflPDgrhuaWQl1jpfCV4h1kcfz5PTszGu2rhQEApCLdUbW71AwHAIxuWdbsz2Etewz0aKx0IyewUcL8kcO1c8TA4WSeMaUs9bt0nub15cfJuPlf6ZEhS/6NxeI9sVYfb+PpOJSfuQs77TCqdsy9V2ZV9RFCKDjyaOfdvIHlM1bY1VnQc0UVif7Z06FuVWT6YW7uo4RvX29E/lih7IrHzHBJDsdxEAs5nfeW4quyzPF175q4OKsNGpY2/LeY2s78XlnLFN0MrrNk4l1DjP1NctYpTBznS3kvzWvttmMcGA6pauDd7KlomLnM6jzmdP1/IOuH1yvaanrbSSBHI8FVnbRLD9zB8oN3kGjlUB0fb74CABi97rzV+c3xNDkT+24k2LwfQvIDCo6Iw2xR2tbAN4et5RHaD9zO2V/oNAC2ZFt9uuvy/ig31SvJGSNZcxyHQF/DbYkmtSmP91uU0byfGK2ualw/rIGmDROgLp3qXqsYfle2xDtZs3j3ZazKqlxwAbPya+x85wRfShO3rRXKrprX2sGRejsOR1Q1EI8iuftlHFRG2joZEyW8jlmiX1CcS8At2SCsl3yBNeKFeunm/nNNK0/6Vh2+i2E/n9EZedsRpTwHblJwRIg5KDgiDuOoCV/tRTt/fCNMW7YvoHbJQOu2dUJNh7nHGB9dDrGftUOjskUxpmVZnJ0ZjSOTW6JoASmW9K6JAQ1L4CEL4d3WUHBUq0QgRjUvw7suL2O9BHODIvOvK+34U56nu/+47LFIZAXQJ3smSmetw0FlDaQwX0RlLsN+ZS2zjzFY9C+OSSdo3rcUXtJLs+XiU81rvjZEC3bdxL4bCdh9NV6zbNCaM2bnwXxUrUaIOSg4Ik7h3mGS4eBBwikMb5Pn/fQOlXQXmPmhiwXqD3PgStrtlooWkKKE1vhHjKnnfOOrMjUUDPeqG2F2o/pHRqogrWlMzYFhg6IlrqoicUhVU2fdNlUj1M76DqeZ+u82RD4FdbNW4hmKYK7C8ulIchxS1jC6PmewSD5v5LnTjxhq0E0IcTwKjtxMEF7jC9EPJgeg8wTawYPSQ3+wWjIpakGZ7ijNfNUiveoW11tWyE+CXeOb4tBHLSzOnyuoIECTrG94l1vrW8XbOKCsiX9UjQxW2+V087e0RHKaYjg6ZX+hV3Kkxum8zob6b/jQwGCT5mghvIQugmOa9+W5Rxgn3AwfZGqWvck2PQebTi7d/dcFIV6Gpg9xM/8Tr0Iz4RX0Ex1AZOZ6V2fHLjgOuPQoyabtbSERCWAqxjF0DKMNhJnugzWvUH/9EqFywfyT5zp6mokwO5dO8fUYW67owpvWnD/fIkUfzeuzrCIOKWugRZ7qKWNtjfIeY6+yDtoIz2Gtoq0ZR+fXK+sTdBGeQACXhk7CGIu2/UbyLbZmNgbA4V/pVABAZcFDbFE2RmnuKRh7y6L9OSI2SkjNxN/nn6Bn3QgUtnGMK0K8DQVHbqaSwLyxTzxBTmBh63QJtm4vNBj4aL22omTLVAnG+OhySMuSo2vNYuj3g2UPV3srFuiDn9+rjwAfMfCjY47xo9KyARYtZex8562OGyGfCH95BpJhXkNwPqdZJZxWVEJBZOARC8YlVRmsknxt9vYPZP2xSZE7CGU74Rm0E6rbEWVdagxAvwpxyp+XUS+yMDKydatzOY7D6/RsjNt4AT3rRuDtGuFWfSZtg346gxvPUnD41gusH97Q5v0R4k0oOHIzQZz7zOZtK3dskF0s0AdPkt445VgBPmIseke3/Yk9q0eqFQvApDZ5B7I0rHl52weH1I4h1yjaYohIe3oN9YcL8ZfieUqW0f1UCvPHjWfGxwjKK6fNkXYePpUPRDpkuMDK5cmnwKbASFsqfLFQ0RdBSLJ4254i/tGvpTvHA+AvGZ686RLOPtQdjZsDsGTvLRy9/RJHb7/E2zXCwRjDyF/P4dbzVHzRrRoalTU88ngO7R8BOef/hInBLAnJj6jNkQdIysjG8gO38Sgxw9VZsUrFUP2qpGV9ze8NZBYzo47jH7fSvNYd4dpyrmhGpf0x//mgCVpWDHbq8bXbUX2qGIQh2ZP10viITQ/SWNhPjL/ej0KN4gHo+N8Alqbp/41jVJXwh5J/OhF7y7bzb8lApGKKaCPKcE90lucNjAD13z0+JbfN0uFbL3DjWSr+vf4cD15loN8PMchSWNaOiRBiGAVHHmDyn5ex+N9b6L7yBO/6gzcT8M+lp7zrXG1Wp8roUUe3EfJ3A+ugs4FqgYU9LJ8XzBRD3cONlWzN7FjJZJq8e3MGV5fFKcxoWZ93/KbyPMHxgu7VUadkYWwd2wS1SgTqrf9a0QMAsF3pPtU9CgtG5jbHRdlIjBZtwzbJTJNp5UqGvdefa94P+uk0nuYpATVnmpGkDLlN7f8IyS8oOPIAJ+68BAC8SNWvqnj8OgND1p7BBxsuODtbZnmvSSkIBRz8JLkPFqnI8GXXu14JvWXO7qnTrHwQutcuDplYAD+J4byKDDVmMqICT6DgSpa2tVKasYH2WZneoSJqlyiks35B92qIKOwLYy6ysqiU+RNmyQfrLF81oI7JOe0cRTs4Oqa0bRoSbX5cFvoK90MG41WReQ375azO+2pz/sVFE4HP7mvx6LLiOE7cfWlpNgnJVyg4cqHCSMEHws0Ig/E6f2MjKXtKe4GiBXMHWXRIGYuxh7YZ0ZX2IJA/D6mHwn4SXJ7dFgMbljS4TbmQ3B5mpo6w/YMmWNKrBpqY0S7EnQUXlOm85yuVK+iTO6RB+6rmVpnpewPdY/EFQtYERxGFreu5p91bLu+wBYmsAG5aMA9fXvPFP+KmbAgmijZZvQ8AGLrWvIEjD8XSGEqEGEPBkQt9LV6BD8V/YqNkntF0xm7/x+944C9ANxzzaEijUgCAwY0iNcGoRCTQC6x6ZX2iea0U+2lemxrjp2qxAHSvXdzmKUOcMeWIMWNblUW3WsUwpiX/iNddaoajfVXrxwjKS7udz9RO1cBx/AFRZBFf1I80by6/koX9TCfiYSw42qFsiLMq8xvHGzJe9DfmiNaiheACJos2QgTDg5DyeZWejciPd+D4nZfIlCux51o8bzqagJYQ46i3mgs1E6onlSwpMDHfkZHn4daL7tnWCDDcVZ5ZGB35Sc24THmChvnyvnjCimKGaDPvJodV1dFaeAFZTIzutYuhbmQhlMhT3ZN3r9oDCYr9cufnksmcM8q1n0SIlEzLHpj2VEAqwle9awIAVhy8q7f+mz618P2Rexbt09hzOg2++FQ+EByAan6F9NbnbBpcUIYRzUrj9INEk8ezNr5kWgGRdqD0kXwktisbYpboF+t2nMdg0b8YjH8BAEWRgmDuNdYrW2Ovqq7Z++j/QwwKSkVIzeK/VtaeeGCPrBLitajkyE2IoUAD7obOsuKcuujb1Y1w7UE7ILLkR2vNiEBMaVfBdEIe3yk7Y7sqyuD635RtMDb7AzTPWgKO41CyiJ/VJTMCJ/yROA74+b36KF3UDz8OMv9B6W5qRARalH6Nsj1+UrYHAIT6G6hq44DoyiEY16qsyf3Zo/RNu+ToT2VzZEIKoQOKRHuLDqGl8BK+lyxBCU7dILskFw8hTPdMMxQYAeoG3pZ6nZ6NTDn1iCP5AwVHbmKe6Cf8LtWtXjsmHY8hwl0ur0qxN5WZ9+UQfym2jGms187FVsH/tX+qX7ootquidGZo15Pn1OtU6XA6K8w2oGEJFC0gRb/6+o3PTalVohAOfNQCrSvxT/7qCfKOBl6vVG512EdvGa6a4sChRkQg76nO+VOMbqkbHEmMNP63xQOeyXeFnPlTzVjjiHQijknH4bB0EpaKlzn0WHklpmej1ry9qPf5PqcelxBXoeDIRd4WHNd530d0iDfdNJHuQHHuPpbJYWV1zWtDjWXNbe9gr2YReRsNH57cEkentETFUNum7LA2ZP2sazWcnt4ahbxsyoY+9axrkFwzIhB/vR+FmOmtMbZVOYPp+H4jaEZh/2+dLO8YSwyY2q6i5m0hXzFmdaqseV8+pACmd6gIczXKXIrWWV8ilen3tktnUp4t7Ks4p25j2FF42uHH0nb+v7GXUl1YpUuIM1Fw5CJLJSvMSifKMynYgRsm2ie5Ec5AVZqrm4L6SIQmu5Ln0n8in1epSyceFm5sdR4EVtTDOaINrT0LJUe3MF2lZUidkoUR4m9eCaGpwTu3jW2stV43xflP2qBscAEU+S8w3TSyEUY0429czucpiuIuK4Z9qtoAgOcsULPuG0UPnFGVx2T5CLP3Z4vewoMIQJpTjqVt8qZLntkRhBALUHDk5gQc03mAGXo+ii3s1eJKntRThsuTVwagR/YcVMxcgyxxYG46l4d8rqH9uR1d+2uselkszL2VVS8eqHntLxPrpMvZx4lprXBp9lsI8NVdb67rLBItsv6HlllLNMsS4Y+e2XOwSdmCd+Rwe1so/h6XZCNQBPadcmjbpacYuvYMUjLlvOs3nXuM/i6eK5AQR6PgyANoPxIMFTj0Eh5yQk4so/MLX7vkyJPiCN6qHAEyIUXtkoW0lnkmj/pb8Mi5xkR5vhi/Dq2PKuH+WDukPu92UpFQPQmvDR6wMGSAv7TroMr09DhNs76y6fg5zsnehxTZCEEi6nCxEMC6tk+XHiUhMT0b4zZcwP6bCVh+4I5d8keIJ6Ku/E4kggJ9hQdwUlXZdGIt2r+YDf16LgzLJvF0JV9zuubb6KiyqkP3/+Ogumjs4AEd60cWNqtrurvIuTS1L1F7libl7KpCqD+Q57T0ztPeqWm5IDQtp55o95gNVUACzvwOBJZ6xELQMHMZPhJvwjtC/glqzRUrG6zzPjKTf1JbQ2LuvULv1ad0Rq9/lZYNAEjJlON1RrZN+SPE01DJkRMNFO7FPPFa7JNOsWg73ZIj/qeN0s7zPtlHbl6LF8odB6ipg4OKypk/YaB8Gk8urKBXrabemzN6i60ZUg/rhzXQvHf3TovO6lUZUUi3vdjuCU3RtoptA08aGhpBu6dkHa2SQnuJRxF8JB9l9/3GSt9FEF5rhgMx5dAtdbosrfnZshRKMMZQfc6/mPznZbvnkRB3RsGRE9UW3LZqO+1njtDAX8yZc0wZo52PeJb7MFnSuybaVQnFplFRZjdGtvZZq67qsM/5yLuXssEFsHdiM7vs2xQ/qQiNPGi6EUdfgXwlU3PeroKKof42B2atK4XwTiui3aB7Zf/aFu2zTuZKm/JkCymnwBnZGByTjscU0UasFH+FSO6ZwfR84xdtv/zMqvGQCPEGFBw5kT0eHp7QRmRo9odYo2iLTcrmmmXFAn2wamAd1DNzigdnsKZheJeaxVAuxL0mj3WldOQGFA5vkK3ptp97ID+p/YZD+GNklN4gktqXSLCZvelyvEKA2Wl3KNVto1J4hgiw1WjRNrQXnsEh6YcYIfwHhXiq4Nccf8C7bXxypsH9elLHCkIsRcGRU1l7M3GPUiFz7VfVwaeKQVB4QZM2vRIJAxFAfuyttm1sY9Ro0hHrFa0wVz5QE7zYatf4pqgXaWYVlh2/GmEBPpj0lu5o7M76q06TD8c8+QBEZ32pWfaMqX9IaA8XYKvp4g1YKl5ul33tyzOsyIW411i4+yaNok28AgVHTiS0sheJu7c10WbPh4llP0yNnaT8F7g4Q/XigRjdshymK4bhJ2V7u12nlcL80aJCsN7y3P077wsxr4u6Yb8505LYIgV++FHZAQnIDQq3KaMQmbne5KTGlmoqvIpK3EOz0hqbBzHvpLbdvj2BlYfuYsVB6uVGPB8FR07UXnjGqu34HgXF8AIFkGFbhvILO8ZGpkpHTgjrAQD2KU135fYG2l3oJTwN4qxtC8RXZcO3J84Bt7CqxdQjp79VOQTtqobiypy39EqUDLky5y08WNARrSrqB3fWCuPs32Nxl3QaPhWt4a1i09bhm6NG1/ON2L/swB0oHdXFjxAnoeDIAxXnXuC4bDzOSdW9XERQuGW1jj0fEO4u5+x/LpuECdmjMUE+xqX5MZexkgFz+ElFmN6hIqa0q2DX6VBa/nft+Mtyq2Y1cZaFAVfRApbla+2Q+pjXpQoW96oBACgoM388pJy0K/qpG2/3zZ5h0bG15XRuOKasYvU+jBkk2osLMuM95dKzDVeR/XnuMSrM3I0bz/QDLFuGTyDEHbh1cKRUKvHJJ5+gVKlS8PHxQZkyZTBv3jydX5WMMcyaNQthYWHw8fFBdHQ0bt+2rleYu9IZIZsBDbgbANQ9UqTIxmnpaEwR/+6i3Lk/Q4GjOWFB3m1NPZczOF9sUTVBGuzfsNZdjWhWxqapQ/hUCQ/A/g+b48S01lpL9U8+MyNQ6larGPo3KIFlfc0rzStaQIqBUZF6o2sDwLyu5o2f5SNRD61xUlUFbbMW4IKqLAZkT8M5leG54/LKufbOMcOT8dqDLzLBWVnlDwDf7NO/3yqUjp2ElxBHc+vgaOHChVi5ciWWL1+OGzduYOHChVi0aBGWLcudkXrRokVYunQpVq1ahZiYGPj5+aFt27bIzDTcy8KbVOEeoDDn/PmVDNGezNVdmkoZGhvKOtQg21nKBBVAAakIDUsXhp9EiCbl9Ic1MKfaTiQU4PNu1dC5RrjNeRrYsKTF28SyEuiWPRfHVNUsuk5ySo5e2LFBNp/rsvdwXzYAQUgCABTnEmwKlgDPaidJCB+37k504sQJdOnSBR07dgQAREZGYsOGDTh9Wj0jNWMMX3/9NWbOnIkuXboAAH755ReEhIRgy5Yt6NOnD+9+s7KykJWVpXmfkuI5o0vbyzVVSVQRmNco0xJhgT7AI/VrV90gN49uhAAfMfwk/13eBjrnmNPgm+7xrrdheEPIlQwSzejN7vNX+f7dulh74j4uP05G77oRJtPnzXmJwr6ISzTUdlCd+ndlS9QS3EEPobr9TxqToQBn+MffXmVtNBFchQ9n2ajWZ2SjNa+3KxtgrHy8RdtrS0znn5eNEE/h1iVHjRo1wv79+3Hr1i0AwKVLl3Ds2DG0b98eAHD//n3Ex8cjOjpas01AQAAaNGiAkydPGtzv/PnzERAQoPkXEWH6puZK9uoirbtPBynTylF7NlvtEoVQJqgAQgNkCA2wbGwaUzgzB7B0hKIFpC47titxHKcVGOmtdWpe8mpTOQTrhjXE5dlvYWYn3WmB+IYjyFtyZE67PDlE+FD+vub9MVU1PGWGxwsbLv8IlbLWYpZ8kMl9G9JJGIPa3C20EFwwmZbvR9BHmy5h9ZG7Vh+fEFdz6+Do448/Rp8+fVCxYkWIxWLUqlULEyZMQP/+/QEA8fHqrqQhIbpTOYSEhGjW8Zk2bRqSk5M1/x49euS4D6ElhemPwGuO+BTdX4luXYFTb7jWG9seXI6f5d2cVK4/2+uHNUCDUoWxakAdV2fFYo74E5bVHoTTBcWTX/euCQBY0L2aVjb08/FJJ745FC2pVtM1RT4c11QlMUf+LppmfWNy+x3KhmYfi89m6RyslXyJL0TfY4Bwr8Xbf7Hzpk3HJ8SV3Lpa7Y8//sC6deuwfv16VKlSBRcvXsSECRMQHh6OQYOs/1UklUohlTr3V7gQSshg3eSNFbg4VBfcwyZlc70bpj2mDVkk722/Bt1Cnt5FLmawQbYVcY/Bj+TA0YIblS3qUdOI8NGeo8xWVcL8td45/yLrWqsY2lUNhUxsfD7D6sUD9ZZp53bfpGb47VSc2cf9Q9kSfyhbat7Pl/dFMJeEoaJdvOnldrq99xMdBKAevbup4ApOqSrjL5XuFDoqK7ruJ6RkYumB2+jfoCQq6fxNCXE9tw6OJk+erCk9AoBq1arh4cOHmD9/PgYNGoTQUPVkk8+fP0dYWJhmu+fPn6NmzZquyDKvG9LBFtf/a9sj/RgAkMFkSH5T0065IlZxl4jPThxRZcuncdkimBhdHhVC7Tv1iqv+HKYCI0O0A/WywcbPRTozHlB+p+wMAAaDoyyYPwSBOZZKVgAAeuIIWDZwQFULSSiIXVfjUWPuv0a3TUjJxLs/nUaXmsWgYgztq4Zi1tZrOHbnJX47FYcHCzraNa+E2Mqtq9UyMjIgEOhmUSgUQqVS96QoVaoUQkNDsX//fs36lJQUxMTEICoqyql55dNTeAg7JdNsCoy0VRE8wEebLtllX85g63PLXoUxLyXFeJf7Sd36t4FX4TgO46PLoV3VUHvsTPuN7ftzoqnyEXjNCmC2kfZAc+TvIkZVEWuU7Ww6lr1KjvgskazCRdlIzfvUTAVvug2n1SVjX+6Jxc34VCzcfRNf7olF6yWHcZ1nfCQ+OQNKKlWM5nMjTuPWwVHnzp3x+eefY8eOHXjw4AH+/vtvLFmyBN26dQOgvuFOmDABn332GbZt24YrV67g3XffRXh4OLp27erazAP4Urwale3YI4xp/rf9gaBb1eSYG467FLJsCJuGrcpG6J41R2f5+y3KoH5kYXxm5tg1asY/lJ/UuhIFV7F1EEg+1o6KbeXBnHcsKxTJMzDmDVYStbNW4WdlW4PbrFW2Q+/sWTqT+lqDb9qRVCvbPRryjvCw0fXTNl8BALzJM98aY0BiuukfjcfvvESlWbuxPiYO0UsOo/fqU9ZnlhALuPVP52XLluGTTz7B6NGjkZCQgPDwcIwcORKzZs3SpJkyZQrS09MxYsQIJCUloUmTJti9ezdkMvv2UnInNKaOZSqUr4DxV8fqLQ/wEeOPUcZLGPUfvcYfxl/3ronR685jfGvHDtyXr2kFRG4eG/Hmj1nwm/SHd+ti2C9nrT5+x6wv4Ic3uMTK4G3hCWxTNkKsbLDV+8trsfg7HFZWxwutOeHySkjJxPbLz6za/4hfziJbocL0v9VB1v2X6VbthxBLuXVwVLBgQXz99df4+uuvDabhOA5z587F3LlznZcxF8n5JdhZaHiYAnfirPYspvSqGwGpSIA6Jc2c6d0IUw/jssEF8e/E5jYfx1s4OnixRymqI33SqTLGb7yI4U1L4fuj9y3atoBUhOjKIaYTGnGNRWpeb1K2sGlfhpyRjcFbWQvxhBVFT+Fh7FbWQzyKaNZP/vOy1ft2aikkIVrcOjgiunLKi1oKL2kts+7mEegjAv4bB9NRtx+hC8cE0iYUcOheu7irs0Ecwj2uMUO61CyGpuWCUMhXbHFw5Enta/6VTtW8niP+BeUyf9G0eTp864XF+xuz/jyy5CqPOgfEu7h1myOiSwgVanGeM2+cc4MjRx3LvJszVXU6E8fzyn0V9pNYVQKSc0VpT77rainMFxlMitOqCkbT/SWZjQjuOWpzt/CxaAPeFhw3mv5RYoYmEErLUmDH5WfYd+O50YlvCXEk9/nWEZPGiLbBD7oDQkZwCTbv11EPdpGblBzZwtwfrhQauYgXV7vkXHsHP2qBOp/tM5jujiocZQVPnZKnbxTd8KNS3e3+gayfwXTVBfdxVDpRZ9m2zEYwFM42XXQQ41uXw8Q25aGi0iLiBqjkyMPUFuiWHE0W2WnwRjsq5KseX6WNje0l3PK5ZyBTqZx9x+8hhulM4eKWF4l95PQkLGJi2pjB8qlG19tqpaKz5nUWcnvfXVdZNgnvA1l/NOBuGFz/zX71vc1UbERVbcQZKDjyMNUFuu0WinLuN2nu/g9bYMPwhvYZ08bNjcsegwPKmvhV0svVWSEeRCJU33qNDSZpbgzwmAVhj7KuzXmaJ++vt2yxvCfOaFWhbVPm9u7skT3b4mP8Lp2HzZJZCMZrGCxvNRkcWXxYQixGwVG+lXuHkYlzf31fYLZ3QS/sJ0FUmSI29zTxhJvgNlVjvCefgjSugKuzYhVHnGPdIRodXbLjmSVHxz9WT9D8fvMyqFYsAMOalNJLY8mfZrp8KNYpWqNj1ueaZV1qhpu9/c+KNnjB+Htzanf6SIGf5vUbWDcFU23BHZyWjcE34hUohBQE4bVmXdyrDJPVajojtHnCTYJ4JAqOPJwvl2XzPjpXz72JFi5o30HiPF/em69nPoy9iU7A5YHVahVCCiKooDqwCPAV458PmmBY09L6CS147r9CAGYohuIayw2yDJ2Z86qyPIfioDKwhW42jI9OPi57DHpkmVei1EV4Ahdko3BGNgYPZP1QiXuIZl8exJOkN0a3ywmInqdkov4X+7FoN01wS+yPgqN8ynMnYCBEm3eUHPCNVK69rGm53ImH+zUooZeWb5khMapKPMfiD44yIIMldwgVBIhnhc1Or22XdBqqcA9w4VGS0XQ5Z2Xlobt4kZqFbw/dtep4hBhDvdXyLfvNVO/d6IS4HQ+eW80Qvu+d9rI1g+vhWXImIgr7AgDGtiyL2OepkCtUaFM5BIv2xOptb6ham2+pCgK8ZAGa93PlA9FKcB7rla3QUGC4EfXA7I/xq2SB5r0SAiiQ247qB0V7DDMwMS6fHdLp6L8tFWJUghxC3tyeuPsKzcsHUZUacSgqOcqnaFwe6xgadJNu1C7Ced4tjC9myZlcVZv2EpFQoAmMACA80ActKwTjrSqhRtv2HZ3SUuf95Lb84xMpIcBpVhFfK7pjXPZY/KRsjwHyGciE1OhAs0dV1XXeqyCAUis4+kX5luZ1rMq8gVjXSebjsnQYfhEvQAfBKRRAhs76WVuv6m1z7PZLAPQ9JPbjeXcWYh86N5Hc1x7YhMOpDN16c9qQEGINW8f24fvacoBOQAUAY1qWhfZVfEUVCQDYomwMgMPXinewTdUIvpLcAMeSnDEACq3HikpnwE7dPW1UtMD47NG8+/HhstFMeAXfSpbiJ8mXWCL+Fk0F6mlIHr7K0Es/4McYTPrjImrN24vzca/11hNiKQqO8intG1VoeITmNf3wyiPvCckTPf7yXn00KVsUS3rVdF6ePIgjgm3tXbr73GrmUmiVHIX4qwPtBqWsa7tTJkjdo+xtM3qrdcuei/qZK3Bdaw42ANg8upHmtaXnWLvkSFvevbxAILaqmpjcX31BLLoLj+FXyQL8LpmL4lwCwJheidnm80+QlCHH6N/Oa5alZymoNIlYhYKjfIqDSvNaUm8wlDUHQtVjjQtz5JmalQ/Cb8Ma6P1CJw7khQ+7yCJ+qFrMH43LFsGfoxphXKuyWNq3ltnbD2ioHpDx7Rrh2P5BU/w7sRlaVAjmTav9w0gBERKg7sJfrVgAb/qbKvMbe3NQV9HpLlETaN1zAOCBSj0O2vvZ483efwPBTRyTTgA+DcS2E8YntL37Ig1VZu/B6HXnjaYjhA8FR/mUzm8uoRjCrsshqNbdrarVLMqLG+XbU6xXtHRMyQ79LSwmFHDYNqYJfhuqDrQnvVUBRU2MjK0tPNAHsZ+1wzd9asJHIkT5EMMjtteKCNRbFuovQ4kiuQG+dvz5AoFokfU/1M1cqbPNznFNefbOdIIjBTP8iPn7v1KjXaoGiMxcbzCdIeskX/Auz1aqoFQx/HLigXr/V+Mt3rcpShXDtafJUPG0FSPegYKjfIpjKtOJXMwdCgj0s+A9T/67rJhbnGNLcZxWpj2wQbZYyJ9ngYCzaeBUqUho1vbFCumPZdagdGGj1U8PWBheQrdkqXK4v146DuopRn5RtMEmRTPEowj+UDQHAHyj6KFJt0rRCSobHz+VBHGQQK63PDE9Gx2XHtVZlpCSibQshU3H0/bJ1qvouPQYvvxXv5cg8Q6ed2chdvFMVoZ3uSc+LAnxBIt6VEd4gAxf9qxuOrFD6X7JW1cMxtwuVdGsXBCA3KlNjBncKFLz+t3s3LndcvY8SzEEkxWjAABTFcPROPMbbFM10tqDfX5k3JINQhCSUJKLRzBeowz3BABwMz4VP598qElX/4v9qDZnj12OCQDrY+IAqMdaIt6JxjnKp/4Mn4zz13ywUdkSO12dGULygV71ItCrXoTphHZWvJAPHr82POr0mFZlEeAjRs+6EQj0FaNGRCCSMvRLZHIMbFgSc96uAgAoVdQPR15qB3v6QQ+DAE8QZHX+TTkj0+3x9rOiDQaJ9qJW5iq8Rm7pFv3wI5agkqN8Kk1UCLMUQ/R6qVB7EV0c3VFt4ojLidP5k9AFa0r7PBNAcwYuaaGAQ7uqYQgL8DEYSHzTpybmda2qeb96YB1o/w3M/bZY+q3qnjUH9TJXmJV2kGgvAOCCbBRKc08Npnv4Kh3L9t9G8hvDgSDJv6jkiOjw1FjAWdn21PPDz/M/DKNo3qQJ0eUhFAj0gqQcfNd0IT+x3rKwABmiK4XoLMvbxslUt//1ipboKjyBtYq2JnKtKwsSvEAhZDMhJJzS7O0OSD/SvG6d9SWgUgIC9VADHZceQ1qWAndepOGbPub3DCT5A5Uc5VPmPORTmOdMQuv42d9zDkQPY/dCfw9T/KQifNy+ImpoeqnpfvmL+En0tgkL8MGSXjU079cMrodjU1vBT6r7ezrv18HQ5LU5piuGo3rW93gO88ZwOqmsjC3KRrjG1EMV9MueYdZ2fPZLJyN7fT/N+5wG2mfuJ1q9T+K9KDjKR+JZIZNptG92I+WTjKbNqDPK1iy5Pc8vW/FCFA/Z5HWxFgCAe6pQzOtSBZFF/XjTda9dHCc+boW1Q+qhRYUgCAX6J15gYckRoB5byVyfKAZjgnwscv7oZ1lFLFd0MXv7vCR3dlu9LclfqFqN6LCk2iij4YfwPbfKcZkhDuWoGMOpsQuV5FksOaQRBmVPxV0WhgP1jA/wGB7og/BAwyXIeeOl58y6Ub0N4evub/O8kIzpXDdPkzPRdcVxBPiIoWIMcqUKE6LLo2HpImbv8uGrdIxedx6jmpdB5xqmRyYn7o9Kjoj13OjBdKFIJwDARVVphx7HW6ar8GzaD0f6e1iM43BYVQOPWbDNX2GJSP0IGZk9EdPkQ3EtTwcPWykd8Yi6qD/g5MVHSTh86wWO3n6JU/cS0Wf1KYt2OW3zFVx7moIPNlywVy6Ji1FwRHRY8qvMjWIjXCj6NrpmzUXf7Jn23bF3tcDW4/BP5+C51YgVON6XVgkL8EH/BiWwR1UPG5StbdybPlM/RiZkj8bXiu6W7XTraDxLfoNl4qU4Lv0AIqjbHo0WbsUDWT/0F+6D+L9lR269wKPEDLzJNt4IPDXTfgNM2sv9l+n4aNMl3H2R5uqseCQKjrzMrYL1gYiGQO91RtMxb2tNw3G4yMriDWSuzglxOCo5sonW6cvbZsgan3erZnDd5LYVEFHYdMeOFhX4x0Hiu0tpB0xp8MFPivaa9zPk75k8FgB8tvALdBaeQjHuFe7I3oUMWZgi/h0A8Ln4J2yTzMR3h+/i3Z9Oo+mig6g0azf+PPfYrH2rM8kAueGxpZxhwA8x+PPcY4tLwYgaBUcO9JfS9IzT9vZaEg4M3QNU6mTV9pZUGzmth5gLKb147iSb2264AerKbxt3OX3+Mv2hAwDT96MDqlpIQW6D8mTG37g8rxWSpTrvb8qG6LyvJIjD/F03dZZ9tOmiwf3pncfNw4HPQ4HEe2blxxGeJKmDsxepWS7LgyezKjjKzMw0uO7Zs2dWZ8b7OP/OY+vDwhsemPYUVFC/mzNxLTd5nnssnXI3J0RHtvyIYsz4tnkbbDNweM0KWH08Q05Kx+KBrD/w6i6wdxYeyPrhfeE2+EEdgHySPBtXpEMhwH9zVl7ZpP7/9Pd2zwtxDquCo9q1a+PixYt6y//66y9Ur+7qeYPch2sa7zrxmO7ys9OBfCV5OnR64ESnXodRtZon0b5NrB/WQPO6URnd3mAHVfoDMfLdQ439gLPnT7vDkgl4IOuHB7J+COP+Gwtp+0Tg+DcAgKnijVgv+RxIS0A9+VkU5N6gq+CYHXNAXMmqO32LFi3QsGFDLFy4EACQnp6OwYMHY+DAgZg+fbpdM+jJXNGWl9lYU6p9MzJZiuRGwZHzskIla8SzOftb26hMUQBAQZkIjcoWxfphDdC6YjC+7Jk7yCTHAWNVH+ptmwX+6jZDONiv9LukIEF/4f3DOm9rCO4Bi8tp3tcVxOqsf52aDvzWAziy2C55Is5j1ThH3377LTp27Ihhw4Zh+/btePbsGQoUKIDTp0+jatWqpneQT7ik5MiJ1Wp5j/SKFYT5I4MQb6VdVeOQdmluFJR7IkeH9y0qBOFQ7AsA6oBoZsdKKF3UD+3+m76kUdmiaFS2qN52Ki43EHrMimKDohVeIUAvnbH7KgeGO6wY6nK3bP0YVuknOqjzvtC1n9Uv7uwDmn3EswVxV1YXM7Rv3x7du3fH8ePHERcXh4ULF1JglIdbj4lj5zvkIWUNdMuea9+duoM8xX9u/Te1gsd/GgqU3MKUdhVQyFeM/R82x9oh9TGvSxW0rhiMXnUj4CcVYXiz0ogo7Gt0H9oDSq5WdMQKZVcMbVLK4rx8Kn8XN1QlzO65Znfb+WcWeJ2ejZ+O3cerNNc2kN5wOg7/XDI8IS9Rsyo4unv3LqKiorB9+3bs2bMHU6ZMwdtvv40pU6ZALqcZjnO4ogLGntVqpmg/l75U9EYcCzGcmLgdzlMHdKCAyO2MblEW52a2QZkgdWPogVGR+HFwPcjEQqPbjWxWGlKRAONbl9MZViDnPsQzYwluqgyP6s3A4QorjfbZC/CHsoXJfGcwqck0Fjv7I+/imb/txZNdX2LC2oO8653hWfIbTNt8hXewyutPUxD3KsMFuXJPVj1Ja9asiVKlSuHSpUto06YNPvvsMxw8eBCbN29G/fr17Z1Hj+Xt1WqO5j45Ie6E8/KBOT2VgC+SMWFah0q49mlblA4qwLu9gON0GnEDwHZVQ8yUD0HHrM81y/5QNMddVRj2qWprlskhQpXMH9Ek6xuDx7/PQnXW31OFWvwZzLXiWT98Il6H/s9d1/4o+Q1/4UVCaiY6LD2KZl+6LnBzN1YFR99++y02btyIwMBAzbJGjRrhwoULqF27tuEN8xnX3MKdF5Bx+XKYLCq1cC/09/B0IqH6PsIbW3HQa5/UsHQR/KZsg2sst8ptimIkWmcvRhZ0h95Ih4/R0qG1yrZ4zIJwVRUJANiobGndh7BAO+EZIP4qkPrc4ccy14OXVGKUl1VPt4EDB/IuL1iwIH78kb9IMX/yvJIjbT1rF7PbvqxBjz3P55AaMKpW80ocb7Wa7t86wEeMidHlDe2Bd6mhH6kqxmGTsjkAoF/2DLybPRU/KDviiNLwiN92s6ox8L/yLp2eiFEJrFFW9Vb75ZdfDK7jOM5g8EQcz9yqPHO+Fi0rBgNXjSTIF88o722QfZ+FoZKrM2EF7/kLuEbNiEBwHFC6qHmjSbtS3tIkjuMZe8wEQ9/Zy6wUcq6mFPjhiEo9tMBfyqZoJrxicV6t8uY1IJIBX4QBRcsDY8849HDavUcZy/2dQb839FkVHI0fP17nvVwuR0ZGBiQSCXx9fSk4+o9rHqROrOpyo2+U++TEAwzdi1mrfsNeVR2PDI600fQhlvOTinBjbjuIhe5VLc5XkpG35KhkEcsDOkP3YYWBx58SxhuR2xNb2Rhcpc7qNy9vARmJgG9hux/nTbYSPhLdz3U7IQ3lQwrojZI+6Y+L+F/PGk4ZPd2dWfXteP36tc6/tLQ0xMbGokmTJtiwYYO98+ixXFJoac/r2USxa3787njFZ46oj1+UbeGokNLR5yg/zOnnaDKxEEIrGlA7W84DesuYxuhUPQzL+9ay+PrSvostU3TVvJYz/uBIzhMcDc6eYtlB/zvWdmUDo2m41KfA6e9yFywqBSQ/BhiDKku3HZBSxTBh4wVM+v2ixVVi60/H6S1r+/UR/Hrqod7yzeef4OKjJIv2743s9tOhXLlyWLBggV6pUn7mTVUw5vjh3bquzoLDUTU9Ic4j/C8SqhkRiOX9apscK4lf7n1YwXIDH74gCOAvObqlKm7xUZcruuIj+SiLt8NXVSCfFwrB/DDcvHtXs7jXdyex5eJTbL7wBI9fvzG5G+0g8k22gjfNykN3eZdnylWW5dkL2bVcVSQS4elTGlwqhzvPrdb9v8bWFUML2nCk3GONal4a0ZW9cJwjiobcXP76AZLfmFO4Na9LFbP3px0QyQ1Uqyl4giOVFdeZHCJkwrpxlMQq9eTuFX+tDcwJAOKv4NzD17l5VBm/L2UrVDq3rsR0dRf+vKVuOdWW9C3SZ1Wbo23btum8Z4zh2bNnWL58ORo3bmyXjHkD11SrmXeZNy0XhP0fNkexQB8HZ8jDqfh/cXkNBwd/Drnp0p3ca51QVkYj4XXsUqrHy+Mb+0j7Fje6RRn0b1ASn2y9ZnCf2j9StUuFlAbKBviCI0NpjVH9t02NzNWYKtqAfqKDmC/vi9XKjrgvG2DZzlY1wQ/iWlit6ITTrJLRajWliqH+F/t0lv10/D44DuhWS7cHslc0E3AQq4Kjrl276rznOA5BQUFo1aoV/ve//9kjX17B3QeBzBnN1tpdObrBnluU2ah0B03Lb1Wlbonu6F6J4zj0k8+AVC7XjFdk6k89PrqcycEnte8j2oGPoe8yXymR9swDsarieC97Mny5LOyVmm6LlIwCmK4YjsWK3kiEP38eBWJwKuOzS0QLLyBaqB7ZOnNTDWD0Ed50r9KzkJShv68fj93Hi1TdqUvoq2SYVdVqKpVK559SqUR8fDzWr1+PsLAwu2bwyZMnGDBgAIoUKQIfHx9Uq1YNZ8+e1axnjGHWrFkICwuDj48PoqOjcfv2bbvmwVruVK02RT7c4j35y0zMiJ0fvlkFvLCq0NPp/GrOB9dgvsIhCxKUC1b/cGtfVf95ol2db07jfO37MF+pkLH0ObQDphcsAE8QhNvMsnZIhgIjAGj6xrJRs2UJl4BrW3jXGSsMvhmfovNewHFYc/w+Fu2Jtej4+YF79eXM4/Xr12jcuDHEYjF27dqF69ev43//+x8KFSqkSbNo0SIsXboUq1atQkxMDPz8/NC2bVtkZma6MOeuYygg+8OKkV+NTSUyPHtS/ngs1eir85a6jhPiGNpVRTvGNcWZGdEoZWIsJnO+jrrVarmPPAFUvJ1IDAVHH2aPwj1VKOYr+hs8lpxZNwzAYxaEepnfWrbRpkG8i1X/nUcOKrQUXEBhpPCmA4CHrzLw6T/Xcfp+os5yD5110a7MrlabNIl/pmE+S5YssSozeS1cuBARERFYs2aNZlmpUrlDxjPG8PXXX2PmzJno0qULAPUAlSEhIdiyZQv69OnDu9+srCxkZeUWL6akGL54PI6THt57VY7vmeYWYYjQROkZcT4KUL2eRCRAUEH+xszaf35TV8Jf7zfC0Wv3gdPq99qNsIVQoRVPJxLG+IOjv1TN8Fd2M6PHmyR/H8sky03kStdhZXUAwAsEYo2iLYaI9pi/sfwNcPUvoHBp4NkloGQjMFlZ+CMdn4l/wtvCk3ikCkLTbMPzyzlKplyJgT/GoEGpIviobQWnH99WZgdHFy7oz+LLx57tULZt24a2bduiZ8+eOHz4MIoVK4bRo0dj+HB1FdH9+/cRHx+P6OhozTYBAQFo0KABTp48aTA4mj9/Pj799FO75dMQd6pWs4rJcY7c5yHlrKy4zycmAChQyufy3oN8JUJkZCs17+uULIQ6YRJNcKRdciSEurv636Mb4YudN3Dmgbo3GN9dj5lZybJd1RB1FbG4pCpj9mfQ7kH3qWIQdigb4A2k2CGdoV7Y93dgQ2/+jT/Xnyg3HMBlWe77CMELs/NiT9svP8OZB69x5sFr7w6ODh48iHv37iEyMhICgXNq4+7du4eVK1di0qRJmD59Os6cOYNx48ZBIpFg0KBBiI+PBwCEhOhG/yEhIZp1fKZNm6ZTEpaSkoKIiAi759+a7p82s+fDgtFYF3lRg2zLOCKApr9A/mbskoos4ofrz/LWBORuoNIqFRL8FxzVKlEIm0Y1wo1nKfCVCJF5Rwjs0t2DufdyBgFmK4aYlTZH3nGVzrKKAIAmWV9DCjnmS+qj/pxk9Jn+JUYLt+IWK45hol18u3IrWQql6URuzKIop1y5cnj58qXmfe/evfH8ueNmFlapVKhduza++OIL1KpVCyNGjMDw4cOxatUqm/YrlUrh7++v888RDA1P70h2rSlmxi9uGqmYEGIv5gbSug2ydRUrxDM0iYH95pQc5agU5o+SRfxQpKD+Phz5o8jQMAGPWTDusmLo9d1J7Lj8DKdUlfGufBp8kG3xMb4UrUJLwQWd2oCSXDzEcNxQJSaGYnJ7FgVHecdW2LlzJ9LT0+2aIW1hYWGoXLmyzrJKlSohLk49FHpoqLpIMW+A9vz5c806V1K4pL274S/xL4q3AOTWcZukMhH5a910qHbDQ9EfjniwnMt3/fAG6FAtFJ93rcqXSvNKO8gRcvwl4xynf9825zl/T2XdM0dlxnNizPrzmtenVZZXUfUUHcEayZf4Nm0CBgj34oGsHw5LJ+FH8ZcW78tclk5x4m7curda48aNERur28Xw1q1bKFmyJAB14+zQ0FDs379fsz4lJQUxMTGIiopyal75OHMCQw0jD7tVys7onjUHI+RmNq4X8w8Q2Shzqd4yD/8eWMDLggkP/MNxRt4Rz2XuwzRYq6F2TmlTozJF8W3/Ogj2lxnaTH0MA4GSNp7YyKySo/bZC0ymydE9a47mdQazbBTtbapGvMtHZk9A2cxfUD3ze+xW1uNNU1Z1H5+Jczs4NRNe4T8IAx4lZqDv6lM4FJtgUf40u/C8W4sOi4IjjuP0ij4d2Sh34sSJOHXqFL744gvcuXMH69evx+rVqzFmzBjNsSdMmIDPPvsM27Ztw5UrV/Duu+8iPDxcb6BKV1Dx9HpwPMPHbFgmCOdZec0AayaVbglU6wl5Nd3u7E9RFIDjB2n08O8WIcQBCvlJsHl0I+wc19S8DSx8Rgm0oqMsJsZfyiZmTQNi9n0VwHlWHl/I+yJOFYQlincsyh+DADdU+m1k0+ADBURIgR++VPQye3+/iOfjbcFxvSq2D/+4hJP3XmHwmjMW5S+HysOjI4saxTDGMHjwYEil6gslMzMTo0aNgp+f7lgUmzdvtkvm6tWrh7///hvTpk3D3LlzUapUKXz99dfo3z93nIkpU6YgPT0dI0aMQFJSEpo0aYLdu3dDJjP+C8IZmhqKyh3JyI1AJrawJEsgAHr8gOwn1yC+ssHGjDmWs3rO0ThHpjn8nkh/g3yvdolCphNpWB8cjZaPw35VHYu2N9dqZWesVna2att3sufgmmyozrJ0llvSf5cVQ6usxTgg/cjkvpoJr/xXgrQCdTNXIgl+OHXvFU4/SDS5rTFKD290ZFFwNGiQ7qBTAwZYOD+MFTp16oROnToZXM9xHObOnYu5c+c6PC+Wqiu45YKj8t8I2lcNRZaCep8R53JEGKMzOCkFSsQUTrsqTWuxgbJpgTA3OHLX3qnp8EG9zBUoyqVgl3QaACALumOypTHL5808K3sfWUyMCgd+Rm3uFmRcNk6o+Npx8fvj7CPEJ2diXOtyHl+tZlFwpD0YI3FX/F/mlQPqYOha64pHDR/KfRpkNysXhNVH7kFkzjTeNvD0L7wzuPpaIERX7gVZuqgfjAwYDQA6Q9VoB0dRpYtg3bAGaLTgAOJTXD8DwwsU0iktysxTrZeAQvhC3hcNBDdRWfAQYZx5JUFSTo7vxf9DG+E5AECtTPN7h0/58zIA4K0qIR4/yrbz+5oTx/KicWUsOW6TckXx56goRJqYboB4AYq+vJLDqsZtaHOU83if07kyBjWKdKuBbwHgDSRIYT7wQyYesyC99dpVd/2F+/C5+Cez9psTGAFALcEdVJuzB0OblMKE6PJ6aV+mZeHKk2Q0L5d7/OQMef7qyk88m9Xfaze7IRhSN7IwihawrOeHpTzkVBBCeJhTTaYbAKlfi4QCzXJ3ugcwCNAgawWqZv2oMzUKn3XKaN7lj1lRLJb3NLjdT5LFKJgZj6/33cbDV/pD97T+32EMWXMGf55/rLPc0xtkU3DkdRzwzc1zkXesHobutYvBV5L/5h3z8O87IW7LcePimO6+r00gzO24kpPekvncnO0NZHgD8zog8U2MG6uKwFplWzxngQa3OyEbhweyfgj6vROQ/kpnXfIbOQDgwA3dLv+efq+kajVv44hqtTy7XNGvtvqFqUEiidtzxP3L02+KxMtY2DZSaKABtzcQaI0KPlU+HPUFN7FA3gdp8EXjrKXoJjyGL8WrDW7vm3Ae+LI0MCfZ6HEYaBBI4naMffsd95vHw78HxEEcUQVB09YQi2gHR2YkN9Qg25Q6JS0ZXsA1tD/N78qW+FD+Pl5AnW8FRNikbIF58v78G2tRLogE4q8AZ9egIheHILyGIk8jI2pzRCz2UBXsuJ07pELc0D4d3DPMoXsnhOQ3Zo1TxllWDZfjz1FRmNO5ssl0vevaf5Jzcwk403fV/araJtMIM18Dq5oA2ydgt/RjnJGNwbEbcZr1jHl+myOqViMmmfNL3Z0aKTqSj8QFU8IQkg84oyeYWcEOT2817XvgmFZlMePvq+hcIxzQmt2K4zgItYYSqVOyEPrWL4GwABlqRATiRWoWrj9NgUQkwO9nH9n6URwmm+W2Jd2trIejqmrYp6yNGNlYo9vdlA3BPPkA/KjsAMDzaxOo5MgFHDqwWH6JUlwkqnQRV2fB7Tn6EqQrnFjLvGtHP5X2Nd2vfgns/7A5vu5dUy+dQCs4mtK2At6pUxyNyxZFAakIpYr6oWP1MN4j/jq0vlk5cwbtXm8blS2xThmN5yjMO6dmXp+If9O8ZoxBimx4ah0ABUcu4NhLxfDX3+4PrXwYiAny4Wd2Zw4e85N4GbO+viaq1TiOQ5mgAjqlRJp1VobuTcvpj1HkKllawVG21uunKIqKmaYHgm4muITSJz9GcMpVXJSOwKeitVD+1hP4pSuQeN8RWXYIqlZzoFOqSmgouOHcgzqhtxohxji6OF2nWzVdnF7DOb2bzIqONK8sLeU353J0915c2iVHeT9/JqSIzFyPB7J+Brf/RbIQuAMMwB8ABwwS7QXu5O7RU1DJkQOtUHRxwVG952HhPZ8k/3JIzzKtJxCVHBG7syHg1o57PDVwz9aao03J+EOE97I/wlrFW5bv3M99SshMoZIjB8pgjh2tmY9TZ43XGT/EM28E+Z2n/9WoWz+xP/2SI2uuskK+/IPklixi+RRHvhIhMrKdM66cUqvM5BkK86Y5oKqNA6ra8Ocy0F14zOx9J2SJEez8x6JVqOTIBRw707ORNkcOPGqrig4cnoA4jOcUcufSDogoJicWsbQrP7O+Wq1cSEHeNBVCC+Lb/vrd5fOOk1Ql3F89US7U99d9k5pjcKNIRFcKsShPluMwJHsyxmWPxSNm/Fiz5IMxNvsDLFV0xdeK7ib3/Co9216ZdDgqOXIgQ0GQN/ZW8xFTF3fifNRA3ns4o/TZ0tIAR/146FAtDCv61caY9ec1y9YPb4D9NxIwep162e8jo5CRpcDOK8/QvU5x+MvEmPN2FQBA5Mc7HJQztYOqWmalS4MvtquiAFUUAKA89xgdhKcBAN8rOmC4aCcA4LCyOibIR2OdB/0ao+DI6zigt5qLHkAe9D0iLuInpaCcWMDCW5mlP2RbVFC3qYko7GMybcfqYSggq49ywQUAAFKREB2qhSH2s3ZQKBn8pCIUkIowuHEpyzLtQksU7yBacA6/Kt/C54oB+FzRHxwYmAdWUlFw5G0cEcgI6DIh7sma9huEGGXD3GphAT648Ekb+EnNu2c2L6/fQFkqEsLMzfWE+ssQn5Jp3cZ2cIcVR7WsH5GladTN6QSYzIN+8npeOOdBHNu2yBAHHLNQpP33SfIHqvUiZnLHLu6aBtkGruMrPurBGw8pa2iWFfKTQCJyzaP11PTWLjmutixIYOiL74Z/YoMoOHIgVwRHxgqOrO7Zw3FIYaaLifMHD/p2E0J0mHcP1O+tFlxQxptyV4XPMFk+AuPkxqfWcBdz5O8CAObKB7o4J+6P6kuISZw5txSO4mxCiHuzdITswn5SjKtfVtOWKK+RbWvjS/jip5rF7JRDx1qrbIdtykZIhL+rs+L2KDhyIENlDEKhwIEFEFpBSsPRwKlvgSqmu1ia3quKf0WtgUDacyCkqs3H8AxUT0SIp7L021u/dGGMeKuCwfUBPmJ81rWabZmyE3PnfXRlYORJ1WoUHDmQoWq18EAf4LWDDqr906jNXKBiR6BYXZt2yYxVEHZZbtO+jaEwhPCi7vteyRld+c07BGfgtXszp4ecq1GDbGKUSOCk0y4UA5FNALG6vtzaew9jRkqOiEdzxC85d2xYSwiQN+wxcJ1q3ShVFg4C6SxnZkRjSONI7J3YTLOMxvyyLyo5ciBD5S2OvIgdNX0Ife1y0IPfEg65HIuUdcBOias5e+JZw+XhWmnc9MYXVFCK2Z2r6CzzhCmcPOl3EwVHDuSa68BwqZS13x2JUACFC0qOPOh7RLQ4/CbtWxiYcBUQ+zr2OMTrWHppumY4Fut4wiTMAT788825I6pWcwUT39DbKut7PhjbdZOyQeYcXo9AwEHIUahC3EhgBOBnXgNUQnJ0rBZqOpEHlMDw4cv23C66pUsh/q6d9bVIAYlLj28JCo4cyJxiW7sz8sXuXS8CK/rVxvGprSze7dWwHgCAw6ymtTkjhBCXKl7InEbL1k8860rlgtUT3a4akDupba2IQuhYPUzzvmKoa7vwe0LVXw6qVnMggw3+TLCtjMbwxScUcDpfFEtUGrQMR/a3RLl6ba3NGCGEGOSOD05PqFb76/0oHLv9Cv0blAAAtKuae4/nOKAUTbFjFQqOvI5jvswSmQ+adezvkH0T70K91Yj7MuP+qB2kuWHAlledkoVRp2RhV2fDLO5/NnNRtZoDueRXhwd8mUn+QVcjcS/mBO7WTzzrjrQfCa7+PK4+viUoOHKFbisdt2+bgyNPunwJId7C2SWO5vx49YRqNVNMndYf3jU9SHDF0IJ2yo3noODIFcJrIbHrOofs2urJZXO2Z+4z2KPb3JbGnHZ1DgghzsJplxy5zV3IKqEBMvj75LaeKSAV6qWJrhyCSmHGG2pXsFNw5ElV7tTmyFU4/YvUHmz9MlvbiNyrFQh2dQ48ijs2rCXEfJ45fYi23ROaIj1LiaIFpJAIc8tAQvxlvOkrhRXEjWcpvOuGNI7EuFblsPXiU4fk1V1RyZGLKIpWNLjOpgDHxgeTO5UcUZhGCLGLmgOAouWBCh0s2syDevLrqBjqjzolC+ktn9C6PG/62Z2qYGiTUvzrOldBIT/+8YlGNCttUb486Z5OwZGLsIJheD97PO86icj0nyUzoAz/CluDI4+6fIk78qSic+I+HFri2HWFunpcbMY4R5znlxwZEuDLP0J1gK8Yn3SqrLf89IzWRvdXLNCyyW6lZjzb3IXn5NTLcABuseK868yZey2u2f8M7tcWNMEsD7HWOCGyQJdlwxNRFRtxG3muRcMDPHpPmyM+y/vVMjttcEH+argcln69pSLHNCdxBAqOHMr4leOQ6jMbH0aZwgI2be+VRBJgzBlgdAwgofm8CMkvPGmEbHN1qh5ucN1XvWtoXkdXMt7WMrpSiN3y5I6oQbZDGaleMPqdM10t4aipSbZEfIxW16ZhlaIzHDjggOcJ4q+rJ4TYh9tUx3pRbzVLdalRDK/SspGepcTwZvxtkHJ81bsGzj547aScOR8FR27IvGHKHFNylCgtji7Zn9m0D0II8Vz5KyDSJhBwGNbUdCPrH96ti4IyMVpUCHJCrlyDqtUcyvCXjANn+FeJGdFReGFDDeHy7xebWI5RA3xCDBJ4we3UEd/w6MrqKjVvblNIwZGHKiDh73VAwRFxJ3Q1EnM5+0FrMGjQmVvNGTnxDmIhh/ndq6F91VBXZ8UuKDhyEZvvAw5qkO1OvOeTEEI8ka0zDrgDe32CgjJ1Kxx/GX9rHA4c+tYvgZUD6qCA1PNb7HhUcLRgwQJwHIcJEyZolmVmZmLMmDEoUqQIChQogB49euD58+euy6SZOBj+5WJWI0CO/0/nTcWcVOFDCHElb7id2us++sfIKERXCsHvI6MMHCf3SGdnRmPVgNp2OrJreExwdObMGXz33XeoXr26zvKJEyfin3/+waZNm3D48GE8ffoU3bt3d1EunYn/W8u84dtMCCGuonUP5Qz8CM2PKoX544dBdU3OwwYAMrEQvhLPLj3yiL98Wloa+vfvj++//x6FCuUOiZ6cnIwff/wRS5YsQatWrVCnTh2sWbMGJ06cwKlTp1yYY9NsLuExuD0FR4QQz+M2Xfm17qGNyxZxYT6IK3lEcDRmzBh07NgR0dHROsvPnTsHuVyus7xixYooUaIETp48aXB/WVlZSElJ0fnnCoaqz1I5cwZipOCIuCd3ecQRYqs6JQu7OgseS/s+4CsRYs2Qei7LizXcPjjauHEjzp8/j/nz5+uti4+Ph0QiQWBgoM7ykJAQxMfHG9zn/PnzERAQoPkXERFh72ybZCyEudtoIc6pypnYAf8evKnNEfF8dDkSj0MXrVWMNV6/OqctWlYwPuK2u3Hr4OjRo0cYP3481q1bB5nM+Bwvlpg2bRqSk5M1/x49emS3fZvL2Peva6smEI/YZ2IH/H+6tGylDbki+Y039MYh3sF9fti5Sz48S94x04oWkGheCzxwwCi3bjF17tw5JCQkoHbt3FbvSqUSR44cwfLly7Fnzx5kZ2cjKSlJp/To+fPnCA01PNaCVCqFVCp1ZNYBmK5eMFStxnEcqhcPNLE1/7b7b75AW5M5I0TNEYNAet5tkBBib1XCAzCzYyUUCzQ0YLF7c+vgqHXr1rhy5YrOsiFDhqBixYqYOnUqIiIiIBaLsX//fvTo0QMAEBsbi7i4OERF8Xc3dCZjDwmbf7GL+S84FTX4IIQQkyoXC+BfoTMIJIX6tjBnKhJ35dbBUcGCBVG1alWdZX5+fihSpIhm+dChQzFp0iQULlwY/v7++OCDDxAVFYWGDRu6IssOd7dYF5Sp+xYg4+9OaWvRdIdqYfj11EOEB9ivGpMQQkxxdm+1QB+JgTXawZFbtzxxK95WRe/WwZE5vvrqKwgEAvTo0QNZWVlo27Ytvv32W1dnC4CJajUrr6P7xTqjTK2eQCZ/Dztbx5aIKlME/05s5hZFod71Vcs/qPCSeA0KjvItjwuODh06pPNeJpNhxYoVWLFihWsyZCWOs/Yh8l/IYOBL+3bNcGuzpFE+pKDN+7AHesh6Pm/7NUnyA+07D12/5vK2SawpLHa29/61aXNNrZmB6jM/gxPSEkII0TDUBEG7eo/aHOVbFBw5W4kGAKz/PcLxvNJNQF9mQojncX5XfkPBkUoriec/Ip3VlMvbSok9/y/vwcyaYNYQQzcSCo4IIcR6Iq3OKFL3aGJAnM/j2hx5C2t/JZksOfKy6J04liN+VdIVSDyCoXuwWAa8uw1gSgqO8jEKjjyO8QbZVHJEXM27mmUSZ3GfiWcBlG7u6hx4HGqQTcyWt9qMif3ypLA8kOFyLkCqViMegC5H4r7o4iSGUXDkQFyeSJobaltPNQAI0QzOSNVqhBBCjPOVCJ1yHG9rkE3Vas4UWtV0GhMqhf5XB27gJ7m3XaCEkPzB6b3VQqs593gu0q12Mey48gxNyxV1dVY8CgVHDmSsN5rttwH+PTCKjQghxLARh4GbO4AmE12dE6eQioT4dWgDV2fD41Bw5FI2NGAz+CuLoiNCCDEovKb6HyFGUJsjF8rbJsmyjQ1Uq1ELWEIIIcQmFBw50FvVSxhd74gwhlFwRAjxQG7VlZ/kexQcOdCIbm2Nrrep5MjIXgkhhBBiPQqOHEgkEuBPZTMAwDNWWGcdx/EHR09DWpjYq6mAiv6khBBCiC2oQbaDzZYPwjVVSexS1sepPOv4yniulxuJcFsOSAVHhBAPRO0liTuh4MiBOHBIhw/WKNvrrRMKOAdVqxFCCCHEFlQH4yJSkRAftSlnPFGpZvrLJAWMb0O/voiLUbtaQoino+DISXrWKa63rEO1MOMbdVut+77+CKBYHRNH8p7giB6yno9idUKIJ6JqNQfSfjAMjCqpn4Dn6a+zxD9P8NThS8sOSgghHoK68hN3QiVHLmX/m4E3za1GcZ5nor8bIe6tZkQgAKB91VDXZsSNUcmRk5j7o8jW4IYGgSSEeCLqreY8Pw2uhz3X4tGpuommHfkYBUcOZPKrbqpazTFHJUSDKjIIyX8K+0nQt77xGRzyO6pWcxL+H0UOqFajX1/ExajpCCHE01Fw5CTOe2BQcETchze1gSOE5B8UHDmQyVIcR0RMVHJECPFA1FuNuBMKjlyKJp4lhBBC3A0FR97Gi0qO6IckIYQQV6DgyIGs6a3mhKMS4lBeFJ8TJ6LOJMSdUHDkUtTmiHgfKvEjJB/yskcPBUeuJJLpL7P1weJFwZEXfZR8i/6GhOQTXvajiIIjBzL5YChaHqjYySl5IYQQQoh5KDhyJY4DOi7JsyxPmnYL1f+3mG7eLulPSgjxQNSVn7gTmj7ESQx+7f2KAn5BQPoL/oQNRwFVuwMFgs08Dt1gCCGEEFtQMYMDmdX7QiAEJlwxnsbMwOi/g5qflhBCCLEHL3v0UHDkJEavG6FE85IJhDYdhzEvu0IJIfkCdeX3cF5WaUHBkZOYe90wG/8kzItuMNQEwfN5z9VICMlPKDhyC7mPEMbZGBzR44gQQgixCQVHboZxtlWrUZsjQgghTudljx7qreYOBALsVtZDANKR6hdp066oKopYgq4X4i6oKz9xJxQcuYlR8okAgEU2Vqt5U/hOhWCEEOIhvCy2pWo1L8MJKKIgruVl90jiJNRbjbgTCo68Dt1giPugBx4hxBO5dXA0f/581KtXDwULFkRwcDC6du2K2NhYnTSZmZkYM2YMihQpggIFCqBHjx54/vy5i3LsDuhhRAghxMm87NHj1sHR4cOHMWbMGJw6dQp79+6FXC7HW2+9hfT0dE2aiRMn4p9//sGmTZtw+PBhPH36FN27d3dhrvk5q7EhVasRV6MrkBDi6dy6Qfbu3bt13q9duxbBwcE4d+4cmjVrhuTkZPz4449Yv349WrVqBQBYs2YNKlWqhFOnTqFhw4auyLZLedPEs9R5hZD8g3qreTgv+/N51JM0OTkZAFC4cGEAwLlz5yCXyxEdHa1JU7FiRZQoUQInT540uJ+srCykpKTo/HM0p7W9oDYexMW87B5JCMmHPCY4UqlUmDBhAho3boyqVasCAOLj4yGRSBAYGKiTNiQkBPHx8Qb3NX/+fAQEBGj+RUREODLrAJz4q4iCI+JG6GokJJ/wsi+7xwRHY8aMwdWrV7Fx40ab9zVt2jQkJydr/j169MgOObQPRr+7CSH5EPVsJO7Erdsc5Rg7diy2b9+OI0eOoHjx4prloaGhyM7ORlJSkk7p0fPnzxEaGmpwf1KpFFKp1JFZdhlqkE0IIYTYxq1LjhhjGDt2LP7++28cOHAApUqV0llfp04diMVi7N+/X7MsNjYWcXFxiIqKcnZ23YLAi359edFHIYQQ4kHcuuRozJgxWL9+PbZu3YqCBQtq2hEFBATAx8cHAQEBGDp0KCZNmoTChQvD398fH3zwAaKiovJlTzUAEAjcOt4lhBBC3J5bB0crV64EALRo0UJn+Zo1azB48GAAwFdffQWBQIAePXogKysLbdu2xbfffuvknLoPbyo5IoTkH9SVn7gTtw6OzPmyyGQyrFixAitWrHBCjqxX2E/ilONwNk9cS4j9UKxOCPFEbh0ceYPvBtZBYno2Shbxc8rxAn2dE4Q5A/2QJCT/oN5qxJ1QcORgbasY7jXnCIG+3tkLjxBCCHEWqoNxMwE+Npb80K8vYgEaV4sQQvRRyZGbWNyzBi4+eo23KofYtiOB0D4ZIoQQQvIpCo7cxDt1iuOdOsVNJzSFo+CIuBb1OiKEeDqqVvM2Aop3ifugRrbEXBRUE3dCwZG38aJqNXqueiYKiAghno6CI29D1WqEEA9EQTVxJxQceRuaPoQQQgixCT1JiduiJgiEEEJcgYIjQohdUcNaQoino+CIEEIIIUQL9fv2Bj6FgNExgNjH1TkhhBBCPB4FR96ioI0jaxNCCCEEAFWrEULsjLpkE0I8HQVHhBBCCLGJt/0kouDIk7VfpP6/+/euzYeDUAGEZ6LeaoTkP972rac2R56swUigzhBAJHF1TgghhBCvQSVHns6LAyMqgCAk/6ASR+JOKDgihBBCCNFCwREh+Rn9WCdugno5ejZv++tRcEQIIYQQm3jb7ywKjgghhBBCtFBwRAghhBCihYIjQgghhNiE2hwRQgghdkZd+Yk7oeCIuC3qvEIIIZ7B20JbCo6I26IfkoTkH9SVn7gTCo4IIYQQQrRQcEQIIYQQm3hbuR8FR4QQQgghWig4IoQQQohNvK2JKAVHhBBCCCFaKDgihBBCiE2ozREhhBBCiBej4IgQQgghRAsFR4QQQgixCTXIJoR4DW+7oRFCiD1QcEQIIYQQm1CDbEIIIYQQL0bBESGEEEJs4m1V9BQcEUIIIYRo8ZrgaMWKFYiMjIRMJkODBg1w+vRpV2eJEEIIyReozZEb+v333zFp0iTMnj0b58+fR40aNdC2bVskJCS4OmuEEEII8TBeERwtWbIEw4cPx5AhQ1C5cmWsWrUKvr6++Omnn1ydNUIIIYR4GI8PjrKzs3Hu3DlER0drlgkEAkRHR+PkyZO822RlZSElJUXnH3E/If5SV2fB60mE9r8FcJy3FbATZwj0EdtlP0ULqO8bEpHHP948Snigj6uzYFcef/W8fPkSSqUSISEhOstDQkIQHx/Pu838+fMREBCg+RcREeGMrBIzLepRHYX9JJjzdhVXZ8VrDW4UieCCUvSuZ/9r/63KIShaQIr2VUPtvm/ivaa2r4gCUhGmd6ho036+fEd9//imd037ZIwY9XXvmijsJ8HnXau6Oit2xTHGPLoH3tOnT1GsWDGcOHECUVFRmuVTpkzB4cOHERMTo7dNVlYWsrKyNO9TUlIQERGB5ORk+Pv7OyXfxDjGGJVAOJgjzzH9/Yg17HXd0PXnXK483ykpKQgICLD781tktz25SNGiRSEUCvH8+XOd5c+fP0doKP8vV6lUCqmUqmzcGd3YHM+R55j+fsQa9rpu6PpzLm883x5frSaRSFCnTh3s379fs0ylUmH//v06JUmEEEIIIebw+JIjAJg0aRIGDRqEunXron79+vj666+Rnp6OIUOGuDprhBBCCPEwXhEc9e7dGy9evMCsWbMQHx+PmjVrYvfu3XqNtAkhhBBCTPH4Btn24KgGXYQQQghxHEc9vz2+zREhhBBCiD1RcEQIIYQQooWCI0IIIYQQLRQcEUIIIYRooeCIEEIIIUQLBUeEEEIIIVooOCKEEEII0ULBESGEEEKIFgqOCCGEEEK0eMX0IbbKGSQ8JSXFxTkhhBBCiLlyntv2nuyDgiMAqampAICIiAgX54QQQgghlkpNTUVAQIDd9kdzqwFQqVR4+vQpChYsCI7jXJ0dm6SkpCAiIgKPHj2ieeIMoHNkHJ0f0+gcGUfnxzg6P6aZe44YY0hNTUV4eDgEAvu1FKKSIwACgQDFixd3dTbsyt/fn750JtA5Mo7Oj2l0joyj82McnR/TzDlH9iwxykENsgkhhBBCtFBwRAghhBCihYIjLyOVSjF79mxIpVJXZ8Vt0Tkyjs6PaXSOjKPzYxydH9NcfY6oQTYhhBBCiBYqOSKEEEII0ULBESGEEEKIFgqOCCGEEEK0UHBECCGEEKKFgiM3t2DBAnAchwkTJmiWZWZmYsyYMShSpAgKFCiAHj164Pnz5zrbxcXFoWPHjvD19UVwcDAmT54MhUKhk+bQoUOoXbs2pFIpypYti7Vr1zrhE9luzpw54DhO51/FihU16/P7+cnx5MkTDBgwAEWKFIGPjw+qVauGs2fPatYzxjBr1iyEhYXBx8cH0dHRuH37ts4+EhMT0b9/f/j7+yMwMBBDhw5FWlqaTprLly+jadOmkMlkiIiIwKJFi5zy+WwRGRmpdw1xHIcxY8YAoGtIqVTik08+QalSpeDj44MyZcpg3rx5OvNX5efrJ0dqaiomTJiAkiVLwsfHB40aNcKZM2c06/PTOTpy5Ag6d+6M8PBwcByHLVu26Kx35rnYtGkTKlasCJlMhmrVqmHnzp2WfyBG3Nbp06dZZGQkq169Ohs/frxm+ahRo1hERATbv38/O3v2LGvYsCFr1KiRZr1CoWBVq1Zl0dHR7MKFC2znzp2saNGibNq0aZo09+7dY76+vmzSpEns+vXrbNmyZUwoFLLdu3c78yNaZfbs2axKlSrs2bNnmn8vXrzQrM/v54cxxhITE1nJkiXZ4MGDWUxMDLt37x7bs2cPu3PnjibNggULWEBAANuyZQu7dOkSe/vtt1mpUqXYmzdvNGnatWvHatSowU6dOsWOHj3KypYty/r27atZn5yczEJCQlj//v3Z1atX2YYNG5iPjw/77rvvnPp5LZWQkKBz/ezdu5cBYAcPHmSM0TX0+eefsyJFirDt27ez+/fvs02bNrECBQqwb775RpMmP18/OXr16sUqV67MDh8+zG7fvs1mz57N/P392ePHjxlj+esc7dy5k82YMYNt3ryZAWB///23znpnnYvjx48zoVDIFi1axK5fv85mzpzJxGIxu3LlikWfh4IjN5WamsrKlSvH9u7dy5o3b64JjpKSkphYLGabNm3SpL1x4wYDwE6ePMkYU1+kAoGAxcfHa9KsXLmS+fv7s6ysLMYYY1OmTGFVqlTROWbv3r1Z27ZtHfzJbDd79mxWo0YN3nV0ftSmTp3KmjRpYnC9SqVioaGh7Msvv9QsS0pKYlKplG3YsIExxtj169cZAHbmzBlNml27djGO49iTJ08YY4x9++23rFChQprzlnPsChUq2PsjOdT48eNZmTJlmEqlomuIMdaxY0f23nvv6Szr3r0769+/P2OMrh/GGMvIyGBCoZBt375dZ3nt2rXZjBkz8vU5yhscOfNc9OrVi3Xs2FEnPw0aNGAjR4606DNQtZqbGjNmDDp27Ijo6Gid5efOnYNcLtdZXrFiRZQoUQInT54EAJw8eRLVqlVDSEiIJk3btm2RkpKCa9euadLk3Xfbtm01+3B3t2/fRnh4OEqXLo3+/fsjLi4OAJ2fHNu2bUPdunXRs2dPBAcHo1atWvj+++816+/fv4/4+HidzxgQEIAGDRronKfAwEDUrVtXkyY6OhoCgQAxMTGaNM2aNYNEItGkadu2LWJjY/H69WtHf0y7yM7Oxm+//Yb33nsPHMfRNQSgUaNG2L9/P27dugUAuHTpEo4dO4b27dsDoOsHABQKBZRKJWQymc5yHx8fHDt2jM6RFmeeC3t97yg4ckMbN27E+fPnMX/+fL118fHxkEgkCAwM1FkeEhKC+Ph4TRrtm3bO+px1xtKkpKTgzZs39vooDtGgQQOsXbsWu3fvxsqVK3H//n00bdoUqampdH7+c+/ePaxcuRLlypXDnj178P7772PcuHH4+eefAeR+Tr7PqH0OgoODddaLRCIULlzYonPp7rZs2YKkpCQMHjwYAH3HAODjjz9Gnz59ULFiRYjFYtSqVQsTJkxA//79AdD1AwAFCxZEVFQU5s2bh6dPn0KpVOK3337DyZMn8ezZMzpHWpx5LgylsfRciSxKTRzu0aNHGD9+PPbu3av3i4So5fx6BYDq1aujQYMGKFmyJP744w/4+Pi4MGfuQ6VSoW7duvjiiy8AALVq1cLVq1exatUqDBo0yMW5cy8//vgj2rdvj/DwcFdnxW388ccfWLduHdavX48qVarg4sWLmDBhAsLDw+n60fLrr7/ivffeQ7FixSAUClG7dm307dsX586dc3XWiI2o5MjNnDt3DgkJCahduzZEIhFEIhEOHz6MpUuXQiQSISQkBNnZ2UhKStLZ7vnz5wgNDQUAhIaG6vWsyXlvKo2/v7/HBRiBgYEoX7487ty5g9DQUDo/AMLCwlC5cmWdZZUqVdJUP+Z8Tr7PqH0OEhISdNYrFAokJiZadC7d2cOHD7Fv3z4MGzZMs4yuIWDy5Mma0qNq1aph4MCBmDhxoqY0m64ftTJlyuDw4cNIS0vDo0ePcPr0acjlcpQuXZrOkRZnngtDaSw9VxQcuZnWrVvjypUruHjxouZf3bp10b9/f81rsViM/fv3a7aJjY1FXFwcoqKiAABRUVG4cuWKzoW2d+9e+Pv7ax6YUVFROvvISZOzD0+SlpaGu3fvIiwsDHXq1KHzA6Bx48aIjY3VWXbr1i2ULFkSAFCqVCmEhobqfMaUlBTExMTonKekpCSdX8EHDhyASqVCgwYNNGmOHDkCuVyuSbN3715UqFABhQoVctjns5c1a9YgODgYHTt21CyjawjIyMiAQKD7eBAKhVCpVADo+snLz88PYWFheP36Nfbs2YMuXbrQOdLizHNht++dRc23iUto91ZjTN3NuESJEuzAgQPs7NmzLCoqikVFRWnW53Qzfuutt9jFixfZ7t27WVBQEG8348mTJ7MbN26wFStWeEw34w8//JAdOnSI3b9/nx0/fpxFR0ezokWLsoSEBMYYnR/G1MNAiEQi9vnnn7Pbt2+zdevWMV9fX/bbb79p0ixYsIAFBgayrVu3ssuXL7MuXbrwdq2tVasWi4mJYceOHWPlypXT6VqblJTEQkJC2MCBA9nVq1fZxo0bma+vr9t1M+ajVCpZiRIl2NSpU/XW5fdraNCgQaxYsWKarvybN29mRYsWZVOmTNGkye/XD2OM7d69m+3atYvdu3eP/fvvv6xGjRqsQYMGLDs7mzGWv85Ramoqu3DhArtw4QIDwJYsWcIuXLjAHj58yBhz3rk4fvw4E4lEbPHixezGjRts9uzZ1JXfW+UNjt68ecNGjx7NChUqxHx9fVm3bt3Ys2fPdLZ58OABa9++PfPx8WFFixZlH374IZPL5TppDh48yGrWrMkkEgkrXbo0W7NmjRM+je169+7NwsLCmEQiYcWKFWO9e/fWGb8nv5+fHP/88w+rWrUqk0qlrGLFimz16tU661UqFfvkk09YSEgIk0qlrHXr1iw2NlYnzatXr1jfvn1ZgQIFmL+/PxsyZAhLTU3VSXPp0iXWpEkTJpVKWbFixdiCBQsc/tnsYc+ePQyA3mdmjK6hlJQUNn78eFaiRAkmk8lY6dKl2YwZM3S6UOf364cxxn7//XdWunRpJpFIWGhoKBszZgxLSkrSrM9P5+jgwYMMgN6/QYMGMcacey7++OMPVr58eSaRSFiVKlXYjh07LP48HGNaQ54SQgghhORz1OaIEEIIIUQLBUeEEEIIIVooOCKEEEII0ULBESGEEEKIFgqOCCGEEEK0UHBECCGEEKKFgiNCCCGEEC0UHBFCCCGEaKHgiBBC3EBsbCzq1auHUqVKYevWra7ODiH5Go2QTQghbqB3796oX78+qlevjqFDhyIuLs7VWSIk36KSI0KIR5gzZw5q1qzp6mxocByHLVu2WLxdbGwsQkNDkZqaqrM8ICAAJUuWRNmyZREcHKy3XcOGDfHXX39Zm11CiAUoOCKEaKxatQoFCxaEQqHQLEtLS4NYLEaLFi100h46dAgcx+Hu3btOzqVz2TsomzZtGj744AMULFhQZ/ncuXPRu3dvlC1bFtOmTdPbbubMmfj444+hUqnslhdCCD8KjgghGi1btkRaWhrOnj2rWXb06FGEhoYiJiYGmZmZmuUHDx5EiRIlUKZMGVdk1SPFxcVh+/btGDx4sN66mJgYFC9eHH369MGJEyf01rdv3x6pqanYtWuXE3JKSP5GwREhRKNChQoICwvDoUOHNMsOHTqELl26oFSpUjh16pTO8pYtWwIAfv31V9StWxcFCxZEaGgo+vXrh4SEBACASqVC8eLFsXLlSp1jXbhwAQKBAA8fPgQAJCUlYdiwYQgKCoK/vz9atWqFS5cuGc3vDz/8gEqVKkEmk6FixYr49ttvNesePHgAjuOwefNmtGzZEr6+vqhRowZOnjyps4/vv/8eERER8PX1Rbdu3bBkyRIEBgYCANauXYtPP/0Uly5dAsdx4DgOa9eu1Wz78uVLdOvWDb6+vihXrhy2bdtmNL9//PEHatSogWLFiumtW7NmDfr164eBAwfit99+0ym9AwChUIgOHTpg48aNRo9BCLEdBUeEEB0tW7bEwYMHNe8PHjyIFi1aoHnz5prlb968QUxMjCY4ksvlmDdvHi5duoQtW7bgwYMHmtIRgUCAvn37Yv369TrHWbduHRo3boySJUsCAHr27ImEhATs2rUL586dQ+3atdG6dWskJiby5nPdunWYNWsWPv/8c9y4cQNffPEFPvnkE/z888866WbMmIGPPvoIFy9eRPny5dG3b19N4HH8+HGMGjUK48ePx8WLF9GmTRt8/vnnmm179+6NDz/8EFWqVMGzZ8/w7Nkz9O7dW7P+008/Ra9evXD58mV06NAB/fv3N5hfQF0KV7duXb3lCQkJ2LlzJwYMGIA2bdqA4zjs2LFDL139+vVx9OhRg/snhNgJI4QQLd9//z3z8/NjcrmcpaSkMJFIxBISEtj69etZs2bNGGOM7d+/nwFgDx8+5N3HmTNnGACWmprKGGPswoULjOM4TXqlUsmKFSvGVq5cyRhj7OjRo8zf359lZmbq7KdMmTLsu+++Y4wxNnv2bFajRg2ddevXr9dJP2/ePBYVFcUYY+z+/fsMAPvhhx80669du8YAsBs3bjDGGOvduzfr2LGjzj769+/PAgICNO/zHjcHADZz5kzN+7S0NAaA7dq1i/ecMMZYjRo12Ny5c/WW/+9//2M1a9bUvB8/fjzr2rWrXrqtW7cygUDAlEqlwWMQQmxHJUeEEB0tWrRAeno6zpw5g6NHj6J8+fIICgpC8+bNNe2ODh06hNKlS6NEiRIAgHPnzqFz584oUaIEChYsiObNmwOApjt6zZo1UalSJU3p0eHDh5GQkICePXsCAC5duoS0tDQUKVIEBQoU0Py7f/8+b4Pv9PR03L17F0OHDtVJ/9lnn+mlr169uuZ1WFgYAGiq/GJjY1G/fn2d9HnfG6O9bz8/P/j7+2v2zefNmzeQyWR6y9esWYMBAwZo3g8YMAA7duzAixcvdNL5+PhApVIhKyvL7DwSQiwncnUGCCHupWzZsihevDgOHjyI169fawKd8PBwRERE4MSJEzh48CBatWoFQB2otG3bFm3btsW6desQFBSEuLg4tG3bFtnZ2Zr99u/fH+vXr8fHH3+M9evXo127dihSpAgAdY+4vG2dcuS0/9GWlpYGQN1eqEGDBjrrhEKhznuxWKx5zXEcANitx5f2vnP2b2zfRYsWxevXr3WWnT17FlevXsWUKVMwdepUzXKlUonffvsNEydO1CxLTEyEn58ffHx87JJ/Qgg/Co4IIXpatmyJQ4cO4fXr15g8ebJmebNmzbBr1y6cPn0a77//PgDg5s2bePXqFRYsWICIiAgA0OntlqNfv36YOXMmzp07hz///BOrVq3SrKtduzbi4+MhEokQGRlpMn8hISEIDw/HvXv30L9/f6s/Z4UKFXDmzBmdZXnfSyQSKJVKq4+hrVatWrh+/brOsjVr1qBZs2ZYsWKFzvJff/0Va9eu1QmOrl69ilq1atklL4QQw6hajRCip2XLljh27BguXryoKTkCgObNm+O7775Ddna2pjF2iRIlIJFIsGzZMty7dw/btm3DvHnz9PYZGRmJRo0aYejQoVAqlXj77bc166KjoxEVFYWuXbvi33//xYMHD3DixAnMmDGDN9AC1I2h58+fj6VLl+LWrVu4cuUK1qxZgyVLlpj9OT/44APs3LkTS5Yswe3bt/Hdd99h165dmhKmnHzfv38fFy9exMuXL22q0mrbti1OnjypCbaysrKwYcMG9O3bF1WrVtX5N2zYMFy+fBnnz5/XbH/06FG89dZbVh+fEGIeCo4IIXpatmyJN2/eoGzZsggJCdEsb968OVJTUzVd/gEgKCgIa9euxaZNm1C5cmUsWLAAixcv5t1v//79cenSJXTr1k2naojjOOzcuRPNmjXDkCFDUL58efTp0wcPHz7UOb62YcOG4YcffsCaNWtQrVo1NG/eHGvXrkWpUqXM/pyNGzfGqlWrsGTJEtSoUQO7d+/GxIkTddoF9ejRA+3atUPLli0RFBSEDRs2mL3/vNq3bw+RSIR9+/YBALZs2YLk5GR069ZNL225cuVQrVo1rFmzBgDw5MkTnDhxAkOGDLH6+IQQ89DcaoQQomX48OG4efOmw7rMr1ixAtu2bcOePXss2m7q1Kl4/fo1Vq9e7ZB8EUJyUZsjQki+tnjxYrRp0wZ+fn7YtWsXfv75Z53BJO1t5MiRSEpKQmpqqt4UIsYEBwdj0qRJDssXISQXlRwRQvK1Xr164dChQ0hNTUXp0qXxwQcfYNSoUa7OFiHEhSg4IoQQQgjRQg2yCSGEEEK0UHBECCGEEKKFgiNCCCGEEC0UHBHy/3brWAAAAABgkL/13kEURQAwcgQAMHIEADByBAAwcgQAMAEUonGxNZBXNAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -820,7 +821,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 22, "id": "d9bd208e-d5f3-45e1-84a4-e4d913f160f3", "metadata": {}, "outputs": [], @@ -831,7 +832,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 23, "id": "6e898d37-f4af-4644-8789-8c0daf674d45", "metadata": {}, "outputs": [], @@ -841,7 +842,7 @@ }, { "cell_type": "code", - "execution_count": 97, + "execution_count": 24, "id": "b311c888-dda5-4ea8-b23b-0cc77e7e4cdc", "metadata": {}, "outputs": [], @@ -862,22 +863,36 @@ }, { "cell_type": "code", - "execution_count": 98, + "execution_count": 25, "id": "445e15e2-7520-4d99-b81e-35fbf010f5a7", "metadata": {}, "outputs": [], "source": [ "from tqdm.auto import tqdm\n", - "import torch\n", "from mmoma.datasets.astropile import FastAstroPileLoader" ] }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 26, "id": "e2306aa7-3bba-4511-843a-5385c131344c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dcd0c907f07c40698b334b6a5041a0b4", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Resolving data files: 0%| | 0/3072 [00:00" ] From d591d7ffc11e108c73a705f31121269a6aa65616 Mon Sep 17 00:00:00 2001 From: Jeff Shen Date: Mon, 7 Apr 2025 14:27:57 -0400 Subject: [PATCH 4/4] wording --- examples/getting_started.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/getting_started.ipynb b/examples/getting_started.ipynb index 66ecc2a..abd9678 100644 --- a/examples/getting_started.ipynb +++ b/examples/getting_started.ipynb @@ -767,7 +767,7 @@ "source": [ "## Embedding-based adaptation\n", "\n", - "Next, I will demonstrate how you can quickly AION to perform downstream tasks based on embeddings. Here I will demonstrate parameter regression for stars.\n", + "Next, I will demonstrate how you can quickly adapt AION to perform downstream tasks based on embeddings. Here I will demonstrate parameter regression for stars.\n", "\n", "The idea is that AION has been pretrained on vast amounts of data and has a good general understanding of stars. So, despite not being explicitly told anything about physical parameters, if we give it some input data, at the end of the encoder (we will not be using the decoder here), we will have some useful representation (embeddings) in which \"important\" information about stars is linearly accessible. We will take advantage of this fact to build a simple projection matrix to access this information and to tie it to some physical properties." ]