From aea1912244036033434c8b0da9700074f5e2f03a Mon Sep 17 00:00:00 2001
From: ChrisC28 <chris.chapman.28@gmail.com>
Date: Tue, 29 Oct 2024 17:16:46 +1100
Subject: [PATCH] Basic working example of WOD->CODA parquet

---
 notebooks/WOD_to_CODA_parquet.ipynb | 1583 +++++++++++++++++++++++++++
 1 file changed, 1583 insertions(+)
 create mode 100644 notebooks/WOD_to_CODA_parquet.ipynb

diff --git a/notebooks/WOD_to_CODA_parquet.ipynb b/notebooks/WOD_to_CODA_parquet.ipynb
new file mode 100644
index 0000000..43827ed
--- /dev/null
+++ b/notebooks/WOD_to_CODA_parquet.ipynb
@@ -0,0 +1,1583 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d4624cff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#import xarray\n",
+    "#import fsspec\n",
+    "import numpy as np\n",
+    "#import s3fs\n",
+    "import proplot\n",
+    "import os\n",
+    "\n",
+    "from matplotlib import pyplot as plt\n",
+    "import pandas\n",
+    "import json"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "e6d4e1fc-5d40-41e8-a125-79b5a1a4ae43",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def set_metadata(tbl, col_meta={}, tbl_meta={}):\n",
+    "    \"\"\"Store table- and column-level metadata as json-encoded byte strings.\n",
+    "\n",
+    "    Table-level metadata is stored in the table's schema.\n",
+    "    Column-level metadata is stored in the table columns' fields.\n",
+    "\n",
+    "    To update the metadata, first new fields are created for all columns.\n",
+    "    Next a schema is created using the new fields and updated table metadata.\n",
+    "    Finally a new table is created by replacing the old one's schema, but\n",
+    "    without copying any data.\n",
+    "\n",
+    "    Args:\n",
+    "        tbl (pyarrow.Table): The table to store metadata in\n",
+    "        col_meta: A json-serializable dictionary with column metadata in the form\n",
+    "            {\n",
+    "                'column_1': {'some': 'data', 'value': 1},\n",
+    "                'column_2': {'more': 'stuff', 'values': [1,2,3]}\n",
+    "            }\n",
+    "        tbl_meta: A json-serializable dictionary with table-level metadata.\n",
+    "    \"\"\"\n",
+    "    # Create updated column fields with new metadata\n",
+    "    if col_meta or tbl_meta:\n",
+    "        fields = []\n",
+    "        for col in tbl.schema.names:\n",
+    "            if col in col_meta:\n",
+    "                # Get updated column metadata\n",
+    "                metadata = tbl.field(col).metadata or {}\n",
+    "                for k, v in col_meta[col].items():\n",
+    "                    metadata[k] = json.dumps(v).encode('utf-8')\n",
+    "                # Update field with updated metadata\n",
+    "                fields.append(tbl.field(col).with_metadata(metadata))\n",
+    "            else:\n",
+    "                fields.append(tbl.field(col))\n",
+    "        \n",
+    "        # Get updated table metadata\n",
+    "        tbl_metadata = tbl.schema.metadata or {}\n",
+    "        for k, v in tbl_meta.items():\n",
+    "            if type(v)==bytes:\n",
+    "                tbl_metadata[k] = v\n",
+    "            else:\n",
+    "                tbl_metadata[k] = json.dumps(v).encode('utf-8')\n",
+    "\n",
+    "        # Create new schema with updated field metadata and updated table metadata\n",
+    "        schema = pa.schema(fields, metadata=tbl_metadata)\n",
+    "\n",
+    "        # With updated schema build new table (shouldn't copy data)\n",
+    "        # tbl = pa.Table.from_batches(tbl.to_batches(), schema)\n",
+    "        tbl = tbl.cast(schema)\n",
+    "\n",
+    "    return tbl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "903fd7a3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def Get_CODA_id(dates,source_data,obs_platform,year,profile_count):\n",
+    "    \n",
+    "    CODA_id_length = 20\n",
+    "    CODA_ID = np.array(['' for _ in range(dates.size)], dtype='S{}'.format(CODA_id_length))\n",
+    "    \n",
+    "    unique_dates = np.unique(dates)\n",
+    "\n",
+    "    \n",
+    "    for i_date in unique_dates:\n",
+    "    \n",
+    "        if not pandas.isnull(i_date):\n",
+    "            \n",
+    "            idx_for_date   =  np.nonzero(dates == i_date)[0]\n",
+    "            count_for_date =  idx_for_date.size\n",
+    "            \n",
+    "            for i_index in idx_for_date:\n",
+    "                #print(i_index)\n",
+    "                #CODA_id_current_profiles = source_data + obs_platform + i_date.strftime('%Y%m%d') + f'{i_profile:04}' \n",
+    "                CODA_id_current_profiles = source_data + obs_platform + np.datetime_as_string(i_date, unit='D').replace('-','') + f'{profile_count:04}'\n",
+    "                CODA_ID[i_index] = CODA_id_current_profiles\n",
+    "                \n",
+    "            #END for i_index\n",
+    "        #if not isnull\n",
+    "    #END for i_date\n",
+    "\n",
+    "    bad_dates_idx = np.nonzero(pandas.isnull(dates))[0]\n",
+    " \n",
+    "    bad_profile_counter = 1\n",
+    "    \n",
+    "    for i_bad_idx in bad_dates_idx:\n",
+    "        CODA_id_current_profiles = source_data + obs_platform + str(year) + 'XXXX' + f'{bad_profile_counter:04}'\n",
+    "        CODA_ID[i_bad_idx] = CODA_id_current_profiles\n",
+    "        bad_profile_counter = bad_profile_counter+1\n",
+    "\n",
+    "    return CODA_ID"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "fa3bab3f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append('/tube1/cha674/CARS_2022/cars-v2/wodpy/wodpy')\n",
+    "import wodnc"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "53988383",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "START_YEAR = 2018\n",
+    "END_YEAR   = 2019"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0223dbe4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "obs_type = ['ctd','xbt','pfl','mrb','gld'] #,'drb'] #,'gld']\n",
+    "#obs_type = ['ctd']\n",
+    "\n",
+    "base_s3_url = 's3://noaa-wod-pds'\n",
+    "\n",
+    "data_container = {}\n",
+    "\n",
+    "output_directory = '/tube1/cha674/CARS_2022_ancillary_data/WOD_2018'\n",
+    "\n",
+    "for i_year in range(START_YEAR,END_YEAR+1):\n",
+    "\n",
+    "    data_container_for_year = {}\n",
+    "    for i_obs_type in obs_type:\n",
+    "        url = base_s3_url + '/' + str(i_year) + '/wod_' + i_obs_type + '_' + str(i_year) + '.nc' #_pfl_2018.nc'\n",
+    "        print(url)\n",
+    "        fs = s3fs.S3FileSystem(anon=True)\n",
+    "        file_obj = fs.open(url)\n",
+    "        ds = xarray.open_dataset(file_obj,engine='h5netcdf')\n",
+    "        data_container_for_year[i_obs_type] = ds\n",
+    "        \n",
+    "        #Write data out\n",
+    "        if not os.path.isdir(os.path.join(output_directory,str(i_year))):\n",
+    "            os.mkdir(os.path.join(output_directory,str(i_year)))\n",
+    "        print(os.path.join(output_directory,str(i_year),'wod_' + i_obs_type + '_' + str(i_year) + '.nc'))\n",
+    "        ds.to_netcdf(os.path.join(output_directory,str(i_year),'wod_' + i_obs_type + '_' + str(i_year) + '.nc'))\n",
+    "        \n",
+    "    data_container[i_year] = data_container_for_year"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "4c034d54",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Working on year:  2018\n",
+      "Working on platform:  ctd\n",
+      "Profile:  0  of  1000\n",
+      "Building dataframe\n",
+      "Writing file: WOD2018_CODA_2018_ctd.parquet\n"
+     ]
+    },
+    {
+     "ename": "NameError",
+     "evalue": "name 'sdaa' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[6], line 167\u001b[0m\n\u001b[1;32m    164\u001b[0m     os\u001b[38;5;241m.\u001b[39mmkdir(os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(output_path,\u001b[38;5;28mstr\u001b[39m(i_year)))\n\u001b[1;32m    165\u001b[0m wod_dataframe\u001b[38;5;241m.\u001b[39mto_parquet(os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mjoin(output_path,\u001b[38;5;28mstr\u001b[39m(i_year),output_file_name),engine\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mpyarrow\u001b[39m\u001b[38;5;124m'\u001b[39m,compression\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msnappy\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m--> 167\u001b[0m \u001b[43msdaa\u001b[49m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'sdaa' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "WOD_directory = '//oa-decadal-climate/work/observations/WOD2018/'\n",
+    "platforms_to_get = ['ctd','osd','pfl','xbt','mrb','gld']\n",
+    "WOD_file_name_stem = 'wod_'\n",
+    "\n",
+    "profile_vars_to_get   = ['Temperature','Salinity','Oxygen','Chlorophyll','Silicate','Phosphate','Nitrate','pH','Alkalinity','tCO2','z']\n",
+    "point_vars_to_get     = ['lat','lon','wod_unique_cast']\n",
+    "ancillary_vars_to_get = ['origflagset','country','dataset','Access_no','Recorder',\n",
+    "                         'dbase_orig','Platform','Project','WOD_cruise_identifier',\n",
+    "                         'Institute','needs_z_fix','Ocean_Vehicle','Temperature_Instrument']\n",
+    "\n",
+    "output_path = '/oa-decadal-climate/work/observations/CARSv2_ancillary/CODA/CODAv1/parquet'\n",
+    "\n",
+    "FILL_VALUE = -10000000000.0\n",
+    "\n",
+    "\n",
+    "column_names = point_vars_to_get.copy()\n",
+    "column_names = column_names.append(profile_vars_to_get)\n",
+    "\n",
+    "\n",
+    "\n",
+    "for i_year in range(START_YEAR,END_YEAR+1):\n",
+    "    print('Working on year: ', i_year)\n",
+    "    for i_platform in platforms_to_get:\n",
+    "        print('Working on platform: ', i_platform)\n",
+    "\n",
+    "        file_name  = WOD_file_name_stem + i_platform + '_' + str(i_year) + '.nc'\n",
+    "        WOD_ragged_object = wodnc.Ragged(os.path.join(WOD_directory,str(i_year),file_name))\n",
+    "        \n",
+    "        vars_in_dataset = list(WOD_ragged_object.variables().keys())\n",
+    "        \n",
+    "        \n",
+    "        n_profiles = WOD_ragged_object.ncasts()\n",
+    "        \n",
+    "        \n",
+    "        profile_data_container   = {}\n",
+    "        ancillary_data_container = {}\n",
+    "        attributes_data_container = {}\n",
+    "        \n",
+    "        data_vars_to_get = profile_vars_to_get + point_vars_to_get\n",
+    "        \n",
+    "        #data_vars_to_get.append(point_vars_to_get)\n",
+    "        \n",
+    "        \n",
+    "        for i_var in data_vars_to_get:\n",
+    "            if i_var in vars_in_dataset:\n",
+    "                \n",
+    "                profile_data_container[i_var]  = []\n",
+    "                \n",
+    "                if i_var in profile_vars_to_get:\n",
+    "                    profile_data_container[i_var + '_WODflag']  = []\n",
+    "                    profile_data_container[i_var + '_origflag'] = []\n",
+    "                \n",
+    "        \n",
+    "                \n",
+    "                attributes_data_container[i_var]            = {}\n",
+    "                attributes_data_container[i_var + '_WODflag']  = {}\n",
+    "                attributes_data_container[i_var + '_origflag'] = {}\n",
+    "        \n",
+    "        for i_ancillary_var in ancillary_vars_to_get:\n",
+    "            if i_ancillary_var in vars_in_dataset:\n",
+    "                \n",
+    "                ancillary_data_container[i_ancillary_var]  = []\n",
+    "                \n",
+    "                attributes_data_container[i_ancillary_var] = {}\n",
+    "        \n",
+    "        \n",
+    "        \n",
+    "        vars_to_CODA = list(profile_data_container.keys())\n",
+    "        \n",
+    "        profile_data_container['time']     = []\n",
+    "        profile_data_container['CODA_id']  = []\n",
+    "\n",
+    "        \n",
+    "        \n",
+    "        # = list(WOD_ragged_object.variables().keys())\n",
+    "\n",
+    "        number_of_levels_by_profile = []\n",
+    "        \n",
+    "        #DEBUG\n",
+    "        n_profiles = 1000\n",
+    "        for i_profile in range(0,n_profiles):\n",
+    "            \n",
+    "             #= pandas.DataFrame(columns=column_names)\n",
+    "            if (i_profile % 1000) ==0:\n",
+    "                print(\"Profile: \", i_profile, ' of ', n_profiles)\n",
+    "            \n",
+    "            WOD_profile_object   = wodnc.ncProfile(WOD_ragged_object,i_profile)      \n",
+    "            n_levels             = WOD_profile_object.n_levels()\n",
+    "            \n",
+    "            number_of_levels_by_profile.append(n_levels)\n",
+    "            \n",
+    "            for i_var in vars_to_CODA:\n",
+    "                if i_var in vars_in_dataset:\n",
+    "                    if WOD_profile_object.is_level_data(i_var):\n",
+    "                \n",
+    "                        current_variable     = WOD_profile_object.level_unpack(i_var)\n",
+    "                \n",
+    "                        #Test for missing data on profile\n",
+    "                        if current_variable.size != 0:\n",
+    "                            profile_data_container[i_var].append(current_variable)\n",
+    "                        else:\n",
+    "                            profile_data_container[i_var].append(np.repeat(np.nan,n_levels))\n",
+    "                        #END if current_variable.size != 0:\n",
+    "                    \n",
+    "                    elif WOD_profile_object.is_metadata(i_var):\n",
+    "                        \n",
+    "                        current_point_data            = WOD_profile_object.metadata(i_var)\n",
+    "                        \n",
+    "                        profile_data_container[i_var].append( np.repeat(current_point_data,n_levels) )\n",
+    "             \n",
+    "            #END for i_var\n",
+    "            \n",
+    "            #Extract datetimes\n",
+    "            current_time = WOD_profile_object.datetime()\n",
+    "            current_datetime = np.datetime64(current_time).astype('datetime64[s]')\n",
+    "            profile_data_container['time'].append( np.repeat(current_datetime,n_levels) )\n",
+    "\n",
+    "            for i_ancillary_var in ancillary_data_container.keys():\n",
+    "                current_ancillary_var = WOD_profile_object.metadata(i_ancillary_var)\n",
+    "                \n",
+    "                if isinstance(current_ancillary_var,str):\n",
+    "                    ancillary_data_container[i_ancillary_var].append(f\"{current_ancillary_var:<100}\")\n",
+    "                else:\n",
+    "                    ancillary_data_container[i_ancillary_var].append(current_ancillary_var)\n",
+    "                #END if isinstance()\n",
+    "            \n",
+    "            #END for i_ancillary_variable    \n",
+    "\n",
+    "            \n",
+    "            source_data   = 'WOD'\n",
+    "\n",
+    "            \n",
+    "            #Set the CODA Identifier\n",
+    "            CODA_id = Get_CODA_id( profile_data_container['time'][-1][0],source_data,i_platform,i_year,i_profile)\n",
+    "            profile_data_container['CODA_id'].append(np.repeat(CODA_id,n_levels))\n",
+    "            \n",
+    "            \n",
+    "        #END for i_profile\n",
+    "        #/oa-decadal-climate/work/observations/CARSv2_ancillary/CODA/CODAv1/\n",
+    "        #Build Dataframe\n",
+    "        print('Building dataframe')\n",
+    "        wod_dataframe = pandas.DataFrame(columns=profile_data_container.keys())\n",
+    "\n",
+    "        for i_var in profile_data_container:\n",
+    "            wod_dataframe[i_var] = np.concatenate(profile_data_container[i_var])\n",
+    "        #END for i_var\n",
+    "        \n",
+    "        for i_ancillary_var in ancillary_data_container.keys():\n",
+    "            #print(i_ancillary_var)\n",
+    "            current_ancillary_var = []\n",
+    "    \n",
+    "            for i_profile in range(0,n_profiles):\n",
+    "                current_ancillary_var.append( np.repeat(ancillary_data_container[i_ancillary_var][i_profile], number_of_levels_by_profile[i_profile]) )\n",
+    "            #END for i_profile    \n",
+    "            n_columns = len(wod_dataframe.columns)\n",
+    "\n",
+    "            wod_dataframe.insert(n_columns,i_ancillary_var,np.concatenate(current_ancillary_var) )\n",
+    "                            \n",
+    "        #END for i_ancillary\n",
+    "        \n",
+    "        output_file_name = 'WOD2018_CODA_' + str(i_year) + '_' + str(i_platform) + '.parquet'\n",
+    "        print('Writing file:', output_file_name)\n",
+    "        if not os.path.isdir(os.path.join(output_path,str(i_year))):\n",
+    "            os.mkdir(os.path.join(output_path,str(i_year)))\n",
+    "        wod_dataframe.to_parquet(os.path.join(output_path,str(i_year),output_file_name),engine='pyarrow',compression='snappy')\n",
+    "\n",
+    "        sdaa\n",
+    "        \n",
+    "        "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "6a94ba74-28b5-41e2-9458-81d16e65b5d8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "origflagset\n",
+      "country\n",
+      "dataset\n",
+      "Access_no\n",
+      "Recorder\n",
+      "dbase_orig\n",
+      "Platform\n",
+      "Project\n",
+      "WOD_cruise_identifier\n",
+      "Institute\n",
+      "needs_z_fix\n",
+      "Temperature_Instrument\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i_ancillary_var in ancillary_data_container.keys():\n",
+    "    print(i_ancillary_var)\n",
+    "    current_ancillary_var = []\n",
+    "    \n",
+    "    for i_profile in range(0,n_profiles):\n",
+    "         current_ancillary_var.append( np.repeat(ancillary_data_container[i_ancillary_var][i_profile], number_of_levels_by_profile[i_profile]) )\n",
+    "                \n",
+    "    wod_dataframe =  wod_dataframe.assign(i_ancillary_var= np.concatenate(current_ancillary_var) )\n",
+    "            "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "id": "06b53914-86fe-4186-9d3b-d6ff03574ca5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array(['                                                                                                    ',\n",
+       "       '                                                                                                    ',\n",
+       "       '                                                                                                    ',\n",
+       "       ...,\n",
+       "       '                                                                                                    ',\n",
+       "       '                                                                                                    ',\n",
+       "       '                                                                                                    '],\n",
+       "      dtype='<U100')"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.concatenate(current_ancillary_var[i_ancillary_var])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "a4f5c0de-5cec-4180-8c97-d353f486561a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Building dataframe\n"
+     ]
+    }
+   ],
+   "source": [
+    "print('Building dataframe')\n",
+    "wod_dataframe = pandas.DataFrame(columns=profile_data_container.keys())\n",
+    "\n",
+    "for i_var in profile_data_container:\n",
+    "    wod_dataframe[i_var] = np.concatenate(profile_data_container[i_var])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "c33fc39f-7621-4af3-9e0d-2b29b067c8e0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing file: WOD2018_CODA_2018_ctd.parquet\n"
+     ]
+    }
+   ],
+   "source": [
+    "output_file_name = 'WOD2018_CODA_' + str(i_year) + '_' + str(i_platform) + '.parquet'\n",
+    "print('Writing file:', output_file_name)\n",
+    "if not os.path.isdir(os.path.join(output_path,str(i_year))):\n",
+    "    os.mkdir(os.path.join(output_path,str(i_year)))\n",
+    "wod_dataframe.to_parquet(os.path.join(output_path,str(i_year),output_file_name),engine='pyarrow',compression='snappy')  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "a8ccf15d-2f62-4fb2-8237-156d0965d4da",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0        [28.78, 28.93, 28.83, 28.5, 25.83, 25.46, 20.4...\n",
+       "1        [28.71, 28.95, 28.88, 28.82, 28.52, 27.66, 26....\n",
+       "2        [29.09, 28.95, 28.87, 28.74, 27.94, 27.26, 24....\n",
+       "3        [28.75, 28.76, 28.75, 28.81, 28.82, 28.59, 27....\n",
+       "4        [28.61, 28.63, 28.74, 28.78, 28.92, 28.87, 28....\n",
+       "                               ...                        \n",
+       "22919    [-0.85, -0.85, -0.86, -1.34, -1.77, -1.66, -1....\n",
+       "22920    [-0.82, -0.9, -1.14, -1.76, -1.51, -1.12, -0.6...\n",
+       "22921    [-1.01, -1.13, -1.79, -1.79, -1.32, 0.48, 0.75...\n",
+       "22922    [-0.17, -0.35, -0.39, -0.49, -1.66, -1.81, -1....\n",
+       "22923    [0.03, -0.01, -0.08, -0.76, -1.55, -1.71, -1.1...\n",
+       "Name: Temperature, Length: 22924, dtype: object"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "b57ce849",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pyarrow as pa\n",
+    "\n",
+    "\n",
+    "year_to_get = 2018\n",
+    "output_file_name = 'WOD2018_CODA_' + str(year_to_get) + '_' + str(i_platform) + '.parquet'\n",
+    "\n",
+    "wod_dataframe = pandas.read_parquet(os.path.join(output_path,str(year_to_get),output_file_name), engine='pyarrow')\n",
+    "\n",
+    "table = pa.Table.from_pandas(wod_dataframe)\n",
+    "\n",
+    "\n",
+    "#col_meta: A json-serializable dictionary with column metadata in the form\n",
+    "#            {\n",
+    "#                'column_1': {'some': 'data', 'value': 1},\n",
+    "#                'column_2': {'more': 'stuff', 'values': [1,2,3]}\n",
+    "#            }\n",
+    "\n",
+    "table_with_metadata = set_metadata(table, col_meta={'Temperature': {'units':'degrees','long_name':'Temperature'}}, tbl_meta={'Parent file':file_name})\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "6743934a-2260-437b-8e2f-87b11fd8c2fc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "pyarrow.Table\n",
+       "Temperature: float\n",
+       "Temperature_WODflag: int8\n",
+       "Temperature_origflag: int8\n",
+       "Salinity: double\n",
+       "Salinity_WODflag: double\n",
+       "Salinity_origflag: double\n",
+       "Oxygen: double\n",
+       "Oxygen_WODflag: double\n",
+       "Oxygen_origflag: double\n",
+       "Chlorophyll: double\n",
+       "Chlorophyll_WODflag: double\n",
+       "Chlorophyll_origflag: double\n",
+       "Nitrate: double\n",
+       "Nitrate_WODflag: double\n",
+       "Nitrate_origflag: double\n",
+       "z: float\n",
+       "z_WODflag: int8\n",
+       "z_origflag: int8\n",
+       "lat: double\n",
+       "lon: double\n",
+       "wod_unique_cast: int64\n",
+       "time: timestamp[ms]\n",
+       "CODA_id: binary\n",
+       "origflagset: string\n",
+       "country: string\n",
+       "dataset: string\n",
+       "Access_no: int64\n",
+       "Recorder: string\n",
+       "dbase_orig: string\n",
+       "Platform: string\n",
+       "Project: string\n",
+       "WOD_cruise_identifier: string\n",
+       "Institute: string\n",
+       "needs_z_fix: string\n",
+       "Temperature_Instrument: string\n",
+       "----\n",
+       "Temperature: [[28.78,28.93,28.83,28.5,25.83,...,1.54,1.53,1.52,1.5,1.5]]\n",
+       "Temperature_WODflag: [[0,0,0,0,0,...,0,0,0,0,0]]\n",
+       "Temperature_origflag: [[-9,-9,-9,-9,-9,...,-9,-9,-9,-9,-9]]\n",
+       "Salinity: [[33.59000015258789,33.779998779296875,33.939998626708984,33.91999816894531,34.47999954223633,...,34.65999984741211,34.65999984741211,34.66999816894531,34.66999816894531,34.66999816894531]]\n",
+       "Salinity_WODflag: [[0,0,0,0,0,...,0,0,0,0,0]]\n",
+       "Salinity_origflag: [[-9,-9,-9,-9,-9,...,-9,-9,-9,-9,-9]]\n",
+       "Oxygen: [[null,null,null,null,null,...,null,null,null,null,null]]\n",
+       "Oxygen_WODflag: [[null,null,null,null,null,...,null,null,null,null,null]]\n",
+       "Oxygen_origflag: [[null,null,null,null,null,...,null,null,null,null,null]]\n",
+       "Chlorophyll: [[null,null,null,null,null,...,null,null,null,null,null]]\n",
+       "..."
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "table_with_metadata"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "0ce6f2c9-1814-4f78-8a5d-1826eefc58e7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "b'\"degrees\"'"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "table_with_metadata.field('Temperature').metadata[b'units']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "1f77e832",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "\n",
+    "CODA_id = wod_dataframe['CODA_id'].unique()\n",
+    "profile = wod_dataframe.loc[wod_dataframe['CODA_id'] == CODA_id[0]]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "5b9cd613",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f73c46c5a20>]"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 400,
+       "width": 400
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(profile['Temperature'].values,-profile['z'].values)\n",
+    "plt.plot(profile['Salinity'].values,-profile['z'].values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "58136614-eeac-4d73-88ca-5c025b0f5e27",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0       4.0\n",
+       "1      26.0\n",
+       "2      80.0\n",
+       "3      90.0\n",
+       "4     113.0\n",
+       "5     116.0\n",
+       "6     123.0\n",
+       "7     135.0\n",
+       "8     141.0\n",
+       "9     154.0\n",
+       "10    164.0\n",
+       "11    175.0\n",
+       "12    191.0\n",
+       "13    219.0\n",
+       "14    241.0\n",
+       "15    270.0\n",
+       "16    294.0\n",
+       "17    310.0\n",
+       "18    391.0\n",
+       "19    441.0\n",
+       "20    618.0\n",
+       "21    746.0\n",
+       "22    834.0\n",
+       "23    861.0\n",
+       "24    989.0\n",
+       "Name: z, dtype: float32"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "profile['z']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "id": "457fdbd9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABQAAAAPACAYAAABq3NR5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAewgAAHsIBbtB1PgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdfZDdVWH/8Y+bZTcPEEPWSxACyUQCE0iQyR+xLRDqz+AQjA7R4CzYFoOJyAhjZHRqdaapU6eT1jpasJU0KgVHnTgNAxgDWCiPKTZWkIQAmkBNCA+b3SQQYDebh83vD+YuLruJoZfsDWdfrxnH8D3fc++54fjP23Pv9x07d+7cHwAAAACgSA31XgAAAAAAcPgIgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAgjXWewEMXaeccko6Ozszfvz4ei8FAAAAirVly5aMHDkyGzdurPdSqBMBkLrp7OzMnj170tAwNA+i7t27N0nS2Oh/hrx59g+1sH+ohf1DLewfamH/UIuhvn/27NmTzs7Oei+DOhqaO58jwvjx49PQ0JD169fXeyl10dbWliQZN25cnVfC25H9Qy3sH2ph/1AL+4da2D/UYqjvnzPOOCM9PT31XgZ1NDSPXgEAAADAECEAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEa670Ahob29vZ0dHT0udbd3Z2mpqY6rQgAAABgaBAAGRTLli3LkiVL+l2vVCp1WA0AAADA0CEAMigWLlyYuXPn9rnW2trqBCAAAADAYSYAMigqlUq/037Nzc1paPAzlAAAAACHk/oCAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAA6yJ554Ip/5zGdy+umn513veldOP/30XHPNNdm6deuA9+/evTvf+MY38r73vS/jxo3LpEmT8vGPfzwPPfTQQd9n586dWbx4cc4666xUKpVMnjw58+fPz/r16w8674UXXsg111yTqVOnplKpZMqUKbn66quzefPm//NnBgAAAKB+3rFz58799V7EUPHTn/40CxYsSFdXV7+xE044IXfeeWcmTJjQe62rqysf/vCHs2bNmn73Dxs2LN/+9rfziU98ot9YR0dHzj///Dz11FP9xkaMGJEf/ehH+cAHPtBvbMOGDbngggvS3t7eb+zYY4/NypUrM23atD/4OQ/VjBkz0tDQ8AejZKna2tqSJOPGjavzSng7sn+ohf1DLewfamH/UAv7h1oM9f1zxhlnpKenZ8C+wNDgBOAg+e1vf5uFCxemq6srV1xxRdauXZvnn38+N998cyZOnJjnnnsuV155ZZ85ixcvzpo1azJmzJjcdNNNef7557Nu3bpccskl2bdvXxYtWpSNGzf2e6+rrroqTz31VMaPH59bb701bW1t+eUvf5lZs2alq6srn/rUp7Jjx44+c/bv35/58+envb09U6dOzV133ZW2trbce++9mT59enbs2JHLLrsse/fuPax/TwAAAAC8tQTAQfK1r30tnZ2dueKKK/L1r389EydOzKhRozJr1qwsX748w4YNy4MPPpi1a9cmSbZu3ZobbrghSbJ06dJcdNFFGTVqVCZMmJClS5dm5syZ6e7uzrXXXtvnfdauXZtVq1Zl2LBhWb58ed7//vdnxIgROe200/LjH/84kydPzvbt2/O9732vz7xVq1Zl7dq1OeaYY7JixYrMmDEjI0aMyPTp07NixYq0tLRk48aNufnmmwfnLwwAAACAt4QAOAja29tz2223ZeTIkfnyl7/cb3zKlClpbW3NtGnT8tvf/jbJa0Guu7s7U6ZMyezZs/vNWbRoUZLXvla8f//r3+K+5ZZbkiSzZs3q93Xd5ubmfPazn02S3HbbbX3GqmGvtbU17373u/uMtbS05LLLLhtwHgAAAABHNgFwEPz85z9PT09PzjvvvBx77LED3vOd73wnq1evzrx585IkDzzwQJLk/PPPH/D+mTNnprm5Odu2bcvjjz/ee/0PzZs1a1aS5NFHH81LL73Ue/3BBx88pHnV1wcAAADg7UEAHAS//vWvkyTTp08/5DnV3/abOnXqgONNTU059dRTk7z28I6q6p8P9LCOk08+Oe985zuzf//+3oeEvPLKK3n++ecPOq+6jh07dmTbtm2H/DkAAAAAqC8BcBBUY97JJ5+cDRs2ZMGCBZk8eXLe9a535fTTT8/VV1+d3/3ud33mPPPMM0mSE0888YCve8IJJ/S5t7OzM9u3b+8zdijztmzZkiRpaGjI8ccfP+CcMWPGZNSoUUmSzZs3H/jDAgAAAHBEEQAHQUdHR5LkkUceyTnnnJOf/OQnaWtry+7du7Nly5bceOONOeecc7J69ereOa+++mqS5Oijjz7g61aD3CuvvNJnzpudV/3vkSNHZtiwYX9w3u+/DwAAAABHtsZ6L2AoqAaz66+/Pscdd1z+6Z/+KR/84AczcuTI/OpXv8pf/dVf5de//nX+7M/+LL/61a8yduzYdHd3J3ntq74HUh3r6upKkt45b3be7t27kyRHHXXUQT9HdV5nZ+dB75sxY8ZBx6uefvrpTJw4MW1tbYd0f2na29vrvQTexuwfamH/UAv7h1rYP9TC/qEWQ33/7N27Nw0NzoANZf7tD4J9+/YlSYYPH55Vq1altbU1Y8eOzfDhw3P22WfnlltuyZgxY7Jt27Z8//vfT/LaE3uTvlHvjd4YCatzktej3kB27drV5/7q/IPNGWgeAAAAAEc+JwAHQfWrs3Pnzu19cMfvGzt2bObPn59vfvObue+++/KFL3who0aNSldXV+/Xcwfy8ssvJ3n9677V96mOtbS0DDiv+prV+6vzu7q6snfv3jQ2DrwtqicZf/99BrJmzZqDjlfNmDEjDQ0NGTdu3CHdX6qh/vmpjf1DLewfamH/UAv7h1rYP9RiqO6fxsbG9PT01HsZ1JETgIOgGuIO9ETfJL1h8LnnnkuSnHTSSUmSZ5999oBzqk/urT4oZOTIkRk7dmyf1zmUeePHj0+S9PT05IUXXhhwzvbt23u/Mly9HwAAAIAjnwA4CE455ZQkB/+K7YgRI5K8/nXcyZMnJ0kee+yxAe/v7u7Ohg0bkqTPqcLqn9etWzfgvE2bNvWeHKy+x9FHH937ZOADzVu/fn2SZPTo0Qd8UjAAAAAARx4BcBD88R//cZLkv//7vw94z8MPP5zk9Vh47rnnJknuuuuuAe9/4IEHsnv37owdOzbTpk3rvX7OOeccdN7dd9+dJDnzzDN7Twu+mXkzZ8484GcAAAAA4MgjAA6C6hN/f/7zn+cXv/hFv/EtW7bkpptuSpJ86EMfSpJceOGFGT58eJ544onceeed/eZcd911SZKLLrqoz5N85s6dm+S1kPfG04N79uzJ9ddfnyT56Ec/2mes+s/Lly/v91TeHTt29K7vjfMAAAAAOLIJgINgzJgxufLKK9PT05OLL744N954Y3bs2JGurq7cfvvtufDCC/Piiy/mzDPPzLx585IklUoll19+eZLk05/+dFauXJnOzs5s2rQpV155Ze65556MGDEiixYt6vNe06ZNy5w5c7Jv375ccskluf/++7Nr16785je/yaWXXponn3wylUolCxYs6DNv9uzZee9735udO3dm3rx5efjhh7Nr16488sgj+djHPpaOjo5MmTKlNzACAAAA8Pbwjp07d+6v9yKGgj179mTevHm55557Bhx/z3vek1tuuSUTJkzovbZr16585CMfGfDUYGNjY5YuXZqLL76439i2bdty/vnnZ+PGjf3GRo0alZ/85Ce9XzH+fRs3bswFF1yQrVu39htraWnJHXfckdNOO+2gn/PNqD4FuPr7gkNN9aTlUH0KFbWxf6iF/UMt7B9qYf9QC/uHWgz1/XPGGWekp6cna9asqfdSqBMnAAfJUUcdlZtvvjn/+I//mOnTp+eYY47JiBEjcvrpp+fLX/5y7r///j7xL0mGDx+elStXZvHixZkyZUpGjBiRlpaWzJ49O7fffvuA8S95Ldbdd999+fznP59Jkyalubk5xx13XObNm5d77713wPiXvPb7g6tXr86CBQty0kknpbm5OSeeeGI++clPZvXq1W9p/AMAAABgcDgBSN04ATi0/x8oamP/UAv7h1rYP9TC/qEW9g+1GOr7xwlAnAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABSssd4LYGhob29PR0dHn2vd3d1pamqq04oAAAAAhgYBkEGxbNmyLFmypN/1SqVSh9UAAAAADB0CIINi4cKFmTt3bp9rra2tTgACAAAAHGYCIIOiUqn0O+3X3NychgY/QwkAAABwOKkvAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABSssd4LYGhob29PR0dHn2vd3d1pamqq04oAAAAAhgYBkEGxbNmyLFmypN/1SqVSh9UAAAAADB0CIINi4cKFmTt3bp9rra2tTgACAAAAHGYCIIOiUqn0O+3X3NychgY/QwkAAABwOKkvAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYI31XgBDQ3t7ezo6Ovpc6+7uTlNTU51WBAAAADA0CIAMimXLlmXJkiX9rlcqlTqsBgAAAGDoEAAZFAsXLszcuXP7XGttbXUCEAAAAOAwEwAZFJVKpd9pv+bm5jQ0+BlKAAAAgMNJfQEAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAuDbwO7du/ONb3wj73vf+zJu3LhMmjQpH//4x/PQQw8ddN7OnTuzePHinHXWWalUKpk8eXLmz5+f9evXH3TeCy+8kGuuuSZTp05NpVLJlClTcvXVV2fz5s1v5ccCAAAAYBAIgEeAv/7rv87o0aOzdOnSfmNdXV258MIL89WvfjVPPPFEurq60tHRkTvuuCMXXnhhfvjDHw74mh0dHTnvvPPyzW9+M08//XS6u7vT1taWFStW5P/9v/+Xu+++e8B5GzZsyNlnn53vfve72bx5c7q7u/Pss8/mxhtvzLnnnpt169a9pZ8dAAAAgMNLAKyzhx56KNdee+0BxxcvXpw1a9ZkzJgxuemmm/L8889n3bp1ueSSS7Jv374sWrQoGzdu7DfvqquuylNPPZXx48fn1ltvTVtbW375y19m1qxZ6erqyqc+9ans2LGjz5z9+/dn/vz5aW9vz9SpU3PXXXelra0t9957b6ZPn54dO3bksssuy969e9/yvwcAAAAADg8BsI5efvnlXHHFFenp6RlwfOvWrbnhhhuSJEuXLs1FF12UUaNGZcKECVm6dGlmzpyZ7u7ufgFx7dq1WbVqVYYNG5bly5fn/e9/f0aMGJHTTjstP/7xjzN58uRs37493/ve9/rMW7VqVdauXZtjjjkmK1asyIwZMzJixIhMnz49K1asSEtLSzZu3Jibb7758PyFAAAAAPCWEwDr6Etf+lJ+97vfHXB81apV6e7uzpQpUzJ79ux+44sWLUqS/PSnP83+/ft7r99yyy1JklmzZmXatGl95jQ3N+ezn/1skuS2227rM1YNe62trXn3u9/dZ6ylpSWXXXbZgPMAAAAAOHIJgHWyatWq/OAHP8jUqVMzY8aMAe954IEHkiTnn3/+gOMzZ85Mc3Nztm3blscff/yQ582aNStJ8uijj+all17qvf7ggw8e0rzq6wMAAABw5BMA66CjoyNXX311mpqa8q//+q9pamoa8L7qb/tNnTp1wPGmpqaceuqpSV57eEdV9c9vPP1XdfLJJ+ed73xn9u/fn6eeeipJ8sorr+T5558/6LzqOnbs2JFt27Yd9DMCAAAAcGQQAOvg6quvTnt7e77yla8cMO4lyTPPPJMkOfHEEw94zwknnNDn3s7Ozmzfvr3P2KHM27JlS5KkoaEhxx9//IBzxowZk1GjRiVJNm/efMDXBgAAAODI0VjvBQw1P/jBD/Kzn/0sf/RHf5TPfe5zB7331VdfTZIcffTRB7ynGuReeeWVPnPe7Lzqf48cOTLDhg076LxXX321z/u80YG+0vxGTz/9dCZOnJi2trZDur807e3t9V4Cb2P2D7Wwf6iF/UMt7B9qYf9Qi6G+f/bu3ZuGBmfAhjL/9gfRpk2b8qUvfSmjRo3K9ddf/wf/x9fd3Z0kB/yK8O+PdXV19ZnzZuft3r07SXLUUUcddE3VeZ2dnQe9DwAAAIAjgxOAg6SnpydXXHFFXn755XzrW9/KpEmT/uCc5ubmdHV19Yl6b/TGSNjc3Nw7Vo16A9m1a1ef+6vzDzZnoHkDWbNmzUFfo2rGjBlpaGjIuHHjDun+Ug31z09t7B9qYf9QC/uHWtg/1ML+oRZDdf80Njamp6en3sugjpwAHCTXXntt/uu//iuzZs3K5Zdffkhz3vg13YG8/PLLSV7/um91zu+PDaT6mtX7q/O7urqyd+/eA86rfvX3998HAAAAgCOXADgI/vd//zdf+9rXcuyxx+Zf/uVfDnneSSedlCR59tlnD3hP9cm91QeFjBw5MmPHjk2SPPfcc4c8b/z48UleO6n4wgsvDDhn+/btvV8Zrt4PAAAAwJFNABwEW7Zsye7du7Njx46ceuqpGT16dJ//PPjgg0mSL37xi73XXnzxxUyePDlJ8thjjw34ut3d3dmwYUOS5NRTT+29Xv3zunXrBpy3adOm3tOB1fc4+uije58MfKB569evT5KMHj36gE8KBgAAAODIIgAewc4999wkyV133TXg+AMPPJDdu3dn7NixmTZtWu/1c84556Dz7r777iTJmWee2Xta8M3Mmzlz5pv5GAAAAADUkQA4CM4999zs3LnzgP+phrevf/3rvdfGjBmTCy+8MMOHD88TTzyRO++8s9/rXnfddUmSiy66qM8ThefOnZvktZD3xtODe/bsyfXXX58k+ehHP9pnrPrPy5cvT1tbW5+xHTt25KabbhpwHgAAAABHLgHwCFapVHofGPLpT386K1euTGdnZzZt2pQrr7wy99xzT0aMGJFFixb1mTdt2rTMmTMn+/btyyWXXJL7778/u3btym9+85tceumlefLJJ1OpVLJgwYI+82bPnp33vve92blzZ+bNm5eHH344u3btyiOPPJKPfexj6ejoyJQpU3oDIwAAAABHvsZ6L4CD+5u/+Zs8/PDD+cUvfpFLL720z1hjY2O+/e1vZ+LEif3mXXfddXnyySezcePGzJkzp8/YqFGj8m//9m8ZPXp0n+vveMc7csMNN+SCCy7Io48+mj/90z/tM97S0pKbbropw4YNe0s+GwAAAACHnxOAR7jhw4dn5cqVWbx4caZMmZIRI0akpaUls2fPzu23356LL754wHktLS2577778vnPfz6TJk1Kc3NzjjvuuMybNy/33ntv7+8LvtEpp5yS1atXZ8GCBTnppJPS3NycE088MZ/85CezevXqnHbaaYfz4wIAAADwFnvHzp0799d7EQxNM2bMSENDQ+/ThYea6u8sjhs3rs4r4e3I/qEW9g+1sH+ohf1DLewfajHU988ZZ5yRnp6erFmzpt5LoU6cAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgjfVeAENDe3t7Ojo6+lzr7u5OU1NTnVYEAAAAMDQIgAyKZcuWZcmSJf2uVyqVOqwGAAAAYOgQABkUCxcuzNy5c/tca21tdQIQAAAA4DATABkUlUql32m/5ubmNDT4GUoAAACAw0l9AQAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgjfVeAENDe3t7Ojo6+lzr7u5OU1NTnVYEAAAAMDQIgAyKZcuWZcmSJf2uVyqVOqwGAAAAYOgQABkUCxcuzNy5c/tca21tdQIQAAAA4DATABkUlUql32m/5ubmNDT4GUoAAACAw0l9AQAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwABAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgjfVeAENDe3t7Ojo6+lzr7u5OU1NTnVYEAAAAMDQIgAyKZcuWZcmSJf2uVyqVOqwGAAAAYOgQABkUCxcuzNy5c/tca21tdQIQAAAA4DATABkUlUql32m/5ubmNDT4GUoAAACAw0l9AQAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKJgACAAAAAAFEwDfBnbv3p1vfOMbed/73pdx48Zl0qRJ+fjHP56HHnrooPN27tyZxYsX56yzzkqlUsnkyZMzf/78rF+//qDzXnjhhVxzzTWZOnVqKpVKpkyZkquvvjqbN29+Kz8WAAAAAIOgsd4LGGq2bt2a6667LnfeeWdvUJs4cWLmzJmTq666KmPGjOlzf1dXVz784Q9nzZo1fa7dcccd+Y//+I98+9vfzic+8Yl+79PR0ZHzzz8/Tz31VO+1tra2rFixIqtWrcqPfvSjfOADH+g3b8OGDbngggvS3t7ee+3ZZ5/NjTfemNtuuy0rV67MtGnTav57AAAAAGBwOAE4iJ544omcffbZ+ad/+qc8+eST6ezsTGdnZx5//PH8wz/8Q84999xs3Lixz5zFixdnzZo1GTNmTG666aY8//zzWbduXS655JLs27cvixYt6jcnSa666qo89Y5KlAkAACAASURBVNRTGT9+fG699da0tbXll7/8ZWbNmpWurq586lOfyo4dO/rM2b9/f+bPn5/29vZMnTo1d911V9ra2nLvvfdm+vTp2bFjRy677LLs3bv3sP49AQAAAPDWEQAHyf79+3P55Zenra0tkyZNyr//+7/nhRdeyIYNG7J06dIcd9xx2bRpU1pbW7Nnz54kr50WvOGGG5IkS5cuzUUXXZRRo0ZlwoQJWbp0aWbOnJnu7u5ce+21fd5r7dq1WbVqVYYNG5bly5fn/e9/f0aMGJHTTjstP/7xjzN58uRs37493/ve9/rMW7VqVdauXZtjjjkmK1asyIwZMzJixIhMnz49K1asSEtLSzZu3Jibb755cP7SAAAAAKiZADhI/vM//zPr16/PUUcdlZtvvjkf/OAHM3LkyIwbNy6XXHJJfv7zn2fkyJH57W9/m1tvvTXJa0Guu7s7U6ZMyezZs/u95qJFi5IkP/3pT7N///7e67fcckuSZNasWf2+rtvc3JzPfvazSZLbbrutz1g17LW2tubd7353n7GWlpZcdtllA84DAAAA4MglAA6Se++9N0ly3nnnZdKkSf3GJ02alIsuuihJsnr16iTJAw88kCQ5//zzB3zNmTNnprm5Odu2bcvjjz/ee/0PzZs1a1aS5NFHH81LL73Ue/3BBx88pHnV1wcAAADgyCcADpKnn346STJlypQD3nPcccclSV599dUk6f1tv6lTpw54f1NTU0499dQkrz28o6r65wM9rOPkk0/OO9/5zuzfv7/3ISGvvPJKnn/++YPOq65jx44d2bZt2wE/BwAAAABHDgFwkHzmM5/J97///QGf2Fv16KOPJkkmTJiQJHnmmWeSJCeeeOIB55xwwgl97u3s7Mz27dv7jB3KvC1btiRJGhoacvzxxw84Z8yYMRk1alSS9D7BGAAAAIAjW2O9FzBUnHvuuQcdv+uuu3LPPfckST70oQ8lef0k4NFHH33AedUg98orr/SZ82bnVf975MiRGTZs2EHnvfrqq33eBwAAAIAjlwB4BPjhD3+YL3zhC0mSj370oznrrLOSJN3d3Ule+6rvgVTHurq6+sx5s/N2796dJDnqqKMOutbqvM7OzgPeM2PGjIO+RtXTTz+diRMnpq2t7ZDuL017e3u9l8DbmP1DLewfamH/UAv7h1rYP9RiqO+fvXv3pqHBl0CHMv/262jdunWZM2dOrrzyyrz66qs555xz8p3vfKd3vLm5OUnfqPdGb4yE1TnJ61FvILt27epzf3X+weYMNA8AAACAI5sTgHXw0ksv5atf/Wq+//3vp6enJ0cddVS++MUv5gtf+EIaG1//VzJq1Kh0dXX1fj13IC+//HKS17/uW/1qb3WspaVlwHnV16zeX53f1dWVvXv39lnH76t+9ff33+eN1qxZc8Cx3zdjxow0NDRk3Lhxh3R/qYb656c29g+1sH+ohf1DLewfamH/UIuhun8aGxvT09NT72VQR04ADrL/+Z//yZ/8yZ/ku9/9bnp6evLhD384a9asyZe+9KV+0e2kk05Kkjz77LMHfL3qk3urDwoZOXJkxo4dmyR57rnnDnne+PHjkyQ9PT154YUXBpyzffv23q8MV+8HAAAA4MgmAA6i+++/P3PmzMkzzzyTCRMm5Gc/+1l++MMf5j3vec+A90+ePDlJ8thjjw043t3dnQ0bNiRJTj311N7r1T+vW7duwHmbNm3qPTlYfY+jjz6698nAB5q3fv36JMno0aMP+KRgAAAAAI4sAuAg2bZtW/7iL/4inZ2dOe+887J69eo/+GTg6vhdd9014PgDDzyQ3bt3Z+zYsZk2bVrv9XPOOeeg8+6+++4kyZlnntl7WvDNzJs5c+ZB1w0AAADAkUMAHCTLli3L9u3bM2HChCxfvjyjR4/+g3MuvPDCDB8+PE888UTuvPPOfuPXXXddkuSiiy7q8zSfuXPnJnkt5L3x9OCePXty/fXXJ3nticO/r/rPy5cv7/dk3h07duSmm24acB4AAAAARy4BcJCsWrUqSTJ//vyMHDnykOZUKpVcfvnlSZJPf/rTWblyZTo7O7Np06ZceeWVueeeezJixIgsWrSoz7xp06Zlzpw52bdvXy655JLcf//92bVrV37zm9/k0ksvzZNPPplKpZIFCxb0mTd79uy8973vzc6dOzNv3rw8/PDD2bVrVx555JF87GMfS0dHR6ZMmdIbGAEAAAA48r1j586d++u9iNLt2bMnxx9/fPbs2XNI91955ZX5+7//+yTJrl278pGPfCS/+MUv+t3X2NiYpUuX5uKLL+43tm3btpx//vnZuHFjv7FRo0blJz/5yYBfQd64cWMuuOCCbN26td9YS0tL7rjjjpx22mmH9Dn+kOpTgKu/LTjUVE9ZDtWnUFEb+4da2D/Uwv6hFvYPtbB/qMVQ3z9nnHFGenp6smbNmnovhTpxAnAQbN269ZDj3xsNHz48K1euzOLFizNlypSMGDEiLS0tmT17dm6//fYB41/yWqy777778vnPfz6TJk1Kc3NzjjvuuMybNy/33nvvAX9/8JRTTsnq1auzYMGCnHTSSWlubs6JJ56YT37yk1m9evVbFv8AAAAAGBxOAFI3TgAO7f8HitrYP9TC/qEW9g+1sH+ohf1DLYb6/nECECcAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKFhjvRfA0NDe3p6Ojo4+17q7u9PU1FSnFQEAAAAMDQIgg2LZsmVZsmRJv+uVSqUOqwEAAAAYOgRABsXChQszd+7cPtdaW1udAAQAAAA4zARABkWlUul32q+5uTkNDX6GEgAAAOBwUl8AAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKFhjvRfA0NDe3p6Ojo4+17q7u9PU1FSnFQEAAAAMDQIgg2LZsmVZsmRJv+uVSqUOqwEAAAAYOgRABsXChQszd+7cPtdaW1udAAQAAAA4zARABkWlUul32q+5uTkNDX6GEgAAAOBwUl8AAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQAAAAAAomAAIAAAAAAUTAAEAAACgYAIgAAAAABRMAAQAAACAggmAAAAAAFAwARAAAAAACiYAAgAAAEDBBEAAAAAAKFhjvRfA0NDe3p6Ojo4+17q7u9PU1FSnFQEAAAAMDQIgg2LZsmVZsmRJv+uVSqUOqwEAAAAYOgRABsXChQszd+7cPtdaW1udAAQAAAA4zARABkWlUul32q+5uTkNDX6GEgAAAOBwUl8AAAAAoGACIAAAAAAUTAAEAAAAgIIJgAAAAABQMAEQAAAAAAomAAIAAABAwQRAAAAAACiYAAgAAAAABRMAAQAAAKBgAiAAAAAAFEwABAAAAICCCYAAAAAAUDABEAAAAAAKJgACAAAAQMEEQPrZv39/vvvd7+a8887LCSeckJNPPjlz5szJ7bffXu+lAQAAAPAmNdZ7ARxZ9u/fnz//8z/Pbbfd1uf6/fffn/vvvz9f+cpX8pd/+Zd1Wh0AAAAAb5YTgPTxz//8z7ntttvS3Nycb33rW9myZUs2bNiQz33uc0mSv/u7v8uDDz5Y51UCAAAAcKgEQHp1d3fnW9/6VpLka1/7Wi6//PKMHj0648aNy9/+7d/mE5/4RPbv35+vf/3rdV4pAAAAAIdKAKTX6tWrs3Xr1hx77LGZP39+v/FrrrkmyWtfB37xxRcHe3kAAAAA/B8IgPSqfrX3vPPOS1NTU7/xyZMnZ8KECdm3b18eeuihwV4eAAAAAP8HAiC9NmzYkCSZOnXqAe+pjlXvBQAAAODIJgDS65lnnkmSnHjiiQe854QTTkiSbN68eVDWBAAAAEBtBEB6vfrqq0mSo48++oD3VMeq9wIAAABwZGus9wI4cnR3dyfJgL//V3XUUUclSbq6ug54z4wZMw7p/Z5++ulMnDgxbW1tb2KV5Whvb6/3Engbs3+ohf1DLewfamH/UAv7h1oM9f2zd+/eNDQ4AzaU+bdPr+bm5iSvh8CBHEokBAAAAODI4QQgvUaNGpUkeeWVVw54T3Wseu9A1qxZc0jvN2PGjDQ0NGTcuHFvYpXlGeqfn9rYP9TC/qEW9g+1sH+ohf1DLYbq/mlsbExPT0+9l0EdOQFIr5NOOilJ8uyzzx7wnueeey5JMn78+EFZEwAAAAC1EQDpNXny5CTJY489dsB71q9fnyQ59dRTB2VNAAAAANRGAKTXueeemyS57777snv37n7jGzZsyObNmzNs2LCcffbZg708AAAAAP4PBEB6nX322Rk3blxefPHF3Hjjjf3Gr7322iT/n717j+6qvPfE/yZCgiCMFiKIUigWXF7gnKGIM1WxUnDGTikCs1qsy1s1WG09aE+ngvXUmf7hooqr1RHpiO0ZewbFwSPQSrWK1CIuLl6WxVqtWO+AMaAOECBckt8f/pKSk4DRSII7r9darhWfZ3+yn/3NRzRvn7138qUvfSmf+cxn2np5AAAAAHwMAkAalJaW5uqrr06S/PCHP8y//Mu/ZMuWLamsrMx//+//PXfddVdKSkoybdq0dl4pAAAAAC3lLcA0cvnll2flypVZuHBhvvOd7+Q73/lOo/n/8T/+R0455ZR2Wh0AAAAAH5UdgDTSqVOn3HXXXfnpT3+af//v/326d++eww8/PGeccUbmz5+fqVOntvcSAQAAAPgI7ACkiU6dOuWSSy7JJZdc0t5LAQAAAKCV7AAEAAAAgAITAAIAAABAgQkAAQAAAKDABIAAAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACkwACAAAAAAFJgAEAAAAgAITAAIAAABAgQkAAQAAAKDABIAAAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACkwACAAAAAAF1rm9F0DHUFVVlY0bNzYaq6mpSWlpaTutCAAAAKBjEADSJubMmZMZM2Y0GS8vL2+H1QAAAAB0HAJA2kRFRUUmTJjQaGzy5Ml2AAIAAAAcYAJA2kR5eXmT3X5lZWUpKfEYSgAAAIADSfoCAAAAAAUmAAQAAACAAhMAAgAAAECBCQABAAAAoMAEgAAAAABQYAJAAAAAACgwASAAAAAAFJgAEAAAAAAKTAAIAAAAAAUmAAQAAACAAhMAAgAAAECBCQABAAAAoMAEgAAAAABQYAJAAAAAACgwASAAAAAAFJgAEAAAAAAKTAAIAAAAAAUmAAQAAACAAhMAAgAAAECBCQABAAAAoMAEgAAAAABQYAJAAAAAACiwzu29ADqGqqqqbNy4sdFYTU1NSktL22lFAAAAAB2DAJA2MWfOnMyYMaPJeHl5eTusBgAAAKDjEADSJioqKjJhwoRGY5MnT7YDEAAAAOAAEwDSJsrLy5vs9isrK0tJicdQAgAAABxI0hcAAAAAKDABIAAAAAAUmAAQAAAAAApMAAgAAAAABSYABAAAAIACEwACAAAAQIEJAAEAAACgwASAAAAAAFBgAkAAAAAAKDABIAAAAAAUmAAQAAAAAApMAAgAAAAABSYABAAAAIACEwACAAAAQIEJAAEAAACgwASAAAAAAFBgAkAAAAAAKDABIAAAAAAUmAAQAAAAAApMAAgAAAAABSYABAAAAIACEwACAAAAQIEJAAEAAACgwDq39wLoGKqqqrJx48ZGYzU1NSktLW2nFQEAAAB0DAJA2sScOXMyY8aMJuPl5eXtsBoAAACAjkMASJuoqKjIhAkTGo1NnjzZDkAAAACAA0wASJsoLy9vstuvrKwsJSUeQwkAAABwIElfAAAAAKDABIAAAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACkwACAAAAAAFJgAEAAAAgAITAAIAAABAgQkAAQAAAKDABIAAAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACkwACAAAAAAFJgAEAAAAgAITAH4KrF27NlOmTMlxxx2X8vLyDBs2LNOnT8+7776737qnn3465513Xo499tgceeSRGTFiRG644YZs3759v3WPPvpozjnnnAwcODB9+/bNqaeemlmzZmXPnj2f5GUBAAAA0AYEgG3oiSeeyPnnn5/jjjsuvXr1yoABAzJ+/PgsXLhwnzUrVqzIGWeckXnz5mXDhg2pqanJa6+9llmzZuX000/P+vXrm61bsGBBzjrrrPzmN79JVVVVduzYkZdeeikzZszI2LFjs2XLlmbrZs2alYkTJ2bp0qV59913s23btjz33HOZPn16Jk2alN27d38inwUAAAAAbUMA2EZuvfXWnH322Vm0aFE2bNiQXbt25b333svvf//7XHDBBamoqEhtbW2jmurq6lx00UXZunVrRo0alZUrV6aysjKLFy/O5z73ubz55puZMmVKk3O99dZbueKKK7Jr165MnDgxzz77bDZs2JB58+ald+/eWbNmTa655pomdc8880yuu+661NXVZcqUKXnxxRezbt26zJ49O926dcvSpUszc+bMA/YZAQAAAPDJEwC2gSeffDI/+tGPkiTf+MY38vTTT6eqqipPPfVUKioq0qlTp9x7771NwrW77rorGzZsSP/+/XPvvffmhBNOyKGHHprTTz899913X0pLS7Ns2bKsWrWqUd1tt92W6urqfOELX8gvf/nLDBo0KN27d89XvvKV/OpXv0qSzJs3L2+++WajupkzZ2bPnj0ZP358Zs6cmX79+qVHjx4577zzcvPNNydJbr/99lRXVx+ojwoAAACAT5gAsA3Mnj07tbW1+dKXvpQ5c+Zk8ODBKSsry5AhQ3LzzTfn+uuvT5Lccsst2blzZ0PdggULkiSXXXZZunfv3uh7Dh48OOPGjUuSLFq0qNFc/S3FU6dOTUlJ4x/xaaedlpNPPjm7d+/O4sWLG8arq6vz8MMPJ0muvvrqJtdw7rnnpl+/fnn//fezbNmyj/U5AAAAAND2BIBt4LHHHkuSXHjhhc3OX3HFFSkrK8uWLVuyZs2aJMn27dvz1FNPJUnGjh3bbN2YMWOSJMuXL28Ye/nll7N+/fqUlJRk9OjRLa5btWpVdu7cmV69emX48OFNakpKSnLmmWcmSR5//PF9XisAAAAABxcB4AG2efPmbNy4MUly/PHHN3tM165d07NnzyRpuL321VdfzZ49e9KlS5ccd9xxzdYNHTo0yQehX721a9cmSQYMGNDwPfdVV3/s3l/XzzXnpJNOalIHAAAAwMGtc3svoOi6dOmSX/7yl0k+COWas379+lRVVTU6pv75fEcddVST23jrHX300UmSrVu3ZtOmTenVq1feeuutRnPN6devX6NzJGmoq5/b3/n+7bMDAQAAADh4CQAPsEMPPTT/9b/+1/0e80//9E9JPthhN3DgwCR/2wl42GGH7bNu7+cCVldXp1evXi2qq5+rrq5OXV1dOnXqlK1bt7b4fB/2EpCRI0fud77eK6+8koEDB6aysrJFxxdNfegLH4f+oTX0D62hf2gN/UNr6B9ao6P3z+7du/e5uYiOwU+/HW3evDmXXHJJ5s+fn5KSkoaXgSRJTU1NkqS0tHSf9XvPbd++vcV1Xbp0SZLU1dVlx44dSdLw8pGWnG/btm37vigAAAAADip2ALaD2tra/J//83/y4x//OO+8805KSkpy44035j/9p//UcExZWVmSvwV6zakP75K/hXMtqdt7rv74+vqWnK++Zl9Wr1693/l6I0eOTElJSfr06dOi44uqo18/raN/aA39Q2voH1pD/9Aa+ofW6Kj907lz59TW1rb3MmhHAsA29swzz+Sqq67Ks88+myQZOHBgZs+enVNPPbXRcfW329bfmtucvefqb91tSd2WLVuSfHB7cv0W4Pr6lpxv71uPAQAAADi4CQA/goULF+aCCy5o0bGf/exn86c//anR2E033ZQbbrghe/bsSc+ePfO9730vV1xxRbp27dqkvn///kmSt99+O7W1tc3eq79+/fokH7xFuHfv3kmSY445Jkmybt26fa5tw4YNSRq/KKS+rv57trQOAAAAgIObAPAj6NGjRwYPHtyiY//t23Svvvrq/OIXv0iSTJgwITfffHNDaNecQYMGpXPnztm1a1defPHFnHDCCU2Oef7555Mkn//859OpU6ckyZAhQ5Ikb7zxRjZv3pyePXs2qasPJuuP3fvrfxtaflgdAAAAAAc3AeBH8OUvfzlPP/30R66bO3dufvGLX6RTp075yU9+km9/+9sfWtO1a9eMGDEiK1euzJIlS5oNAJcsWZIkGTVqVMPYsccem6OPPjrr1q3L0qVLc8455zSpe/TRR5vUjRw5MmVlZdm0aVOeeeaZDB8+vFFNbW1tHnvssSTJGWec8eEXDQAAAMBBwVuA28BPfvKTJMk//MM/tCj8qzdhwoQkyR133NHwlt96r7zySh544IEkycSJExvN1Yd+t956a+rq6hrNrVixIk8++WS6dOmSr33taw3j3bt3z1lnnZUkueWWW5qsZf78+Vm/fn2OOOKInHnmmS2+BgAAAADalwDwAHv++efz2muvJUm+853vfKTaCy+8MEcddVTeeOONTJ48OX/5y1+yY8eOLF++PJMmTUpNTU3GjBmTkSNHNqq78sorc9hhh+Wpp57KpZdemtdffz3btm3Lgw8+mPPPPz9JcsEFFzQ896/e97///RxyyCFZsGBBpk+fnsrKymzZsiVz587NVVddlSS56qqr0q1bt4/5aQAAAADQ1jpt3ry57sMP4+OaO3duLr/88hYfv3z58gwbNqzh71etWpWJEyc2vLl3bwMHDsySJUty5JFHNplbtGhRvvWtb2XXrl1N5oYPH57f/va3zQZ5s2fPzrRp05rsHEySs88+O/fcc0+zLyT5OEaOHJmSkpKGZxl2NJWVlUk67mvoaR39Q2voH1pD/9Aa+ofW0D+0RkfvnxNPPDG1tbVZvXp1ey+FdmIH4AG2v7fxtsQpp5ySP/zhD5k8eXL69u2bsrKyDBw4MFdeeWWWLVvWbPiXJOPHj88jjzyScePGpXfv3unatWuGDBmSa6+9Ng899NA+d/FdfvnlWbhwYUaPHp3DDz883bp1y7Bhw3LjjTd+ouEfAAAAAG3DDkDajR2AHfv/QNE6+ofW0D+0hv6hNfQPraF/aI2O3j92AGI7FwAAAAAUmAAQAAAAAApMAAgAAAAABSYABAAAAIACEwACAAAAQIEJAAEAAACgwASAAAAAAFBgAkAAAAAAKDABIAAAAAAUmAAQAAAAAApMAAgAAAAABSYABAAAAIACEwACAAAAQIEJAAEAAACgwASAAAAAAFBgndt7AXQMVVVV2bhxY6OxmpqalJaWttOKAAAAADoGASBtYs6cOZkxY0aT8fLy8nZYDQAAAEDHIQCkTVRUVGTChAmNxiZPnmwHIAAAAMABJgCkTZSXlzfZ7VdWVpaSEo+hBAAAADiQpC8AAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACkwACAAAAAAFJgAEAAAAgAITAAIAAABAgQkAAQAAAKDABIAAAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACkwACAAAAAAFJgAEAAAAgAITAAIAAABAgQkAAQAAAKDABIAAAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACkwACAAAAAAFJgAEAAAAgAITAAIAAABAgXVu7wXQMVRVVWXjxo2NxmpqalJaWtpOKwIAAADoGASAtIk5c+ZkxowZTcbLy8vbYTUAAAAAHYcAkDZRUVGRCRMmNBqbPHmyHYAAAAAAB5gAkDZRXl7eZLdfWVlZSko8hhIAAADgQJK+AAAAAECBCQABAAAAoMAEgAAAAABQYAJAAAAAACgwASAAAAAAFJgAEAAAAAAKTAAIAAAAAAUmAAQAAACAAhMAAgAAAECBCQABAAAAoMAEgAAAAABQYAJAAAAAACgwASAAAAAAFJgAEAAAAAAKTAAIAAAAAAUmAAQAAACAAhMAAgAAAECBCQABAAAAoMAEgAAAAABQYAJAAAAAACgwASAAAAAAFJgAEAAAAAAKTAAIAAAAAAXWub0XQMdQVVWVjRs3NhqrqalJaWlpO60IAAAAoGMQANIm5syZkxkzZjQZLy8vb4fVAAAAAHQcAkDaREVFRSZMmNBobPLkyXYAAgAAABxgAkDaRHl5eZPdfmVlZSkp8RhKAAAAgANJ+gIAAAAABSYABAAAAIACEwACAAAAQIEJAAEAAACgwASAAAAAAFBgAkAAAAAAKDABIAAAAAAUmAAQAAAAAApMAAgAAAAABSYABAAAAIACEwACAAAAQIEJAAEAAACgwASAAAAAAFBgAkAAAAAAKDAB4KfA2rVrM2XKlBx33HEpLy/PsGHDMn369Lz77rv7rXv66adz3nnn5dhjj82RRx6ZESNG5IYbbsj27dv3W/foo4/mnHPOycCBA9O3b9+ceuqpmTVrVvbs2fNJXhYAAAAAbUAA2I62bt2av/u7v0vPnj2zdevWZo9ZsWJFzjjjjMybNy8bNmxITU1NXnvttcyaNSunn356rFWDIQAAIABJREFU1q9f32zdggULctZZZ+U3v/lNqqqqsmPHjrz00kuZMWNGxo4dmy1btjRbN2vWrEycODFLly7Nu+++m23btuW5557L9OnTM2nSpOzevfsTu34AAAAADjwBYDu69tpr8+qrr+5zvrq6OhdddFG2bt2aUaNGZeXKlamsrMzixYvzuc99Lm+++WamTJnSpO6tt97KFVdckV27dmXixIl59tlns2HDhsybNy+9e/fOmjVrcs011zSpe+aZZ3Ldddelrq4uU6ZMyYsvvph169Zl9uzZ6datW5YuXZqZM2d+op8BAAAAAAeWALCdPPTQQ/nf//t/7/eYu+66Kxs2bEj//v1z77335oQTTsihhx6a008/Pffdd19KS0uzbNmyrFq1qlHdbbfdlurq6nzhC1/IL3/5ywwaNCjdu3fPV77ylfzqV79KksybNy9vvvlmo7qZM2dmz549GT9+fGbOnJl+/fqlR48eOe+883LzzTcnSW6//fZUV1d/ch8EAAAAAAeUALAdbNq0Kd/97nc/9LgFCxYkSS677LJ079690dzgwYMzbty4JMmiRYsazS1cuDBJMnXq1JSUNP4Rn3baaTn55JOze/fuLF68uGG8uro6Dz/8cJLk6quvbrKWc889N/369cv777+fZcuWfejaAQAAADg4CADbwdSpU/POO+/kkksu2ecx27dvz1NPPZUkGTt2bLPHjBkzJkmyfPnyhrGXX34569evT0lJSUaPHt3iulWrVmXnzp3p1atXhg8f3qSmpKQkZ555ZpLk8ccf39/lAQAAAHAQEQC2sblz5+bXv/51/sN/+A/5h3/4h30e9+qrr2bPnj3p0qVLjjvuuGaPGTp0aJIPQr96a9euTZIMGDAgPXv23G9d/bF7f10/15yTTjqpSR0AAAAABzcBYBt64403cs0116R79+75+c9/3uT23L3VP5/vqKOO2udxRx99dJIP3ia8adOmJB+8AGTvueb069ev0Tn2rquf29/5/u2zAwEAAAA4eHVu7wV0FLW1tfn2t7+dzZs352c/+1kGDRqU119/fZ/H179o47DDDtvnMXs/F7C6ujq9evVqUV39XHV1derq6tKpU6ds3bq1xef7sJeAjBw5cr/z9V555ZUMHDgwlZWVLTq+aKqqqtp7CXyK6R9aQ//QGvqH1tA/tIb+oTU6ev/s3r17v5uQKD4//TYya9asLF++PGPHjs23vvWtDz2+pqYmSVJaWrrPY/ae2759e4vrunTpkiSpq6vLjh07kiQ7d+5s8fm2bdv2oesHAAAA4OBgB2Ab+POf/5wf//jHOeKIIzJr1qwW1ZSVlSX5W6DXnPrwLvlbONeSur3n6o+vr2/J+epr9mX16tX7na83cuTIlJSUpE+fPi06vqg6+vXTOvqH1tA/tIb+oTX0D62hf2iNjto/nTt3Tm1tbXsvg3YkADzAdu7cmYqKitTU1OTnP/95+vbt26K6+ttt62/Nbc7ec/W37rakbsuWLUmSQw89tGELcH19S863963HAAAAABzcBIAfwcKFC3PBBRe06NjPfvaz+dOf/pRbbrklzz33XCZNmpRJkya1+Fz9+/dPkrz99tupra1t9l799evXJ0m6du2a3r17J0mOOeaYJMm6dev2+b03bNiQpPGLQurr6r9nS+sAAAAAOLgJAD+CHj16ZPDgwS06tv5tun/961+TJP/6r/+af/3Xf/3Q4//Lf/kvueeeezJo0KB07tw5u3btyosvvpgTTjihSc3zzz+fJPn85z+fTp06JUmGDBmS5IM3Dm/evDk9e/ZsUvenP/2p0bF7f10/15zm6gAAAAA4uAkAP4Ivf/nLefrpp9vkXF27ds2IESOycuXKLFmypNkAcMmSJUmSUaNGNYwde+yxOfroo7Nu3bosXbo055xzTpO6Rx99tEndyJEjU1ZWlk2bNuWZZ57J8OHDG9XU1tbmscceS5KcccYZrb4+AAAAANqGtwAfYD//+c+zefPmZv967rnnGo5bv359Nm/enHvuuadhbMKECUmSO+64o+Etv/VeeeWVPPDAA0mSiRMnNpqrD/1uvfXW1NXVNZpbsWJFnnzyyXTp0iVf+9rXGsa7d++es846K0lyyy23NLmO+fPnZ/369TniiCNy5plnfuTPAQAAAID2IQA8iF144YU56qij8sYbb2Ty5Mn5y1/+kh07dmT58uWZNGlSampqMmbMmIwcObJR3ZVXXpnDDjssTz31VC699NK8/vrr2bZtWx588MGcf/75SZILLrig4bl/9b7//e/nkEMOyYIFCzJ9+vRUVlZmy5YtmTt3bq666qokyVVXXZVu3bq1zQcAAAAAQKt12rx5c92HH8aB8Prrr2fo0KFJPtgBWP8m3r2tWrUqEydObHhz794GDhyYJUuW5Mgjj2wyt2jRonzrW9/Krl27mswNHz48v/3tb5sN8mbPnp1p06Y12TmYJGeffXbuueeeZl9I8nGMHDkyJSUlDc8y7GgqKyuTdNzX0NM6+ofW0D+0hv6hNfQPraF/aI2O3j8nnnhiamtrs3r16vZeCu3EDsCD3CmnnJI//OEPmTx5cvr27ZuysrIMHDgwV155ZZYtW9Zs+Jck48ePzyOPPJJx48ald+/e6dq1a4YMGZJrr702Dz300D538V1++eVZuHBhRo8encMPPzzdunXLsGHDcuONN36i4R8AAAAAbcNLQNrRgAEDsnnz5g897vOf/3zuuOOOj/z9hw8fnrlz537kujPPPNNz/gAAAAAKwnYuAAAAACgwASAAAAAAFJgAEAAAAAAKTAAIAAAAAAUmAAQAAACAAhMAAgAAAECBCQABAAAAoMAEgAAAAABQYAJAAAAAACgwASAAAAAAFJgAEAAAAAAKTAAIAAAAAAUmAAQAAACAAhMAAgAAAECBCQABAAAAoMA6t/cC6BiqqqqycePGRmM1NTUpLS1tpxUBAAAAdAwCQNrEnDlzMmPGjCbj5eXl7bAaAAAAgI5DAEibqKioyIQJExqNTZ482Q5AAAAAgANMAEibKC8vb7Lbr6ysLCUlHkMJAAAAcCBJXwAAAACgwASAAAAAAFBgAkAAAAAAKDABIAAAAAAUmAAQAAAAAApMAAgAAAAABSYABAAAAIACEwACAAAAQIEJAAEAAACgwASAAAAAAFBgAkAAAAAAKDABIAAAAAAUmAAQAAAAAApMAAgAAAAABSYABAAAAIACEwACAAAAQIEJAAEAAACgwASAAAAAAFBgAkAAAAAAKDABIAAAAAAUmAAQAAAAAApMAAgAAAAABSYABAAAAIAC69zeC6BjqKqqysaNGxuN1dTUpLS0tJ1WBAAAANAxCABpE3PmzMmMGTOajJeXl7fDagAAAAA6DgEgbaKioiITJkxoNDZ58mQ7AAEAAAAOMAEgbaK8vLzJbr+ysrKUlHgMJQAAAMCBJH0BAAAAgAITAAIAAABAgQkAAQAAAKDABIAAAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACkwACAAAAAAFJgAEAAAAgAITAAIAAABAgQkAAQAAAKDABIAAAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACkwACAAAAAAFJgAEAAAAgAITAAIAAABAgQkAAQAAAKDABIAAAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACqxzey+AjqGqqiobN25sNFZTU5PS0tJ2WhEAAABAxyAApE3MmTMnM2bMaDJeXl7eDqsBAAAA6DgEgLSJioqKTJgwodHY5MmT7QAEAAAAOMAEgLSJ8vLyJrv9ysrKUlLiMZQAAAAAB5L0BQAAAAAKTAAIAAAAAAUmAAQAAACAAhMAAgAAAECBCQABAAAAoMAEgAAAAABQYAJAAAAAACgwASAAAAAAFJgAEAAAAAAKTAAIAAAAAAUmAAQAAACAAhMAAgAAAECBCQABAAAAoMAEgAAAAABQYALANnbvvffm7LPPzoABA9KnT5+MGjUq//zP/5y6urp91qxduzZTpkzJcccdl/Ly8gwbNizTp0/Pu+++u99zPf300znvvPNy7LHH5sgjj8yIESNyww03ZPv27fute/TRR3POOedk4MCB6du3b0499dTMmjUre/bs+VjXDAAAAED76bR58+Z9J098Ympra1NRUZH58+c3O/+Nb3wjd9xxRzp16tRofMWKFZk0aVK2bt3apKZ///555JFH0q9fvyZzCxYsyKWXXppdu3Y1mRs2bFgefPDB9OjRo8ncrFmzcu211zYbSI4ePTr33XdfOnfuvM/r/ChGjhyZkpKSPP/885/I9/u0qaysTJL06dOnnVfCp5H+oTX0D62hf2gN/UNr6B9ao6P3z4knnpja2tqsXr26vZdCO7EDsI3cdNNNmT9/fj7zmc/kzjvvzFtvvZW1a9fm+uuvT0lJSe69997cfffdjWqqq6tz0UUXZevWrRk1alRWrlyZysrKLF68OJ/73Ofy5ptvZsqUKU3O9dZbb+WKK67Irl27MnHixDz77LPZsGFD5s2bl969e2fNmjW55pprmtQ988wzue6661JXV5cpU6bkxRdfzLp16zJ79ux069YtS5cuzcyZMw/YZwQAAADAJ08A2AY2btyYn/70p+ncuXPuu+++fP3rX0/Pnj3Tp0+f/OM//mOmTp2aJLn99tsb1d11113ZsGFD+vfvn3vvvTcnnHBCDj300Jx++um57777UlpammXLlmXVqlWN6m677bZUV1fnC1/4Qn75y19m0KBB6d69e77yla/kV7/6VZJk3rx5efPNNxvVzZw5M3v27Mn48eMzc+bM9OvXLz169Mh5552Xm2++uWGN1dXVB+qjAgAAAOATJgBsA3fffXe2bduW8ePHZ8SIEU3mKyoqMnTo0HTq1KlRuLZgwYIkyWWXXZbu3bs3qhk8eHDGjRuXJFm0aFGjuYULFyZJpk6dmpKSxj/i0047LSeffHJ2796dxYsXN4xXV1fn4YcfTpJcffXVTdZ47rnnpl+/fnn//fezbNmyFl87AAAAAO1LANgGfve73yVJJkyY0Oz8MccckyeeeCLLly9vCPq2b9+ep556KkkyduzYZuvGjBmTJFm+fHnD2Msvv5z169enpKQko0ePbnHdqlWrsnPnzvTq1SvDhw9vUlNSUpIzzzwzSfL444/v+2IBAAAAOKgIANvAH//4xyRpNljbl1dffTV79uxJly5dctxxxzV7zNChQ5N8EPrVW7t2bZJkwIAB6dmz537r6o/d++v6ueacdNJJTeoAAAAAOLgJAA+wysrKbN68OZ07d06/fv3yf//v/81ZZ52VY445Jn379s2oUaNy2223ZefOnY3q6p/Pd9RRRzW5jbfe0UcfnSTZunVrNm3alOSDF4DsPdec+rcG7/0MwPq65t4o/G/P92+fHQgAAADAwatzey+g6KqqqpIk3bp1yz/+4z/mF7/4RaP5Z599Ns8++2x+85vf5P7772+4Bbj+WYCHHXbYPr/33s8FrK6uTq9evVpUVz9XXV2durq6dOrUKVu3bm3x+bwEBAAAAODTQwB4gNWHZZs3b84vfvGLjB49Oj/84Q8zbNiwbN26NQsWLMh1112XFStW5Ac/+EFmzZqVJKmpqUmSlJaW7vN77z23ffv2Ftd16dIlSVJXV5cdO3bk0EMPbdiB2JLzbdu2bb/XPHLkyP3O13vllVcycODAVFZWtuj4oqkPh+Hj0D+0hv6hNfQPraF/aA39Q2t09P7ZvXv3Pu8upGPw0z/AamtrG74+44wzcv/99+fkk09OWVlZevXqlUsvvTQzZ85M8sHbgutvxS0rK0vyt0CvOTt27Gj4uj6ca0nd3nP1x9fXt+R89TUAAAAAHPzsADzAunXr1vD1f/tv/63ZxP2b3/xmfvzjH+ftt9/O448/nnPPPbfhdtv6W3Obs/dc/a27LanbsmVLkuTQQw9tWE99fUvOt/etx81ZvXr1fufrjRw5MiUlJenTp0+Lji+qjn79tI7+oTX0D62hf2gN/UNr6B9ao6P2T+fOnRttUKLjsQPwI1i4cGF69uzZor/q35jbq1evhvoTTzyx2e9bUlKSwYMHJ0k2bNiQJOnfv3+S5O23397nP6Tr169PknTt2jW9e/dOkhxzzDFJknXr1u3zOurPsfeLQurr6r9nS+sAAAAAOLjZAfgR9OjRoyGo+zD1b9M9+uij071791RXV2fXrl37PL5r165J/nYr7qBBg9K5c+fs2rUrL774Yk444YQmNc8//3yS5POf/3w6deqUJBkyZEiS5I033sjmzZvTs2fPJnV/+tOfGh2799f1c81prg4AAACAg5sA8CP48pe/nKeffvoj1XTq1CkjR47M73//+6xatSrjx49vcsyePXuyZs2aJMmxxx6b5INAcMSIEVm5cmWWLFnSbAC4ZMmSJMmoUaMaxo499tgcffTRWbduXZYuXZpzzjmnSd2jjz7apG7kyJEpKyvLpk2b8swzz2T48OGNampra/PYY48l+eBZhgAAAAB8OrgFuA3Uh3A33nhjoxd31LvzzjtTWVmZf/fv/l1OP/30hvEJEyYkSe64446Gt/zWe+WVV/LAAw8kSSZOnNjs+W699dbU1dU1mluxYkWefPLJdOnSJV/72tcaxrt3756zzjorSXLLLbc0WeP8+fOzfv36HHHEETnzzDNbduEAAAAAtDsBYBv45je/mQEDBuS5557LuHHjsmrVqtTU1OTtt9/OT37yk0ybNi3JBy8JqX8ZR5JceOGFOeqoo/LGG29k8uTJ+ctf/pIdO3Zk+fLlmTRpUmpqajJmzJiMHDmy0fmuvPLKHHbYYXnqqady6aWX5vXXX8+2bdvy4IMP5vzzz0+SXHDBBQ3P/av3/e9/P4ccckgWLFiQ6dOnp7KyMlu2bMncuXNz1VVXJUmuuuqqRi82AQAAAODg1mnz5s11H34YrfXHP/4x48aNy/vvv9/s/MUXX5yf/exnDc/yq7dq1apMnDix4c29exs4cGCWLFmSI488ssncokWL8q1vfavZ5w4OHz48v/3tb5sN8mbPnp1p06Y12TmYJGeffXbuueeeZt9k/HHUvwW4/lmGHU1lZWWSjvsWKlpH/9Aa+ofW0D+0hv6hNfQPrdHR++fEE09MbW1tVq9e3d5LoZ3YAdhG/u7v/i4rV67MpZdemgEDBqS0tDSHH354Ro8enXvuuSe33HJLk/AvSU455ZT84Q9/yOTJk9O3b9+UlZVl4MCBufLKK7Ns2bJmw78kGT9+fB555JGMGzcuvXv3TteuXTNkyJBce+21eeihh/a5i+/yyy/PwoULM3r06Bx++OHp1q1bhg0blhtvvPETDf8AAAAAaBt2ANJu7ADs2P8HitbRP7SG/qE19A+toX9oDf1Da3T0/rEDENu5AAAAAKDABIAAAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACkwACAAAAAAFJgAEAAAAgAITAAIAAABAgQkAAQAAAKDABIAAAAAAUGACQAAAAAAoMAEgAAAAABSYABAAAAAACkwACAAAAAAFJgAEAAAAgALr3N4LoGOoqqrKxo0bG43V1NSktLS0nVYEAAAA0DEIAGkTc+bMyYwZM5qMl5eXt8NqAAAAADoOASBtoqKiIhMmTGg0NnnyZDsAAQAAAA4wASBtory8vMluv7KyspSUeAwlAAAAwIEkfQEAAACAAhMAAgAAAECBCQABAAAAoMAEgAAAAABQYAJAAAAAACgwASAAAAAAFJgAEAAAAAAKTAAIAAAAAAUmAAQAAACAAhMAAgAAAECBCQABAAAAoMAEgAAAAABQYAJAAAAAACgwASAAAAAAFJgAEAAAAAAKTAAIAAAAAAUmAAQAAACAAuvc3gug43rrrbeya9eunHjiie29lHaxe/fuJEnnzv4x5KPTP7SG/qE19A+toX9oDf1Da3T0/vnrX/+aLl26tPcyaEcds/M5KHTr1i3btm1LbW1tm5xvz549ee+993LEEUfkkEMOaZNz7s9rr72WJBk0aFD7LuT/d7B9Ptazf/rHelpD/1hPa+gf62kN/WM9raF/rKc1Onr/dOnSJd26dTvg5+Hg1Wnz5s117b0IaAsvvPBCTjnllKxatSrHH398ey8nI0eOTJKsXr26nVfygYPt87Ge/dM/1tMa+sd6WkP/WE9r6B/raQ39Yz2toX/o6DwDEAAAAAAKTAAIAAAAAAUmAAQAAACAAhMAAgAAAECBCQDpMHr37p1p06ald+/e7b2Ug9LB9vlYz6fLwfb5WM+ny8H2+VjPp8vB9vlYz6fLwfb5WM+ny8H2+VjPp4vPh7bmLcDQTg62t1Dx6aJ/aA39Q2voH1pD/9Aa+ofW0D90dHYAAgAAAECBCQABAAAAoMAEgAAAAABQYJ4BCAAAAAAFZgcgAAAAABSYABAAAAAACkwACAAAAAAFJgAEAAAAgAITAAIAAABAgQkAoRXuvffenH322RkwYED69OmTUaNG5Z//+Z9TV7fvl2uvXbs2U6ZMyXHHHZfy8vIMGzYs06dPz7vvvrvfcz399NM577zzcuyxx+bII4/MiBEjcsMNN2T79u37rXv00UdzzjnnZODAgenbt29OPfXUzJo1K3v27PlY10z70j+0hv7h46qrq8udd96ZM844I/369ctnP/vZfPWrX82DDz7Y3kvjILFz587cfPPNOeWUU9KnT58MGjQoX//617NixYr91m3evDnXX399/v7v/z7l5eUZPHhwLr744jz//PP7rXv77bfzve99LyeddFLKy8tz/PHH58orr8wbb7zxSV4WbUT/UO+FF17It7/97Zxwwgnp3bt3TjjhhHzve9/LO++80+zxegdartPmzZv3nVQAzaqtrU1FRUXmz5/f7Pw3vvGN3HHHHenUqVOj8RUrVmTSpEnZunVrk5r+/fvnkUceSb9+/ZrMLViwIJdeeml27drVZG7YsGF58MEH06NHjyZzs2bNyrXXXttsIDl69Ojcd9996dy58z6vk7azdevWnHrqqXn11Vezfv36HHbYYU2O0T/Ue+KJJ/Lzn/88q1evzsaNG3PYYYfl7//+73PxxRfnnHPOabZG//Bx1dXV5fzzz8+vf/3rZud/+MMf5pprrmnjVXEgvfPOO/mf//N/5ne/+13DL7UDBw7MV7/61Xz3u9/N4Ycf3uj47du3Z9y4cVm9enWT73XIIYfktttuy3nnnddkbuPGjRk7dmz++te/Npk79NBDc/fdd+fLX/5yk7m1a9fmP//n/5yqqqomc0cccUQeeOCBDB06tMXXy4H3ox/9KD/72c9y00035bLLLms0p3+o95vf/CaXXnpps/+DsV+/fvnd736XAQMGNIzpHfho7ACEj+Gmm27K/Pnz85nPfCZ33nln3nrrraxduzbXX399SkpKcu+99+buu+9uVFNdXZ2LLrooW7duzahRo7Jy5cpUVlZm8eLF+dznPpc333wzU6ZMaXKut956K1dccUV27dqViRMn5tlnn82GDRsyb9689O7dO2vWrGn2F69nnnkm1113Xerq6jJlypS8+OKLWbduXWbPnp1u3bpl6dKlmTlz5gH7jPhorr322rz66qv7nNc/1Lv11ltz9tlnZ9GiRdmwYUN27dqV9957L7///e9zwQUXpKKiIrW1tY1q9A+tMWvWrPz6179OWVlZfvaznzX8O2/q1KlJkhtuuCHLly9v51XySXnhhRdy6qmn5pZbbsmLL76Ybdu2Zdu2bfnzn/+cG2+8MaeffnpefvnlRjXXX399Vq9encMPPzy/+tWvsmHDhjz33HM599xzs2fPnlx11VVNapLku9/9bv7617/mmGOOyaJFi1JZWZknn3wyY8aMyfbt23PJJZfkvffea1RTV1eXiy++OFVVVTnppJOyZMmSVFZW5rHHHsvw4cPz3nvv5cILL8zu3bsP6OdEy61YsSK33nrrPuf1D0ny0ksvpaKiItu3b89ll12WNWvWZMOGDbn//vszcODArF+/PpdffnmjGr0DH40dgPARbdy4MSeddFJ27tyZhx9+OCNGjGg0f/311+enP/1phg4dmieeeKJh/Pbbb8+0adPSv3//rF69Ot27d2+YW7t2bf7jf/yP2blzZx555JGccsopDXPTpk3L7bffni984Qt59NFHU1Lyt9x++fLl+cpXvpLOnTvnj3/8Y/r3798w981vfjMPPPBAxo8fn3/5l39ptMa5c+fm8ssvz+GHH54XXnih0Vpoew899FC+/vWvN/x9czsA9Q9J8uSTT2bs2LGpra3NN77xjfzgBz/IZz/72bz++uv5X//rf+XOO+9MXV1drrvuuvzgBz9oqNM/fFw1NTU58cQT88477zS7c+fyyy/P3Llzc+aZZ2bRokXttEo+KXV1dfniF7+Y559/PoMGDcqNN96Y0047LVu2bMnSpUvzT//0T3nnnXcyZMiQrFixIl26dMk777yTE088MTU1NQ2PRtnbV7/61SxbtiwXXXRRoxBozZo1Oe2003LIIYdk2bJljXbN1NTU5Itf/GLWrl2bH/3oR/n+97/fMLd48eKce+656dGjR5566qkcddRRDXObNm3KiBEjsmnTptx5552N/t1K+9iyZUtOPfXUvPbaa0nS5M8R/UO9Cy64IAsXLsxll12Wm266qdHcCy+8kC9+8YvZs2dPli9fnmHDhukd+BjsAISP6O677862bdsyfvz4JuFfklRUVGTo0KHp1KlTqqurG8YXLFiQJLnsssua/MI7ePDgjBs3Lkma/AK1cOHCJMnUqVMb/fKdJKeddlpOPvnk7N69O4sXL24Yr66uzsMPP5wkufrqq5us8dxzz02/fv3y/vvvZ9myZS2+dj55mzZtyne/+90PPU7/kCSzZ89ObW1tvvSlL2XOnDkZPHhwysrKMmTIkNx88825/vrrkyS33HJLdu7c2VAeMsWOAAATpklEQVSnf/i4nnjiibzzzjs54ogjcvHFFzeZ/973vpckWbZsWd5///22Xh6fsKVLl+b5559Ply5dcv/99+ess85Kt27d0qdPn5x77rl5+OGH061bt7z00ksNf1789re/TU1NTY4//vgmv4AnyVVXXZXkg1v79n4kQP2fL2PGjGlyy1xZWVm+853vJEmTW8/vv//+JMnkyZMb/QKeJL169cqFF17YbB3tY9q0aQ3hX3P0D0lSVVWVX//61+nWrVuuvfbaJvPHH398Jk+enKFDh+all15Konfg4xAAwkf0u9/9LkkyYcKEZuePOeaYPPHEE1m+fHnDL9rbt2/PU089lSQZO3Zss3VjxoxJkka3Ub388stZv359SkpKMnr06BbXrVq1Kjt37kyvXr0yfPjwJjUlJSU588wzkySPP/74vi+WA27q1Kl55513cskll+zzGP1DvcceeyxJGv4j89+64oorUlZWli1btmTNmjVJ9A+tU/+zPeOMM1JaWtpkfvDgwRkwYED27NnzoQ9c5+BX/2fMGWeckUGDBjWZHzRoUMNzRuvvcqj/53hff76MGjUqZWVl2bRpU/785z83jH9YXf2fL3/84x/z//7f//v/2rvzoKrKP47jH0BUUFHABbcw1zQ1x0kz93Ip11TcstTRcGFK08wJc5pxWsclx0zFTGnQYRx1XHLP0UzTXDLFyNLRVIhIEEQvsklcfn/cOccLXPBe/KV5er9mGOE+z5d78Xx5Lud7nvM85uNGTt4rjvHl4du9e7fWrVun1q1bq2PHji77kD+QpH379slut6tHjx4KDAx02ScqKkpHjx7V8OHDJZE7QHlQAAQ8dPbsWUlyeWJbmitXrqigoEC+vr5q0aKFyz7GFSjndSouXrwoSQoNDVVAQECZcUZf58/LWoS2devWJeLwYMXGxmr79u3q1KmTpk+fXmo/8geSY7e6tLQ0SY4r4a5UrlzZPNbGDGTyB/fDOEbGMXOF42kdly9fllT6GCNJtWvXlnR3jDHGjdJypGLFimrevLkkz8aKxx57TNWrV1dhYaG5UP/t27f1119/lRlnvI6MjAylp6eX+nPgn5WWlqZp06apYsWKWrVqlcsLCBL5A4e4uDhJnp1fkTuA5ygAAh5ISUmRzWZThQoVVK9ePW3cuFF9+/ZVgwYNFBISou7du2vZsmVFbr2TpD/++EOSVLdu3RK30Rnq168vyfEGY7xpJCUlFWlzxdi103gO5zhXO3oWfz7nODw4iYmJeuedd1SlShWtXLmy1LyQyB84+Pr6Kjo6WtHR0UV2wHOWnJxs7kxn9CF/cD+MY+ROHhi7xeLRNXXqVEVHR7vcNdNgXAgtPsZ4MlZkZ2frxo0bRdrciTPGF29vb4WEhLiMqVGjhnkHBjn58EybNk3Xr1/X3Llzy7yAQP5AulvMe+yxx3Tx4kWFh4erWbNmqlmzplq1aqVp06aVuJWc3AE8V+FhvwDgUWKcWPv7+2vWrFlas2ZNkfa4uDjFxcVpx44d2rJli/kmYFwlL76xgzPndbmysrIUHBzsVpzRlpWVpcLCQnl5een27dtuP5/zOoV4MOx2u6ZOnSqbzaYlS5aocePGSkhIKLU/+QNJ8vPzM297Kc17770nyXEVulGjRpLIH9wfT/MAj7Zu3bqV2b5//34dPHhQkjRgwABJno0xxvjgnCuexBn/+vv7y8fHp8y4rKwscvIhWbdunXbt2qVOnTqZu4WXhvyBJPMOhzNnzmjGjBnKyckx25KSkhQTE6OtW7dqw4YN6tKliyRyBygPZgACHjAGc5vNpjVr1uj555/XgQMHdP36dV25ckWLFy+Wv7+/jh07VmQHzry8PEkq9faH4m3Gm547cb6+vpIcO/fl5uZKkjkD0Z3ny87OLrUP/hnLly/XkSNH1KdPH02cOPGe/ckf3IvNZtNrr72mTZs2ydvb29wMRCJ/cH88yQPnEzZYT2xsrMaOHStJGjZsmNq1ayfJszGm+PjiaZwxvhg5d684xpgHLyEhQZGRkW7d4SCRP3AwzrFWrlypatWqadWqVbp69apSU1O1Z88etWvXTjabTa+++qo5g4/cATxHARDwgN1uNz/v0aOHtmzZog4dOqhSpUoKDg5WeHi4Fi1aJMmxW7AxXbxSpUqSir7pFGecPEt33zzciXNuM/ob8e48nxGDB+PXX3/V+++/r8DAQC1fvtytGPIHpbHb7Vq7dq3at29vFv8WLFigF154wexD/uB+eJIHZZ1M4dEVHx+vgQMHKiIiQllZWeratauioqLM9vLkiPPvfvFlU5wVHyuM+LJiXMXhwbDb7ZoyZYoyMzP10UcfudxIpjjyB5JUUFAgybGW8e7duzV69GgFBQWpcuXK6tKli7Zt26YaNWooPT1d0dHRksgdoDwoAAIe8Pf3Nz+fPXu2y6uaY8aMUUhIiAoKCsxdoIpPI3fFuc2Yku5OXGZmpiTH7YHG6zHi3Xk+51v/8M+6c+eOJk2apLy8PC1evLjUNUSKI3/gyunTp9WzZ0+98cYbSk1NVaNGjbRr1y5Nnjy5SD/yB/fDk/zheFrLrVu39NZbb6lbt246fPiwfH199e6772r79u3y8/Mz+3kyVhQfX5zbXCmeW0Z8Tk6O/v7771LjjNlE5OSDtXTpUv3www/q3bu3W3c4SOQPHIz/66FDh5obdzgLCgrShAkTJEmHDh0qEkPuAO6jAIj/rG3btikgIMCtD2Px4uDgYDP+ySefdPl9vb291axZM0kyd4tq2LChJOnatWtFZhE6S05OluS48lWzZk1JUoMGDSRJf/75Z6k/h/EczgvgGnHG93Q3Du4rT/589tlnio+PV1hYmMLCwtx+LvLHesqTP84WLlyoXr16KS4uTgEBAZo3b55OnjxprovjjPzB/TDyp6w8MI61cezx6Dt16pQ6d+6s1atXy263a9CgQTp58qQiIyNVoULRJcTdyZHiv/P+/v4KCgqS5NlYYeSY3W7XtWvXXMbcuHHDvG2PnHxwrly5og8//FCBgYFasWKF23HkD6S751hlbRhjFAaNY07uAJ5jExD8Z1WrVs0s1N2LsRNU/fr1zcVd8/PzS+1fuXJlSXenizdu3FgVKlRQfn6+zp8/r1atWpWIOXfunCSpadOm8vLyknT3jS4xMVE2m00BAQEl4n755ZcifZ0/N9pccRUH95Unf37//XdJ0ubNm7V58+Z79h8wYIDWr19P/lhQefLHMHPmTHMDoqFDh+rTTz81i3aukD+4H0aelnU8jfzheFrD4cOHNXLkSGVnZys0NFQrVqwoc3OQZs2a6cyZM6XmSF5eni5evCip5Fhx/PhxxcfHq3PnziXiEhISzBk6Rh5WrVpV9erVU3JysuLj412eZBv5GBAQ4PZMe9y/pKQk3blzR3fu3ClzLJg9e7Zmz54tyfH+Qv5Acvz9cejQoTJvsTVmHhvnV+QO4DlmAOI/q1evXvrpp5/c+tixY4ckycvLSx07dpQknThxwuX3LSgo0M8//yxJatKkiSRHQfDpp5+W5NhBzxXj8e7du5uPNWnSRPXr15fdbte3337rMu7AgQMl4jp27KhKlSopPT1dp0+fLhFjt9v13XffSXKsZQjPlSd/yov8sZ7y5k9sbKzWrFkjLy8vLViwQDExMWUW/yTyB/fHKPyUdmJ28eJFJSYmysfHx+UMVDxa0tPTNW7cOGVnZ6tHjx46evToPXcGNtpLG1++//573blzR0FBQWrTpo35eNeuXcuMM8aXtm3bmjN2PIlzHpfw70X+QJKeffZZSaWfX0ky/6Zo2rSpJHIHKA8KgICHhgwZIklasGBBkYXzDatXr1ZKSoqqV69e5I/moUOHSpJWrVpVYqfEy5cva+fOnZIcO+u5er6lS5eqsLCwSNuxY8f0448/ytfXV4MHDzYfr1Klivr27SvJcdtpcZs2bVJycrICAwP13HPPufeD476tXLlSNpvN5Ud8fLzZLzk5WTabTevXrzcfI38gSfPnz5ckTZ8+XVOnTnU7jvxBeXXp0kV16tTRzZs3FRMTU6J96dKlkqSePXsWOVHCo+nLL7/UjRs3FBoaqg0bNric+Vtc//79VblyZf3222/65ptvSrR//vnnkhzjifPayca4tH///hIzePLz87Vy5UpJJccl4+sNGzYoJSWlSFtGRobWrl3rMg7/rG7dupX6N47NZjOLJwsXLjQfq1GjBvkDSVLfvn3l7++vffv26fjx4yXak5KSzGMzYMAASYw9QHlQAAQ8NGbMGIWGhio+Pl6DBg3SiRMnlJeXp2vXrmn+/PmKjIyU5LjFwVgwVpLGjx+vunXrKjExUaNHj9aFCxeUm5urI0eOKCwsTHl5eerdu7c5w9Awbdo0Va1aVadOnVJ4eLgSEhKUnZ2tPXv2aOzYsZKkcePGlZiK/vbbb8vHx0dbt27VnDlzlJKSoszMTMXGxmrGjBmSpBkzZhTZ2AT/XuQPzp07p6tXr0qSXn/9dY9iyR+UV8WKFTVz5kxJ0ty5c7Vu3TplZmYqJSVF8+bNU0xMjLy9vc33Pjzadu/eLUmaMGGC27+ftWrVMjd8mDx5snbu3Kns7GwlJCQoIiJCBw8elJ+fn/m7b2jTpo0GDhyogoICvfzyyzp8+LByc3N14cIFjRkzRufPn1etWrUUHh5eJK5fv3566qmnZLPZNHz4cJ0+fVq5ubk6c+aMwsLClJaWppYtW5on+fh3I38gSTVq1FBERITsdrtGjBihmJgYZWRkKCcnR3v27FH//v118+ZNtW3bVsOHD5dE7gDl4WWz2Qrv3Q2As7Nnz2rQoEG6efOmy/YJEyZoyZIl5lpahhMnTmjYsGEud51q1KiR9u/fr9q1a5do+/rrrzVx4kSX6w62b99eu3fvdvmHelRUlCIjI0vM3JEcb2Lr1693uZMxHryEhATz9oTk5OQixWMD+fPfFhsbq4iICLf7HzlyRG3btjW/Jn9QXoWFhRo/fry2bdvmsv2DDz7Qm2+++YBfFf7f8vPzFRISUuYax84iIiLMWcm5ubkaPHiwy5k7FSpU0BdffKERI0aUaEtPT1efPn106dKlEm1VqlTRxo0bXd6CfOnSJb344otKTU0t0RYcHKy9e/eqRYsWbv0ceDD69++vI0eOaOHChZoyZUqRNvIHkmMMGj58uA4ePOiyvUmTJtq2bZtCQ0PNx8gdwDM+c+bMmfewXwTwqAkJCdGoUaOUm5ur9PR05eTkqFq1aurcubM+/vhjTZ8+vUTxT3LsCPXSSy/p1q1bSktLU35+vho2bKixY8dq9erVRXYZdvbEE0+oT58+Sk9P140bN2S329W4cWNNmTJFy5YtMxfFLa5Dhw7q1KmTUlNTlZGRIW9vb7Vs2VKzZs3SJ598wsn3v8itW7cUFRUlSZo1a5a5wLEz8ue/be/evTp8+LDb/SdOnKg6deqYX5M/KC8vLy8NGTJEderUUWpqqjIzM1WlShU988wzWrRokV555ZWH/RLxf3Dt2jXzlm53dOjQQX369JHkONEeNWqU/Pz8lJqaqqysLFWvXl09e/bU8uXLzWUBivP399eYMWNUWFio1NRUZWdnKzg4WP369dPq1avVvn17l3FBQUEaNWqUcnJydP36deXl5SkkJERhYWH66quv9Pjjj3v+H4B/VGxsrBITE9W3b19zXVoD+QNJ8vHx0ciRI1WrVi2lpaXp9u3b8vHxUfPmzTVp0iRFRUWVuFBJ7gCeYQYgAAAAAAAAYGFcfgcAAAAAAAAsjAIgAAAAAAAAYGEUAAEAAAAAAAALowAIAAAAAAAAWBgFQAAAAAAAAMDCKAACAAAAAAAAFkYBEAAAAAAAALAwCoAAAAAAAACAhVEABAAAAAAAACyMAiAAAAAAAABgYRQAAQAAAAAAAAujAAgAAAAAAABYGAVAAAAAAAAAwMIoAAIAAAAAAAAWRgEQAAAAAAAAsDAKgAAAAAAAAICFUQAEAAAAAAAALIwCIAAAAAAAAGBhFAABAAAAAAAAC6MACAAAAAAAAFgYBUAAAAAAAADAwigAAgAAAAAAABZGARAAAAAAAACwMAqAAAAAAAAAgIVRAAQAAAAAAAAsjAIgAAAAAAAAYGEUAAEAAAAAAAALowAIAAAAAAAAWBgFQAAAAAAAAMDCKAACAAAAAAAAFkYBEAAAAAAAALAwCoAAAAAAAACAhVEABAAAAAAAACyMAiAAAAAAAABgYRQAAQAAAAAAAAujAAgAAAAAAABYGAVAAAAAAAAAwMIoAAIAAAAAAAAWRgEQAAAAAAAAsDAKgAAAAAAAAICFUQAEAAAAAAAALIwCIAAAAAAAAGBhFAABAAAAAAAAC6MACAAAAAAAAFgYBUAAAAAAAADAwigAAgAAAAAAABZGARAAAAAAAACwMAqAAAAAAAAAgIVRAAQAAAAAAAAsjAIgAAAAAAAAYGEUAAEAAAAAAAALowAIAAAAAAAAWBgFQAAAAAAAAMDCKAACAAAAAAAAFkYBEAAAAAAAALAwCoAAAAAAAACAhVEABAAAAAAAACyMAiAAAAAAAABgYRQAAQAAAAAAAAujAAgAAAAAAABYGAVAAAAAAAAAwMIoAAIAAAAAAAAWRgEQAAAAAAAAsDAKgAAAAAAAAICFUQAEAAAAAAAALIwCIAAAAAAAAGBhFAABAAAAAAAAC6MACAAAAAAAAFgYBUAAAAAAAADAwv4HiU6xJNiI7PkAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 480,
+       "width": 640
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "CODA_id = wod_dataframe['CODA_id'].unique()\n",
+    "\n",
+    "#first_profile = wod_dataframe.loc[wod_dataframe['CODA_id']==CODA_id[0]]\n",
+    "for i_ancillary_var in ancillary_vars_to_get:\n",
+    "            if i_ancillary_var in vars_in_dataset:\n",
+    "                \n",
+    "                ancillary_data_container[i_ancillary_var]  = 0\n",
+    "                attributes_data_container[i_ancillary_var] = {}\n",
+    "for i_profile in range(0,100):\n",
+    "    #print()\n",
+    "    profile_to_plot = wod_dataframe.loc[wod_dataframe['CODA_id']==CODA_id[i_profile]]\n",
+    "\n",
+    "    plt.plot(profile_to_plot['Nitrate'],-profile_to_plot['z'])\n",
+    "#plt.xlim([0,40])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "id": "47e0a3d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Oxygen 300\n",
+      "Oxygen_WODflag 300\n",
+      "Oxygen_origflag 300\n",
+      "Temperature 300\n",
+      "Temperature_WODflag 300\n",
+      "Temperature_origflag 300\n",
+      "Salinity 300\n",
+      "Salinity_WODflag 300\n",
+      "Salinity_origflag 300\n",
+      "Chlorophyll 300\n",
+      "Chlorophyll_WODflag 300\n",
+      "Chlorophyll_origflag 300\n",
+      "Nitrate 300\n",
+      "Nitrate_WODflag 300\n",
+      "Nitrate_origflag 300\n",
+      "z 300\n",
+      "z_WODflag 300\n",
+      "z_origflag 300\n",
+      "lat 300\n",
+      "lon 300\n",
+      "wod_unique_cast 300\n",
+      "time 300\n"
+     ]
+    }
+   ],
+   "source": [
+    "for i_var in profile_data_container:\n",
+    "    print(i_var,len(profile_data_container[i_var]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2d44de7e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "time_stuff = profile_data_container['time']\n",
+    "\n",
+    "for i_profile in range(0,len(time_stuff)):\n",
+    "    print(i_profile)\n",
+    "    print(time_stuff[i_profile])\n",
+    "    print(\"===================\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "id": "ee3dd6cb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d5c4a56e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "time_stuff = profile_data_container['time']\n",
+    "\n",
+    "for i_profile in range(0,len(time_stuff)):\n",
+    "    \n",
+    "    print(i_profile)\n",
+    "    print(time_stuff[i_profile])\n",
+    "    print('=========================')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "be40c8bf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "first_pass = True\n",
+    "            for i_var in point_vars_to_get:\n",
+    "                \n",
+    "                if i_var in vars_in_dataset:\n",
+    "                \n",
+    "                    current_point_var = WOD_profile_object.metadata(i_var)\n",
+    "                \n",
+    "                    if first_pass == True:\n",
+    "                    \n",
+    "                        current_profile_dataframe = pandas.DataFrame({i_var:np.repeat(current_point_var,n_levels)})\n",
+    "                    \n",
+    "                        first_pass = False\n",
+    "                \n",
+    "                    else:\n",
+    "                        current_profile_dataframe[i_var] = np.repeat(current_point_var,n_levels)\n",
+    "                    #END if first_passtemperature = np.concatenate(profile_data_container['Temperature'])\n",
+    "\n",
+    "\n",
+    "                else:\n",
+    "                    current_profile_dataframe[i_var] = np.repeat(np.nan,n_levels)\n",
+    "\n",
+    "                \n",
+    "            #END for i_var in point_vars_to_get\n",
+    "            \n",
+    "            current_profile_dataframe['time'] = np.datetime64(WOD_profile_object.datetime())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "0febf1cf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "T = WOD_profile_object.level_unpack('Temperature')\n",
+    "S = WOD_profile_object.level_unpack('Salinity')\n",
+    "O2 = WOD_profile_object.level_unpack('Oxygen')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "e2757996",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7fe01ff14b90>]"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 480,
+       "width": 640
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(S,T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "id": "fdeaf99c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lat = pandas.unique(wod_dataframe.loc[wod_dataframe['wod_unique_cast']==21349376]['lat'])\n",
+    "lon = pandas.unique(wod_dataframe.loc[wod_dataframe['wod_unique_cast']==21349376]['lon'])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "014ce4fe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "lat = wod_dataframe['lat']\n",
+    "lon = wod_dataframe['lon']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "74f03d5f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.PathCollection at 0x7fddf8978fd0>"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 480,
+       "width": 640
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.scatter(lon,lat)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "98717fdd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Working on year:  2005\n",
+      "Working on platform:  osd\n",
+      "Profile:  0  of  14845\n",
+      "Profile:  1000  of  14845\n",
+      "Profile:  2000  of  14845\n",
+      "Profile:  3000  of  14845\n",
+      "Profile:  4000  of  14845\n",
+      "Profile:  5000  of  14845\n",
+      "Profile:  6000  of  14845\n",
+      "Profile:  7000  of  14845\n",
+      "Profile:  8000  of  14845\n",
+      "Profile:  9000  of  14845\n",
+      "Profile:  10000  of  14845\n",
+      "Profile:  11000  of  14845\n",
+      "Profile:  12000  of  14845\n",
+      "Profile:  13000  of  14845\n",
+      "Profile:  14000  of  14845\n",
+      "Writing file: WOD2018_CODA_2005_osd.nc\n",
+      "Working on platform:  ctd\n",
+      "Profile:  0  of  26194\n",
+      "Profile:  1000  of  26194\n",
+      "Profile:  2000  of  26194\n",
+      "Profile:  3000  of  26194\n",
+      "Profile:  4000  of  26194\n",
+      "Profile:  5000  of  26194\n",
+      "Profile:  6000  of  26194\n",
+      "Profile:  7000  of  26194\n",
+      "Profile:  8000  of  26194\n",
+      "Profile:  9000  of  26194\n",
+      "Profile:  10000  of  26194\n",
+      "Profile:  11000  of  26194\n",
+      "Profile:  12000  of  26194\n",
+      "Profile:  13000  of  26194\n",
+      "Profile:  14000  of  26194\n",
+      "Profile:  15000  of  26194\n",
+      "Profile:  16000  of  26194\n",
+      "Profile:  17000  of  26194\n",
+      "Profile:  18000  of  26194\n",
+      "Profile:  19000  of  26194\n",
+      "Profile:  20000  of  26194\n",
+      "Profile:  21000  of  26194\n",
+      "Profile:  22000  of  26194\n",
+      "Profile:  23000  of  26194\n",
+      "Profile:  24000  of  26194\n",
+      "Profile:  25000  of  26194\n",
+      "Profile:  26000  of  26194\n",
+      "Writing file: WOD2018_CODA_2005_ctd.nc\n",
+      "Working on platform:  xbt\n",
+      "Profile:  0  of  29618\n",
+      "Profile:  1000  of  29618\n",
+      "Profile:  2000  of  29618\n",
+      "Profile:  3000  of  29618\n",
+      "Profile:  4000  of  29618\n",
+      "Profile:  5000  of  29618\n",
+      "Profile:  6000  of  29618\n",
+      "Profile:  7000  of  29618\n",
+      "Profile:  8000  of  29618\n",
+      "Profile:  9000  of  29618\n",
+      "Profile:  10000  of  29618\n",
+      "Profile:  11000  of  29618\n",
+      "Profile:  12000  of  29618\n",
+      "Profile:  13000  of  29618\n",
+      "Profile:  14000  of  29618\n",
+      "Profile:  15000  of  29618\n",
+      "Profile:  16000  of  29618\n",
+      "Profile:  17000  of  29618\n",
+      "Profile:  18000  of  29618\n",
+      "Profile:  19000  of  29618\n",
+      "Profile:  20000  of  29618\n",
+      "Profile:  21000  of  29618\n",
+      "Profile:  22000  of  29618\n",
+      "Profile:  23000  of  29618\n",
+      "Profile:  24000  of  29618\n",
+      "Profile:  25000  of  29618\n",
+      "Profile:  26000  of  29618\n",
+      "Profile:  27000  of  29618\n",
+      "Profile:  28000  of  29618\n",
+      "Profile:  29000  of  29618\n",
+      "Writing file: WOD2018_CODA_2005_xbt.nc\n",
+      "Working on platform:  pfl\n",
+      "Profile:  0  of  64100\n",
+      "Profile:  1000  of  64100\n",
+      "Profile:  2000  of  64100\n",
+      "Profile:  3000  of  64100\n",
+      "Profile:  4000  of  64100\n",
+      "Profile:  5000  of  64100\n",
+      "Profile:  6000  of  64100\n",
+      "Profile:  7000  of  64100\n",
+      "Profile:  8000  of  64100\n",
+      "Profile:  9000  of  64100\n",
+      "Profile:  10000  of  64100\n",
+      "Profile:  11000  of  64100\n",
+      "Profile:  12000  of  64100\n",
+      "Profile:  13000  of  64100\n",
+      "Profile:  14000  of  64100\n",
+      "Profile:  15000  of  64100\n",
+      "Profile:  16000  of  64100\n",
+      "Profile:  17000  of  64100\n",
+      "Profile:  18000  of  64100\n",
+      "Profile:  19000  of  64100\n",
+      "Profile:  20000  of  64100\n",
+      "Profile:  21000  of  64100\n",
+      "Profile:  22000  of  64100\n",
+      "Profile:  23000  of  64100\n",
+      "Profile:  24000  of  64100\n",
+      "Profile:  25000  of  64100\n",
+      "Profile:  26000  of  64100\n",
+      "Profile:  27000  of  64100\n",
+      "Profile:  28000  of  64100\n",
+      "Profile:  29000  of  64100\n",
+      "Profile:  30000  of  64100\n",
+      "Profile:  31000  of  64100\n",
+      "Profile:  32000  of  64100\n",
+      "Profile:  33000  of  64100\n",
+      "Profile:  34000  of  64100\n",
+      "Profile:  35000  of  64100\n",
+      "Profile:  36000  of  64100\n",
+      "Profile:  37000  of  64100\n",
+      "Profile:  38000  of  64100\n",
+      "Profile:  39000  of  64100\n",
+      "Profile:  40000  of  64100\n",
+      "Profile:  41000  of  64100\n",
+      "Profile:  42000  of  64100\n",
+      "Profile:  43000  of  64100\n",
+      "Profile:  44000  of  64100\n",
+      "Profile:  45000  of  64100\n",
+      "Profile:  46000  of  64100\n",
+      "Profile:  47000  of  64100\n",
+      "Profile:  48000  of  64100\n",
+      "Profile:  49000  of  64100\n",
+      "Profile:  50000  of  64100\n",
+      "Profile:  51000  of  64100\n",
+      "Profile:  52000  of  64100\n",
+      "Profile:  53000  of  64100\n",
+      "Profile:  54000  of  64100\n",
+      "Profile:  55000  of  64100\n",
+      "Profile:  56000  of  64100\n",
+      "Profile:  57000  of  64100\n",
+      "Profile:  58000  of  64100\n",
+      "Profile:  59000  of  64100\n",
+      "Profile:  60000  of  64100\n",
+      "Profile:  61000  of  64100\n",
+      "Profile:  62000  of  64100\n",
+      "Profile:  63000  of  64100\n",
+      "Profile:  64000  of  64100\n",
+      "Writing file: WOD2018_CODA_2005_pfl.nc\n",
+      "Working on platform:  mrb\n",
+      "Profile:  0  of  45977\n",
+      "Profile:  1000  of  45977\n",
+      "Profile:  2000  of  45977\n",
+      "Profile:  3000  of  45977\n",
+      "Profile:  4000  of  45977\n",
+      "Profile:  5000  of  45977\n",
+      "Profile:  6000  of  45977\n",
+      "Profile:  7000  of  45977\n",
+      "Profile:  8000  of  45977\n",
+      "Profile:  9000  of  45977\n",
+      "Profile:  10000  of  45977\n",
+      "Profile:  11000  of  45977\n",
+      "Profile:  12000  of  45977\n",
+      "Profile:  13000  of  45977\n",
+      "Profile:  14000  of  45977\n",
+      "Profile:  15000  of  45977\n",
+      "Profile:  16000  of  45977\n",
+      "Profile:  17000  of  45977\n",
+      "Profile:  18000  of  45977\n",
+      "Profile:  19000  of  45977\n",
+      "Profile:  20000  of  45977\n",
+      "Profile:  21000  of  45977\n",
+      "Profile:  22000  of  45977\n",
+      "Profile:  23000  of  45977\n",
+      "Profile:  24000  of  45977\n",
+      "Profile:  25000  of  45977\n",
+      "Profile:  26000  of  45977\n",
+      "Profile:  27000  of  45977\n",
+      "Profile:  28000  of  45977\n",
+      "Profile:  29000  of  45977\n",
+      "Profile:  30000  of  45977\n",
+      "Profile:  31000  of  45977\n",
+      "Profile:  32000  of  45977\n",
+      "Profile:  33000  of  45977\n",
+      "Profile:  34000  of  45977\n",
+      "Profile:  35000  of  45977\n",
+      "Profile:  36000  of  45977\n",
+      "Profile:  37000  of  45977\n",
+      "Profile:  38000  of  45977\n",
+      "Profile:  39000  of  45977\n",
+      "Profile:  40000  of  45977\n",
+      "Profile:  41000  of  45977\n",
+      "Profile:  42000  of  45977\n",
+      "Profile:  43000  of  45977\n",
+      "Profile:  44000  of  45977\n",
+      "Profile:  45000  of  45977\n",
+      "Writing file: WOD2018_CODA_2005_mrb.nc\n",
+      "Working on platform:  gld\n",
+      "Profile:  0  of  9161\n",
+      "Profile:  1000  of  9161\n",
+      "Profile:  2000  of  9161\n",
+      "Profile:  3000  of  9161\n",
+      "Profile:  4000  of  9161\n",
+      "Profile:  5000  of  9161\n",
+      "Profile:  6000  of  9161\n",
+      "Profile:  7000  of  9161\n",
+      "Profile:  8000  of  9161\n",
+      "Profile:  9000  of  9161\n",
+      "Writing file: WOD2018_CODA_2005_gld.nc\n",
+      "Working on year:  2006\n",
+      "Working on platform:  osd\n",
+      "Profile:  0  of  15066\n",
+      "Profile:  1000  of  15066\n",
+      "Profile:  2000  of  15066\n",
+      "Profile:  3000  of  15066\n",
+      "Profile:  4000  of  15066\n",
+      "Profile:  5000  of  15066\n",
+      "Profile:  6000  of  15066\n",
+      "Profile:  7000  of  15066\n",
+      "Profile:  8000  of  15066\n",
+      "Profile:  9000  of  15066\n",
+      "Profile:  10000  of  15066\n",
+      "Profile:  11000  of  15066\n",
+      "Profile:  12000  of  15066\n",
+      "Profile:  13000  of  15066\n",
+      "Profile:  14000  of  15066\n",
+      "Profile:  15000  of  15066\n",
+      "Writing file: WOD2018_CODA_2006_osd.nc\n",
+      "Working on platform:  ctd\n",
+      "Profile:  0  of  25074\n",
+      "Profile:  1000  of  25074\n",
+      "Profile:  2000  of  25074\n",
+      "Profile:  3000  of  25074\n",
+      "Profile:  4000  of  25074\n",
+      "Profile:  5000  of  25074\n",
+      "Profile:  6000  of  25074\n",
+      "Profile:  7000  of  25074\n",
+      "Profile:  8000  of  25074\n",
+      "Profile:  9000  of  25074\n",
+      "Profile:  10000  of  25074\n",
+      "Profile:  11000  of  25074\n",
+      "Profile:  12000  of  25074\n",
+      "Profile:  13000  of  25074\n",
+      "Profile:  14000  of  25074\n",
+      "Profile:  15000  of  25074\n",
+      "Profile:  16000  of  25074\n",
+      "Profile:  17000  of  25074\n",
+      "Profile:  18000  of  25074\n",
+      "Profile:  19000  of  25074\n",
+      "Profile:  20000  of  25074\n",
+      "Profile:  21000  of  25074\n",
+      "Profile:  22000  of  25074\n",
+      "Profile:  23000  of  25074\n",
+      "Profile:  24000  of  25074\n",
+      "Profile:  25000  of  25074\n",
+      "Writing file: WOD2018_CODA_2006_ctd.nc\n"
+     ]
+    }
+   ],
+   "source": [
+    "WOD_directory = '//oa-decadal-climate/work/observations/WOD2018/'\n",
+    "platforms_to_get = ['osd','ctd','xbt','pfl','mrb','gld']\n",
+    "WOD_file_name_stem = 'wod_'\n",
+    "\n",
+    "profile_vars_to_get = ['Oxygen','Temperature','Salinity','Chlorophyll','Silicate','Phosphate','Nitrate','pH','Alkalinity','tCO2','z']\n",
+    "point_vars_to_get   = ['lat','lon'] #,'time','wod_unique_cast']\n",
+    "ancillary_vars_to_get = ['origflagset','country','dataset','Access_no','Recorder',\n",
+    "                         'dbase_orig','Platform','Project','WOD_cruise_identifier',\n",
+    "                         'Institute','needs_z_fix','Ocean_Vehicle','Temperature_Instrument']\n",
+    "\n",
+    "output_path = '/oa-decadal-climate/work/observations/CARSv2_ancillary/CODA/CODAv1/'\n",
+    "\n",
+    "FILL_VALUE = -10000000000.0\n",
+    "\n",
+    "for i_year in range(START_YEAR,END_YEAR+1):\n",
+    "    print('Working on year: ', i_year)\n",
+    "    for i_platform in platforms_to_get:\n",
+    "        print('Working on platform: ', i_platform)\n",
+    "\n",
+    "        file_name  = WOD_file_name_stem + i_platform + '_' + str(i_year) + '.nc'\n",
+    "        WOD_ragged_object = wodnc.Ragged(os.path.join(WOD_directory,str(i_year),file_name))\n",
+    "        n_profiles = WOD_ragged_object.ncasts()\n",
+    "        \n",
+    "        max_depth_levels = 0for i_ancillary_var in ancillary_vars_to_get:\n",
+    "            if i_ancillary_var in vars_in_dataset:\n",
+    "                \n",
+    "                ancillary_data_container[i_ancillary_var]  = 0\n",
+    "                attributes_data_container[i_ancillary_var] = {}\n",
+    "        \n",
+    "        for i_profile in range(0,n_profiles):\n",
+    "            \n",
+    "            WOD_profile_object = wodnc.ncProfile(WOD_ragged_object,i_profile)\n",
+    "            n_depth_levels  = WOD_profile_object.n_levels()\n",
+    "            \n",
+    "            if n_depth_levels>max_depth_levels:\n",
+    "                max_depth_levels = n_depth_levels\n",
+    "        \n",
+    "         \n",
+    "        #END for i_profile\n",
+    "        vars_in_dataset = list(WOD_ragged_object.variables().keys())\n",
+    "        \n",
+    "        \n",
+    "        profile_data_container   = {}\n",
+    "        ancillary_data_container = {}\n",
+    "        attributes_data_container = {}\n",
+    "        for i_var in profile_vars_to_get:\n",
+    "            if i_var in vars_in_dataset:\n",
+    "\n",
+    "                profile_data_container[i_var]               = np.nan*np.zeros([n_profiles,max_depth_levels],dtype='float32')\n",
+    "                profile_data_container[i_var + '_WODflag']  = np.nan*np.zeros([n_profiles,max_depth_levels],dtype='int8')\n",
+    "                profile_data_container[i_var + '_origflag'] = np.nan*np.zeros([n_profiles,max_depth_levels],dtype='float32')\n",
+    "                \n",
+    "                attributes_data_container[i_var]            = {}\n",
+    "                attributes_data_container[i_var + '_WODflag']  = {}\n",
+    "                attributes_data_container[i_var + '_origflag'] = {}\n",
+    "            #END if i_var\n",
+    "        #END for i_var\n",
+    "\n",
+    "        point_data_container = {}\n",
+    "        for i_var in point_vars_to_get:\n",
+    "            point_data_container[i_var] = np.nan*np.zeros([n_profiles],dtype='float32')\n",
+    "            \n",
+    "            attributes_data_container[i_var] = {}\n",
+    "\n",
+    "        point_data_container['time']                 = np.zeros([n_profiles],dtype='datetime64[ns]')\n",
+    "        point_data_container['wod_unique_cast']      = np.zeros([n_profiles],dtype='int32')\n",
+    "        \n",
+    "        attributes_data_container['wod_unique_cast'] = {}\n",
+    "        attributes_data_container['time']            = {}\n",
+    "\n",
+    "        \n",
+    "        for i_ancillary_var in ancillary_vars_to_get:\n",
+    "            if i_ancillary_var in vars_in_dataset:\n",
+    "                \n",
+    "                ancillary_data_container[i_ancillary_var]  = 0\n",
+    "                attributes_data_container[i_ancillary_var] = {}\n",
+    "\n",
+    "        \n",
+    "        \n",
+    "        #Begin the loop through the profiles\n",
+    "        \n",
+    "        for i_profile in range(0,n_profiles):\n",
+    "            \n",
+    "            if (i_profile % 1000) ==0:\n",
+    "                print(\"Profile: \", i_profile, ' of ', n_profiles)\n",
+    "            \n",
+    "            WOD_profile_object   = wodnc.ncProfile(WOD_ragged_object,i_profile)                \n",
+    "            \n",
+    "            for i_var in profile_data_container:\n",
+    "                current_variable     = WOD_profile_object.level_unpack(i_var)\n",
+    "                 \n",
+    "                if current_variable.size != 0:\n",
+    "                    #Test for missing data on profile\n",
+    "                    profile_data_container[i_var][i_profile,0:current_variable.size] = current_variable\n",
+    "                    \n",
+    "                    \n",
+    "                #END if current_variable.size != 0:\n",
+    "            #END for i_var\n",
+    "            \n",
+    "            if i_profile ==0:\n",
+    "                for i_var in profile_data_container:\n",
+    "                    variable_attributes = WOD_profile_object.show_variable_attr(i_var)\n",
+    "                    for i_attribute in variable_attributes:\n",
+    "                        attributes_data_container[i_var][i_attribute] = WOD_profile_object.get_variable_attr(i_var,i_attribute)\n",
+    "                    #END for i_attribute\n",
+    "                #for i_var \n",
+    "            #if i_profile ==0 \n",
+    "            \n",
+    "            point_data_container['wod_unique_cast'][i_profile] = WOD_profile_object.metadata('wod_unique_cast')\n",
+    "            if i_profile==0:\n",
+    "                variable_attributes = WOD_profile_object.show_variable_attr('wod_unique_cast')\n",
+    "                for i_attribute in variable_attributes:\n",
+    "                    attributes_data_container['wod_unique_cast'][i_attribute] = WOD_profile_object.get_variable_attr('wod_unique_cast',i_attribute)\n",
+    "            \n",
+    "            \n",
+    "            \n",
+    "            point_data_container['time'][i_profile] = np.datetime64(WOD_profile_object.datetime())\n",
+    "            if i_profile==0:\n",
+    "                variable_attributes = WOD_profile_object.show_variable_attr('time')\n",
+    "                for i_attribute in variable_attributes:\n",
+    "                    attributes_data_container['time'][i_attribute] = WOD_profile_object.get_variable_attr('time',i_attribute)\n",
+    "            \n",
+    "            for i_var in point_vars_to_get:\n",
+    "                if i_var in vars_in_dataset:\n",
+    "                    point_data_container[i_var][i_profile] = WOD_profile_object.metadata(i_var)\n",
+    "                    \n",
+    "                    if i_profile==0:\n",
+    "                        variable_attributes = WOD_profile_object.show_variable_attr(i_var)\n",
+    "                        for i_attribute in variable_attributes:\n",
+    "                            \n",
+    "                            attributes_data_container[i_var][i_attribute] = WOD_profile_object.get_variable_attr(i_var,i_attribute)\n",
+    "                #END if i_var\n",
+    "            #END for i_var\n",
+    "            \n",
+    "            \n",
+    "            for i_ancillary_var in ancillary_data_container.keys():\n",
+    "                current_ancillary_var = WOD_profile_object.metadata(i_ancillary_var)\n",
+    "                #print(type(current_ancillary_var))\n",
+    "                \n",
+    "                \n",
+    "                if i_profile ==0:\n",
+    "                    var_type = type(current_ancillary_var)\n",
+    "                    if var_type is str:\n",
+    "                        \n",
+    "                        ancillary_data_container[i_ancillary_var] = np.zeros([n_profiles],dtype='S{}'.format(100))\n",
+    "                    else:\n",
+    "                        ancillary_data_container[i_ancillary_var] = np.zeros([n_profiles],dtype=var_type)\n",
+    "                    #END if var_type=='str'\n",
+    "                    \n",
+    "\n",
+    "                    ancillary_variable_attributes = WOD_profile_object.show_variable_attr(i_ancillary_var)\n",
+    "\n",
+    "                    for i_attribute in ancillary_variable_attributes:\n",
+    "                         attributes_data_container[i_ancillary_var][i_attribute] = WOD_profile_object.get_variable_attr(i_ancillary_var,i_attribute)\n",
+    "\n",
+    "                    #END for i_attribute\n",
+    "                #END if i_profile = 0\n",
+    "                \n",
+    "                ancillary_data_container[i_ancillary_var][i_profile] = current_ancillary_var\n",
+    "\n",
+    "            #END for i_ancillary_var\n",
+    "            \n",
+    "            if i_profile==0:\n",
+    "                crs_attribs = {}\n",
+    "                crs = WOD_profile_object.r.variables()['crs'][:]\n",
+    "\n",
+    "                for i_attr in WOD_profile_object.show_variable_attr('crs'):\n",
+    "                    crs_attribs[i_attr] = WOD_profile_object.get_variable_attr('crs',i_attr)\n",
+    "            \n",
+    "        #END for i_profile\n",
+    "        \n",
+    "        \n",
+    "        \n",
+    "        cast_index = np.arange(1,n_profiles+1)\n",
+    "        \n",
+    "        \n",
+    "        \n",
+    "        CODA_output_dataset = xarray.DataArray(point_data_container['wod_unique_cast'],dims=['cast'],coords={'cast':cast_index},attrs = attributes_data_container['wod_unique_cast'])\n",
+    "        CODA_output_dataset = CODA_output_dataset.to_dataset(name='WOD_id')                                  \n",
+    "        \n",
+    "        \n",
+    "        CODA_output_dataset['time'] = xarray.DataArray(point_data_container['time'],dims=['cast'],coords={'cast':cast_index} ) #,attrs = attributes_data_container['time'])\n",
+    "        CODA_output_dataset['time'].encoding['units'] = 'days since 1770-01-01T00:00:00+00:00'\n",
+    "        CODA_output_dataset['time'].encoding['calendar'] = 'proleptic_gregorian'\n",
+    "        CODA_output_dataset['time'].encoding['_FillValue'] = FILL_VALUE\n",
+    "\n",
+    "        \n",
+    "        \n",
+    "        #Add the point or cast information (lat and lon)\n",
+    "        for i_var in point_vars_to_get:\n",
+    "            CODA_output_dataset[i_var] = xarray.DataArray(point_data_container[i_var],dims=['cast'],coords={'cast':cast_index},attrs = attributes_data_container[i_var])\n",
+    "            CODA_output_dataset[i_var] = CODA_output_dataset[i_var].fillna(FILL_VALUE)\n",
+    "            CODA_output_dataset[i_var].attrs['_FillValue'] = FILL_VALUE\n",
+    "        #END for i_var\n",
+    "            \n",
+    "        #Add the ancillary data\n",
+    "        for i_ancillary_var in ancillary_data_container.keys():\n",
+    "            CODA_output_dataset[i_ancillary_var] = xarray.DataArray(ancillary_data_container[i_ancillary_var],dims=['cast'],coords={'cast':cast_index},\n",
+    "                                                                    attrs = attributes_data_container[i_ancillary_var])\n",
+    "            if '_FillValue' in CODA_output_dataset[i_ancillary_var].attrs:\n",
+    "                #print('found fill value')\n",
+    "                #print(CODA_output_dataset[i_ancillary_var])\n",
+    "                CODA_output_dataset[i_ancillary_var].attrs['_FillValue'] = FILL_VALUE\n",
+    "                CODA_output_dataset[i_ancillary_var] = CODA_output_dataset[i_ancillary_var].fillna(FILL_VALUE)\n",
+    "            #END if \n",
+    "        #END for i_ancillary_var\n",
+    "            \n",
+    "            \n",
+    "        #Add the profile data\n",
+    "        for i_var in profile_data_container.keys():\n",
+    "            CODA_output_dataset[i_var]  = xarray.DataArray(profile_data_container[i_var],dims=['cast','z_index'],\n",
+    "                                                            coords= {'cast':cast_index,'z_index':np.arange(0,max_depth_levels,1)}, attrs = attributes_data_container[i_var])\n",
+    "            \n",
+    "            CODA_output_dataset[i_var] = CODA_output_dataset[i_var].fillna(FILL_VALUE)\n",
+    "            CODA_output_dataset[i_var].attrs['_FillValue'] = FILL_VALUE\n",
+    "        #END for i_var\n",
+    "        \n",
+    "        CODA_output_dataset['crs']       = xarray.DataArray(crs,dims=[],attrs = crs_attribs)        \n",
+    "        \n",
+    "        source_data   = 'WOD'\n",
+    "        CODA_dates    = CODA_output_dataset['time'].dt.date.values\n",
+    "\n",
+    "        CODA_ID = Get_CODA_id(CODA_dates,source_data,i_platform,i_year)\n",
+    "        \n",
+    "        \n",
+    "        CODA_output_dataset['CODA_id'] = xarray.DataArray(CODA_ID,dims=['cast'],coords={'cast':cast_index},\n",
+    "                                                          attrs={'Comment':'Unique CODA identifier with format <Source Dataset><Obs Platform><Counter for date><YYYYMMDD>'})\n",
+    "        CODA_output_dataset.attrs = {'Parent ragged array file':file_name}\n",
+    "        \n",
+    "        output_file_name = 'WOD2018_CODA_' + str(i_year) + '_' + str(i_platform) + '.nc'\n",
+    "        print('Writing file:', output_file_name)\n",
+    "        if not os.path.isdir(os.path.join(output_path,str(i_year))):\n",
+    "            os.mkdir(os.path.join(output_path,str(i_year)))\n",
+    "    \n",
+    "        CODA_output_dataset.to_netcdf(os.path.join(output_path,str(i_year),output_file_name)) #,encoding=encoding) #,engine='netcdf4')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2091f5f0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def Get_CODA_id(dates,source_data,obs_platform,year):\n",
+    "    \n",
+    "    CODA_id_length = 20\n",
+    "    CODA_ID = np.array(['' for _ in range(dates.size)], dtype='S{}'.format(CODA_id_length))\n",
+    "    \n",
+    "    unique_dates = np.unique(CODA_dates)\n",
+    "\n",
+    "    \n",
+    "    for i_date in unique_dates:\n",
+    "    \n",
+    "        if not pandas.isnull(i_date):\n",
+    "            \n",
+    "            idx_for_date   =  np.nonzero(dates == i_date)[0]\n",
+    "            count_for_date =  idx_for_date.size\n",
+    "            i_profile = 1\n",
+    "            \n",
+    "            for i_index in idx_for_date:\n",
+    "                #print(i_index)\n",
+    "                CODA_id_current_profiles = source_data + obs_platform + i_date.strftime('%Y%m%d') + f'{i_profile:04}'\n",
+    "                CODA_ID[i_index] = CODA_id_current_profiles\n",
+    "                i_profile = i_profile+1\n",
+    "                \n",
+    "            #END for i_index\n",
+    "        #if not isnull\n",
+    "    #END for i_date\n",
+    "\n",
+    "    bad_dates_idx = np.nonzero(pandas.isnull(dates))[0]\n",
+    " \n",
+    "    bad_profile_counter = 1\n",
+    "    \n",
+    "    for i_bad_idx in bad_dates_idx:\n",
+    "        CODA_id_current_profiles = source_data + obs_platform + str(year) + 'XXXX' + f'{bad_profile_counter:04}'\n",
+    "        CODA_ID[i_bad_idx] = CODA_id_current_profiles\n",
+    "        bad_profile_counter = bad_profile_counter+1\n",
+    "\n",
+    "    return CODA_ID"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "53b2826b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7d65db87",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}