{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "35a714635ce02cf3",
   "metadata": {},
   "source": [
    "# Unit-aware computations with ``brainunit``\n",
    "\n",
    "[![Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/chaobrain/brainx/blob/main/docs/basics/brainunit_unit_aware_computations.ipynb)\n",
    "[![Open in Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/chaobrain/brainx/blob/main/docs/basics/brainunit_unit_aware_computations.ipynb)\n",
    "\n",
    "Welcome! This tutorial introduces ``brainunit``, the physical units and unit-aware mathematical system in the BrainX ecosystem."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intro-motivation",
   "metadata": {},
   "source": [
    "## Why Physical Units?\n",
    "\n",
    "**Brain models involve many physical quantities:**\n",
    "- Time (milliseconds, seconds)\n",
    "- Voltage (millivolts)\n",
    "- Current (nanoamperes, microamperes)\n",
    "- Conductance (nanosiemens, microsiemens)\n",
    "- Capacitance (picofarads)\n",
    "- Resistance (megaohms)\n",
    "\n",
    "**Problems without unit tracking:**\n",
    "- Mixing incompatible units (adding voltage and current)\n",
    "- Forgetting to convert units (using seconds instead of milliseconds)\n",
    "- Hard-to-debug errors from dimensionally incorrect equations\n",
    "\n",
    "**Benefits of ``brainunit``:**\n",
    "- Automatic dimension checking prevents errors\n",
    "- Clear, self-documenting code\n",
    "- Seamless unit conversions\n",
    "- JAX-compatible for GPU/TPU acceleration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "imports",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "import brainunit as u\n",
    "import jax.numpy as jnp\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "basic-units",
   "metadata": {},
   "source": [
    "## Creating Quantities with Units\n",
    "\n",
    "A **quantity** combines a numerical value with a physical unit.\n",
    "In ``brainunit``, multiply values by unit constants:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "create-quantities",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t1 = 10. ms\n",
      "t2 = 0.01 s\n",
      "t3 = 1.5 us\n"
     ]
    }
   ],
   "source": [
    "# Time quantities\n",
    "t1 = 10.0 * u.ms  # 10 milliseconds\n",
    "t2 = 0.01 * u.second  # 0.01 seconds\n",
    "t3 = 1.5 * u.us  # 1.5 microseconds\n",
    "\n",
    "print(\"t1 =\", t1)\n",
    "print(\"t2 =\", t2)\n",
    "print(\"t3 =\", t3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "1552ce60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Neuron voltages:\n",
      "V_rest = -70. mV\n",
      "V_thresh = -50. mV\n",
      "V_spike = 40. mV\n"
     ]
    }
   ],
   "source": [
    "# Voltage quantities\n",
    "V_rest = -70.0 * u.mV\n",
    "V_thresh = -50.0 * u.mV\n",
    "V_spike = 40.0 * u.mV\n",
    "\n",
    "print(\"\\nNeuron voltages:\")\n",
    "print(\"V_rest =\", V_rest)\n",
    "print(\"V_thresh =\", V_thresh)\n",
    "print(\"V_spike =\", V_spike)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "09ea913f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Circuit parameters:\n",
      "I_app = 200. pA\n",
      "g_leak = 10. nS\n",
      "C_m = 100. pF\n"
     ]
    }
   ],
   "source": [
    "# Current and conductance\n",
    "I_app = 200.0 * u.pA  # applied current in picoamperes\n",
    "g_leak = 10.0 * u.nS  # leak conductance in nanosiemens\n",
    "C_m = 100.0 * u.pF    # membrane capacitance in picofarads\n",
    "\n",
    "print(\"\\nCircuit parameters:\")\n",
    "print(\"I_app =\", I_app)\n",
    "print(\"g_leak =\", g_leak)\n",
    "print(\"C_m =\", C_m)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "common-units",
   "metadata": {},
   "source": [
    "### Common Units in Neuroscience\n",
    "\n",
    "**Time:** `u.second`, `u.ms` (millisecond), `u.us` (microsecond)\n",
    "\n",
    "**Voltage:** `u.volt`, `u.mV` (millivolt)\n",
    "\n",
    "**Current:** `u.amp`, `u.mA` (milliampere), `u.uA` (microampere), `u.nA` (nanoampere), `u.pA` (picoampere)\n",
    "\n",
    "**Conductance:** `u.siemens`, `u.mS` (millisiemens), `u.uS` (microsiemens), `u.nS` (nanosiemens)\n",
    "\n",
    "**Capacitance:** `u.farad`, `u.uF` (microfarad), `u.nF` (nanofarad), `u.pF` (picofarad)\n",
    "\n",
    "**Resistance:** `u.ohm`, `u.kohm` (kiloohm), `u.Mohm` (megaohm)\n",
    "\n",
    "**Frequency:** `u.Hz` (hertz), `u.kHz` (kilohertz)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unit-arithmetic",
   "metadata": {},
   "source": [
    "## Unit Arithmetic\n",
    "\n",
    "``brainunit`` automatically checks dimensional consistency and propagates units through calculations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "arithmetic-examples",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delta_V = 20. mV\n"
     ]
    }
   ],
   "source": [
    "# Addition and subtraction: units must match\n",
    "V1 = -70.0 * u.mV\n",
    "V2 = -50.0 * u.mV\n",
    "delta_V = V2 - V1\n",
    "print(\"delta_V =\", delta_V)  # 20.0 mV\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7618a698",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "V = I * R = 20000. uV\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Multiplication and division: units combine\n",
    "I = 100.0 * u.pA\n",
    "R = 200.0 * u.Mohm\n",
    "V = I * R\n",
    "print(\"\\nV = I * R =\", V)  # Voltage in appropriate units\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "48e64702",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "g = I / V = -1.4285715 nS\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Division produces new units\n",
    "g = I / V1  # conductance = current / voltage\n",
    "print(\"g = I / V =\", g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "7951be37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "tau_m = R_m * C_m = 10000. us\n"
     ]
    }
   ],
   "source": [
    "# Time constant: tau = R * C\n",
    "R_m = 100.0 * u.Mohm\n",
    "C_m = 100.0 * u.pF\n",
    "tau_m = R_m * C_m\n",
    "print(\"\\ntau_m = R_m * C_m =\", tau_m)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dimension-checking",
   "metadata": {},
   "source": [
    "### Automatic Dimension Checking\n",
    "\n",
    "``brainunit`` prevents dimensionally incorrect operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "dimension-errors",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Valid: V_total = -50. mV\n"
     ]
    }
   ],
   "source": [
    "# This will work: same dimensions\n",
    "V_total = (-70.0 * u.mV) + (20.0 * u.mV)\n",
    "print(\"Valid: V_total =\", V_total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "b53fa90c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Error caught: UnitMismatchError\n",
      "Message: Cannot calculate \n",
      "100. mV + 50. ms, because units do not match: mV != ms ...\n"
     ]
    }
   ],
   "source": [
    "# This will raise an error: incompatible dimensions\n",
    "try:\n",
    "    bad_sum = (100.0 * u.mV) + (50.0 * u.ms)  # voltage + time!\n",
    "except Exception as e:\n",
    "    print(\"\\nError caught:\", type(e).__name__)\n",
    "    print(\"Message:\", str(e)[:100], \"...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "eaca32a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Error caught: UnitMismatchError\n",
      "Message: Cannot calculate \n",
      "10. mV + 5. mA, because units do not match: mV != mA ...\n"
     ]
    }
   ],
   "source": [
    "# This will also raise an error: incompatible units\n",
    "try:\n",
    "    bad_sum2 = (10.0 * u.mV) + (5.0 * u.mA)  # voltage + current!\n",
    "except Exception as e:\n",
    "    print(\"\\nError caught:\", type(e).__name__)\n",
    "    print(\"Message:\", str(e)[:100], \"...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unit-conversions",
   "metadata": {},
   "source": [
    "## Unit Conversions\n",
    "\n",
    "Convert quantities between compatible units using ``.to()`` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "conversions",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time conversions:\n",
      "  100. ms = 0.1 s = 100000. us\n"
     ]
    }
   ],
   "source": [
    "# Time conversions\n",
    "t_ms = 100.0 * u.ms\n",
    "t_s = t_ms.to(u.second)\n",
    "t_us = t_ms.to(u.us)\n",
    "\n",
    "print(\"Time conversions:\")\n",
    "print(f\"  {t_ms} = {t_s} = {t_us}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "84f85b69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Voltage conversions:\n",
      "  -70. mV = -0.07 V\n"
     ]
    }
   ],
   "source": [
    "# Voltage conversions\n",
    "V_mv = -70.0 * u.mV\n",
    "V_v = V_mv.to(u.volt)\n",
    "\n",
    "print(\"\\nVoltage conversions:\")\n",
    "print(f\"  {V_mv} = {V_v}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "5065d516",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Current conversions:\n",
      "  200. pA = 0.2 nA = 0.0002 uA\n"
     ]
    }
   ],
   "source": [
    "# Current conversions\n",
    "I_pa = 200.0 * u.pA\n",
    "I_na = I_pa.to(u.nA)\n",
    "I_ua = I_pa.to(u.uA)\n",
    "\n",
    "print(\"\\nCurrent conversions:\")\n",
    "print(f\"  {I_pa} = {I_na} = {I_ua}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "48f2e46d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Automatic conversion:\n",
      "  10. ms + 0.01 s = 20. ms\n"
     ]
    }
   ],
   "source": [
    "# Automatic conversion in compatible operations\n",
    "t1 = 10.0 * u.ms\n",
    "t2 = 0.01 * u.second\n",
    "t_sum = t1 + t2  # automatically handles different units\n",
    "print(\"\\nAutomatic conversion:\")\n",
    "print(f\"  {t1} + {t2} = {t_sum}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "arrays-units",
   "metadata": {},
   "source": [
    "## Working with Arrays\n",
    "\n",
    "``brainunit`` seamlessly works with NumPy and JAX arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "array-examples",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Voltages array: [-70. -60. -50. -40. -30.] mV\n",
      "Shape: (5,)\n",
      "Unit: mV\n"
     ]
    }
   ],
   "source": [
    "# Create array quantities\n",
    "voltages = np.array([-70.0, -60.0, -50.0, -40.0, -30.0]) * u.mV\n",
    "print(\"Voltages array:\", voltages)\n",
    "print(\"Shape:\", voltages.shape)\n",
    "print(\"Unit:\", voltages.unit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "66228583",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Statistics:\n",
      "  Mean: -50. mV\n",
      "  Std: 14.142136 mV\n"
     ]
    }
   ],
   "source": [
    "# Array operations preserve units\n",
    "V_mean = u.math.mean(voltages)\n",
    "V_std = u.math.std(voltages)\n",
    "print(\"\\nStatistics:\")\n",
    "print(\"  Mean:\", V_mean)\n",
    "print(\"  Std:\", V_std)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "5ea2be57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Shifted voltages: [-60. -50. -40. -30. -20.] mV\n"
     ]
    }
   ],
   "source": [
    "# Element-wise operations\n",
    "V_shifted = voltages + 10.0 * u.mV\n",
    "print(\"\\nShifted voltages:\", V_shifted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "110c9ac7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Time array:\n",
      "  Length: 1000\n",
      "  First 5 points: [0.  0.1 0.2 0.30000001 0.40000001] ms\n",
      "  Last point: 99.9 ms\n"
     ]
    }
   ],
   "source": [
    "# Time arrays for simulation\n",
    "dt = 0.1 * u.ms\n",
    "t_end = 100.0 * u.ms\n",
    "n_steps = int(t_end / dt)\n",
    "time = np.arange(n_steps) * dt\n",
    "print(\"\\nTime array:\")\n",
    "print(\"  Length:\", len(time))\n",
    "print(\"  First 5 points:\", time[:5])\n",
    "print(\"  Last point:\", time[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mathematical-functions",
   "metadata": {},
   "source": [
    "## Mathematical Functions\n",
    "\n",
    "Use ``u.math`` when a mathematical operation should understand physical units. The most important rule is dimensional consistency:\n",
    "\n",
    "- Functions such as ``exp()``, ``sin()``, and ``cos()`` require a dimensionless input, because their arguments represent pure numbers or phases.\n",
    "- Ratios such as ``t / tau`` or ``frequency * time`` are dimensionless and are safe to pass into these functions.\n",
    "- The result of these functions is dimensionless, so you can multiply it by a physical quantity afterward.\n",
    "- Convert quantities to plain numbers only at boundaries such as plotting or formatted reporting.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "dimensionless-decay",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exponential decay:\n",
      "  tau = 10. ms\n",
      "  t/tau at the first point = 0.00\n",
      "  t/tau at the last point = 5.00\n",
      "  exp(-t/tau) at the last point = 0.0067\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Build a dimensionless argument before calling exp().\n",
    "tau = 10.0 * u.ms\n",
    "time = np.linspace(0.0, 50.0, 200) * u.ms\n",
    "normalized_time = time / tau\n",
    "\n",
    "decay = u.math.exp(-normalized_time)\n",
    "\n",
    "print(\"Exponential decay:\")\n",
    "print(f\"  tau = {tau}\")\n",
    "print(f\"  t/tau at the first point = {normalized_time[0]:.2f}\")\n",
    "print(f\"  t/tau at the last point = {normalized_time[-1]:.2f}\")\n",
    "print(f\"  exp(-t/tau) at the last point = {decay[-1]:.4f}\")\n",
    "\n",
    "plt.figure(figsize=(7, 3))\n",
    "plt.plot(time.to(u.ms).magnitude, decay, linewidth=2)\n",
    "plt.xlabel('Time (ms)')\n",
    "plt.ylabel('exp(-t / tau)')\n",
    "plt.title('A dimensionless exponential decay')\n",
    "plt.grid(True, alpha=0.3)\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mathematical-functions-with-units",
   "metadata": {},
   "source": [
    "The dimensionless result can then scale a unitful quantity. This is common in neural models, where exponential factors describe how voltage, current, or conductance relaxes over time.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "decay-scales-voltage",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Voltage relaxation:\n",
      "  Initial voltage = -50. mV\n",
      "  Final voltage = -69.86524 mV\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAArIAAAEiCAYAAAAF9zFeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAV/1JREFUeJzt3Qd4U1UbB/B/96alhdKyR9l7740MAUUZDvYSlE8QcaGyBUQEFURxMdwMNyJLkCEgS3Zl71VWF91Nvuc97Q1JFy00TW77/z3PJcnNzc3pPUl4c/Le9zgYjUYjiIiIiIh0xtHWDSAiIiIiuh8MZImIiIhIlxjIEhEREZEuMZAlIiIiIl1iIEtEREREusRAloiIiIh0iYEsEREREekSA1kiIiIi0iUGskRERESkSwxkiYgy0KZNG7XcDwcHB0yePBl56ezZs+p5lyxZgoJIL39/2bJlMWjQIFs3gyjfYCBLlI/Jf+ryn3tmy86dO1GQHT16VAWcEgTlR6tXr87zgJqA7du3q+MeHh5u66YQ5XvOtm4AEVnf1KlTUa5cuXTrQ0JCUNAD2SlTpqiRVxkpM7du3Trkh0B2wYIFDGZtEMjK60pGXv38/CzuO3bsGBwdOYZElFsYyBIVAF26dEGDBg1s3QxdcXV1tXUTCjSDwYCEhAS4u7sjP3Fzc7N1E4jyFX4tJCJMmjRJjRL9+eefFuufeeYZFdAdOHBA3f7rr79USsKyZcvw+uuvIygoCF5eXnjkkUdw4cKFdPtdsWIF6tevDw8PDxQpUgT9+vXDpUuXLLaRUStvb2+1vkePHup60aJF8dJLLyE5OTldcPP++++jevXqKsApVqwYRowYgdu3b1tsJ6Or3bp1w7Zt29CoUSO1bfny5fHll19apF307t1bXW/btq0p3UL+xoxyZCWomjhxovp7fH191d/dsmVLbNq0KcfH+9q1a3B2dlajdmnJiJ2048MPPzStO336tGqrv78/PD090aRJE/z+++9ZPoccVxmNFebpJJp3330XzZo1Q0BAgOof+btWrlyZbj+xsbEYPXq06j8fHx/V19JXGeUBy/ohQ4aofpGATfpp0aJF2Tomsr///e9/+Oabb9Tj5PFr1qx5oP0ePHhQHQfpe3kNyOtV9nPz5k2Lv69KlSpqkeuaW7duITg4WB0j7XWYnf3JMXn55ZfVdfkVRDvuWvpKRjmy2elf7b23fPlyTJ8+HSVLllRtaN++PU6ePJmtY0yUH3FElqgAiIiIwI0bNyzWyX+KEsSIN998E7/99huGDh2KQ4cOqYBl7dq1+OyzzzBt2jTUrl3b4rHyH6k8/tVXX0VYWJgKLjt06ID9+/eroEgLFAcPHoyGDRti5syZKnj74IMP8Pfff+Pff/+1+MlVAoVOnTqhcePGKsDasGED5syZgwoVKuDZZ581bSdBq7ZfCa7OnDmjAj7Zn+zXxcXFtK38596rVy/1Nw0cOFAFPhJASMAmgVCrVq3UPubNm6eC8qpVq6rHaZdpRUZG4vPPP8dTTz2F4cOHIyoqCl988YVq965du1CnTp1s94cEZK1bt1ZBiXyJMCdfEpycnExBthw3CaZiYmJUe6XPli5dqgJKCTwfe+yxDJ9DjtXly5exfv16fPXVV+nul76QffTt21cF6d9//716zlWrVqFr166m7eSYSTv79++vAqzNmzdb3K+Rdsr9WkAqX0b++OMPdfzl2L3wwgv3PC4bN25UzyWPl8BZgr4H2a/87RIkyutFgs4jR47g008/VZeSHy77lNerHM/mzZvjjTfewNy5c9VjR40apd438nqT/sju/h5//HEcP34c3333Hd577z31dwhpd0Zy2r9vv/22+tIpX/Skfe+8847qw3/++eeex5coXzISUb61ePFio7zNM1rc3Nwstj106JDR1dXVOGzYMOPt27eNJUqUMDZo0MCYmJho2mbTpk3qsXJfZGSkaf3y5cvV+g8++EDdTkhIMAYGBhpr1KhhjI2NNW23atUqtd3EiRNN6wYOHKjWTZ061aI9devWNdavX990e+vWrWq7b775xmK7NWvWpFtfpkwZtW7Lli2mdWFhYepvHjdunGndihUr1Hbyd6XVunVrtWiSkpKM8fHxFtvIcSpWrJhxyJAhFutln5MmTTJm5ZNPPlHbyXE3V61aNWO7du1Mt1944QW1nfz9mqioKGO5cuWMZcuWNSYnJ6t1Z86cUdtJn2tGjRql1mUkJibG4rb0mfSX+XPv3btXPV7aYG7QoEHp/sahQ4cag4ODjTdu3LDY9sknnzT6+vqme760ZH+Ojo7GI0eOWKzP7n4z+vszes7vvvsu3WtDjB8/Xj2/rNdeF++//77FNtnd3+zZs9U6aVNa8tqU13xO+1d771WtWtXidSjvuYxeR0QFBVMLiAoA+YlZRpPMFxnVMlejRg31U7eMOsooo4zgysiQ/ASe1oABA9SorUZGPuVnWDm5SOzZs0eN1D733HMWOY4ykic/4Wb0s/jIkSMtbsvP9jL6ZZ6mID/pP/TQQ6pt2iIjrJKOkPYn/mrVqql9aGRErHLlyhb7zAkZldPyZiXFQX56TkpKUrnH+/bty/H+ZOROjq2MwGoOHz6sTkB74oknTOvkmEp6RIsWLUzr5O+VtA/5uVq2vx/ayLmQ1AwZ3ZPjZf63aD/tSz+ae/755y1uSxz6ww8/oHv37uq6ef/Ia0n2nZ1jJKPU0m+5tV/zvzEuLk49TkZ3RdrHSUqAjNTL6L38vdIWGSG93/1lV077V0aDzfO3tdf4/b6uifSOqQVEBYD8R5mdk70kt09+YpafymfMmGERVJirWLGixW35SVUqIGh5gOfOnVOXEjimJYGs5K6ak2A37U+vhQsXtsh9PXHihApcAgMDM2yTBM7mSpcunW6btPvMKQnsJeXhv//+Q2Jioml9RhUh7kV+cpb8RvkpXdI3hAS1EtxKkKuRYykpF2lpKRByv3wJySlJIXjrrbdUOkh8fLxpvXkerexbfsZO+/elrXZx/fp1VWpKfmaXJTv9k5G0z/Og+5UvG/LlTF7TabeT15I5CQ4l/URSYeT1uHjxYotjkdP9ZVdO+zft61pe0+JBXtdEesZAlohMZFRHAkYhubJ5RctBzIqMgkoQKycDZSRtIJzZPlN+xc65r7/+WuWLyglpEvBLW+Q5JP/31KlT97XPJ598Uo2wSTApObYS1Epwq+VVWsvWrVtVDqbkCX/00UdqNF3yiyV4+/bbb3O8P+kbISfzyYhmRmrVqnXP/ZiPeObGfvv06aNKYUl/yfGVkU7ZZ+fOnU37Nid54dpoq7wP0gbWOd2fNeT265pI7xjIEpEi/xFLoFaoUCF1Ao2MyErKgPnooEYLds3/E5WTq7SgokyZMqYz8Nu1a2exrazT7s8JOfFLTgKTk3LSBjz3K+2IW1bkxBs5W/3HH3+0eFzak7VyQoJiOSlLSy+Qk4TGjx9vsY0cKzlmacmosHZ/Tv8++bleRh0lcDMvByWBbNrnlteFnFRnPgqf9ix5+RIhqSZy0p6c9JdbHmS/MkIpVThkBFWqTWT22tVIRQKpt6x9sRg2bJj6MifpLDndX05eVw/Sv0TE8ltElErO1pbRJvkJV37qljOppWJA2moHQspYyVn75kHelStXVL1aIWkMMmK5cOFCi5+tJS83NDQ0w7Pe70VGwySg0X6GNye5qvczi5KU0BLZeaw2EmY+8iVniu/YsQP3Syo3SK6njMTKz9Xy87YEt+Yefvhhleph/jx37txR/SRn9WeW/pHV3yd/iwRb5uXNJC3k559/tthO2iZk1Nbc/Pnz0+2vZ8+eKkCWPN+0JEXgfjzIfjPqLyEVNtKSNBH5Ele8eHFVzUEqFUg1gbFjx97X/nLyunqQ/iUijsgSFQgSQGojPOYkWJVRRgkuJ0yYoP4zlxNrhPxnLj+fyokvEmiZk3qXcnKKjF7Jf/jyn7nkTUpZKiE/U8+aNUvdLyfNSMkqrfyW/OdsHiBkl+xHRi/lp3wZMevYsaN6HhkRkxPBZN8ygpwT8vdJgCJtlRxHGZ2UEeSM8nClLq2Mxko5JAnEZZRSAnUJNKKjo3G/5MQu+elcgkUJHNPOBPXaa6+pUk7yJUFOPpJjL7m68vwS4GU1S5ScCCfkcbJv+VslnUHaL19c5Cfxp59+WuV7ygmB0ocyMmn+eAkkpX+lVqpWfktGjtOOPEpZKDnhTvI95XUgx0VySuUkKBlJl+v34373K78sSOqElKeSQLVEiRJqtjY5bmlpucIy4iojwPLLgoy6Slk6eU1JsJmT/WnHXcp5yfGW16m8r7QAN7f6l4hYfouowJbf0koVSVmphg0bGkuWLGkMDw+3eLxW2mfZsmUWJYCk5JCUK5ISWx4eHsauXbsaz507l+755XFSRkvKXvn7+xv79u1rvHjxosU2UorIy8sr3WOltFNGH1GffvqpKsslz+vj42OsWbOm8ZVXXjFevnzZosSRtOleJbXEZ599ZixfvrzRycnJohRX2m0NBoNxxowZat/y98jfJeXEpP2yLqfltzRSxkz+FnnM119/neE2p06dMvbq1cvo5+dndHd3NzZq1Eg9t7mMyk9J3z7//PPGokWLGh0cHCyO5xdffGGsWLGi+luqVKmiHpfRMb9z544q4yX95+3tbezRo4fx2LFjaru3337bYttr166pbUuVKmV0cXExBgUFGdu3b6/67F5kf/LYjGRnvxn9/fJae+yxx9Rxk1JdvXv3Vq8T8/6REmPOzs7qOJnT3hfFixdXZdayuz/NtGnTVJk6KellXoorbfmt7Pav9t6T0mDmMvq7iQoSB/nH1sE0EemDzC4ks2DJCGhORz8p/5DRy7p166oT4KQYPxGRrfA3CyIiypT5tK0aSTWQn7zlp3YiIltijiwREWVKckL37t2rRuKlxq3kW8siBftLlSpl6+YRUQHHQJaIiDIlJwTKTHBSLUJOapOC/DILlpzIRERka8yRJSIiIiJdYo4sEREREekSA1kiIiIi0iXmyKYh0zFevnxZFcXOyTSDRERERPTgJOtVZo+U2fbuNSkIA9k0JIjlmbhEREREtnXhwgWULFkyy20YyKYhI7HawZMpCa09+itzhRctWpTTEOoM+07f2H/6xb7TL/adfhnyuO8iIyPVoKIWk2WFgWwaWjqBBLF5EcjGxcWp5+GbWl/Yd/rG/tMv9p1+se/0y2CjvstOiidfSURERESkSwxkiYiIiEiXdBPIli1bVg0xmy9vv/22xTYHDx5Ey5Yt4e7urnIrZGpFIiIiIsqfdJUjO3XqVAwfPtx02zwJWBKDO3bsiA4dOmDhwoU4dOgQhgwZAj8/PzUnOBEREdG9JCcnIzEx0dbNsLsc2cTERJUnmxs5si4uLnBycip4gawErkFBQRne98033yAhIQGLFi2Cq6srqlevjv3792Pu3Ll2HcjevJOIQFs3goiIqICT2qVXr15FeHi4rZtil8fGYDCo2q65VWNfBholpnvQ/ekqkJVUgmnTpqF06dJ4+umnMXbsWDg7p/wJO3bsQKtWrVQQq+nUqRNmzZqF27dvo3DhwrAncYnJWLDpJD7ZfAqfD3RDq0oMZ4mIiGxFC2IDAwPh6enJSZHSBLJJSUkq5nrQ4yL7iomJQVhYmLodHBxcMALZ0aNHo169evD398f27dsxfvx4XLlyRY24ai/AcuXKWTymWLFipvsyC2Tj4+PVYp6iIOSbhyzWsvrQZczfeFJdn/TrEaweXRhuzrkzzE7WJ68N7Rsq6Q/7T7/Yd/plz30n6QQy6CVBrMQZlJ6kFkhKQG6Qc5nktSDBbJEiRdKlGeTkNWLTQPa1115TI6ZZCQ0NRZUqVfDiiy+a1tWqVUuNvI4YMQIzZ86Em5vbfbdBHj9lypR066Xwr+SCWEuTYGfUDPbCoSt3cOZGDN5fcxiDGz3YtxLKO/Imi4iIUG9E1kPUH/affrHv9Mue+06CNGmfxBYy8kiWpM8k2Be5NVItx1qOuQw2pg2QJYVBF4HsuHHjMGjQoCy3KV++fIbrGzdurF5sZ8+eReXKlVWexbVr1yy20W5nllcrZGTXPEjWZpOQ2SusPSHCzJ7ueHTBdiQbgSW7ruLpZhVRyt/Tqs9JuUPefPJm5gw1+sT+0y/2nX7Zc9/JwJUETxJQaSmLlF5ujchq+5LXQUBAgBqhNZf2dlZs2lvyYpblfsiJXHIA5GcA0bRpU7zxxhsWQ9/r169XQW5W+bEympvRiK7s29pvtGrFfdG7TiC+/zcM8UkGTFkVii8GNmBejk5IP+XF64Ssg/2nX+w7/bLXvpP2mJf3pPQjstpxya3jox3rjF4POXl92NcrKRNyItf777+PAwcO4PTp06pCgZzo1a9fP1OQKid/yTD10KFDceTIESxbtgwffPCBxWirPRrepDiKFUoJpDf+F4b1Ry1HlYmIiIhIx4GsjJh+//33aN26tSqrNX36dBXIfvrpp6ZtfH19sW7dOpw5cwb169dXaQsTJ06069JbwsvNCW8+XNV0e8pvRxGTwPwcIiIiylz37t3RuXPnDO/bunWrGu2UiaLykqR7yvPKr+Z5RReJIFKtYOfOnffcTk4Ck87Tm4drBmH53iLYeuIGLoXHqmoGr3auYutmERERkZ2SX6B79uyJixcvomTJkhb3LV68GA0aNFBxUU5P6NJbjrAuRmTzO/n2MuWR6nB1SumOz7acxolr2T9jj4iIiAqWbt26qfOMlixZYrE+OjoaK1asUIFuVv766y8Vf/zxxx/ql2z59Xvbtm3qpDyp6CQlTT08PFC7dm2sXLnS9DgpU9a3b1/13HJ/xYoVVeAstDKodevWVftu06YNrI2BrJ0oX9QbI1unVGhIMhgx4ZfD6tsRERER2YbMGJrZkrZMV1bbpp3yNrPtckJGTgcMGKACWfN4QYJYGVl96qmnsl0KVSacknKnMoIrQeyXX36JhQsXqnOOJJWzf//+2LJli9p+woQJOHr0qAqA5TEff/yxqgUrdu3apS43bNigav3/+OOPsDZ9jR/nc8+1DcFP+y/hwq1Y7Dx9Cyv3XkTvBqVs3SwiIqICacaMGZneJyORMjKpmT17drqAVVO2bFmLcqNyArvMbpXW5MmTc9S+IUOGqOfdvHmzafRTRkcl5UDOHcqOqVOn4qGHHlLXZYIo+ZslEJVqUFoZVEnb/Oyzz9CuXTucP39ejbhK6oL2t2m0SlRSUiur0qe5iSOydsTdxQlTH61huv3W76G4HnV31jEiIiIiTZUqVdCsWTMsWrRI3T558qQKOu+VVmBOC0i1x0uALYGtt7e3afnqq69U1Sjx7LPPqhPw69Spg1deeUXNtmpLHJG1M20rB+KR2sXx64HLiIhNxNRVRzH/qbq2bhYREVGB8/rrr2d6X9papy+//HKm26atvfrCCy8gtwwdOhTPP/88FixYoEZjK1SooKo8ZZeXl5dFfq34/fffUaJECdN6SV3QppHt0qULzp07h9WrV6t6/e3bt8eoUaPw7rvvwhY4ImuHJnavBj/PlEkdfjtwGX+GsrYsERFRXpP69Jktac/uz2rbtDNiZbbd/ejTp48Kqr/99luV2yrpBvc7aUG1atXUSV+SPhASEmKxyKyn5ikEAwcOxNdff63SJLRyqNrfoE1nmxc4ImuHini7YULXahi34oC6/ebPh9G4fAC83dhdREREdJe3tzeeeOIJjB8/HpGRkRa5uDnl4+ODl156SZ3gJdULWrRogYiICFXNQEZuJUiWGv1S5UDq+ktO7apVq1C1ako9fJltVSoZrFmzRpUEk6lms5ure784ImunHq9XAi0rppwFeCUiDrPX/GfrJhEREZEdGjp0qCqL1alTJxQvXvyB9jVt2jRVmUCqF0iAKpMuSBqBVlpLRl0laJYKB61atVIpB5IzK2SUet68efjkk09UOx599FFYm4ORNZ4syLcZ+fYg30AKFSpk1eeSbzthYWHqG0xG8wpfuBWDju9tQWxiMuRXgpUjm6J+GX+rtolyp+/IvrH/9It9p1/23HdxcXFqZlAJ1mQUkSxJqCjlxiRQvd+0hZwc85zEYvb1SiILpfw9Ma5jJXVdvm68+sMhxCflXd4JERERkT1jIGvnBjUri1olU/JLToZF46NNp2zdJCIiIrJzI0eOtCihZb7IffkFzx6yc85Ojnj78Vp45MNtasavBZtOomP1Yqhe3LrJ00RERKRfU6dOVSduZcTaqZN5iYGsDlQrXgjPtqmA+RtPqmB23PID+PV/LeDqzAF1IiIiSk9ykWXJ7xgJ6cTz7SqiSpCPuv7f1SjM33jC1k0iIiIisikGsjoho69z+tSGs2PK2YIf/XUKBy+G27pZRERE+QYLOenvWDOQ1RHJi5WRWZGcmmIQl8gqBkRERA9Cm3krJibG1k0pMGJSj3XaWc9yijmyOvNc2wpYH3oVhy9F4kRYNN7fcAKvdali62YRERHplhT19/PzU3VuhaenZ67VS80PjLlYR1b2JUGsHGs55nLsHwQDWZ1xcXLEnN510G3+ViQmG/HpllOqikG90oVt3TQiIiLdCgoKUpdaMEuWwadMaCETWeRWgC9BrHbMHwQDWR2qHOSDFzpUwuy1x2AwAi8tP4DVY1rC3eXBvtUQEREVVBKgBQcHqzP9ExMTbd0cu2IwGHDz5k0EBATkyqxskk7woCOxGgayOjWiVXmsO3oNBy6E4/SNO5i5OhRTHq1h62YRERHpmgRYuRVk5adA1sXFRU0la2/TC9tXayhHEyXM6V0Lbqm1ZJfuOIdNx/hzCBERERUcDGR1LCTQB290rWq6/fKKg7gRHW/TNhERERHlFQayOte/SRm0rVxUXZcg9rUfDrIOHhERERUIDGR1TpLT3+lVGwFerur2htAwfPPPeVs3i4iIiMjqGMjmA0V93PBOr1qm22/9fhQnw6Jt2iYiIiIia2Mgm0+0r1oM/ZqUVtfjEg14Ydm/SEgy2LpZRERERFbDQDYfeePhaqhQ1Etdl5m/5q4/busmEREREVkNA9l8xMPVCR88WRcuTimzbnyy5RS2nrhu62YRERERWQUD2XymRglfvNypsrouxQvGLtuPsMg4WzeLiIiIKNcxkM2HhrUojzamklwJGPP9fiTLXLZERERE+QgD2XzI0dEBc/vUQbFCbur2jtM3MX/jCVs3i4iIiChXMZDNp/y9XDHvybpwTEmXxQd/nsD2Uzds3SwiIiKiXMNANh9rXD4ALz5UyZQvKykGnMKWiIiI8gsGsvncc21C0LJiEXX9elS8OvnLwHxZIiIiygcYyBaQfFmZ/UtsPXEDCzadtHWziIiIiB4YA9kCQILYD56oA4fUfNm5G45j83HWlyUiIiJ9000gW7ZsWTg4OFgsb7/9tun+s2fPprtflp07d9q03faiWUgRvNjBPF/2X1y4FWPrZhERERHdN2foyNSpUzF8+HDTbR8fn3TbbNiwAdWrVzfdDggIyLP22btRbUNw4GI4NoSGITwmEc9+sxcrRzaDu4uTrZtGRERElH9HZLXANSgoyLR4eXml20YCV/NtXFxcbNJWe82XndOnDsoGeKrbhy9FYsLPh2GUIVoiIiIindHViKykEkybNg2lS5fG008/jbFjx8LZ2fJPeOSRRxAXF4dKlSrhlVdeUbezEh8frxZNZGSkujQYDGqxJtm/BJHWfh5zPm5O+KhvPfT8eAdiE5OxYu9F1Cnli6calc6zNuQHtug7yj3sP/1i3+kX+06/DHncdzl5Ht0EsqNHj0a9evXg7++P7du3Y/z48bhy5Qrmzp2r7vf29sacOXPQvHlzODo64ocffkCPHj3w888/ZxnMzpw5E1OmTEm3/vr16yogtnZHRUREqBeHtDmv+DsC49uXxsQ1Z9Ttyb8dRZB7MqoHpR/hJvvqO8od7D/9Yt/pF/tOvwx53HdRUVHZ3tbBaMPflV977TXMmjUry21CQ0NRpUqVdOsXLVqEESNGIDo6Gm5uKaWl0howYADOnDmDrVu35mhEtlSpUrh9+zYKFSoEa78wJGAuWrSoTd7UU1cdxZLt59T1YF93/PxcM1OZLrLvvqMHw/7TL/adfrHv9MuQx30nsVjhwoVV8HyvWMymI7Ljxo3DoEGDstymfPnyGa5v3LgxkpKSVLWCypUrZ7rN+vXrs9y/BMEZBcLSUXnRWVJZIa+eK603ulbDkcuR2H32Nq5ExOG5b//Ft8Mbw82ZJ3/Ze9/Rg2P/6Rf7Tr/Yd/rlkId9l5PnuK9A9vz58zh37hxiYmJUdC5VAjIbFc2KPFaW+7F//371hwYGBma5TXBw8H3tvyBwcXLEgr718Mj8v3E1Mg57z93Gmz8dxju9aqkXLBEREZE9y3YgKyOfH3/8Mb7//ntcvHjR4kx3V1dXtGzZEs888wx69uyZ69H6jh078M8//6Bt27aqcoHclhO9+vXrp4aexdKlS1U76tatq27/+OOPKv3g888/z9W25DeBPu74bEAD9P5kO+ISDerkr8pBPhjWMuORcCIiIiJ74ZjdE61q166t8k3feustHD16VOUtJCQk4OrVq1i9ejVatGiBiRMnolatWti9e3euNlJGeyWAbt26tRr9nT59ugpkP/30U4vtpKJB/fr1VUrBL7/8gmXLlmHw4MG52pb8qGZJX8zuVdt0e8bqUM78RURERHYvWyd7SYWAl156KVuTC6xZs0alHDz++OPQI0kw9vX1zVaCcW4kT4eFhan0CHvIF3p37TF8uOmkuu7j7oyfRzVHhaLetm6WXbK3vqOcYf/pF/tOv9h3+mXI477LSSyWrdZIiarszpDVuXNn3QaxBd2LD1VCx2rF1PWouCQMW7oHETGJtm4WERERUYayHVY3aNAACxcuNE0YQPlz5q/3nqiDKkEpU/+euXEHz327F4nJLF5NREREOg5kJUdWZsqSKgD9+/fHX3/9Zd2WkU14uTmrk7/8vVzV7b9P3sQbPx3iNLZERESk30D2iy++UCd2LViwABcuXED79u0REhKCGTNm4NKlS9ZtJeWpUv6e+LR/fbg6p7w8lu+5iAWpubNERERE9iJHGbuenp5qAgMZjT1+/DiefPJJfPLJJyhbtiy6du2qSl5R/tCgrD/m9L5byeDddcfxy35+YSEiIiL7cd+nnlWoUEGV4pL6st999x127tyJ3r17527ryKa61y6OVzvfnR745RUH8c/pmzZtExEREZHmgWooyMisjNDKkpycjOHDhz/I7sgOjWxdHk81KqWuJyQb8MxXe3HqerStm0VERESU80BWZvWSkVjJj23Xrp0akf3oo49w5coVVdWA8heZqnbqozXQqlLKVMIRsYkYtHgXrkfF27ppREREVMBlO5Bdvny5qhFbrlw5NVVtnz59VJ7s5s2bMWDAAHh4eFi3pWQzLk6OWPB0XVNZrgu3YjF4yS5ExbHGLBEREekgkO3Xr58KVn/66SdVtUCqFcioLBUMPu4uWDy4IYJ93dXtw5ciMeKrvYhPSrZ104iIiKiAcsxJSoEEsd26dePUcgVUsK8HvhzSCH6eLur29lM38eKyA0g2sMYsERER5T3n7G4o8+tqLl++jG3btql5d2X+XXOjR4/O3RaSXalYzAdfDGyIvp/vRFyiAb8fuqImT5j6aHWVT0tERERkd4GsZsmSJRgxYgRcXV0REBBgEbzIdQay+V/9MoXxcd/6GPblHjUa+9XOcyji7YYxHSraumlERERUgOQ4R2DChAmYOHEiIiIiVMWCM2fOmJbTp09bp5Vkd9pWCcTsXrVMt9/bcBxf7zxn0zYRERFRwZLjQDYmJkbN6MU8WXq8Xkm82bWq6faEXw7jp38v2rRNREREVHDkOBodOnQoVqxYYZ3WkO4Ma1keI1tXUNeNRmDc8gP449AVWzeLiIiICoAc58jOnDlTVS5Ys2YNatasCReXlDPYNXPnzs3N9pEOvNq5MmISkvDljnOQAgajv/8Xn7g4ol2VYrZuGhEREeVj9xXIrl27FpUrV1a3057sRQWP9Pvk7tURk5CMlXsvIjHZiJFf78PiQQ3RPKSIrZtHRERE+VSOA9k5c+Zg0aJFGDRokHVaRLrk6OiAWT1rIS4xGasOXkFCkgHDlu7BV0MboUFZf1s3j4iIiPKhHOfIurm5oXnz5tZpDemak6MD3nuiDh6qlpJSEJuYjMGLd+PAhXBbN42IiIjyoRwHsmPGjMH8+fOt0xrSPRcnR3z4dF20rJiSUhAVn4R+X/yD/QxmiYiIyNapBbt27cLGjRuxatUqVK9ePd3JXj/++GNuto90yM3ZCZ/2b4BBi3fhnzO3EBWXhP6f/4MvhzZC3dKFbd08IiIiKqgjsn5+fnj88cfRunVrFClSBL6+vhYLkfBwdcLiwQ3RpLy/aWS2/xe7sPfcbVs3jYiIiArqiOzixYut0xLKdzxdnbF4UCMMXbob20/dRHR8EgYu2oWlQxqifhmeAEZEREQPhtNzkdVHZr8YKGW4AtRtCWYHfLELe87esnXTiIiIqCAEsp07d8bOnTvvuV1UVBRmzZqFBQsW5EbbKJ8Fs9oJYHcSkjFg0S5sP3nD1k0jIiKi/J5a0Lt3b/Ts2VPlwHbv3h0NGjRA8eLF4e7ujtu3b+Po0aPYtm0bVq9eja5du2L27NnWbznpiruLEz4b0ADDv9yDrSduqMkTBi3ZjY+erocOqeW6iIiIiHI9kB06dCj69euHFStWYNmyZfj0008RERFhmtWpWrVq6NSpE3bv3o2qVavmqAFU8ILZ/327DxtCw9SkCSO/3ou5T9TBI7WL27p5RERElF9P9pKJECSYlUVIIBsbG4uAgIB0JbiIsgpmP+5XH+OWH8CvBy4jyWDEmO//RXRcEp5uXNrWzSMiIqKCcLKXpBkEBQUxiKX7mjRBZgB7qlEpddtoBF7/6RA+23La1k0jIiIiHWHVArLZdLYzHquJ4S3LmdZNXx2Kd9ceg1EiWyIiIqJ7YCBLNiP51a8/XBUvPlTJtO7DTSfx6g8HkZRssGnbiIiIyP4xkCWbB7Oj21fEpO7V4OCQsm75nosY8dVexCYk27p5REREZMcYyJJdGNy8HOY9WReuTikvyT//C8PTn+/ErTsJtm4aERER5adANjw8HJ9//jnGjx+PW7dSZmjat28fLl26lNvtowKke+3iWDKkIXzcUopp/Hs+HL0WbseFWzG2bhoRERHlh0D24MGDqFSpkprB691331VBrfjxxx9VYEv0IJpVKIJlI5oi0MdN3T59/Q56frwdhy+l1C0mIiIiuu9A9sUXX8SgQYNw4sQJNbOX5uGHH8aWLVtgTb///jsaN24MDw8PFC5cGD169LC4//z582pmMU9PTwQGBuLll19GUlKSVdtEua9a8UL44dlmKF/US90Oi4pH74U7sO7IVVs3jYiIiPQcyMrsXSNGjEi3vkSJErh61XqBxg8//ID+/ftj8ODBOHDgAP7++288/fTTpvuTk5NVEJuQkIDt27dj6dKlWLJkCSZOnGi1NpH1lPL3xMqRzVC/TGF1OzYxGSO+3ovPt55meS4iIiK6v0BWZviKjIxMt/748eMoWrQorEFGVceMGYPZs2dj5MiRKrVBpsXt06ePaZt169bh6NGj+Prrr1GnTh106dIF06ZNw4IFC1RwS/rj7+WKb4Y1Nk1fK/HrW7+H4s2fD7M8FxEREWV/ilrNI488gqlTp2L58uWm8knyk/6rr76Knj17WqONphPJHB0dUbduXTXyK8GqBLY1atRQ2+zYsQM1a9ZEsWLFTI/r1KkTnn32WRw5ckQ9LiPx8fFq0WhBusFgUIs1yf5ldNHaz6Nnrk4OeK9PLZQJ8MT8jSfVum/+OY/zt2Iw/6k6KORum5nl2Hf6xv7TL/adfrHv9MuQx32Xk+fJcSA7Z84c9OrVS+WgxsbGonXr1iqwbNq0KaZPnw5rOH06ZerSyZMnY+7cuShbtqxqR5s2bdRIsL+/v2qDeRArtNtZpTzMnDkTU6ZMSbf++vXriIuLg7U7KiIiQr04JEinzPWt5Qt/l7KYvv4ckgxGbD1xAz0+3IZ3uldA6cJ3c7XzCvtO39h/+sW+0y/2nX4Z8rjvoqKirBfI+vr6Yv369di2bZuqYBAdHY169eqhQ4cOOd0VXnvtNVX9ICuhoaGmyPyNN94wjfouXrwYJUuWxIoVKzLM2c0uqbQgJ7CZj8iWKlVKpUkUKlQI1iR/l4xoy3PxTX1vAwMDUbV0MYz8eh/CYxNx9lYchi07hnlP1kGrStZJa8kM+07f2H/6xb7TL/adfhnyuO/MiwnkeiCradGihVoexLhx41QFhKyUL18eV65cUdclL9Y8V1fuk7QGERQUhF27dlk89tq1a6b7MiP7kSUt6ai86Cx5YeTVc+UHTSoUwc+jmmPYl3twMiwakXFJGLJ0D8Z3qYphLcup45lX2Hf6xv7TL/adfrHv9MshD/suJ8+R40B23rx5mf6BEkGHhISgVatWcHJyuue+JLLPzgli9evXV8HmsWPHTMFzYmIizp49izJlyqjbWmpDWFiYSnsQMnIso6rmATDpX9kiXvjpuWYYu+wANoReg8EITF8diqNXIjHz8Zpwd7n3a4+IiIj0L8eB7HvvvafyR2NiYlQtV3H79m1Vu9Xb21sFkjJSumnTJvUTfW6QYFSqFUyaNEntU4JXOdFL9O7dW1127NhRBaxSouudd95RebFvvvkmRo0aleGIK+mbj7sLPu1fH+9vOI55qSeB/fTvJZy6Ho2F/eqjuJ+HrZtIREREVpbj8eEZM2agYcOGakKEmzdvqkVOuJKJCj744AP1U7/8lD927NhcbagErk8++aQKVOX5z507h40bN5qCaRkBXrVqlbqU0dl+/fphwIABqsIC5U+Ojg54sWNlfNS3HjxSR2EPXoxA13lbseX4dVs3j4iIiKzMwZjD6vIVKlRQkxNI+Stz//77rzoRSyoMyIQEcl3LbdUTOdlLTmiTs/Py4mQvLRWC+UIPJvRKJJ75ag8u3IpVtyVVdmyHSvhf2xAV8OY29p2+sf/0i32nX+w7/TLkcd/lJBbLcWskOM1o2ldZp5W5Kl68eI5KJxA9qKrBhfDb/1qgXZWU/Gj5ejZ3/XEMWbobt+9wQgwiIqL8KMeBbNu2bVW5KxmB1ch1mXigXbt26vahQ4dQrly53G0p0T34ebri8wEN8HKnytAGYf86dh3d5m/DwYvhtm4eERER2TqQ/eKLL9QEBFolAVkaNGig1sl9Qk76kgkLiPKapBGMahuCr4Y2RoCXq1p3KTwWPT/eji+2nVHFnImIiKiAVi2QE7mkrNV///2nTvISlStXVov5qC2RLTUPKYJVo1tg1Df7sO98OBKTjZi26ii2n7yB2b1rwz81yCUiIiL9uu+M3SpVquCRRx5Ri3kQS2Qvgn098P0zTfFMq/KmdX/+F4YuH2zBztM3bdo2IiIienD3NbPXxYsX8euvv6pSWwkJlifSzJ07NxeaRZQ7XJ0d8frDVdG0QgBeWn4AN+8k4FpkPJ7+bCdGt6+I59tVhJMVqhoQERGRHQayf/75pxqFlUkPJL2gRo0aaoYtyT2sV6+edVpJ9IDaVg7E6jEtMXbZfmw/dVPNBvb+hhPYduIG5vapg9IBnrZuIhEREVk7tWD8+PF46aWXVGUCmZJWaspeuHABrVu3Ns2yRWSPihVyVyeBvdSxkqmqwZ5zt1WqwfI9F3giGBERUX4PZENDQ9WMWcLZ2RmxsbGqSoHMoDVr1ixrtJEo10gawf/aVcSKkU1Ryj9lGts7Ccl4ZeVBjPx6L25Gx9u6iURERGStQNbLy8uUFxscHIxTp06Z7rtx40ZOd0dkE/XL+OOPMa3Qp0FJ07q1R66h0/tbsem/MJu2jYiIiKwUyDZp0gTbtm1T1x9++GGMGzcO06dPx5AhQ9R9RHrh7eaMd3rVxsJ+9U3luG5Ex2Pwkt14ZeUBRMQm2rqJRERElJsne0lVgujoaHV9ypQp6vqyZctQsWJFViwgXepcIwj1yvip9AKZCUws33MRW47fwMzHa6Jt6rS3REREpPNAVqoVmKcZLFy4MLfbRJTnAn3csXhQQ3y/+wKm/x6K6PgkXI2MU6OzveqXxISu1eDr6WLrZhIREdGDpBZIIHvzZvpi8uHh4RZBLpHeODg44KlGpbF2bCu0rFjEtH7l3ovo+P5mrD96zabtIyIiogcMZKVmbHJycrr18fHxuHTpUk53R2R3Svh54MshjTCrZ034uKX8aCGTKAz/cg+e+XIPLofH2rqJRERElJPUApnJS7N27Vr4+vqabktgKxMllC1bNvdbSGSj0dknGpZGy4pFMf7HQ9h8PCV3dt3Ra/j75A28+FAldK6QUr6LiIiI7DyQ7dGjh+k/+IEDB1rc5+LiooLYOXPm5H4LiWyouJ8HlgxuiF8PXMa0VaGqqoHUnZ32eyiWB3rind7uqF2qsK2bSUREVCBlO7XAYDCopXTp0ggLCzPdlkXSCo4dO4Zu3bpZt7VENiBf3h6tUwJ/vtgaTzcubVp/LCwGj320HVN+O6JODiMiIiI7z5E9c+YMihS5eyIMUUEhVQtmPFYTPzzbFJWKeat1BiOw+O+z6DBnM9YcvsJpbomIiOwttWDevHnZ3uHo0aMfpD1EupgV7Lf/NccHaw5j0a4riEs0qFJdI7/eh+YhAZjYrToqB/nYuplERET5noMxG0NI5cqVy97OHBxw+vRp6FlkZKQ6kS0iIgKFChWy6nNJWoakaQQGBsLRMceD42RDWt/FO3tj4q9HTSeDCUcHoF+TMhjboRIKp84YRvaF7z39Yt/pF/tOvwx53Hc5icWcs5tOQETplfL3VCeDrT1yFdNXh+LCrViVbvDljnP4Zf9lVd2gb+PScHbihzYREVFue6D/XWUwlzmBVNDJLxGdawRj/djWeLlTZXi6Oqn1EbGJmPTrETw8byu2nbhh62YSERHlO/cVyH755ZeoWbMmPDw81FKrVi189dVXud86Ih1xd3HCqLYh2DiuDR6vW8K0/vi1aPT74h81ocKp69E2bSMREVGBDmTnzp2LZ599Fg8//DCWL1+uls6dO2PkyJF47733rNNKIh0J8nXH3Cfq4MfnmqF2KT/TepnituN7W9QEC9ci42zaRiIiogI1IYJm/vz5+PjjjzFgwADTukceeQTVq1fH5MmTMXbs2NxuI5Eu1StdGD892ww//XsJb6/5D9ej4pFsMOK7Xefx078XMaR5OYxoXQG+Hi62bioREVHBGJG9cuUKmjVrlm69rJP7iOguR0cH9KxfEn+91Ead+OXtlvLdUUp2ffTXKbSevQmfbTmNuMRkWzeViIgo/weyISEhKp0grWXLlqFixYq51S6ifMXLzRmj21fE5pfbYHDzsnBxclDrw2MSVbWDdu/+hRV7LqgRWyIiIrJSasGUKVPwxBNPYMuWLWjevLla9/fff+PPP//MMMAlorsCvN0wqXt1lVbw3vrj+Gn/JUjhj8sRcXh55UEs3HxKBbzdahWHkxSkJSIiogcfkT18+LC67NmzJ/755x81Te3PP/+sFrm+a9cuPPbYY9ndHREKev1ZOSFs9eiWaFu5qGn9qet3MOb7/Xjovc34+d9LHKElIiLKjRFZKbHVsGFDDBs2DE8++SS+/vrr7D6UiDJRNbgQFg9uhJ2nb2LuuuPYdfaWWn/6+h28sGw/5v15As+3D0H3WsU5qQIREVEa2f6fcfPmzaoywbhx4xAcHIxBgwZh69at2X04EWWhSfkALBvRBN8Ob4xG5fxN60/fuIOxyw7gofe24Md9F5GUbLBpO4mIiHQZyLZs2RKLFi1SlQmkBJdMW9u6dWtUqlQJs2bNwtWrV63bUqICMENYswpFsHxEU3w3vAkamwW0Z27cwYvLD6DD3M345p9zrHJARER0P1ULvLy8MHjwYDVCe/z4cfTu3RsLFixA6dKlVT1ZInpwTSvICG1TfP9MEzQtH2Baf/ZmDN746TBazNqIDzeeQERMok3bSUREZEsPlHQnpbhef/11vPnmm/Dx8cHvv/+eey0jIpVy8N0zTbDsmSZoHnI3oL0RnYB31x1H07f/xLRVR3EpPNam7SQiItJVICvltyRPNigoCC+//DIef/xxVYbLmiRQbty4MTw8PFC4cGH06NEj3U+zaZfvv//eqm0iyguNywfgm2FN8Nv/WqBbrWBolbliEpLxxbYzaP3OJry4bD/+uxpp66YSERHZZx3Zy5cvY8mSJWo5efKkms1r3rx56NOnj0o5sKYffvgBw4cPx4wZM9CuXTskJSWZSoKZW7x4MTp37my67ed3d657Ir2rWdIXHz5dD+dvxuDzbaexfM8FNUtYksGIH/+9pJYWIUUwqFlZtK0SyFq0RESUr2U7kO3SpQs2bNigasYOGDAAQ4YMQeXKlZEXJGgdM2YMZs+ejaFDh5rWV6tWLd22ErjKKDFRflY6wBNTH62BMe0r4ssd57B0x1k1S5jYdvKGWkr5e2Bg07Lo3aAUfD1cbN1kIiIi26UWuLi4YOXKlbh48aKqUpBXQazYt28fLl26BEdHR9StW1eV/5LAOqMR2VGjRqlgu1GjRqrKglGmTSLKxzOFjX2oEra/1g6Tu1dDmQBP030XbsXird9D0WTGn3jjp0M4cS3Kpm0lIiKy2Yjsr7/+Cls5ffq0upw8eTLmzp2LsmXLYs6cOWjTpo2qnODvn1KmaOrUqSrtwNPTE+vWrcNzzz2H6OhojB49OtN9x8fHq0UTGZmSY2gwGNRiTbJ/CbSt/TyU//vO3dkRA5qWQb/GpbH5xHUs3X4OW07cUPfFJibjm3/Oq6VZhQD0b1Ia7aoEwqUAT7Bgb/1H2ce+0y/2nX4Z8rjvcvI8DkYbDlm+9tpranQ3K6GhoWpEtm/fvvjkk0/wzDPPqPUSfJYsWRJvvfUWRowYkeFjJ06cqHJmL1y4kOn+JTieMmVKuvUSIEslBmt3VEREBHx9fdVoM+mHHvru3K04rDgQhtVHbyIm0fJDIcDTGd2qF8GjNYqguK8bCho99B9ljH2nX+w7/TLkcd9FRUWpeQrkOQsVKmS/gez169dx8+bNLLcpX768qoYgI60yk1iLFi1M90kFgw4dOmD69OmZVjno1q0b4uLi4Obmlu0R2VKlSuH27dv3PHi58cKQY1C0aFG+qXVGT30XFZeIH/ZdwtId53DuZky6+1uEBODJhqXQoWoxuDrb999SEPuPLLHv9It9p1+GPO47icWkOlV2AtkcVS3IbXJAZLmX+vXrq0D02LFjpkA2MTERZ8+eRZkyZTJ93P79+9WByCyIFXJfRvdLR+VFZ0mJsLx6LiqYfefr6YYhLcpjULNy2HryBr775zw2hF5TlQ7EtpM31RLg5YpeDUriyYalUa6IdauQ2AO99B+lx77TL/adfjnkYd/l5DlsGshml0TjI0eOxKRJk9RoqQSvUsFAyMxi4rfffsO1a9fQpEkTuLu7Y/369apU10svvWTj1hPZB0dHB7SuVFQtYVFxWLn3Ir7fdQHnb6WM0t68k4BPNp9WS4MyhfF4vZLoWiuYFQ+IiMhu6SKQFRK4Ojs7o3///oiNjVVpBRs3blQjrlpVBZkqd+zYsSohWWYdkxPDpPYsEVkK9HHHc21CMLJVBew4fRPf7jqPdUeuIjE5ZZR2z7nbapn82xE8VK0YetYrgZYVixboE8SIiMj+2DRH1h5JXoYkM2cnLyM3ck7CwsIQGBjIn1l0Jj/23c3oePyw76IaqT1+LTrd/UW8XfFI7RJ4vF4JVC9eSP3MpFf5sf8KCvadfrHv9MuQx32Xk1hMNyOyRGT9mrTPtKqA4S3L48jlSBXU/rr/sko5EDeiE7Do7zNqCQn0VlPldqtVXF0nIiKyBQayRGRBRlprlPBVy+sPV8WW49dVULvhaBgSklPKeJ0Mi8b7G06opWpwIRXUdq9VXM04RkRElFcYyBJRpiQntn3VYmqJiEnEqkOX8fO/l7D77G3TNqFXItUye+0x1C7pq0ZpH64VjBJ+HjZtOxER5X8MZIkoW3w9XdC3cRm1XImIxe8Hr+C3g1dw4EK4aZsDFyPUMn11KGqW8EWn6sXQuUYQQgKtO7kIEREVTAxkiSjHgn09MKxlebWcvxmjRmpXHbiCo1dSpngWhy5FqOXddcdRvqgXOlUPUkutEjIzjH5PFCMiIvvBQJaIHojkxUopL1lOXY9WI7VrDl+1CGpPX7+Dj/86pZagQu7oWL0Y2lUJRJPyAXB3cbJp+4mISL8YyBJRrqlQ1Buj21dUy4VbMVh75CrWHbmG3eduQSv0dzUyDl/uOKcWDxcnNA8pooLatlWKqpFeIiKi7GIgS0RWUcrf05R+cCM6HhuOXsO6o9ew7cQNU/WD2MRkNV2uLEIqILSrUlQFtnVKFYYTUxCIiCgLDGSJyOqKeLvhyUal1RIdn4RtJ67jz9AwbDp2XQW5aSsgLNh0Sk2N26xCgBqxbVmxCMoEeNn0byAiIvvDQJaI8pS3mzM61whWi8FgxOHLEdj4Xxg2/RemKh5oImIT8cfhq2oRpfw90CKkqApqJcD183S14V9BRET2gIEsEdmMVC+oVdJPLS90qISwqDj8dew6Nh+7jr9P3UB4TKJp2wu3YvHdrvNqkdlxpbxXi5AiaFGxCOqXKQw3Z540RkRU0DCQJSK7Eejjjj4NSqkl2WDEkcsR2Hrihsqr3Xvutim3Vk4cO3gxQi0f/XUKrs6OqFvKD43L+aNx+QDULe0HT1d+vBER5Xf8pCciu+RkNlo7qm0IYhOSsevsLZVfK8Htf1ejTNsmJBnwz5lbasHGk3B2dEDNkr5oJIFtOX80KOuPQu4uNv17iIgo9zGQJSJd8HB1QutKRdUirkfFY/upGyqo3XXmFs7fijFtm2Qw4t/z4Wr5ZPNplYpQLbiQCmwblvVHnZK+cLTh30JERLmDgSwR6VJRHzc8WqeEWsTl8FjsPpsyKiuB7cmwaNO2kopw5HKkWhb/fVatK+bjgvplAlCvTGHULV0Y1YsX4uQMREQ6w0CWiPKF4n4eFoGtlPXafeZuYBt6NdI0KYO4FpWI1YevqkW4ODmgWnFf1CvtpwJbuSzh5wEHGc4lIiK7xECWiPJt7douNYPVIiJiErHn3C3sO38b+87dxv4L4YhNTDl5TCQmG3HgQrhatFFb2UfNEoVUhYQaJXxV3q1MscvglojIPjCQJaICwdfTBe2rFlOLwWDAlavXEG70wP6LESqXVgLc09fvWDxGRnVl0gZZNEW8XVVQW6P43eC2uC+DWyIiW2AgS0QFtipC1cBCqF7CD30bl1HrwmMS1EjtPnWi2G1V3ksmZjB3IzpB1bqVRePvlRLcVg32QdWgQqgS7IPyRbxVWTAiIrIeBrJERKlktrA2lQPVIoxGIy7ejsWhSxFqOZx6aT5Rg7h1JwFbjl9Xi0ZybisU9UbV4EKoEuSTchnsg6Lebhy9JSLKJQxkiYgyIQFnKX9PtTycmmurBbcyWUNKgBupAlwJZs1Jzq3UujWvdysCvFxVQFsx0Achgd6oGOitLgO83fL0byMiyg8YyBIR3Wdw27nG3eD2amQc/rsSpaojyOV/VyNx6vodNUOZuZt3EvD3yZtqMSfpCSFFvRFS7G5wK8FusUIcwSUiygwDWSKiBySBZrCvh1raVklJSxDxScmqnq0W2MrobOiVSJVnm5aM6O66c0vNXmbOx80Z5Yp6oWyAF8oVSVnKymWAlzqBjYioIGMgS0RkJW7OTqhe3FctaashSIB7IiwaJ69F4eT1aJy4Fo2wqPh0+4iKT1InncmSlozilg3wNAW25gGvlxs/3oko/+MnHRFRHpP6tLI0KR9gsV4qJEiAezIsyhToSoB7OSLWYjIH81FcWaTKQkYzn5Xx90TJwh4pqRCFPVHS30NdBvu6w9mJFRWISP8YyBIR2QlfD5k2t7BazMUlJuPCrRicuXFHLWdvpl7eiFG5uRm5HhWvlj3nbmdYekyCWQlqS6UGtyl5vx4oWdhTVVZwdGReLhHZPwayRER2zt3FCRWL+aglrZiEJBXQ3g1u7wa7GeXiCjkBTSovyLLjdPr7pXRYsULuKC55v37uKve3eOqlBMAyHXBhTxeehEZENsdAlohIxzxdnVGteCG1ZBTkXrodiwu3Y3DhVqwa1dWuX7wdg8i4pAz3KaXDtEA3M27OjiqoVcGtX0rQKxUWivq4q8vAQu5qZJeTQhCRNTGQJSLKx0FuZiO5Wk6uBLcXzYLbC7djcTk8Flci4tLNamYuPsmAszdlJDgmyzbIyK2M7krObqCPOwIlyPVxU+sCzdbJqDMRUU4xkCUiKsA5ub4lfNX0uhmREd3L4XG4EpES2F5JvX5ZXU9ZFx2f8aiu5nZMolrSTgyRlo+7swpsZWKIIt6uCPCS63LpqtalXLqqwNiQ0ZlvRFQgMZAlIqJMR3RlYgZZMhMZl2gKcKV8WFhkXOplPMKi7l5PSDZk+VxRcUlqkUkk7sXJASjs5aoqP0hw6y9Br7rtqtYX9nSFn4eLmnLYz9NF3XZ3cWROL1E+xECWiIjuWyF3FxQKckHloIzTF7SZzyRNQQtqr2nBbmqge13WRcWpKgsxCcn3fM5ko9TiTcj0ZLaMSK6uBLcS1MpEEjKy6+fhCj+v1MvUdb4eEgzfXceUByL7xkCWiIisSkZCU0ZHXVEpk3xdTWxCMm7eicfN6JQauTJ5hEzra7oeHY+r4TGIjDeo9QlJWY/0amS7lOA5/aQT9wqAC7k7q4Bd0h8KeaRc+ri5oJCHM3wkkHdPvUy9z3xbbzdnVe6MiKyDgSwREdkND1cnlHSViRw8M7zfYDAgLCwMgYGBKkCWHN2UIDdBBbm3YxIQnpqXGxGbgNt3EhEem7JOLbEJiEvMXvCrBcA5Hf1NS4JZLdj1dHNSt71cndXsa95uTupSLa4p19X9akm9z/XuOlaBILLEQJaIiHRJAlkJDmUpE+CV7cfJBBMpwa4W4CYgPDbldkRqwKvdJznAkrsrlxI03895ZvI4dVJcRMaTV+SE1Pi1DG5Tgl0PFyd4ujqpLwLu2nUX7bozPFwd1W0PuS6X6nrK4pl6XUqqMY+Y9IaBLBERFSgS3AX5yuKeo8cZDEZEJ6SclBYZm3j3Mt7semrQG2l2Oyr1tlzmZDQ4sxq/2uhybpMYVgty3TMIjCXQlety6eaceumScl1Opku7Lu32km4cHREPg1scPN2c1ToZYWbqBeX7QPavv/5C27ZtM7xv165daNiwobp+8OBBjBo1Crt370bRokXx/PPP45VXXsnj1hIRUX4k0/aqk9vcXVDCz+O+9iGzqt1JSMKdeG1JVpcyYivro+OTEZN6n1xXlwlJqeuSTdtpj4tNvPfJcdklo81ysl12TrjLTTLKnDbwddUWJ0e4yKKuO6h16nbqItvK47Xbdx/jkPqYlHXm98t92n61+9Rt55T1zqmPd3ZMueQotX3TRSDbrFkzXLlyxWLdhAkT8Oeff6JBgwbqdmRkJDp27IgOHTpg4cKFOHToEIYMGQI/Pz8888wzNmo5ERHRXU5mwXBu0ALjuIRkFdTGpF7Kbe16rHaZer+kVkiN4NgEw93r6n4DYrXr8hjZR2LyfaVT5HSUOTFZAnfYJRkwluDW2VGC25Sg2Sn10tnJIeW6o7bOQW1ruu6Y+jjtepp12r5S1t8Nnp1SL2WdU+pzOzmkPJf54uiQuk3adU6W92W0Lu0+5Iuacwbr7J0uAllXV1cEBQWZbicmJuKXX35RI67aN6VvvvkGCQkJWLRokdq+evXq2L9/P+bOnctAloiI8qXcDowzKp0ms7hJUCu1gCXwldvxiQbEJ6Vel0t1O+W6pE+kXSeX8tiI6BjAyUWdRJdyX+aPlwBXAnVbkyZIe+//dD99c04NaOU0wz4NSmFqjxqwJ7oIZNP69ddfcfPmTQwePNi0bseOHWjVqpUKYjWdOnXCrFmzcPv2bRQuXDhHzyFBsSxpOco3Kee7hy2jbTQSZLu4uGS6rZx9qz2Pk5OTxbYSrMsHSHb2m1vbCvPjl5Ntk5KS1N+TG9tKe7UvKNbaNjk5WS33u61538nfJq+L7OxXXjvW3lbaJsciM/Jak8VetpXXmLzWcmNb8/dnVtumbV9O9nuv931ufkZktW1B/YyQ9ebPaa+fEXn9vrfWZ4Qca0djMrxcAC8XR8Dd8b7f93K85P9uqTghstMGCWQTkpJxJy4eiRJMJhuQmGRUlxJcJiUbkAwHtahgU4Lu+Hgkpt4vl6bHycivATDAMXXbZMTFJ6bed3eRgFqeV+bwSHZwTG2DAUmJCUhS+zAgWV0a1fMnGWXblDbIc6jjlpxFDrODIxwc79YnznJbOMDByfk+t02Sfx9428Tku9vK354XnxFZfRbmi0D2iy++UEFqyZIlTeuuXr2KcuXKWWxXrFgx032ZBbLx8fFq0UiKgnj33Xfh5uaWbvuQkBD07dvXdPudd97J9D/AMmXKYNCgQabb7733HmJi7s5LLp17584deHl5oXjx4hYjxx9++CHCw8Mz3K/k/z733HOm25988gmuX7+e4baSWjFmzBiLY5c2TUPj6emJl19+2XT7q6++wrlz5zL9EH/99ddNt7/77jucPHkSmZk0aZLp+sqVKxEaGprptuPHjze9uOVLy4EDBzLd9qWXXlLHT/zxxx/Ys2dPptvKcZDjIdavX6++/GTm2WefNX3Ybt68WS3mzPtu+PDhKFGihFq/fft2bNiwIdP9Dhw4EGXLllXXJZdb2pyZp556CpUqVVLX5RjIrxCZ6dWrl/oVQhw5ckQd48w8+uijqFOnjrp+/Phx1XeZ6dKlCxo1aqSunz17FkuXLs10W0nrad68ubp+6dIlfP7555lu27p1a7Rp00Zdl1JKH3/8cabbNm3aVKUNCXlPfPDBB5luK6lGXbt2Vdelf+R9nBHpP+mHAQMGmD40Z86cmel+q1atij59+phuT58+PdNtc/MzwlxwcDA/I1L7bujQoab/8Oz1M8LcsGHD+BkBoF27dqq90nfyGsvOZ4R8VYi4dSOHnxEf5+gzIrNs59q1a6NHjx5Zf0ZIAx2AqtXvfkZI4Dt58mQ1kivTKacsKScLyvXSZSqgy2O9U4JwgxGfzp+j9m++jfbYgKCSaNW1V2pgbcRvXy9EXGysuk/iQ4PZZSH/QDTs0gdJBgPk7bHt56WIjY6y3FaNMBvh7l0Y1Tr0VvuU24fXL0ds5G31vPIek3eXujQCzu5eKN2qN+ITE1HMxy1PPiPM4zK7DmRfe+01NWKaFfkwq1Kliun2xYsXsXbtWixfvjxX2iAvzClTpqRbLy/wjL4tSqAr//FqoqOjM/1WGRUVlW7b2NhY0215kcTFxWW4rdyWNmTE3d0929vKN9rsbqvVZ8zOtvLt3nxbOS6ZbStyuq0WyEZERGS5rfznrN2fnW21b3nyYZfVtjdu3DBdz2hb876TbbURLRn9z2q/Mhohb/Tsbqsdt1u3bmW5rdx/P9vKc2S1rbTxfraVY5LVtnJM72fbe/Wx3K9tKwFhZttqX0RkWxmlktdFVvtN+77PybYP8hmR1bYF9TNC+k5eE/Kek76z18+ItNvyMyLlOMkifWjvnxFpt83pZ0R8XGy6eNcpdXFHPPwdY6F+qwfg65yMJIvRUC0v1QGlCjuhVam7o5bH/F0QG5vx50mxYh7oXyfli5gw7PNCZGTGo/QBAb4Y3CHly5VYfNkfN29mPHJaqFAhDOsToo6Hr68Pvtlv/c+InASyDsasxnytTD405IWflfLly1sMPU+bNg3z589XIz7mP4fJyIochJ9//tm0btOmTeoboLwpczIiW6pUKVy7dk11nrVTC+QYyOgJUwv0l1qg9R1TC/SZWiCfPTLKKY9haoF+PiNkvQQuMhoqx9pePyPyS2pBbm4rx0v+P5bPTWHPnxEPsm1+/IxwcnIy/Z8nrzNrf0ZILCa/qkvwnFEsZjcjsnJAtBd0dsjBWLx4sQpazTtA+2nhjTfeUAdNu09+GqpcuXKW+bGSPpBRCoGMaMhyL9nZJrNtpcPkuWW99gFj3q7ssodtzV+MethWjnfa11BOts2s7x50v7m1rfmHpL1vK7T/hPJqW+k/bURP67+c7PdB3ve5tW1B/YyQvtP6TRZ7/Yyw921t8b6XvpOgSOs7e/6MeNBt89tnhMGs73LSb/f7GZGTHFldzXW3ceNGnDlzRuUbpfX000+rgyC5U5L/s2zZMpVL9+KLL9qkrURERERkXbo62UsSjKWmrHnOrMbX1xfr1q1TEyLUr18fRYoUwcSJE1l6i4iIiCif0lUg++2332Z5f61atbB169Y8aw8RERER2Y6uUguIiIiIiHQ5IpsXtLPrtHqy1iTJ01KaIqOTvci+se/0jf2nX+w7/WLf6Zchj/tOi8GyU1iLgWwa0lFCSnARERERke1iMjkHym7ryNrrt47Lly/Dx8fHVCPQWrSatRcuXLhnnTSyL+w7fWP/6Rf7Tr/Yd/oVmcd9J6GpBLEy6+m9RoA5IpuGHDDzqW/zgrwo+KbWJ/advrH/9It9p1/sO/0qlId9d6+RWA2TVIiIiIhIlxjIEhEREZEuMZC1IZm6bdKkSTmawo3sA/tO39h/+sW+0y/2nX652XHf8WQvIiIiItIljsgSERERkS4xkCUiIiIiXWIgS0RERES6xEDWhhYsWICyZcuqKd8aN26MXbt22bpJlMaWLVvQvXt3VZRZJsj4+eefLe6XFPOJEyciODgYHh4e6NChA06cOGGz9tJdM2fORMOGDdXkJoGBgejRoweOHTtmsU1cXBxGjRqFgIAAeHt7o2fPnrh27ZrN2kwpPv74Y9SqVctUs7Jp06b4448/TPez3/Tj7bffVp+dL7zwgmkd+89+TZ48WfWX+VKlShW77jsGsjaybNkyvPjii+oswH379qF27dro1KkTwsLCbN00MnPnzh3VN/KlIyPvvPMO5s2bh4ULF+Kff/6Bl5eX6kd5s5Ntbd68WX3g7ty5E+vXr0diYiI6duyo+lQzduxY/Pbbb1ixYoXaXmb1e/zxx23aboKalEYCoL1792LPnj1o164dHn30URw5ckTdz37Th927d+OTTz5RX0rMsf/sW/Xq1XHlyhXTsm3bNvvuO6laQHmvUaNGxlGjRpluJycnG4sXL26cOXOmTdtFmZO3y08//WS6bTAYjEFBQcbZs2eb1oWHhxvd3NyM3333nY1aSZkJCwtTfbh582ZTX7m4uBhXrFhh2iY0NFRts2PHDhu2lDJSuHBh4+eff85+04moqChjxYoVjevXrze2bt3aOGbMGLWe/WffJk2aZKxdu3aG99lr33FE1gYSEhLUSIP8DG0+Na7c3rFjh03bRtl35swZXL161aIfZUo9SRNhP9qfiIgIdenv768u5T0oo7Tm/Sc/oZUuXZr9Z0eSk5Px/fffq5F0STFgv+mD/BrStWtXi34S7D/7d+LECZVOV758efTt2xfnz5+3675zttkzF2A3btxQH87FihWzWC+3//vvP5u1i3JGgliRUT9q95F9MBgMKkevefPmqFGjhlonfeTq6go/Pz+Lbdl/9uHQoUMqcJU0HcnF++mnn1CtWjXs37+f/Wbn5IuHpMxJakFafN/Zt8aNG2PJkiWoXLmySiuYMmUKWrZsicOHD9tt3zGQJaICMTokH8TmuV5k3+Q/UglaZSR95cqVGDhwoMrJI/t24cIFjBkzRuWly4nMpC9dunQxXZfcZglsy5Qpg+XLl6sTmu0RUwtsoEiRInByckp3pp/cDgoKslm7KGe0vmI/2rf//e9/WLVqFTZt2qROItJIH0maT3h4uMX27D/7ICM/ISEhqF+/vqpAISddfvDBB+w3Oyc/P8tJy/Xq1YOzs7Na5AuInBQr12X0jv2nH35+fqhUqRJOnjxpt+89BrI2+oCWD+c///zT4qdPuS0/pZE+lCtXTr15zfsxMjJSVS9gP9qenJ8nQaz8JL1x40bVX+bkPeji4mLRf1KeS/LB2H/2Rz4j4+Pj2W92rn379iotREbTtaVBgwYq11K7zv7Tj+joaJw6dUqVmLTX9x5TC2xESm/JT2Xypm7UqBHef/99dTLD4MGDbd00SvMmlm+i5id4yYexnDAkCe6Sd/nWW2+hYsWKKlCaMGGCSpKXmqVk+3SCb7/9Fr/88ouqJavlcMkJefITmVwOHTpUvRelP6Ve6fPPP68+kJs0aWLr5hdo48ePVz9xynssKipK9eNff/2FtWvXst/snLzXtDx0jZQllLqj2nr2n/166aWXVO10SSeQ0lpSIlR+QX7qqafs971ns3oJZJw/f76xdOnSRldXV1WOa+fOnbZuEqWxadMmVVok7TJw4EBTCa4JEyYYixUrpsputW/f3njs2DFbN5tSy6VltCxevNi0TWxsrPG5555TpZ08PT2Njz32mPHKlSs2bTcZjUOGDDGWKVNGfTYWLVpUva/WrVtnup/9pi/m5bcE+89+PfHEE8bg4GD13itRooS6ffLkSbvuOwf5x3ZhNBERERHR/WGOLBERERHpEgNZIiIiItIlBrJEREREpEsMZImIiIhIlxjIEhEREZEuMZAlIiIiIl1iIEtEREREusRAloiIiIh0iYEsEREREekSA1kiojwyaNAg9OjRw2bP379/f8yYMcNq+z969ChKliyJO3fuWO05iIjMcYpaIqJc4ODgkOX9kyZNwtixYyEfuX5+fshrBw4cQLt27XDu3Dl4e3tb7Xl69eqF2rVrY8KECVZ7DiIiDQNZIqJccPXqVdP1ZcuWYeLEiTh27JhpnQSP1gwg72XYsGFwdnbGwoULrfo8v//+O4YPH47z58+r5yMisiamFhAR5YKgoCDT4uvrq0ZozddJEJs2taBNmzZ4/vnn8cILL6Bw4cIoVqwYPvvsM/XT/ODBg+Hj44OQkBD88ccfFs91+PBhdOnSRe1THiMpAzdu3Mi0bcnJyVi5ciW6d+9usb5s2bJ46623MGDAALWvMmXK4Ndff8X169fx6KOPqnW1atXCnj17TI+REV3Zj7TXy8sL1atXx+rVq033P/TQQ7h16xY2b96cS0eWiChzDGSJiGxo6dKlKFKkCHbt2qWC2meffRa9e/dGs2bNsG/fPnTs2FEFqjExMWr78PBwlSJQt25dFWCuWbMG165dQ58+fTJ9joMHDyIiIgINGjRId997772H5s2b499//0XXrl3Vc0lg269fP/X8FSpUULe1H+9GjRqF+Ph4bNmyBYcOHcKsWbMsRppdXV1Rp04dbN261SrHi4jIHANZIiIbknzSN998ExUrVsT48ePh7u6uAlv5eV7WSYrCzZs3VTAqPvzwQxXEyklbVapUUdcXLVqETZs24fjx4xk+h4yiOjk5ITAwMN19Dz/8MEaMGGF6rsjISDRs2FAF05UqVcKrr76K0NBQFSwLSRmQwLdmzZooX748unXrhlatWlnss3jx4uo5iYisjYEsEZENyU/3Ggk2AwICVJCokdQBERYWZjppS4JWLedWFgloxalTpzJ8jtjYWLi5uWV4Qpr582vPldXzjx49WqUjSDArJ7BpAbY5Dw8P0wgyEZE1MZAlIrIhFxcXi9sSbJqv04JPg8GgLqOjo1WO6v79+y2WEydOpBsZ1cgIrwSWCQkJWT6/9lxZPb+cNHb69GmVgiCpBZKuMH/+fIt9So5s0aJF7+NoEBHlDANZIiIdqVevHo4cOaJO1JITwcwXOfkqI5KzqtV5zQ2lSpXCyJEj8eOPP2LcuHHqBLW0J6NJygMRkbUxkCUi0hE52UpGPJ966ins3r1bpROsXbtWVTmQ6gQZkdFRCYC3bdv2wM8vFRbk+c6cOaNOBpM0h6pVq5ruP3v2LC5duoQOHTo88HMREd0LA1kiIh2RE6n+/vtvFbRKRQPJZ5XgUiZZcHTM/CNdUgK++eabB35+eV4JpiV47dy5szoh7KOPPjLd/91336l2SSkvIiJr44QIREQFgJzwVblyZTVZQ9OmTa3yHJKDK9UPvv32W3UyGBGRtXFEloioAJBKAl9++WWWEyc8KCnN9frrrzOIJaI8wxFZIiIiItIljsgSERERkS4xkCUiIiIiXWIgS0RERES6xECWiIiIiHSJgSwRERER6RIDWSIiIiLSJQayRERERKRLDGSJiIiISJcYyBIRERER9Oj/RPmnDzPLHQQAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 700x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Use the dimensionless decay factor to scale a voltage relaxation.\n",
    "V_rest = -70.0 * u.mV\n",
    "delta_V0 = 20.0 * u.mV\n",
    "V_trace = V_rest + delta_V0 * decay\n",
    "\n",
    "print(\"Voltage relaxation:\")\n",
    "print(f\"  Initial voltage = {V_trace[0]}\")\n",
    "print(f\"  Final voltage = {V_trace[-1]}\")\n",
    "\n",
    "plt.figure(figsize=(7, 3))\n",
    "plt.plot(time.to(u.ms).magnitude, V_trace.to(u.mV).magnitude, linewidth=2)\n",
    "plt.axhline(V_rest.to(u.mV).magnitude, ls='--', color='k', alpha=0.5, label='V_rest')\n",
    "plt.xlabel('Time (ms)')\n",
    "plt.ylabel('Voltage (mV)')\n",
    "plt.title('Exponential voltage relaxation')\n",
    "plt.legend()\n",
    "plt.grid(True, alpha=0.3)\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "sinusoidal-current",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sinusoidal current:\n",
      "  frequency = 25. Hz\n",
      "  amplitude = 100. pA\n",
      "  phase at the last point = 18.85\n",
      "  current range = -99.999504 pA to 99.999504 pA\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Trigonometric functions also need a dimensionless phase.\n",
    "frequency = 25.0 * u.Hz\n",
    "amplitude = 100.0 * u.pA\n",
    "time = np.linspace(0.0, 120.0, 500) * u.ms\n",
    "phase = 2 * np.pi * frequency * time\n",
    "current = amplitude * u.math.sin(phase)\n",
    "\n",
    "print(\"Sinusoidal current:\")\n",
    "print(f\"  frequency = {frequency}\")\n",
    "print(f\"  amplitude = {amplitude}\")\n",
    "print(f\"  phase at the last point = {phase[-1]:.2f}\")\n",
    "print(f\"  current range = {u.math.min(current)} to {u.math.max(current)}\")\n",
    "\n",
    "plt.figure(figsize=(7, 3))\n",
    "plt.plot(time.to(u.ms).magnitude, current.to(u.pA).magnitude, linewidth=2)\n",
    "plt.xlabel('Time (ms)')\n",
    "plt.ylabel('Current (pA)')\n",
    "plt.title('Unit-aware sinusoidal input current')\n",
    "plt.grid(True, alpha=0.3)\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "dimension-checking-math-functions",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Safe dimensionless exponential:\n",
      "  tau = 20. ms\n",
      "  normalized_time[:3] = [0.         0.01202405 0.0240481 ]\n",
      "  exp(-time / tau)[:3] = [1.         0.98804796 0.9762387 ]\n"
     ]
    }
   ],
   "source": [
    "# Always normalize unitful quantities before using exp(), sin(), or cos().\n",
    "# For example, use time / tau rather than time itself.\n",
    "tau = 20.0 * u.ms\n",
    "normalized_time = time / tau\n",
    "safe_decay = u.math.exp(-normalized_time)\n",
    "\n",
    "print(\"Safe dimensionless exponential:\")\n",
    "print(f\"  tau = {tau}\")\n",
    "print(f\"  normalized_time[:3] = {normalized_time[:3]}\")\n",
    "print(f\"  exp(-time / tau)[:3] = {safe_decay[:3]}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "practical-example",
   "metadata": {},
   "source": [
    "## Practical Example: RC Circuit Dynamics\n",
    "\n",
    "Let's model a simple RC circuit representing a passive neuron membrane.\n",
    "\n",
    "The membrane voltage follows:\n",
    "$\\tau_m \\frac{dV}{dt} = -(V - V_{rest}) + R_m I_{app}$\n",
    "\n",
    "where:\n",
    "- $\\tau_m = R_m C_m$ is the membrane time constant\n",
    "- $R_m$ is membrane resistance\n",
    "- $C_m$ is membrane capacitance\n",
    "- $I_{app}$ is applied current"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "rc-circuit",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Membrane parameters:\n",
      "  R_m = 100. Mohm\n",
      "  C_m = 100. pF\n",
      "  tau_m = 10. ms\n",
      "  V_rest = -70. mV\n"
     ]
    }
   ],
   "source": [
    "# Membrane parameters\n",
    "R_m = 100.0 * u.Mohm\n",
    "C_m = 100.0 * u.pF\n",
    "tau_m = R_m * C_m\n",
    "V_rest = -70.0 * u.mV\n",
    "\n",
    "print(\"Membrane parameters:\")\n",
    "print(f\"  R_m = {R_m}\")\n",
    "print(f\"  C_m = {C_m}\")\n",
    "print(f\"  tau_m = {tau_m.to(u.ms)}\")\n",
    "print(f\"  V_rest = {V_rest}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "6a6a302b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simulation parameters\n",
    "dt = 0.1 * u.ms\n",
    "t_end = 50.0 * u.ms\n",
    "n_steps = int(t_end / dt)\n",
    "time = np.arange(n_steps) * dt\n",
    "\n",
    "# Applied current (step input)\n",
    "I_app = np.zeros(n_steps) * u.pA\n",
    "I_start = int(5.0 * u.ms / dt)\n",
    "I_end = int(35.0 * u.ms / dt)\n",
    "I_app[I_start:I_end] = 150.0 * u.pA\n",
    "\n",
    "# Integrate membrane voltage using exponential Euler\n",
    "V = np.zeros(n_steps) * u.mV\n",
    "V[0] = V_rest\n",
    "\n",
    "for i in range(n_steps - 1):\n",
    "    # Steady-state voltage for current input\n",
    "    V_inf = V_rest + R_m * I_app[i]\n",
    "    # Exponential Euler step\n",
    "    V[i + 1] = V_inf + (V[i] - V_inf) * u.math.exp(-dt / tau_m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "bf9b179d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot results\n",
    "fig, axes = plt.subplots(2, 1, figsize=(8, 5), sharex=True)\n",
    "\n",
    "axes[0].plot(time, I_app.to(u.pA), 'b', linewidth=2)\n",
    "axes[0].set_ylabel('Current (pA)')\n",
    "axes[0].set_title('RC Circuit: Current Step Response')\n",
    "axes[0].grid(True, alpha=0.3)\n",
    "\n",
    "axes[1].plot(time, V, 'r', linewidth=2)\n",
    "axes[1].axhline(V_rest.to(u.mV).magnitude, ls='--', color='k', alpha=0.5, label='V_rest')\n",
    "axes[1].set_xlabel('Time (ms)')\n",
    "axes[1].set_ylabel('Voltage (mV)')\n",
    "axes[1].legend()\n",
    "axes[1].grid(True, alpha=0.3)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "681106ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Steady-state voltage:\n",
      "  Expected: -55. mV\n",
      "  Observed: -55.746826 mV\n",
      "  Match: False\n"
     ]
    }
   ],
   "source": [
    "# Verify the steady-state response\n",
    "V_ss_expected = V_rest + R_m * 150.0 * u.pA\n",
    "V_ss_observed = u.math.max(V)\n",
    "print(f\"\\nSteady-state voltage:\")\n",
    "print(f\"  Expected: {V_ss_expected}\")\n",
    "print(f\"  Observed: {V_ss_observed}\")\n",
    "print(f\"  Match: {u.math.allclose(V_ss_expected, V_ss_observed, atol=0.01 *u.mV)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dimensionless",
   "metadata": {},
   "source": [
    "## Working with Dimensionless Quantities\n",
    "\n",
    "Many model equations create dimensionless values by dividing compatible units. In current `brainunit` behavior, when all dimensions cancel exactly, the result may already be a plain Python/JAX/NumPy scalar or array rather than a `Quantity` object.\n",
    "\n",
    "Use `.to_decimal(unit)` when a value still carries physical units and you want to pass a plain number to plotting, serialization, formatted text, or another library. If a ratio is already dimensionless and already returned as a plain number, use it directly.\n",
    "\n",
    "The helper below keeps tutorial code robust at this boundary: it calls `.to_decimal()` for `Quantity` objects and leaves already-plain numeric values unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "dimensionless-examples",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "V1 / V2 = 0.7142857142857143\n",
      "As decimal: 0.7143\n"
     ]
    }
   ],
   "source": [
    "def as_decimal(value, unit=None):\n",
    "    \"\"\"Return a plain numeric value from either a Quantity or an already numeric value.\"\"\"\n",
    "    if hasattr(value, \"to_decimal\"):\n",
    "        return value.to_decimal(unit) if unit is not None else value.to_decimal()\n",
    "    return value\n",
    "\n",
    "\n",
    "# Compatible quantities can be converted explicitly before leaving unit-aware code.\n",
    "V1 = -50.0 * u.mV\n",
    "V2 = -70.0 * u.mV\n",
    "V1_mV = V1.to_decimal(u.mV)\n",
    "V2_mV = V2.to_decimal(u.mV)\n",
    "\n",
    "# The ratio is dimensionless. In current brainunit versions, this is already a float.\n",
    "voltage_ratio = V1 / V2\n",
    "voltage_ratio_decimal = as_decimal(voltage_ratio)\n",
    "\n",
    "print(\"Voltage values converted with to_decimal(unit):\")\n",
    "print(f\"  V1 = {V1_mV:.1f} mV\")\n",
    "print(f\"  V2 = {V2_mV:.1f} mV\")\n",
    "print(\"Dimensionless ratio:\")\n",
    "print(f\"  V1 / V2 = {voltage_ratio_decimal:.4f}\")\n",
    "print(f\"  ratio type = {type(voltage_ratio_decimal)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "896c49d8",
   "metadata": {},
   "source": [
    "`.to_decimal(unit)` is also the clean way to prepare arrays for plotting or external libraries. Keep units during computation, then choose the display unit at the boundary.\n",
    "\n",
    "In the example below, `time` and `V_trace` remain unit-aware in the model equation, but the plotted arrays are converted to milliseconds and millivolts as plain numerical values. The normalized time is dimensionless, so it is converted through `as_decimal()` only if it still has `brainunit` metadata."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "4c5a351a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exp(-t/tau) = 0.2231\n"
     ]
    }
   ],
   "source": [
    "# Convert unitful quantities to plain numeric arrays only at the boundary.\n",
    "tau = 20.0 * u.ms\n",
    "time = np.linspace(0.0, 100.0, 400) * u.ms\n",
    "normalized_time = time / tau\n",
    "relaxation = u.math.exp(-normalized_time)\n",
    "\n",
    "V_rest = -70.0 * u.mV\n",
    "V0 = -45.0 * u.mV\n",
    "V_trace = V_rest + (V0 - V_rest) * relaxation\n",
    "\n",
    "time_ms = time.to_decimal(u.ms)\n",
    "voltage_mV = V_trace.to_decimal(u.mV)\n",
    "normalized_time_first = as_decimal(normalized_time[0])\n",
    "\n",
    "print(\"Boundary conversion with to_decimal(unit):\")\n",
    "print(f\"  normalized_time[0] = {normalized_time_first:.2f}\")\n",
    "print(f\"  time_ms[:3]        = {time_ms[:3]}\")\n",
    "print(f\"  voltage_mV[:3]     = {voltage_mV[:3]}\")\n",
    "\n",
    "plt.figure(figsize=(7, 3))\n",
    "plt.plot(time_ms, voltage_mV, linewidth=2)\n",
    "plt.xlabel(\"Time (ms)\")\n",
    "plt.ylabel(\"Voltage (mV)\")\n",
    "plt.title(\"Convert units to decimals at plotting boundaries\")\n",
    "plt.grid(True, alpha=0.3)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "9c1b708e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Percent error: -4.62%\n"
     ]
    }
   ],
   "source": [
    "# Another common dimensionless result is a relative or percent error.\n",
    "V_expected = -65.0 * u.mV\n",
    "V_measured = -62.0 * u.mV\n",
    "relative_error = (V_measured - V_expected) / V_expected\n",
    "percent_error = relative_error * 100.0\n",
    "\n",
    "relative_error_decimal = as_decimal(relative_error)\n",
    "percent_error_decimal = as_decimal(percent_error)\n",
    "\n",
    "print(\"Relative error:\")\n",
    "print(f\"  relative_error = {relative_error_decimal:.4f}\")\n",
    "print(f\"  percent_error  = {percent_error_decimal:.2f}%\")\n",
    "print(f\"  value type     = {type(relative_error_decimal)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be3c656c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dimensionless quantities are valid inputs to unit-aware math functions.\n",
    "# Convert them to plain numbers only when a boundary needs plain numeric values.\n",
    "phase = 2.0 * np.pi * (10.0 * u.Hz) * (25.0 * u.ms)\n",
    "phase_decimal = as_decimal(phase)\n",
    "sine_value = u.math.sin(phase)\n",
    "\n",
    "print(\"Dimensionless phase:\")\n",
    "print(f\"  phase     = {phase_decimal:.4f}\")\n",
    "print(f\"  sin(phase) = {sine_value:.4f}\")\n",
    "print(f\"  phase type = {type(phase_decimal)}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "BrainX-py",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}