Repository: google-deepmind/optax (language: python)

Issue:
Adopt US spelling for the documentation
Make sure the documentation is consistently using US spelling. Currently it's a mixed bag, for example:
![image](https://github.com/user-attachments/assets/e37e4cc5-0c04-45f1-8c08-33c2b9231de6)



Discussion / hints:
Hi @fabianp  I'm working on this issue, I'd appreciate it if you could assign it to me. :+1: 

Fix patch:
diff --git a/README.md b/README.md
index 8caf38e6..38841126 100644
--- a/README.md
+++ b/README.md
@@ -15,12 +15,12 @@ Our goals are to
 
 *   Provide simple, well-tested, efficient implementations of core components.
 *   Improve research productivity by enabling to easily combine low-level
-    ingredients into custom optimisers (or other gradient processing components).
+    ingredients into custom optimizers (or other gradient processing components).
 *   Accelerate adoption of new ideas by making it easy for anyone to contribute.
 
-We favour focusing on small composable building blocks that can be effectively
+We favor focusing on small composable building blocks that can be effectively
 combined into custom solutions. Others may build upon these basic components
-in more complicated abstractions. Whenever reasonable, implementations prioritise
+in more complicated abstractions. Whenever reasonable, implementations prioritize
 readability and structuring code to match standard equations, over code reuse.
 
 An initial prototype of this library was made available in JAX's experimental
diff --git a/docs/api/stochastic_gradient_estimators.rst b/docs/api/stochastic_gradient_estimators.rst
index 9836cb44..18c3bc39 100644
--- a/docs/api/stochastic_gradient_estimators.rst
+++ b/docs/api/stochastic_gradient_estimators.rst
@@ -2,7 +2,7 @@ Stochastic Gradient Estimators
 ==============================
 
 .. warning::
-    This module has been depreated and will be removed in optax 0.3.0.
+    This module has been deprecated and will be removed in optax 0.3.0.
 
 .. currentmodule:: optax.monte_carlo
 
diff --git a/docs/gallery.rst b/docs/gallery.rst
index 89e66dee..6ab69938 100644
--- a/docs/gallery.rst
+++ b/docs/gallery.rst
@@ -218,7 +218,7 @@ Examples that make use of the :doc:`api/contrib` module.
 
 .. raw:: html
 
-      <div class="sphx-glr-thumbcontainer" tooltip="Example usage of reduce_on_plateau learing rate scheduler.">
+      <div class="sphx-glr-thumbcontainer" tooltip="Example usage of reduce_on_plateau learning rate scheduler.">
 
 .. only:: html
 
@@ -229,7 +229,7 @@ Examples that make use of the :doc:`api/contrib` module.
 
 .. raw:: html
 
-      <div class="sphx-glr-thumbnail-title">Example usage of reduce_on_plateau learing rate scheduler.</div>
+      <div class="sphx-glr-thumbnail-title">Example usage of reduce_on_plateau learning rate scheduler.</div>
     </div>
 
 
diff --git a/docs/getting_started.ipynb b/docs/getting_started.ipynb
index 02a52b7c..1b871275 100644
--- a/docs/getting_started.ipynb
+++ b/docs/getting_started.ipynb
@@ -10,7 +10,7 @@
         "\n",
         "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.sandbox.google.com/github/google-deepmind/optax/blob/main/docs/optax-101.ipynb)\n",
         "\n",
-        "Optax is a simple optimization library for [JAX](https://jax.readthedocs.io/). The main object is the {py:class}`GradientTransformation \u003coptax.GradientTransformation\u003e`, which can be chained with other transformations to obtain the final update operation and the optimizer state. Optax also contains some simple loss functions and utilities to help you write the full optimization steps. This notebook walks you through a few examples on how to use Optax."
+        "Optax is a simple optimization library for [JAX](https://jax.readthedocs.io/). The main object is the {py:class}`GradientTransformation <optax.GradientTransformation>`, which can be chained with other transformations to obtain the final update operation and the optimizer state. Optax also contains some simple loss functions and utilities to help you write the full optimization steps. This notebook walks you through a few examples on how to use Optax."
       ]
     },
     {
@@ -44,7 +44,7 @@
         "id": "n7kMS9kyM8vM"
       },
       "source": [
-        "In this example, we begin by setting up a simple linear model and a loss function. You can use any other library, such as [haiku](https://github.com/deepmind/dm-haiku) or [Flax](https://github.com/google/flax) to construct your networks. Here, we keep it simple and write it ourselves. The loss function (L2 Loss) comes from Optax's {doc}`losses \u003capi/losses\u003e` via {py:class}`l2_loss \u003coptax.l2_loss\u003e`."
+        "In this example, we begin by setting up a simple linear model and a loss function. You can use any other library, such as [haiku](https://github.com/deepmind/dm-haiku) or [Flax](https://github.com/google/flax) to construct your networks. Here, we keep it simple and write it ourselves. The loss function (L2 Loss) comes from Optax's {doc}`losses <api/losses>` via {py:class}`l2_loss <optax.l2_loss>`."
       ]
     },
     {
@@ -98,7 +98,7 @@
       "source": [
         "### Basic usage of Optax\n",
         "\n",
-        "Optax contains implementations of {doc}`many popular optimizers \u003capi/optimizers\u003e` that can be used very simply. For example, the gradient transform for the Adam optimizer is available at {py:class}`optax.adam`. For now, let's start by calling the {py:class}`GradientTransformation \u003coptax.GradientTransformation\u003e` object for Adam the `optimizer`. We then initialize the optimizer state using the `init` function and `params` of the network."
+        "Optax contains implementations of {doc}`many popular optimizers <api/optimizers>` that can be used very simply. For example, the gradient transform for the Adam optimizer is available at {py:class}`optax.adam`. For now, let's start by calling the {py:class}`GradientTransformation <optax.GradientTransformation>` object for Adam the `optimizer`. We then initialize the optimizer state using the `init` function and `params` of the network."
       ]
     },
     {
@@ -123,9 +123,9 @@
         "id": "CpAvP1WSnsyM"
       },
       "source": [
-        "Next we write the update loop. The {py:class}`GradientTransformation \u003coptax.GradientTransformation\u003e` object contains an `update` function that takes in the current optimizer state and gradients and returns the `updates` that need to be applied to the parameters: `updates, new_opt_state = optimizer.update(grads, opt_state)`.\n",
+        "Next we write the update loop. The {py:class}`GradientTransformation <optax.GradientTransformation>` object contains an `update` function that takes in the current optimizer state and gradients and returns the `updates` that need to be applied to the parameters: `updates, new_opt_state = optimizer.update(grads, opt_state)`.\n",
         "\n",
-        "Optax comes with a few simple {doc}`update rules \u003capi/apply_updates\u003e` that apply the updates from the gradient transforms to the current parameters to return new ones: `new_params = optax.apply_updates(params, updates)`."
+        "Optax comes with a few simple {doc}`update rules <api/apply_updates>` that apply the updates from the gradient transforms to the current parameters to return new ones: `new_params = optax.apply_updates(params, updates)`."
       ]
     },
     {
@@ -143,7 +143,7 @@
         "  params = optax.apply_updates(params, updates)\n",
         "\n",
         "assert jnp.allclose(params, target_params), \\\n",
-        "'Optimization should retrive the target params used to generate the data.'"
+        "'Optimization should retrieve the target params used to generate the data.'"
       ]
     },
     {
@@ -154,7 +154,7 @@
       "source": [
         "### Custom optimizers\n",
         "\n",
-        "Optax makes it easy to create custom optimizers by {py:class}`chain \u003coptax.chain\u003e`ing gradient transforms. For example, this creates an optimizer based on Adam. Note that the scaling is `-learning_rate` which is an important detail since {py:class}`apply_updates \u003coptax.apply_updates\u003e` is additive."
+        "Optax makes it easy to create custom optimizers by {py:class}`chain <optax.chain>`ing gradient transforms. For example, this creates an optimizer based on Adam. Note that the scaling is `-learning_rate` which is an important detail since {py:class}`apply_updates <optax.apply_updates>` is additive."
       ]
     },
     {
@@ -200,7 +200,7 @@
         "  params = optax.apply_updates(params, updates)\n",
         "\n",
         "assert jnp.allclose(params, target_params), \\\n",
-        "'Optimization should retrive the target params used to generate the data.'"
+        "'Optimization should retrieve the target params used to generate the data.'"
       ]
     },
     {
@@ -220,7 +220,7 @@
       "source": [
         "#### Modifying hyperparameters of optimizers in a schedule.\n",
         "\n",
-        "In some scenarios, changing the hyperparameters (other than the learning rate) of an optimizer can be useful to ensure training reliability. We can do this easily by using {py:class}`inject_hyperparams \u003coptax.inject_hyperparams\u003e`. For example, this piece of code decays the `max_norm` of the {py:class}`clip_by_global_norm \u003coptax.clip_by_global_norm\u003e` gradient transform as training progresses:\n",
+        "In some scenarios, changing the hyperparameters (other than the learning rate) of an optimizer can be useful to ensure training reliability. We can do this easily by using {py:class}`inject_hyperparams <optax.inject_hyperparams>`. For example, this piece of code decays the `max_norm` of the {py:class}`clip_by_global_norm <optax.clip_by_global_norm>` gradient transform as training progresses:\n",
         "\n",
         "\n"
       ]
@@ -306,14 +306,14 @@
         "}\n",
         "\n",
         "\n",
-        "def net(x: jnp.ndarray, params: optax.Params) -\u003e jnp.ndarray:\n",
+        "def net(x: jnp.ndarray, params: optax.Params) -> jnp.ndarray:\n",
         "  x = jnp.dot(x, params['hidden'])\n",
         "  x = jax.nn.relu(x)\n",
         "  x = jnp.dot(x, params['output'])\n",
         "  return x\n",
         "\n",
         "\n",
-        "def loss(params: optax.Params, batch: jnp.ndarray, labels: jnp.ndarray) -\u003e jnp.ndarray:\n",
+        "def loss(params: optax.Params, batch: jnp.ndarray, labels: jnp.ndarray) -> jnp.ndarray:\n",
         "  y_hat = net(batch, params)\n",
         "\n",
         "  # optax also provides a number of common loss functions.\n",
@@ -369,7 +369,7 @@
         }
       ],
       "source": [
-        "def fit(params: optax.Params, optimizer: optax.GradientTransformation) -\u003e optax.Params:\n",
+        "def fit(params: optax.Params, optimizer: optax.GradientTransformation) -> optax.Params:\n",
         "  opt_state = optimizer.init(params)\n",
         "\n",
         "  @jax.jit\n",
@@ -474,7 +474,7 @@
       "source": [
         "## Components\n",
         "\n",
-        "We refer to the {doc}`docs \u003cindex\u003e` for a detailed list of available Optax components. Here, we highlight the main categories of building blocks provided by Optax."
+        "We refer to the {doc}`docs <index>` for a detailed list of available Optax components. Here, we highlight the main categories of building blocks provided by Optax."
       ]
     },
     {
@@ -485,7 +485,7 @@
       "source": [
         "### Gradient Transformations ([transform.py](https://github.com/google-deepmind/optax/blob/main/optax/_src/transform.py))\n",
         "\n",
-        "One of the key building blocks of Optax is a {py:class}`GradientTransformation \u003coptax.GradientTransformation\u003e`. Each transformation is defined by two functions:\n",
+        "One of the key building blocks of Optax is a {py:class}`GradientTransformation <optax.GradientTransformation>`. Each transformation is defined by two functions:\n",
         "\n",
         "`state = init(params)`\n",
         "\n",
@@ -514,7 +514,7 @@
         "tx = optax.scale_by_rms()\n",
         "state = tx.init(params)  # init stats\n",
         "grads = jax.grad(loss)(params, TRAINING_DATA, LABELS)\n",
-        "updates, state = tx.update(grads, state, params)  # transform \u0026 update stats."
+        "updates, state = tx.update(grads, state, params)  # transform & update stats."
       ]
     },
     {
@@ -525,9 +525,9 @@
       "source": [
         "### Composing Gradient Transformations ([combine.py](https://github.com/google-deepmind/optax/blob/main/optax/_src/combine.py))\n",
         "\n",
-        "The fact that transformations take candidate gradients as input and return processed gradients as output (in contrast to returning the updated parameters) is critical to allow to combine arbitrary transformations into a custom optimiser / gradient processor, and also allows to combine transformations for different gradients that operate on a shared set of variables.\n",
+        "The fact that transformations take candidate gradients as input and return processed gradients as output (in contrast to returning the updated parameters) is critical to allow to combine arbitrary transformations into a custom optimizer / gradient processor, and also allows to combine transformations for different gradients that operate on a shared set of variables.\n",
         "\n",
-        "For instance, {py:class}`chain \u003coptax.chain\u003e` combines them sequentially, and returns a new {py:class}`GradientTransformation \u003coptax.GradientTransformation\u003e` that applies several transformations in sequence.\n",
+        "For instance, {py:class}`chain <optax.chain>` combines them sequentially, and returns a new {py:class}`GradientTransformation <optax.GradientTransformation>` that applies several transformations in sequence.\n",
         "\n",
         "For example:"
       ]
@@ -543,7 +543,7 @@
         "max_norm = 100.\n",
         "learning_rate = 1e-3\n",
         "\n",
-        "my_optimiser = optax.chain(\n",
+        "my_optimizer = optax.chain(\n",
         "    optax.clip_by_global_norm(max_norm),\n",
         "    optax.scale_by_adam(eps=1e-4),\n",
         "    optax.scale(-learning_rate))"
@@ -557,9 +557,9 @@
       "source": [
         "### Wrapping Gradient Transformations ([wrappers.py](https://github.com/google-deepmind/optax/blob/main/optax/_src/wrappers.py))\n",
         "\n",
-        "Optax also provides several wrappers that take a {py:class}`GradientTransformation \u003coptax.GradientTransformation\u003e` as input and return a new {py:class}`GradientTransformation \u003coptax.GradientTransformation\u003e` that modifies the behaviour of the inner transformation in a specific way.\n",
+        "Optax also provides several wrappers that take a {py:class}`GradientTransformation <optax.GradientTransformation>` as input and return a new {py:class}`GradientTransformation <optax.GradientTransformation>` that modifies the behavior of the inner transformation in a specific way.\n",
         "\n",
-        "For instance, the {py:class}`flatten \u003coptax.flatten\u003e` wrapper flattens gradients into a single large vector before applying the inner {py:class}`GradientTransformation \u003coptax.GradientTransformation\u003e`. The transformed updates are then unflattened before being returned to the user. This can be used to reduce the overhead of performing many calculations on lots of small variables, at the cost of increasing memory usage.\n",
+        "For instance, the {py:class}`flatten <optax.flatten>` wrapper flattens gradients into a single large vector before applying the inner {py:class}`GradientTransformation <optax.GradientTransformation>`. The transformed updates are then unflattened before being returned to the user. This can be used to reduce the overhead of performing many calculations on lots of small variables, at the cost of increasing memory usage.\n",
         "\n",
         "For example:"
       ]
@@ -572,7 +572,7 @@
       },
       "outputs": [],
       "source": [
-        "my_optimiser = optax.flatten(optax.adam(learning_rate))"
+        "my_optimizer = optax.flatten(optax.adam(learning_rate))"
       ]
     },
     {
@@ -594,7 +594,7 @@
         "\n",
         "Many popular transformations use time-dependent components, e.g. to anneal some hyper-parameter (e.g. the learning rate). Optax provides for this purpose schedules that can be used to decay scalars as a function of a `step` count.\n",
         "\n",
-        "For example, you may use a {py:class}`polynomial_schedule \u003coptax.polynomial_schedule\u003e` (with `power=1`) to decay a hyper-parameter linearly over a number of steps:"
+        "For example, you may use a {py:class}`polynomial_schedule <optax.polynomial_schedule>` (with `power=1`) to decay a hyper-parameter linearly over a number of steps:"
       ]
     },
     {
@@ -655,7 +655,7 @@
       "source": [
         "schedule_fn = optax.polynomial_schedule(\n",
         "    init_value=-learning_rate, end_value=0., power=1, transition_steps=5)\n",
-        "optimiser = optax.chain(\n",
+        "optimizer = optax.chain(\n",
         "    optax.clip_by_global_norm(max_norm),\n",
         "    optax.scale_by_adam(eps=1e-4),\n",
         "    optax.scale_by_schedule(schedule_fn))"
@@ -668,7 +668,7 @@
       },
       "source": [
         "Schedules can also be used in place of the `learning_rate` argument of a\n",
-        "{py:class}`GradientTransformation \u003coptax.GradientTransformation\u003e` as\n"
+        "{py:class}`GradientTransformation <optax.GradientTransformation>` as\n"
       ]
     },
     {
@@ -679,7 +679,7 @@
       },
       "outputs": [],
       "source": [
-        "optimiser = optax.adam(learning_rate=schedule_fn)"
+        "optimizer = optax.adam(learning_rate=schedule_fn)"
       ]
     },
     {
@@ -688,9 +688,9 @@
         "id": "cKHZrM203kx4"
       },
       "source": [
-        "### Popular optimisers ([alias.py](https://github.com/google-deepmind/optax/blob/main/optax/_src/alias.py))\n",
+        "### Popular optimizers ([alias.py](https://github.com/google-deepmind/optax/blob/main/optax/_src/alias.py))\n",
         "\n",
-        "In addition to the low-level building blocks, we also provide aliases for popular optimisers built using these components (e.g. RMSProp, Adam, AdamW, etc, ...). These are all still instances of a {py:class}`GradientTransformation \u003coptax.GradientTransformation\u003e`, and can therefore be further combined with any of the individual building blocks.\n",
+        "In addition to the low-level building blocks, we also provide aliases for popular optimizers built using these components (e.g. RMSProp, Adam, AdamW, etc, ...). These are all still instances of a {py:class}`GradientTransformation <optax.GradientTransformation>`, and can therefore be further combined with any of the individual building blocks.\n",
         "\n",
         "For example:"
       ]
@@ -717,9 +717,9 @@
       "source": [
         "### Applying updates ([update.py](https://github.com/google-deepmind/optax/blob/main/optax/_src/update.py))\n",
         "\n",
-        "After transforming an update using a {py:class}`GradientTransformation \u003coptax.GradientTransformation\u003e` or any custom manipulation of the update, you will typically apply the update to a set of parameters. This can be done trivially using `jax.tree.map`.\n",
+        "After transforming an update using a {py:class}`GradientTransformation <optax.GradientTransformation>` or any custom manipulation of the update, you will typically apply the update to a set of parameters. This can be done trivially using `jax.tree.map`.\n",
         "\n",
-        "For convenience, we expose an {py:class}`apply_updates \u003coptax.apply_updates\u003e` function to apply updates to parameters. The function just adds the updates and the parameters together, i.e. `jax.tree.map(lambda p, u: p + u, params, updates)`."
+        "For convenience, we expose an {py:class}`apply_updates <optax.apply_updates>` function to apply updates to parameters. The function just adds the updates and the parameters together, i.e. `jax.tree.map(lambda p, u: p + u, params, updates)`."
       ]
     },
     {
@@ -730,7 +730,7 @@
       },
       "outputs": [],
       "source": [
-        "updates, state = tx.update(grads, state, params)  # transform \u0026 update stats.\n",
+        "updates, state = tx.update(grads, state, params)  # transform & update stats.\n",
         "new_params = optax.apply_updates(params, updates)  # update the parameters."
       ]
     },
@@ -740,7 +740,7 @@
         "id": "eg85y6_s4C2c"
       },
       "source": [
-        "Note that separating gradient transformations from the parameter update is critical to support composing a sequence of transformations (e.g. {py:class}`chain \u003coptax.chain\u003e`), as well as combining multiple updates to the same parameters (e.g. in multi-task settings where different tasks need different sets of gradient transformations)."
+        "Note that separating gradient transformations from the parameter update is critical to support composing a sequence of transformations (e.g. {py:class}`chain <optax.chain>`), as well as combining multiple updates to the same parameters (e.g. in multi-task settings where different tasks need different sets of gradient transformations)."
       ]
     },
     {
@@ -751,7 +751,7 @@
       "source": [
         "### Losses ([loss.py](https://github.com/google-deepmind/optax/tree/main/optax/losses))\n",
         "\n",
-        "Optax provides a number of standard losses used in deep learning, such as {py:class}`l2_loss \u003coptax.l2_loss\u003e`, {py:class}`softmax_cross_entropy \u003coptax.softmax_cross_entropy\u003e`, {py:class}`cosine_distance \u003coptax.cosine_distance\u003e`, etc."
+        "Optax provides a number of standard losses used in deep learning, such as {py:class}`l2_loss <optax.l2_loss>`, {py:class}`softmax_cross_entropy <optax.softmax_cross_entropy>`, {py:class}`cosine_distance <optax.cosine_distance>`, etc."
       ]
     },
     {
diff --git a/docs/index.rst b/docs/index.rst
index fe0e296d..8c9c3d27 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -6,19 +6,19 @@ Optax
 
 Optax is a gradient processing and optimization library for JAX. It is designed
 to facilitate research by providing building blocks that can be recombined in
-custom ways in order to optimise parametric models such as, but not limited to,
+custom ways in order to optimize parametric models such as, but not limited to,
 deep neural networks.
 
 Our goals are to
 
 *   Provide readable, well-tested, efficient implementations of core components,
 *   Improve researcher productivity by making it possible to combine low level
-    ingredients into custom optimiser (or other gradient processing components).
+    ingredients into custom optimizer (or other gradient processing components).
 *   Accelerate adoption of new ideas by making it easy for anyone to contribute.
 
-We favour focusing on small composable building blocks that can be effectively
+We favor focusing on small composable building blocks that can be effectively
 combined into custom solutions. Others may build upon these basic components
-more complicated abstractions. Whenever reasonable, implementations prioritise
+more complicated abstractions. Whenever reasonable, implementations prioritize
 readability and structuring code to match standard equations, over code reuse.
 
 Installation
diff --git a/examples/contrib/sam.ipynb b/examples/contrib/sam.ipynb
index c67e8e93..b1a21c65 100644
--- a/examples/contrib/sam.ipynb
+++ b/examples/contrib/sam.ipynb
@@ -70,7 +70,7 @@
         "id": "7-p_W8vkhnO1"
       },
       "source": [
-        "To actually use SAM then, you create your adversarial optimizer, here SGD with normalized gradients, an outer optimzer, and then wrap them with SAM.\n",
+        "To actually use SAM then, you create your adversarial optimizer, here SGD with normalized gradients, an outer optimizer, and then wrap them with SAM.\n",
         "\n",
         "The drop-in SAM optimizer described in the paper uses SGD for both optimizers."
       ]
@@ -648,7 +648,7 @@
         "id": "NLAJFJ-SjmIK"
       },
       "source": [
-        "The behavior is identical to transparent mode, but the percieved number of gradient steps is half as many as in transparent mode (or 1/5 as many for SAM Adam)."
+        "The behavior is identical to transparent mode, but the perceived number of gradient steps is half as many as in transparent mode (or 1/5 as many for SAM Adam)."
       ]
     },
     {
diff --git a/examples/flax_example.ipynb b/examples/flax_example.ipynb
index b805f0f6..3246342b 100644
--- a/examples/flax_example.ipynb
+++ b/examples/flax_example.ipynb
@@ -146,7 +146,7 @@
         "    def squared_error(x, y):\n",
         "      pred = model.apply(params, x)\n",
         "      return jnp.inner(y-pred, y-pred) / 2.0\n",
-        "    # Vectorises the squared error and computes mean over the loss values.\n",
+        "    # Vectorizes the squared error and computes mean over the loss values.\n",
         "    return jnp.mean(jax.vmap(squared_error)(x_batched, y_batched), axis=0)\n",
         "  return jax.jit(mse)  # `jit`s the result.\n",
         "\n",
@@ -163,9 +163,9 @@
         "id": "8-Lm815FrcDD"
       },
       "source": [
-        "In the next cell, we construct a simple Adam optimiser using Optax gradient transformations passed to the `optax.chain`.\n",
+        "In the next cell, we construct a simple Adam optimizer using Optax gradient transformations passed to the `optax.chain`.\n",
         "\n",
-        "The same result can be achieved by using the `optax.adam` alias. However, here, we demonstrate how to work with gradient transformations manually so that you can build your own custom optimiser if needed."
+        "The same result can be achieved by using the `optax.adam` alias. However, here, we demonstrate how to work with gradient transformations manually so that you can build your own custom optimizer if needed."
       ]
     },
     {
@@ -179,7 +179,7 @@
         "tx = optax.chain(\n",
         "    # Sets the parameters of Adam. Note the learning_rate is not here.\n",
         "    optax.scale_by_adam(b1=0.9, b2=0.999, eps=1e-8),\n",
-        "    # Puts a minus sign to *minimise* the loss.\n",
+        "    # Puts a minus sign to *minimize* the loss.\n",
         "    optax.scale(-LEARNING_RATE)\n",
         ")"
       ]
@@ -190,7 +190,7 @@
         "id": "dZhCXZC0qpV1"
       },
       "source": [
-        "We then pass the initial parameters of the model to the optimiser to initialize it."
+        "We then pass the initial parameters of the model to the optimizer to initialize it."
       ]
     },
     {
@@ -223,12 +223,12 @@
       "source": [
         "loss_history = []\n",
         "\n",
-        "# Minimises the loss.\n",
+        "# Minimizes the loss.\n",
         "for _ in range(NUM_STEPS):\n",
         "  # Computes gradient of the loss.\n",
         "  loss_val, grads = loss_grad_fn(params)\n",
         "  loss_history.append(loss_val)\n",
-        "  # Updates the optimiser state, creates an update to the params.\n",
+        "  # Updates the optimizer state, creates an update to the params.\n",
         "  updates, opt_state = tx.update(grads, opt_state)\n",
         "  # Updates the parameters.\n",
         "  params = optax.apply_updates(params, updates)"
@@ -257,9 +257,9 @@
       "outputs": [
         {
           "data": {
-            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvwAAAIqCAYAAABYP569AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90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\n",
+            "image/png": "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",
             "text/plain": [
-              "\u003cFigure size 600x400 with 1 Axes\u003e"
+              "<Figure size 600x400 with 1 Axes>"
             ]
           },
           "metadata": {
@@ -284,6 +284,9 @@
     "colab": {
       "collapsed_sections": [],
       "provenance": []
+    },
+    "language_info": {
+      "name": "python"
     }
   },
   "nbformat": 4,
diff --git a/examples/lbfgs.ipynb b/examples/lbfgs.ipynb
index 76073de7..57fa2583 100644
--- a/examples/lbfgs.ipynb
+++ b/examples/lbfgs.ipynb
@@ -8,7 +8,7 @@
       "source": [
         "# L-BFGS\n",
         "\n",
-        "L-BFGS is a classical optimization method that uses past gradients and parameters informations to iteratively refine a solution to a minimization problem. In this notebook, we illustrate\n",
+        "L-BFGS is a classical optimization method that uses past gradients and parameters information to iteratively refine a solution to a minimization problem. In this notebook, we illustrate\n",
         "1. how to use L-BFGS as a simple gradient transformation,\n",
         "2. how to wrap L-BFGS in a solver, and how linesearches are incorporated,\n",
         "3. how to debug the solver if needed,\n"
@@ -123,7 +123,7 @@
       "source": [
         "## L-BFGS as a solver\n",
         "\n",
-        "L-BFGS is a stample in numerical optimization to solve medium scale problems. It is often the backend of generic minimization functions in software libraries like [scipy](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize). A key ingredient to make it a simple optimization blackbox, is to remove the need of tuning the stepsize, a.k.a. learning rate in machine learning. In a deterministic setting (no additional varying inputs like inputs/labels), such automatic tuning of the stepsize is done by means of linesearches reviewed below."
+        "L-BFGS is a sample in numerical optimization to solve medium scale problems. It is often the backend of generic minimization functions in software libraries like [scipy](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize). A key ingredient to make it a simple optimization blackbox, is to remove the need of tuning the stepsize, a.k.a. learning rate in machine learning. In a deterministic setting (no additional varying inputs like inputs/labels), such automatic tuning of the stepsize is done by means of linesearches reviewed below."
       ]
     },
     {
@@ -146,7 +146,7 @@
         "\n",
         "where $c_1$ is some constant set to $10^{-4}$ by default. Consider for example the update direction to be $u_k = -g_k$, i.e., moving along the negative gradient direction. In that case the criterion above reduces to $f(w_k - \\eta_k g_k) \\leq f(w_k) - c_1 \\eta_k ||g_k||_2^2$. The criterion amounts then to choosing the stepsize such that it decreases the objective by an amount proportional to the squared gradient norm.\n",
         "\n",
-        "As long as the update direction is a *descent direction*, that is, $\\langle u_k, g_k\\rangle \u003c 0$ the above criterion is guaranteed to be satisfied by some sufficiently small stepsize.\n",
+        "As long as the update direction is a *descent direction*, that is, $\\langle u_k, g_k\\rangle < 0$ the above criterion is guaranteed to be satisfied by some sufficiently small stepsize.\n",
         "A simple linesearch technique to ensure a sufficient decrease is then to decrease a candidate stepsize by a constant factor up until the criterion is satisfied. This amounts to the backtracking linesearch implemented in [optax.scale_by_backtracking_linesearch](https://optax.readthedocs.io/en/latest/api/transformations.html#optax.scale_by_backtracking_linesearch) and briefly reviewed below.\n",
         "\n",
         "#### Small curvature (Strong wolfe criterion)\n",
@@ -303,7 +303,7 @@
         "    iter_num = otu.tree_get(state, 'count')\n",
         "    grad = otu.tree_get(state, 'grad')\n",
         "    err = otu.tree_l2_norm(grad)\n",
-        "    return (iter_num == 0) | ((iter_num \u003c max_iter) \u0026 (err \u003e= tol))\n",
+        "    return (iter_num == 0) | ((iter_num < max_iter) & (err >= tol))\n",
         "\n",
         "  init_carry = (init_params, opt.init(init_params))\n",
         "  final_params, final_state = jax.lax.while_loop(\n",
diff --git a/examples/meta_learning.ipynb b/examples/meta_learning.ipynb
index 8df9648c..a67ee464 100644
--- a/examples/meta_learning.ipynb
+++ b/examples/meta_learning.ipynb
@@ -34,7 +34,7 @@
         "bounded between 0 and 1, we parametrize the learning rate as a sigmoid\n",
         "over the meta parameter $\\eta$.\n",
         "\n",
-        "In the following snippts, we will solve the problem using optax. To begin with, we define a generator that samples from the hidden underlying distribution."
+        "In the following snippets, we will solve the problem using optax. To begin with, we define a generator that samples from the hidden underlying distribution."
       ]
     },
     {
@@ -63,7 +63,7 @@
       },
       "outputs": [],
       "source": [
-        "def generator() -\u003e Iterator[Tuple[chex.Array, chex.Array]]:\n",
+        "def generator() -> Iterator[Tuple[chex.Array, chex.Array]]:\n",
         "  rng = jax.random.PRNGKey(0)\n",
         "\n",
         "  while True:\n",
@@ -114,7 +114,7 @@
       },
       "outputs": [],
       "source": [
-        "def f(theta: chex.Array, x: chex.Array) -\u003e chex.Array:\n",
+        "def f(theta: chex.Array, x: chex.Array) -> chex.Array:\n",
         "  return x * theta\n",
         "\n",
         "theta = jax.random.normal(jax.random.PRNGKey(42))"
diff --git a/examples/nanolm.ipynb b/examples/nanolm.ipynb
index 8c2e248c..b098b69c 100644
--- a/examples/nanolm.ipynb
+++ b/examples/nanolm.ipynb
@@ -31,16 +31,16 @@
       "cell_type": "code",
       "execution_count": null,
       "metadata": {
-        "id": "jIabArrRWFw0",
-        "outputId": "75c89cb3-35ca-4217-a8e0-4b45f9efe31f",
         "colab": {
           "base_uri": "https://localhost:8080/"
-        }
+        },
+        "id": "jIabArrRWFw0",
+        "outputId": "75c89cb3-35ca-4217-a8e0-4b45f9efe31f"
       },
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
             "JAX running on GPU\n"
           ]
@@ -88,7 +88,7 @@
         "LEARNING_RATE = 5e-3 # @param{type:\"number\"}\n",
         "# @markdown Batch size:\n",
         "BATCH_SIZE = 128  # @param{type:\"integer\"}\n",
-        "# @markdown Numer of training iterations:\n",
+        "# @markdown Number of training iterations:\n",
         "N_ITERATIONS = 50_000  # @param{type:\"integer\"}\n",
         "# @markdown Number of training iterations between two consecutive evaluations:\n",
         "N_FREQ_EVAL = 2_000 # @param{type:\"integer\"}\n",
@@ -131,16 +131,16 @@
       "cell_type": "code",
       "execution_count": null,
       "metadata": {
-        "id": "USiJ0GjWSPu_",
-        "outputId": "bd033bb3-1c6a-4dc4-a1e3-b38a04dd43c0",
         "colab": {
           "base_uri": "https://localhost:8080/"
-        }
+        },
+        "id": "USiJ0GjWSPu_",
+        "outputId": "bd033bb3-1c6a-4dc4-a1e3-b38a04dd43c0"
       },
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
             "Length of text for training: 1_059_624 characters\n",
             "Length of text for validation: 55_770 characters\n"
@@ -156,16 +156,16 @@
       "cell_type": "code",
       "execution_count": null,
       "metadata": {
-        "id": "wOq-djQ9cueI",
-        "outputId": "8d639dad-b1df-4536-8f74-bed86a869201",
         "colab": {
           "base_uri": "https://localhost:8080/"
-        }
+        },
+        "id": "wOq-djQ9cueI",
+        "outputId": "8d639dad-b1df-4536-8f74-bed86a869201"
       },
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
             "First Citizen:\n",
             "Before we proceed any further, hear me speak.\n",
@@ -235,19 +235,19 @@
       "cell_type": "code",
       "execution_count": null,
       "metadata": {
-        "id": "rESkNoDXFE-4",
-        "outputId": "42579042-716c-4101-cf08-14ebefa6c984",
         "colab": {
           "base_uri": "https://localhost:8080/"
-        }
+        },
+        "id": "rESkNoDXFE-4",
+        "outputId": "42579042-716c-4101-cf08-14ebefa6c984"
       },
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
             "Vocabulary:,  \n",
-            " !$\u0026',-.3:;?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n",
+            " !$&',-.3:;?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n",
             "Length of vocabulary:  65\n"
           ]
         }
@@ -473,23 +473,23 @@
         "id": "kgSjWONs4eFp"
       },
       "source": [
-        "We've now instatiated a NanoLM model with the following number of parameters"
+        "We've now instantiated a NanoLM model with the following number of parameters"
       ]
     },
     {
       "cell_type": "code",
       "execution_count": null,
       "metadata": {
-        "id": "9Ckqdkd6QVsl",
-        "outputId": "2c202753-b938-4148-992c-cc63077be607",
         "colab": {
           "base_uri": "https://localhost:8080/"
-        }
+        },
+        "id": "9Ckqdkd6QVsl",
+        "outputId": "2c202753-b938-4148-992c-cc63077be607"
       },
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
             "Total number of parameters: 3_408_513\n"
           ]
@@ -543,8 +543,8 @@
       },
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
             "Step: 0\t train loss: 4.586461067199707\t eval loss: 6.037547588348389\n",
             "Step: 2000\t train loss: 1.3876519203186035\t eval loss: 1.4252502918243408\n",
@@ -618,14 +618,14 @@
       },
       "outputs": [
         {
-          "output_type": "display_data",
           "data": {
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHHCAYAAACRAnNyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABg/ElEQVR4nO3dd3hUxcIG8PdsTd30QgoJJJAQCL0YkaI0ARHUq4iogP2KnyK2q9cCooJ4RbGhiIJy5WKjqYAGIRSld5BOKNJCgGRTN5vd+f5Yssm2ZBO2Bd7f8+yTnLOz58xOEvZlZs4cSQghQEREROSDZN6uABEREZEjDCpERETksxhUiIiIyGcxqBAREZHPYlAhIiIin8WgQkRERD6LQYWIiIh8FoMKERER+SwGFSIiIvJZDCpE5HLLly9H+/bt4efnB0mSUFBQ4JbzzJkzB5Ik4dixY245vqc9/vjj6Nevn8fON3r0aCQnJ7vseDk5OZAkCTk5OS47Zn1cuHABgYGBWLp0qVfOT+7BoEIeceTIETz66KNo3rw5/Pz8oNFo0L17d0yfPh1lZWXerh650IULF3DXXXfB398fH3/8MebOnYvAwEBvV8vn5ebmYtasWXjppZfM+06fPo0JEyZgx44d3qtYIxIREYGHHnoIr7zyirerQi6k8HYF6Or3yy+/4M4774Rarcb999+PNm3aoKKiAuvWrcNzzz2HvXv3YubMmd6uJrnI5s2bUVRUhEmTJqFv377erk6jMX36dDRr1gw33nijed/p06cxceJEJCcno3379i4/5+effw6j0ejy43rTY489hg8++AArV67ETTfd5O3qkAswqJBb5ebm4u6770ZSUhJWrlyJJk2amJ8bO3YsDh8+jF9++cWLNbxy5eXlUKlUkMnYQQkAeXl5AIDQ0FDvVqQR0ev1+Oabb/DYY49d0XFKS0sREBDgdHmlUnlF5/NFrVq1Qps2bTBnzhwGlasE/2Ult5o6dSqKi4vxxRdfWISUKqmpqXjqqafM25WVlZg0aRJSUlKgVquRnJyMl156CTqdzuJ1ycnJuOWWW7Bu3Tp07doVfn5+aN68Ob7++mtzmS1btkCSJHz11Vc25/31118hSRJ+/vln875Tp07hgQceQExMDNRqNVq3bo0vv/zS4nVVY/Dz58/Hyy+/jPj4eAQEBECr1QIAvv/+e2RkZMDPzw9t2rTBwoUL7c4DMBqNeP/999G6dWv4+fkhJiYGjz76KC5dulTv91mloKAATz/9NJKTk6FWq5GQkID7778f+fn55jI6nQ6vvfYaUlNToVarkZiYiOeff96mfR35/vvv0alTJ/j7+yMyMhL33nsvTp06ZX6+d+/eGDVqFACgS5cukCQJo0ePdni848eP4/HHH0daWhr8/f0RERGBO++80+6ck7179+Kmm26Cv78/EhIS8MYbb9jtDVi8eDEGDx6MuLg4qNVqpKSkYNKkSTAYDBblevfujTZt2mDXrl3o1asXAgICkJqaih9++AEAsHr1anTr1g3+/v5IS0vDihUrzK/dtWsXJEnCkiVLzPu2bt0KSZLQsWNHi/MMHDgQ3bp1c9yoANatW4f8/HyLHqicnBx06dIFADBmzBhIkgRJkjBnzhyL+m/duhU9e/ZEQECAedjI2Taw/t08duwYJEnCf/7zH8ycOdP8d9ilSxds3ry51vdQm7p+bwDg7NmzGDNmDBISEqBWq9GkSRMMHTrU4ndhy5YtGDBgACIjI+Hv749mzZrhgQcesDlfv3798NNPP0EI0eA6kw8RRG4UHx8vmjdv7nT5UaNGCQDiH//4h/j444/F/fffLwCIYcOGWZRLSkoSaWlpIiYmRrz00kvio48+Eh07dhSSJIk9e/aYyzVv3lwMGjTI5jxjxowRYWFhoqKiQgghxNmzZ0VCQoJITEwUr7/+upgxY4a49dZbBQDx3nvvmV+3atUqAUBkZGSI9u3bi2nTponJkyeLkpIS8fPPPwtJkkTbtm3FtGnTxCuvvCLCwsJEmzZtRFJSksX5H3roIaFQKMTDDz8sPv30U/HCCy+IwMBA0aVLF3Od6vM+i4qKRJs2bYRcLhcPP/ywmDFjhpg0aZLo0qWL2L59uxBCCIPBIPr37y8CAgLEuHHjxGeffSaeeOIJoVAoxNChQ+v82cyePVsAEF26dBHvvfee+Ne//iX8/f1FcnKyuHTpkhBCiN9++0088sgjAoB4/fXXxdy5c8Wff/7p8Jjff/+9aNeunXj11VfFzJkzxUsvvSTCwsJEUlKSKCkpMZc7c+aMiIqKEmFhYWLChAninXfeES1atBBt27YVAERubq657LBhw8Rdd90l3nnnHTFjxgxx5513CgDi2WeftTh3r169RFxcnEhMTBTPPfec+PDDD0VGRoaQy+Vi/vz5IjY2VkyYMEG8//77Ij4+XoSEhAitVmtuy9DQUPHMM8+Yj/fee+8JmUwmZDKZKCwsNJfTaDQ257b2xhtvCEmSzK8TwvQ7+frrrwsA4pFHHhFz584Vc+fOFUeOHDHXPzY2VkRFRYn/+7//E5999plYtGhRvdpg1KhRFr+bubm5AoDo0KGDSE1NFW+//baYOnWqiIyMFAkJCRa/m/ZU/X2sWrXKvM+Z3xshhLj++utFSEiIePnll8WsWbPEW2+9JW688UaxevVqIYQQ586dE2FhYaJly5binXfeEZ9//rn497//LVq1amVTj//+978CgNi9e3et9aXGgUGF3KawsFAAcOpDUAghduzYIQCIhx56yGL/s88+KwCIlStXmvclJSUJAGLNmjXmfXl5eUKtVlt8eLz44otCqVSKixcvmvfpdDoRGhoqHnjgAfO+Bx98UDRp0kTk5+dbnPvuu+8WISEhorS0VAhR/Q9x8+bNzfuqZGZmioSEBFFUVGTel5OTIwBYfBisXbtWABDffPONxeuXL19us9/Z9/nqq68KAGLBggXCmtFoFEIIMXfuXCGTycTatWstnv/0008FAPHHH3/YvLZKRUWFiI6OFm3atBFlZWXm/T///LMAIF599VXzvqoPps2bNzs8XhXrNhRCiPXr1wsA4uuvvzbvGzdunAAgNm7caN6Xl5cnQkJCbIKKvWM++uijIiAgQJSXl5v39erVSwAQ8+bNM+/bv3+/ACBkMpnYsGGDef+vv/4qAIjZs2eb9w0ePFh07drVvH377beL22+/XcjlcrFs2TIhhBDbtm0TAMTixYtrbYd7771XRERE2OzfvHmzzXmt6//pp5/aPOdsGzgKKhERERZ/M4sXLxYAxE8//VTr+7AOKs7+3ly6dEkAEO+8847DYy9cuNDp36s///xTABDffvttnWXJ93Hoh9ymajgkODjYqfJVlxSOHz/eYv8zzzwDADZzWTIyMtCjRw/zdlRUFNLS0nD06FHzvuHDh0Ov12PBggXmfb/99hsKCgowfPhwAIAQAj/++COGDBkCIQTy8/PNjwEDBqCwsBDbtm2zOPeoUaPg7+9v3j59+jR2796N+++/H0FBQeb9vXr1QmZmpsVrv//+e4SEhKBfv34W5+rUqROCgoKwatWqer/PH3/8Ee3atcNtt91m066SJJnP26pVK6Snp1uct2oc3/q8NW3ZsgV5eXl4/PHH4efnZ94/ePBgpKenN3ieUc021Ov1uHDhAlJTUxEaGmrR5kuXLsV1112Hrl27mvdFRUVh5MiRtR6zqKgI+fn56NGjB0pLS7F//36LskFBQbj77rvN22lpaQgNDUWrVq0shmuqvq/Z5j169MC2bdtQUlICwDR8M2jQILRv3x5r164FAKxduxaSJOGGG26otR0uXLiAsLCwWsvYo1arMWbMGJv99WkDe4YPH25Rn6rfv5rv3xnO/t74+/tDpVIhJyfHZvizStWcp59//hl6vb7W81bVveawJzVeDCrkNhqNBoDpH0pnHD9+HDKZDKmpqRb7Y2NjERoaiuPHj1vsb9q0qc0xwsLCLP6ha9euHdLT0/Htt9+a93377beIjIw0f0CfP38eBQUFmDlzJqKioiweVR8CVRNEqzRr1sym7gBs6m5v36FDh1BYWIjo6Gib8xUXF9ucy5n3eeTIEbRp08amnPV59+7da3POli1b2n2P9t5fWlqazXPp6ek2PxtnlZWV4dVXX0ViYiLUajUiIyMRFRWFgoICFBYWWpy/RYsWNq+3V5+9e/fitttuQ0hICDQaDaKionDvvfcCgMUxASAhIcEc5KqEhIQgMTHRZh8Aizbv0aMHKisrsX79ehw4cAB5eXno0aMHevbsaRFUMjIyEB4eXmdbiAbMp4iPj4dKpbLZX582sMf6d67qg99RiHDE2d8btVqNt99+G8uWLUNMTAx69uyJqVOn4uzZs+byvXr1wh133IGJEyciMjISQ4cOxezZs+3Or6pqS+ufLTVOvOqH3Eaj0SAuLg579uyp1+uc/cdFLpfb3W/9D/7w4cPx5ptvIj8/H8HBwViyZAlGjBgBhcL06181IfPee+81TwS11rZtW4vtmv9jrS+j0Yjo6Gh88803dp+Pioqy2Hb2fTpz3szMTEybNs3u89Yfzp7wf//3f5g9ezbGjRuHrKwshISEQJIk3H333Q26bLagoAC9evWCRqPB66+/jpSUFPj5+WHbtm144YUXbI7pqG2dafPOnTvDz88Pa9asQdOmTREdHY2WLVuiR48e+OSTT6DT6bB27Vq7vVzWIiIi6h0CAPu/h/VtA3tc9TtXH+PGjcOQIUOwaNEi/Prrr3jllVcwefJkrFy5Eh06dIAkSfjhhx+wYcMG/PTTT/j111/xwAMP4N1338WGDRssejKr2jIyMtJt9SXPYVAht7rlllswc+ZMrF+/HllZWbWWTUpKgtFoxKFDh9CqVSvz/nPnzqGgoABJSUkNqsPw4cMxceJE/Pjjj4iJiYFWq7Xo7o+KikJwcDAMBkOD1/2oqtvhw4dtnrPel5KSghUrVqB79+5XFHisj1lXIExJScHOnTvRp0+fev9Ps+r9HThwwOaSzwMHDjT4Z/PDDz9g1KhRePfdd837ysvLbVayTUpKwqFDh2xef+DAAYvtnJwcXLhwAQsWLEDPnj3N+3NzcxtUv9qoVCp07doVa9euRdOmTc3DIz169IBOp8M333yDc+fOWdTDkfT0dHzzzTcoLCw0994ADesR8GQb1KW+vzcpKSl45pln8Mwzz+DQoUNo37493n33Xfz3v/81l7nuuutw3XXX4c0338S8efMwcuRIzJ8/Hw899JC5TNV7rfnvCDVeHPoht3r++ecRGBiIhx56COfOnbN5/siRI5g+fToAYNCgQQCA999/36JMVQ/A4MGDG1SHVq1aITMzE99++y2+/fZbNGnSxOIfcLlcjjvuuAM//vij3Q/78+fP13mOuLg4tGnTBl9//TWKi4vN+1evXo3du3dblL3rrrtgMBgwadIkm+NUVlY2aLn5O+64Azt37sTChQttnqv6X/Bdd92FU6dO4fPPP7cpU1ZWZp5rYU/nzp0RHR2NTz/91KKrfdmyZdi3b1+DfzZyudzmf+kffvihzWW0gwYNwoYNG7Bp0ybzvvPnz9v0SlX1BNQ8ZkVFBT755JMG1a8uPXr0wMaNG7Fq1SpzUImMjESrVq3w9ttvm8vUJSsrC0IIbN261WJ/1Yq+9fmd8HQb1MbZ35vS0lKUl5dbvDYlJQXBwcHm1126dMnmd6VqETzr4Z+tW7ciJCQErVu3dvVbIi9gjwq5VUpKCubNm4fhw4ejVatWFivT/vnnn/j+++/N62y0a9cOo0aNwsyZM83d15s2bcJXX32FYcOGWazYWV/Dhw/Hq6++Cj8/Pzz44IM2i7NNmTIFq1atQrdu3fDwww8jIyMDFy9exLZt27BixQpcvHixznO89dZbGDp0KLp3744xY8bg0qVL+Oijj9CmTRuL8NKrVy88+uijmDx5Mnbs2IH+/ftDqVTi0KFD+P777zF9+nT84x//qNf7e+655/DDDz/gzjvvxAMPPIBOnTrh4sWLWLJkCT799FO0a9cO9913H7777js89thjWLVqFbp37w6DwYD9+/fju+++w6+//orOnTvbPb5SqcTbb7+NMWPGoFevXhgxYgTOnTuH6dOnIzk5GU8//XS96lvllltuwdy5cxESEoKMjAysX78eK1asQEREhEW5559/HnPnzsXNN9+Mp556CoGBgZg5cyaSkpKwa9cuc7nrr78eYWFhGDVqFJ588klIkoS5c+e6bciiR48eePPNN3Hy5EmLQNKzZ0989tlnSE5ORkJCQp3HueGGGxAREYEVK1ZY9DykpKQgNDQUn376KYKDgxEYGIhu3brZzJGqydNtUBtnf28OHjyIPn364K677kJGRgYUCgUWLlyIc+fOmXs/v/rqK3zyySe47bbbkJKSgqKiInz++efQaDTm/+RUyc7OxpAhQzhH5Wrh+QuN6Fp08OBB8fDDD4vk5GShUqlEcHCw6N69u/jwww8tLpfU6/Vi4sSJolmzZkKpVIrExETx4osvWpQRwnTZ7uDBg23O06tXL9GrVy+b/YcOHRIABACxbt06u3U8d+6cGDt2rEhMTBRKpVLExsaKPn36iJkzZ5rLVF1++f3339s9xvz580V6erpQq9WiTZs2YsmSJeKOO+4Q6enpNmVnzpwpOnXqJPz9/UVwcLDIzMwUzz//vDh9+nSD3ueFCxfEE088IeLj44VKpRIJCQli1KhRFpdcV1RUiLffflu0bt1aqNVqERYWJjp16iQmTpxosYaHI99++63o0KGDUKvVIjw8XIwcOVL8/fffFmXqc3nypUuXxJgxY0RkZKQICgoSAwYMEPv37xdJSUli1KhRFmV37dolevXqJfz8/ER8fLyYNGmS+OKLL2wuT/7jjz/EddddJ/z9/UVcXJx4/vnnzZcX11zfo1evXqJ169Y2dXLU5gDE2LFjLfZptVohl8tFcHCwqKysNO+vWsfjvvvuq7MNqjz55JMiNTXVZv/ixYtFRkaGUCgUFpcqO6q/EM63gaPLk+1dJgxAvPbaa7W+B3vrqAhR9+9Nfn6+GDt2rEhPTxeBgYEiJCREdOvWTXz33XfmMtu2bRMjRowQTZs2FWq1WkRHR4tbbrlFbNmyxeJc+/btEwDEihUraq0rNR6SEFy6j8id2rdvj6ioKGRnZ3u7KuTDjh49ivT0dCxbtgx9+vTxdnUarXHjxmHNmjXmlYKp8eMcFSIX0ev1qKystNiXk5ODnTt3onfv3t6pFDUazZs3x4MPPogpU6Z4uyqN1oULFzBr1iy88cYbDClXEfaoELnIsWPH0LdvX9x7772Ii4vD/v378emnnyIkJAR79uyxmXdBRER142RaIhcJCwtDp06dMGvWLJw/fx6BgYEYPHgwpkyZwpBCRNRA7FEhIiIin8U5KkREROSzGFSIiIjIZzXqOSpGoxGnT59GcHAwZ3gTERE1EkIIFBUVIS4uzmYBTmuNOqicPn3aKzdSIyIioit38uTJOldvbtRBJTg4GIDpjWo0GpceW6/X47fffjMvb07uwXb2DLazZ7CdPYPt7DnuamutVovExETz53htGnVQqRru0Wg0bgkqAQEB0Gg0/ENwI7azZ7CdPYPt7BlsZ89xd1s7M22Dk2mJiIjIZzGoEBERkc9iUCEiIiKfxaBCREREPotBhYiIiHwWgwoRERH5LAYVIiIi8lkMKkREROSzGFSIiIjIZzGoEBERkc9iUCEiIiIbycnJ+OCDD7xdDQYVG5U6oOgskH8IYSVHgLy/vF0jIiIip/Tu3Rvjxo1zybE2b96Mhx56yCXHuhJeDyqnTp3Cvffei4iICPj7+yMzMxNbtmzxXoX+/BB4Nw3Kz7LQ8+BEyFe94b26EBERuZAQApWVlU6VjYqKQkBAgJtrVDevBpVLly6he/fuUCqVWLZsGf766y+8++67CAsL816l/EIst3Va79SDiIi8zmgUuFCs8+rDaBRO1XX06NFYvXo1pk+fDkmSIEkS5syZA0mSsGzZMnTq1AlqtRrr1q3DkSNHMHToUMTExCAoKAhdunTBihUrLI5nPfQjSRJmzZqF2267DQEBAWjRogWWLFni0va2R+H2M9Ti7bffRmJiImbPnm3e16xZMy/WCDZBRdIVeakiRETkbZdKK9DpjRV1F3SjrS/3RUSQus5y06dPx8GDB9GmTRu8/vrrAIC9e/cCAP71r3/hP//5D5o3b46wsDCcPHkSgwYNwptvvgm1Wo2vv/4aQ4YMwYEDB9C0aVOH55g4cSKmTp2Kd955Bx9++CFGjhyJ48ePIzw83DVv1g6vBpUlS5ZgwIABuPPOO7F69WrEx8fj8ccfx8MPP2y3vE6ng06nM29rtabeDr1eD71e75I6SYoAi0YxlhXC6KJjk62qn5urfn5kH9vZM9jOnuHJdtY7OUzi7jro9XUPgAQEBECpVMLPzw8REREATEM9APDqq6+id+/e5rIZGRnIyMgwb7/66qtYsGABFi5ciMcff9y832AwmOpwua3vu+8+/OMf/wBgCi0ffPAB/vzzTwwYMKB+76kePzuvBpWjR49ixowZGD9+PF566SVs3rwZTz75JFQqFUaNGmVTfvLkyZg4caLN/t9++81l42jyiwdwS41tXfFFZC9d6pJjk2PZ2dnersI1ge3sGWxnz/BEOxfrAS9/VOL3FSsQpHSu7IULF5Cbm4ullz+3du/eDQAoLCw07wOAsrIyzJ8/H1u3bsXFixdhNBpRUVGBnJwcJCcnAwBKS0tx4MABpKWlmdu6srLS4jgBAQFYsWKFOdA4q7S01OmyXm19o9GIzp0746233gIAdOjQAXv27MGnn35qN6i8+OKLGD9+vHlbq9UiMTER/fv3h0ajcUmdps7VWQQVP2MZBg28GZC8Pu/4qqTX65GdnY1+/fpBqXTyL5Hqje3sGWxnz/BkO18oqcC/t+S49Rx16dO3LyICVU6VnTZtGpo1a4ZBgwYBAAIDAwEAQ4YMQWhoqLnc2LFjsXv3bkybNg0pKSnw9/fH3XffjcTERPNrAwICkJaWBgDo168fAKBr167m5wFAqVQiMzPTYp8zqkZEnOHVoNKkSROLricAaNWqFX788Ue75dVqNdRq23E6pVLpsl/Wv8stjy+TBGRGHeDnmiBE9rnyZ0iOsZ09g+3sGZ5o52iNAltf7uvWc9QlLEAFmUxyqqxarYYQwtwuCoXpY966rdavX4/Ro0fjzjvvBAAUFxfj+PHjkMlkFuXkcrn59VXHs25zuVxe759Dfcp7Nah0794dBw4csNh38OBBJCUlealGQKkUaLtTp2VQISK6BslkklMTWX1FcnIyNm7ciGPHjiEoKAhGo9FuuRYtWmDBggUYMmQIJEnCK6+84rCst3l1POPpp5/Ghg0b8NZbb+Hw4cOYN28eZs6cibFjx3qtTuWSP4zCKrmWF3qnMkRERPXw7LPPQi6XIyMjA1FRUThx4oTdctOmTUNYWBiuv/56DBkyBAMGDEDHjh09XFvneLVHpUuXLli4cCFefPFFvP7662jWrBnef/99jBw50mt1EpIMxfCDBmXVO8u5lgoREfm+li1bYv369Rb7Ro8ebVMuOTkZK1eutNhn3Ulw7Ngx6PV68+TZqiuIaiooKLiyCjvBu1OZAdxyyy245ZZb6i7oQVoEWgYVLvpGRETkFbyUxY4i4W+5gz0qREREXsGgYkcRrNZkKS/wSj2IiIiudQwqdhQJq6DCoR8iIiKvYFCxQ2vTo8KgQkRE5A0MKnawR4WIiMg3MKhYkQAUwXoyLddRISIi8gYGFTtselQ49ENEROQVDCp22Fz1w6EfIiIir2BQsUPLHhUiIiKfwKBiB3tUiIioMerduzfGjRvnsuM9+OCDeOutt1x2vIZgULHDtkeFk2mJiIi8gUHFDpselYpiwGjwTmWIiMh7jEagJN+7D6PRqaqOHj0aq1evxvTp0yFJEiRJwrFjx7Bnzx4MHDgQQUFBiImJwX333Yf8/Hzz63744QdkZmbC398fERER6Nu3L0pKSjBhwgTMnTsXmzZtgkqlgiRJyMnJcVNDO+b1mxL6IpseFcA0/OMf5vnKEBGR95RdBN5J8W4dnjsCBEbWWWz69Ok4ePAg2rRpg9dffx0AoFQq0bVrVzz00EN47733UFZWhhdeeAF33XUXVq5ciTNnzmDEiBGYOnUqbrvtNhQVFWHt2rUQQuDZZ5/F3r17cfToUSxatAhKpRLh4eHufrc2GFTssOlRAUwTahlUiIjIR4WEhEClUiEgIACxsbEAgDfeeAMdOnSwmGfy5ZdfIjExEQcPHkRxcTEqKytx++23IykpCQCQmZlpLuvv7w+FQoHY2FgolUrPvqHLOPRjRynUqBRWTcN5KkRE1Mjs3LkTq1atQlBQkPmRnp4OADhy5AjatWuHPn36IDMzE3feeSc+//xzXLp0ycu1tsSgYpeEYuvVaXnlDxERNTLFxcUYMmQIduzYYfE4dOgQevbsCblcjuzsbCxbtgwZGRn48MMPkZaWhtzcXG9X3YxDP1YkyfRVKwIQKpVUP8G1VIiIrj3+4aY5It6ug5NUKhUMhuqLPzp27Igff/wRycnJUCjsf+RLkoTu3buje/fuePXVV5GUlISFCxdi/PjxUKlUMDo5mdddGFQc4FoqREQEmcypiay+Ijk5GRs3bsSxY8cQFBSEsWPH4vPPP8eIESPw/PPPIzw8HIcPH8b8+fMxa9YsbNmyBb///jv69++P6OhobNy4EefPn0erVq0AAElJSViyZAkOHDiA2NhYhISEeHyuCod+HLAJKpyjQkREPu7ZZ5+FXC5HRkYGoqKiUFFRgT/++AMGgwH9+/dHZmYmxo0bh9DQUMhkMmg0GqxZswaDBg1Cy5Yt8fLLL+Pdd9/FwIEDAZgWfIuLi0NWVhaioqLwxx9/ePw9sUfFAd6YkIiIGpuWLVti/fr1NvsXLFhgt3yrVq2wfPlyh8eLiorCxIkTMWjQIF7142u0NkM/7FEhIiLyNAYVB3hjQiIiIu9jUHGgyPryZM5RISIi8jgGFQds5qjwqh8iIiKPY1BxwPaqHwYVIiIiT2NQsSKE6avNHBX2qBAREXkcg4oD7FEhIiLyPgYVK1VL6Nuuo8LJtERERJ7GoOKAzVU/lWWAQe+dyhAREV2jGFQc0IpA250c/iEiIvIoBhUHbFamBbg6LRERkYcxqDiggxIVQm65k/NUiIiIPIpBxSGJV/4QERF5GYNKLbiWChERkXcxqNSCPSpERETexaBSC66lQkRE5F0MKrWw6VHh0A8REZFHMajUokhYLfrGoR8iIiKPYlCxIkEyf6+F1aJvXEeFiIjIoxhUamGzjD7nqBAREXkUg0otbCfTcuiHiIjIkxhUamGzjD4n0xIREXkUg0otbBZ8Y48KERGRRzGo1IKXJxMREXkXg0otuOAbERGRdzGo1MLmqh9DBaAv905liIiIrkEMKrXQikDbnRz+ISIi8hgGlVrYzFEBOKGWiIjIgxhUrEjVC9NCDwXKhdKyAOepEBEReQyDSh1sr/xhUCEiIvIUBpU6cC0VIiIi72FQqQPXUiEiIvIeBpU62PaocOiHiIjIUxhU6mB7B2X2qBAREXkKg0odbFan5dAPERGRx3g1qEyYMAGSJFk80tPTvVklG1pYLfrGHhUiIiKPUXi7Aq1bt8aKFSvM2wqFd6skhOV2kbAa+mGPChERkcd4PagoFArExsZ6uxoO2Vz1w8m0REREHuP1oHLo0CHExcXBz88PWVlZmDx5Mpo2bWq3rE6ng06nM29rtabeDb1eD71e75L6CGG02LaeoyLKClDponMRzD83V/38yD62s2ewnT2D7ew57mrr+hxPEsJ6sMNzli1bhuLiYqSlpeHMmTOYOHEiTp06hT179iA4ONim/IQJEzBx4kSb/fPmzUNAgJ378jTAR3tlOKStnrrTT7YFn6ummbdLVNFY0fo/LjkXERHRtai0tBT33HMPCgsLodFoai3r1aBiraCgAElJSZg2bRoefPBBm+ft9agkJiYiPz+/zjfqrPtnb8H6oxfN29fJ/sJ81RvmbeEfjsrxB11yLjKl6uzsbPTr1w9KpbLuF1CDsJ09g+3sGWxnz3FXW2u1WkRGRjoVVLw+9FNTaGgoWrZsicOHD9t9Xq1WQ61W2+xXKpUua0Cp5l0JYTv0I5UXQqlQWN69kK6YK3+G5Bjb2TPYzp7BdvYcV7d1fY7lU+uoFBcX48iRI2jSpIm3q2KmtV7wTRgAfal3KkNERHSN8WpQefbZZ7F69WocO3YMf/75J2677TbI5XKMGDHCm9WyoBWBtju5lgoREZFHeHXo5++//8aIESNw4cIFREVF4YYbbsCGDRsQFRXlzWpZKLbuUQEur6XiO70+REREVyuvBpX58+d78/ROMUAOKAMBfUn1Tq6lQkRE5BE+NUfFZ/lZzUjm0A8REZFHMKg4Q20VVHTsUSEiIvIEBhVn+IVYbrNHhYiIyCMYVJxhM/TDHhUiIiJPYFCxYncdN5uhH/aoEBEReQKDijM4mZaIiMgrGFScYT1HhT0qREREHsGg4gzroR/2qBAREXkEg4ozbK764WRaIiIiT2BQcQYn0xIREXkFg4ozuI4KERGRVzCoOMP6qh+uTEtEROQRDCrOsDeZ1mj0Tl2IiIiuIQwqzrDuUYEAKoq9UhUiIqJrCYOKFQl2lqa1nqMCcEItERGRBzCoOEMVDFgHGE6oJSIicjsGFWfIZIA62HIf11IhIiJyOwYVZ3EtFSIiIo9jUHEWb0xIRETkcQwqzrK5MSGHfoiIiNyNQcVZNmupMKgQERG5G4OKszj0Q0RE5HEMKla6NQu3/wQn0xIREXkcg4qVpMhAi+2W0UGmb3hjQiIiIo9jUHGWzY0JGVSIiIjcjUHFip0F9E04mZaIiMjjGFScxaEfIiIij2NQcZbNOioMKkRERO7GoFIHAWH6xmboh0GFiIjI3RhUnGU9mbaiCDAavFMXIiKiawSDirOse1QADv8QERG5GYOKs6znqAAc/iEiInIzBhVnqQIBSW65jz0qREREbsWg4ixJAtTBlvu4lgoREZFbMajUB29MSERE5FEMKvWh5loqREREnsSgYkVyuIY+uDotERGRhzGo1IfN0A/nqBAREbkTg0p9WK+lomNQISIicicGlToIUWODk2mJiIg8ikGlPnhjQiIiIo9iUKkP3piQiIjIoxhU6oOTaYmIiDyKQaU+bCbTskeFiIjInRhU6oPrqBAREXkUg0p9cDItERGRRzGoWJFQy9K01kM/+lLAoHdvhYiIiK5hDCr1YT2ZFuDwDxERkRsxqNSHdY8KwNVpiYiI3IhBpQ41F6aF0h+QKS0LsEeFiIjIbRhU6kOSuJYKERGRBzGo1BfXUiEiIvIYBpX64o0JiYiIPIZBpb64lgoREZHHMKjUl82NCTlHhYiIyF18JqhMmTIFkiRh3Lhx3q5K7biMPhERkcf4RFDZvHkzPvvsM7Rt29bbVambzWRa9qgQERG5i9eDSnFxMUaOHInPP/8cYWFh3q4OpFpW0AfAHhUiIiIPUni7AmPHjsXgwYPRt29fvPHGG7WW1el00Ol05m2t1hQS9Ho99HrX3HOnsrLSYlsIYXFsmTIQ8hrPG8sLYXDRua9FVW3rqp8f2cd29gy2s2ewnT3HXW1dn+N5NajMnz8f27Ztw+bNm50qP3nyZEycONFm/2+//YaAgACX1GnHBQmoEUVKSkqwdOlS83bTC8fQoUb5wnMnsKbG89Qw2dnZ3q7CNYHt7BlsZ89gO3uOq9u6tLTU6bJeCyonT57EU089hezsbPj5+Tn1mhdffBHjx483b2u1WiQmJqJ///7QaOzch6cBpD1nMfvgLvN2YGAgBg26ofr5/QbgxBfm7VA/CYMGDXLJua9Fer0e2dnZ6NevH5RKZd0voAZhO3sG29kz2M6e4662rhoRcYbXgsrWrVuRl5eHjh07mvcZDAasWbMGH330EXQ6HeRyucVr1Go11Gq1zbGUSqXLGlChsG4SyfLYgeGWz+qK+IfiAq78GZJjbGfPYDt7BtvZc1zd1vU5lteCSp8+fbB7926LfWPGjEF6ejpeeOEFm5DiM2zWUeFkWiIiInfxWlAJDg5GmzZtLPYFBgYiIiLCZr9Psb7qx6AD9OWA0rnhKyIiInKe1y9PbnSse1QALqNPRETkJl6/PLmmnJwcb1ehbtY3JQRMwz9B0Z6vCxER0VWOPSr1pVADCqthHq5OS0RE5BYMKg3BGxMSERF5BIOKlbpW0AdgO/zDK3+IiIjcgkGlTsJ2l82NCRlUiIiI3IFBpSF4Y0IiIiKPYFBpCOuhH/aoEBERuQWDSkNwMi0REZFHMKg0BId+iIiIPIJBpSGsgwqHfoiIiNyCQaUhOPRDRETkEQwqDWGzjgqDChERkTswqDQE11EhIiLyCAaVhuDKtERERB7BoGJFslpDX9hZmNbuZFq7BYmIiOhKMKg0hPXQj7ES0Jd6py5ERERXMQaVhrDuUQE4/ENEROQGDCoNoQ623ccJtURERC7XoKDy1Vdf4ZdffjFvP//88wgNDcX111+P48ePu6xyPkuuBJSBlvvYo0JERORyDQoqb731Fvz9/QEA69evx8cff4ypU6ciMjISTz/9tEsr6LO4lgoREZHbKRryopMnTyI1NRUAsGjRItxxxx145JFH0L17d/Tu3duV9fNdag1QdKZ6W8egQkRE5GoN6lEJCgrChQsXAAC//fYb+vXrBwDw8/NDWVmZ62rny7iWChERkds1qEelX79+eOihh9ChQwccPHgQgwYNAgDs3bsXycnJrqyf7+KNCYmIiNyuQT0qH3/8MbKysnD+/Hn8+OOPiIiIAABs3boVI0aMcGkFfZbNjQkZVIiIiFytQT0qoaGh+Oijj2z2T5w48Yor5GtyLzhYyI2TaYmIiNyuQT0qy5cvx7p168zbH3/8Mdq3b4977rkHly5dclnlvGH3KScDB29MSERE5HYNCirPPfcctFrTB/Pu3bvxzDPPYNCgQcjNzcX48eNdWkFPW7DtlHMFreeocOiHiIjI5Ro09JObm4uMjAwAwI8//ohbbrkFb731FrZt22aeWNtYyazvSugIJ9MSERG5XYN6VFQqFUpLTXM3VqxYgf79+wMAwsPDzT0tjZWzOcV2Mi3nqBAREblag3pUbrjhBowfPx7du3fHpk2b8O233wIADh48iISEBJdW0NOc71HhVT9ERETu1qAelY8++ggKhQI//PADZsyYgfj4eADAsmXLcPPNN7u0gp4ma2iPClemJSIicrkG9ag0bdoUP//8s83+995774or5G1Sg+eoFAFGIyDjDamJiIhcpUFBBQAMBgMWLVqEffv2AQBat26NW2+9FXK53GWV8wan56hYD/0II1BRbLufiIiIGqxBQeXw4cMYNGgQTp06hbS0NADA5MmTkZiYiF9++QUpKSkuraQnyZ1NKtZDP4Dpyh8GFSIiIpdp0DjFk08+iZSUFJw8eRLbtm3Dtm3bcOLECTRr1gxPPvmkq+voUZ2SwpwrqA623ccJtURERC7VoB6V1atXY8OGDQgPDzfvi4iIwJQpU9C9e3eXVc4bhndJxPzNJ+suKJObelVqrp/CtVSIiIhcqkE9Kmq1GkVFRTb7i4uLoVKprrhS3nS2sNxmX0Fphf3CXEuFiIjIrRoUVG655RY88sgj2LhxI4QQEEJgw4YNeOyxx3Drrbe6uo4eZW+Kyqbci/YLcy0VIiIit2pQUPnggw+QkpKCrKws+Pn5wc/PD9dffz1SU1Px/vvvu7iKnhUX6m+zb9baXPuFuZYKERGRWzVojkpoaCgWL16Mw4cPmy9PbtWqFVJTU11aOW+IClbb7DtXZDscBIA3JiQiInIzp4NKXXdFXrVqlfn7adOmNbxGXhar8bPZ989eDi63th764WRaIiIil3I6qGzfvt2pck6v7Oqj7NU/yM9BM3EyLRERkVs5HVRq9phc7dJjg7H/bPVVTQajsF+Qk2mJiIjcijemsUNudWfCSoODoGIzmZZBhYiIyJUYVOxQWAUVg3DUo8LJtERERO7EoGKHzDqoOBz6sQ4qnKNCRETkSgwqdhSVV1ps6w1G+wU59ENERORWDCp2HM4rttj+43C+/YKcTEtERORWDCpO+HXvOftPWA/9VBQBRoP7K0RERHSNYFBxgvVVQGbWQz8Ah3+IiIhciEHFCTe3ibX/hPXQD8DhHyIiIhdiUHHCL7vO2H9CFQRIVk3IHhUiIiKXYVC5EpJkZxl9BhUiIiJXYVCxo22C5STZm9KjHRe2ufKHa6kQERG5CoOKHV2Swy22I4NUjgurra784dAPERGRy3g1qMyYMQNt27aFRqOBRqNBVlYWli1b5s0qAQBUCstm0ZZVOigJrqVCRETkRl4NKgkJCZgyZQq2bt2KLVu24KabbsLQoUOxd+9eb1YLx/JLLLaX7z3ruLD1Wio6Dv0QERG5isKbJx8yZIjF9ptvvokZM2Zgw4YNaN26tZdqBSzbU0swscbJtERERG7jM3NUDAYD5s+fj5KSEmRlZXm1Lglh/s4X5mRaIiIit/FqjwoA7N69G1lZWSgvL0dQUBAWLlyIjIwMu2V1Oh10Op15W6s19V7o9Xro9XqX1emergmY+ushi32Oji9TBkFeY9tYVgCDC+tytatqV1f+/MgW29kz2M6ewXb2HHe1dX2OJwkhhEvPXk8VFRU4ceIECgsL8cMPP2DWrFlYvXq13bAyYcIETJw40Wb/vHnzEBAQ4LI6bciT8L8j1fGjaaDAM23t38Mn9dwvaH36W/P2ueBMbEh9zmV1ISIiutqUlpbinnvuQWFhITQaO6u81+D1oGKtb9++SElJwWeffWbznL0elcTEROTn59f5Rutj0Y7TeO7HPebtVrHBWDLW/nCUtP1rKJaON28b4zvDMHq5y+pytdPr9cjOzka/fv2gVCq9XZ2rFtvZM9jOnsF29hx3tbVWq0VkZKRTQcXrQz/WjEajRRipSa1WQ61W2+xXKpUubUC1yvJYBiEcHz8gzGJTptNCxj+cenP1z5DsYzt7BtvZM9jOnuPqtq7PsbwaVF588UUMHDgQTZs2RVFREebNm4ecnBz8+uuv3qwWVHLLuyXrDbV0OnEdFSIiIrfxalDJy8vD/fffjzNnziAkJARt27bFr7/+in79+nmzWlDKLS+G0huMjgtzZVoiIiK38WpQ+eKLL7x5eocU9Qkq1gu+6UsBgx6QszuSiIjoSvnMOiq+RHklQz8Ah3+IiIhchEHFjvoN/dgJKlxGn4iIyCUYVOyoV1BR+gMyqxE09qgQERG5BIOKHQqZ5dBPZW1DP5Jk58aEDCpERESuwKBih0ph2SyVRoFa18XjjQmJiIjcgkHFDuuhH6C+a6lwjgoREZErMKjYYT30A9RzQi2HfoiIiFyCQcUO66EfoJ5rqXDoh4iIyCUYVOyw36NS29APJ9MSERG5A4OKHcr69qjYTKYtcG2FiIiIrlEMKnYoZbbNUuslyrwxIRERkVswqNhhvYQ+AFRwMi0REZHHMajYIZdJkKyySqWRk2mJiIg8jUHFDkmSbCbU6iu5jgoREZGnMag4oLJa9I1DP0RERJ7HoOKAQm59v5/ahn44mZaIiMgdGFQcsL2Dcm1DP6GW2wYdoC93faWIiIiuMQwqDtjMUaltMq310A/A4R8iIiIXYFBxwKZHpbIeQz8Ah3+IiIhcgEHFAeugUmmsZehHoQbkast9Ol75Q0REdKUYVBzQVRostitq61EBuJYKERGRGzCoOHCqwHIy7Nbjl2p/gfXwD+eoEBERXTEGFSfN3XC89gI2Nybk0A8REdGVYlBxFa6lQkRE5HIMKq7C1WmJiIhcjkHFVTiZloiIyOUYVByI1VhebjysfVztL7AJKpyjQkREdKUYVBzo0SLSYjssUFX7Czj0Q0RE5HIMKg7sPW0ZNGb/caz2F9hMpmWPChER0ZViUHHgrzNF9XuB9dAPe1SIiIiuGIOKq3AdFSIiIpdjUHEVrqNCRETkcgwqrmJvMq2o5UaGREREVCcGFVexnqNirAT0Zd6pCxER0VWCQcWBW9s2qd8LrIMKwHkqREREV4hBxYF+GdE2+w6eq+VKIHWw7T5e+UNERHRFGFQcCFTLbfZtyr3o+AVyJaAMsNzHCbVERERXhEHFgZbRQTb7Fmz7u/YX2aylwqEfIiKiK8Gg4kCMxs9mX2SQ2k7JGmzWUmGPChER0ZVgUKmHYl1l7QW4jD4REZFLMajUw59HLtRegDcmJCIicikGFVfi6rREREQuxaDiSrwxIRERkUsxqLgSb0xIRETkUgwqrsShHyIiIpdiUHElNYd+iIiIXIlBxZWs56iwR4WIiOiKMKjUk9EoHD/JdVSIiIhcikGlFv5y21CiNxodv8BmHRUGFSIioivBoFKLW5rahpItxy45foF1j4quCBC19MAQERFRrRhUahHlb7tv5KyNjl9gPUdFGIGKYtdWioiI6BrCoFILhVTP3hDroR+A81SIiIiuAINKLeID6/kCdbDtPl75Q0RE1GAMKrXwk9fzBTI5oLIKK1xLhYiIqMEYVFyNq9MSERG5jFeDyuTJk9GlSxcEBwcjOjoaw4YNw4EDB7xZpSvHGxMSERG5jFeDyurVqzF27Fhs2LAB2dnZ0Ov16N+/P0pKSrxZrStjc2PCAq9Ug4iI6Gqg8ObJly9fbrE9Z84cREdHY+vWrejZs6eXalU3IQQkSbL/JId+iIiIXMarQcVaYaHpUt7w8HC7z+t0Ouh0OvO2VmsKAXq9Hnq93qV1qe14ZwtKEBmktvucXBVk0U1lKCuA0cV1u5pUtbOrf35kie3sGWxnz2A7e4672ro+x5OE8I2lU41GI2699VYUFBRg3bp1dstMmDABEydOtNk/b948BAQEuKVeT623zXKvdqhEhJ/98m1PzkGz/JXm7dzIm7ArcbRb6kZERNQYlZaW4p577kFhYSE0GjtrkNXgM0Hln//8J5YtW4Z169YhISHBbhl7PSqJiYnIz8+v843Wl16vR3Z2tt2gcleneLw5rLXd18lWTYL8z+nmbWPr22EYNtOldbuaVLVzv379oFQqvV2dqxbb2TPYzp7BdvYcd7W1VqtFZGSkU0HFJ4Z+nnjiCfz8889Ys2aNw5ACAGq1Gmq17ZCLUql02y9rt2Zh2JhreX+f77aewtQ729t/gX+oxaasohgy/iHVyZ0/Q6rGdvYMtrNnsJ09x9VtXZ9jefWqHyEEnnjiCSxcuBArV65Es2bNvFkdux6+Ibl+L+BkWiIiIpfxao/K2LFjMW/ePCxevBjBwcE4e/YsACAkJAT+/nbuCOgFPVIj6/cCv1DLba6jQkRE1GBe7VGZMWMGCgsL0bt3bzRp0sT8+Pbbb71ZLQsymYPLkB2xWUeFNyUkIiJqKK/2qPjIPF7X4tAPERGRy/BePw20/6yDAGLdo1JRBBgN7q8QERHRVYhBpYGemLfd/hPW9/oBAF2ReytDRER0lWJQaaDDecX2n7Ae+gE4T4WIiKiBGFSc8PLgVs4XVgUBklWz8sofIiKiBmFQccKdnROdLyxJgDrYch8n1BIRETUIg4oTVHL7zeTwqiW11TwV9qgQERE1CIOKE/xVcrv71xzKt/8C6wm17FEhIiJqEAaVKzAj57D9J2zWUuFkWiIiooZgULkCG45etP+E9VoqOgYVIiKihmBQcQeuTktEROQSDCpOahkTZHf/xZIK253Wc1Q4mZaIiKhBGFSc9H83tbC7v+OkbNudvDEhERGRSzCoOGlgm1jnC3Poh4iIyCUYVJykcLCWil02k2kZVIiIiBqCQcUFisr1lju4jgoREZFLMKjUw8E3BtrdnznhN8sdXEeFiBq7ygrg763AhhnADw8A/70DWDEROLMTcLQqN5EbKLxdgcZEpXAy13EJfSJqbLRngL83ASc3AX9vBk7vAAw6yzKHVwDrpgHhzYHWtwEZw4DYTNM9zhobgx64mAsUngCMBkAYTQFMGE0PCMt9QO1lJAkISQSi0oDgJo2zTXwUg4qLFJbpEeKvNG1Y96joS01/FHKl5ytGRGStsgI4u+tyKNkE/L0FKDzp/OsvHgXWvmt6hKeYQkvr24CY1r73AV1ZYarv+X3A+QPA+f1A3n7gwmHAqK/79Q2h1gCRLYDINCCq5eWvaUBoEiD3wMduRQlQnAeUnAcCIoCIFPef040YVFyk3cTfcGzKYNOG9WRaANAVAQHhnq0UEREAaE9X95Q46i1pqItHgLX/MT0iUqtDS3SGZ0NLpQ64cMQ2kFw8AhgrPVcPwNSLfmqr6VGTXGVqo8iWpuBS9TUiFVD6Oz6eEKbPkJLzlwNIXnUQsfiaBxSfB/Ql1a+9/kmg/yT3vE8PYVCpp9HXJ2POn8fsPne2sByxIX62k2kB0zwVBhUi32TQA6UXAH0ZUFle/bWyHNCXA5VlDr5alpFXlKLLuTzIVm4GYjIufxilAWr7C0a6XKXO1FOQt8/0OL/fFEq0fzf8mJEtgYSupn/X9v8EFJxwXPbCYWDNO6ZHRIsaoaXVlYcWIUz/jpbkQ9KeQfzF9ZDl7AQuHrwcSI4CwnBl53A3QwWQ95fpYUECQpuafl/CU0xBo/h8dfAoyTP9njVEyfkrrra3MajU0+M3pjgMKv/8ZisWPt7dlIxlCssUzwm1RN5Xcxggb7/pg/x81TDAlf+vWwYgDgDWW/1PumruQlR69dfIloB/aMNOZNBXB5Lz+6u/XjhyZR/Wag0Q3wlI7GoKJ/EdLf+DNeBN4PQ2YO9CYO9i0/wORy4cAtZMNT0i04DWw6pDSxV9OVCab/owLcmv7h2o2rb+/vJQjQJAZwA43vC3ahYQCagCAEiAJDMFKklWyzbsP19ZDlw4atmb4TQBFBw3PVytOM/1x/QwBpV6ig72c/jc9hMFpm8kyfQHX1bjpoWcUEvXKoMeKDoDFJ4CtJcfhadMvRIBkUBg1OVHje8DIq5sLL+ywtTln1c1DHD5q4sCSb0VnjQ9Dq+w3B/c5HJwaWUZZKrCgaHSKljtc+38isg0ILGLKZQkdDGdWyZ3XF6STEEmvhPQbxJwahuwdwHw1+La57jkHwBWv216hDUzHack37P/LtbV1q5gNJp+v/MPAOcPWn4tveC68zhL4Vf7z7ORYFBpgLkPdsV9X2yy+1yXN1dg87/7mibU1gwqXEuFrkZGA1B87nII+bs6jBT+bZoXoT0FFJ0F0IDLWf3Da4QXR4Em0hQ8qoJIVTDxxryEhig6Y3oczbHcHxht+gC9eNQ0XOAK6hAgoVN1KEnoBPiHNfx4knT5eJ2A/m+Y5mPsXQjsXVT7UNOl3Iaf0xma+Msh5HIQiW51Zb1X9SGTAaGJpkdqX8vnSi5cDi4HgPyD1V/rM4kZAJSBQFCU6XckKNr0d2DxtcZ+dbDvTW5uAAaVBuieEunwufNFOlwqqUAYb0xIjV1VCKkKHFVfC2v0ihSdcd+8gLKLpkf+QfccvzZytel/o0q/y1/9nfpqkKlwZP8upIYYIMs/aPpQrrq0tT5KLk+MbChNAhB9+cM6OsM0hBOZZvogdQdJAhI6mx79JlWHlr8WmX5XXEyoAlGKQPgntoXM/D4vBxLrqy59RWAEEHg9kHS95X5dsWmYrKrnpfBvU8AIjLYfSFSB3qm/FzGoNIBMVntC7TApG7npGliU4hwV8iWVFaaQoT0NFJ2+HEJqBpLTpp4QX5+c2FDBTar/1131QReeYvoQUPg1+APdqNdjn3Ypmg0aBJlSaZqDceHw5bkwB6q/uqrHp+p9RLcyPaqGNbz5YS2TmYaTErtc7mnZcjm0LHYcWmQKOz1nDnrSAiJRKSmxYulSDKpq58ZMHQTEdTA9yC4GlQY6+MZAtHx5mcPnz+vViK65g0M/vq2ywtQFW3B58Sd1sO2jMYz16surL10szjP1iBTnQVZ0Fl2P7oD8i3dNAeVK/rfeUAo/U7d8SLzpf/yqgMuTJPOrJ1SWXkSDhokcCY6rDiI1hwM8MQwAmHpkYtuYHjWZJ/XWDDD7gfxD9ueeBEZffh+taoSStCsbuvEEmcw0MTexK9D/TVNPS/6Byz0GNQKIX2j9hij0blr/hHwSg0oD1bVK7ZoTFfhHzc81Dv14l9EIFJ8FLl2eWW/9VXuq7i56ZaD9AKPW2N+n9Dct8idTmNZPkCsBmdI0SVSmrPGc0nZbrqoORgb95XUSzlkGEJt9eYDOfs+dHEATAHBXx55cBWjiTAEkJP7y9/FASEL1V/+wuj+MDJWm4R6bKz+sv17+vqLI9Lqa8xKiawQSe0sF+AKFylTP6HTL/YZK03BR3j5TL2x4c1MouRqWNqjZ00JUDwwqV2DLy33R+Y0Vdp/TigCLbVFeiMY/pcmHCQGUXbIfQi4dN/WUXOkCV/qSy+sbnHVNneskmUKLqyZTNpRcZRpi0FQFkLjqAFL1fUCka+Y/yBWmcfig6LrLAqb1ToTx6hm3lysur2jawts1IfIZDCpXIDJI7fC5IlgGlQv5eXA8BfcaJ4TpNgPl5aaep3Kt6av5+yLn9utLvf1OXEy4P6Qo/KvDR80goqnRKxIQ4b5JmFeqttU8ieiqwKByhRaP7Y6hH/9hs18rLP8BDfl7FfDJ9aZZ3EEx1TO4zd/HmLYDIhrHXIj6MBpMQyuXjgOXjpkeBabvFZeOY0jJBch2+MikTXWIae6Errh6WKExkquqrxYIioYxIBKHzmiR0rEXFGFNqwOJM8MxRERexKByhdolhuK1IRmY+JPlksjWPSpKUQHk7QXqmsMoyUzd6FXd3zU+bCBXma4UMFaa5i0YDdXbxko729aPy88rLi/zb/EItdz2v7yt8Kv7g6xq2KVGALEIJYV/O1ycSrr88BiFn2mp6tAkICzJ9mvNyYlGI1BRfLnnpqi6B8diu6i6l6fmvnKtaaVK889Kb/pa9X1DrviQ5DUuU4y5/IiyCruX91lNTjTo9di/dCmadxwENParJIjomsKg4gJjujezCSpHjU0adjBhrF5D4ZwLKnel5Co7oSakeuXdS8eASyccTuL0OElmmtBZM3yEJVd/Hxjt/DCGTGa6zNMdl3oK4TjEGPTVzxkqTOEqKMYUonx1CIaIyE0YVFzE+nLlraIl/ld5I+6S50AuufByS08zVFRfZeEpCj9TEPLTVF9B46e5fHWNvf3BpiGbwEjTxE55I+gxkC5PlG0MdSUi8iIGFRdRKWR4qk8LTP/9EABAQIYXKx/G5MoRiJMuIkoqQCQKTV8lrXm7a1QllOX5kJVegEvXj/BFqqDLPRvJlx9JqAxOwLqdh9G9z0AoAyNMoUOh8nZNiYjIRzCouNDT/Vrif5tOIK+o+jJYLYKgFUHYL5raf9Fp0xc5DFg4Og1tQ3SX7yBatVjX+eoFvISxxrobCtOkW5mixqNq29HzCtPQgb4cKC8wrdNg71FR3LAGkOSmNTSqgog5lDQzDbsERNjMdxF6PQoPVZrKcO4EERFZYVBxsU3/7ouV+8/hgTlb6vU6A+S4dc5hdE4Kw9R/XIfmLYLcVENnKqO/PCG0ACgrcBxo1EGWoaSxDLsQEVGjwaDiBjelxzi8bLkuW45fwk3vrgYAjOiaiJSoINyflVznSrguJVeaVsK8GlbDJCKiRo1BxU3aJYbivw92w71fbGzwMf63yXT77zd+2QcA+GfvFPTLiEH7hNA6b4xIRER0NWBQcaMbWkRi/Ys3IWvySpccb0bOEczIOWKx7/mb0/DPXimQuGgXERFdhRhU3KxJiD9yJw/CkfPF6DttjcuPP3X5AUxdfsBi3+TbM3Fd8whEBqkQ7Mc5I0RE1HgxqHiAJElIjQ7Grgn90XbCb24/34sLdpu/v71jPO67LgnntOVonxiG2BA/t5+fiIjIVRhUPEjjp8SxKYNxtrAc103+3SPnXLDtFBZsO2Wzv2l4ANonhuKpvi2QX6RDqzgNNOx9ISIiH8Og4gWxIX44/OZA5BXpMOzjPyzWXfGUExdLceJiKZbsPG3z3M//dwMig9QI8VfCXyWHEIJzYIiIyCsYVLxEIZchLtQfm/7dFwCgNxgxf/NJvLJoj5drBtzy4bpanw8NUOKzezuhWWQg/i4og8ZPgdToYA/VjoiIriUMKj5CKZfhvuuScN91SQCASoMR72YftLnKxxcUlOoxfOYGu8/d3SURreM0eGXxXoQGKPHGsDZIjgiEQi7h05wj0BsEnu7XEqnRXlzQjoiIGg0GFR+lkMvwws3peOHmdBzOK8ZHKw9h0Q7bYRpfM3/zSfP3BaV6PDFvu02ZX3afwbD2cchMCMVXf+bCUC5HYOp53NAyBn5KuSerS0REPo5BpRFIjQ7C+3d3wPt3d0BFpRFlFQbsPlV4RYvJeduiHadrBC8JD821DDTxof7o2yoaAzObIEAlx6bci/BXyREVpEa3ZhEICVCiqFwPpVwGP6UcRqPAntOFCAtQITE8wPNviIiI3IJBpZFRKWRQKWS4oUUkjk0ZbN6vNxix74wWt35U/2X7fdGpgjJ8tf44vlp/vEGv/3J0Z0QGqTFrbS4ig9R4sk8q/FVyqBXssSEiakwYVK4SSrkMbRNCcWzKYAgh8EnOEazcn4eHbmiGPacL8fEq35vr4k7WN4X88o/cWsv3aBGJx3unok28BgCw6+9CzN98EmUVBoy9MQUxGj/EhfoDMM0fKqkwIEitgJy3MiAicisGlauQJEkYe2Mqxt6YCgAYmNkEzw1IBwAYjAJfrz+GiT/95c0q+py1h/Kx9lC+3edW7Dvn1DFSogLx1m2ZUCvlaBEdhHPacgSoFPj7UiliNH61Dkmd05Zj+4kCtI7TcOiKiKgGBpVrjFwmYUz3ZhjTvZl5nxAC57Q6VBqNKCjVAwDOF+nw5PztKCqv9FZVG50j50scXg1lbeZ9ndChaRgOnC3C52uPYvXB8xbPz3uoG/KKdPgk5zBiNH5467ZMJIYHoFhXCZ3egIggtc0xDUYBXaUBfgo5b1pJRFcNBhWCJEnmpfUTwqr3754wwPz9qYIy6PQGNI8KQkFpBSb+9BcWbrdd8Zac88jcrbU+f8+s6onSB88Vo8fUVbWWDw1QmkMmALRNCME/e6VgYGYTLNl5Gl+uO4rT5+UojDqJ+LBAJEcGIiUqCKUVlThdUIb40AD4q658/o7BKCCEgEIuu+JjEREBDCrkpPjL8zMAIDRAhfeGt8d7w9vblNOW67H12CVsP3EJH6w87MEaXttqhhTANMfmn99ssyol4dUl++p97HkPd0Nhqd58vDbxGhSU6lFRacSwDvF4fkAa5DIJv+w+Y74cvVNSGMbemAIA6N0y2m4Pj9EoUGEwQiWXXXEPULneAJkkQaVgQCK62jCokEtp/JS4MT0aN6ZHY3z/NIvnrP+3vfNkAUbP3oRLpXo0CfHDmcJyb1SZ6nDP55aXwe85pTV/P3PNUcxcc9TmNVuPX7KZ0FzFXylHmd5gsS8+1B+nCspsyk4a2ho9W0ZBgoR/fPon8op0iNX44am+LXCmoAxDO8Tjp52n8f6KQ+bjFJXr0SwyEFPuaIsSXSUSwwMQo+HNOIkaKwYV8hjTFTLV/3NulxiKTS/eiKVLl2LQoJ6QyxUorqhEgFIOhVyG7ScuoVxvREp0IFSX10vJ0+rwyNwt2H+2yHtvhK6IdUgBYDekAMAri/fa7DurLTffIdy6167qODv/LsTA6WsbVL8+6dH4fX+eeXvLy31xvkiH7L/OoV9GDNQKGZbtOYukiADcmBaNr9cfx3dbTuKOjvHo3jwcOWcknFyTi97pMWgTHwIAOHSuCHd9th6t40Iwe0wXKK2Gxvaf1SJPq8N1zSOgUshgNApIEizusSWEwNLdZ3Eorwi3totD8yiu7kzXBq8GlTVr1uCdd97B1q1bcebMGSxcuBDDhg3zZpXIi2QyyeIOzh2ahtmUaRoRgOXjetrsNxoFjDV6a4p1lVi1Pw/fbTkJg1EgRuPHOTXklJohBQA6v7HC/P207IMOX/ef3w7iPwAAOXDsEP6TfcimzLrD+Wjx72VXXMeqHiQAeLx3ChQyyRza3r4jE/nFFbghNRLtEkPrPFZhqR5qpcxmVWghBA7nFeOHrX/DYBS4PysZTSMCbMoApt5SAD47N0kIAaMAZFbhjxoHrwaVkpIStGvXDg888ABuv/12b1aFGjmZTIKsRm9NkFqBIe3iMKRdnHmfvTk1ZwrLkKfVIS7UH0fPF2PMnM0ovbx2ihDApdIKzN98Epf/PSbyOZ9Y3Q/shR9NvU3v/HrApeeZta72tYgcGdE1ES8NaoW8Ih2O5BVj8Y7T+GX3GQCm+U/7zhTh933nsP9sES6WVKB7agQmDGmN2X8eQ4muEmNvTEVSRADm/HEMfx65gJSoILSND8beixIO/X4YN7aKQaekcLvnPl+kw1d/HsNHq0whrl9GDD64u4PFxHEhBMr1RijkEr5efxybci/gnm5J6NUyqkHvl1xPEsI3/gmWJKnePSparRYhISEoLCyERqNxaX30ev3lIYlBUCqVdb+AGqSxtLOu0gCDUSBAZcr2h/OKUayrRLuEEJwqKMPZwnIUlulxsaQCQgD7zxZh4fa/oVLI0DQ8AB2TwvDzzjMOhziIyPcMyozF0t1nHT5/Q2ok+rSKxg2pkTAK4N4vNuJ8kQ7BagWeHZCGiT/txeXOJtyflYS7OieiwmDEn4fz0aNFFJIjAnG+uBx9p60xH3NY+zjc3jEBcaF+iNb44b8bjmPqclPofLpvSzzVtwVOXiw1/7uTGB6AtgkhEAL4aedp/HfjcSSEBeD1W1tD46+84l4kd/0bXZ/P70YVVHQ6HXQ6nXlbq9UiMTER+fn5bgkq2dnZ6Nevn09/gDZ213o7a8v0kCQJwX4KFJbpcb5Ih+SIACjkMpzTlmP6yiP4cdsp8z92RESe1jnSiMcGdECv9BiXHVOr1SIyMvLqCyoTJkzAxIkTbfbPmzcPAQFczZOuPZVGYM8lCeUGoMIARPsDUX4CoWpALgEGAZRXAufKAJUcCFIAFUbgRLGEQ1oJG/J8c04BEfme6VmuWwC0tLQU99xzz9UXVNijcvVhO3uGK9tZbzBCJkk4cbEUuRdK0SUpDBUGI/acKkTT8ABEB6uxYPtp7DhZCF2lAQNax8BoFHj2xz0uejdE5A2HJvV32bHq06PSqC5PVqvVUKttlw5XKpVu+5Bz57GpGtvZM1zRzlUvb9lEhZZNQs37Y0MDzd8/0CPF5nX/6JIEwHSFFoB6L/JmNAqU6Q0QMK3FUq43oERXiUC1Ag/M2YyNuRctyreMCUJekQ5CAIVlevsHJSKnufLf6Pocq1EFFSJq/Bq6Cq1MJiFQXf1PVqBaYd6e/8h1+OuMFhGBavPtIBoiv1iH/GIdWkQHW9wZu/zy2i/HL5TinLYcMklCy5gglFYYsHTPGRw8W4Rdpwpx9HwJAOCfvZphRNdkZO87B12lAS2ig/HH4XzM23QCFZXGBteP6Frk1aBSXFyMw4erF2zKzc3Fjh07EB4ejqZNm3qxZkTUmEiShNZxIVd8nMggNSLt3PCxao2RtNhgpMUGWzz3eO9U8/fmKyT6toBSqcSDN1Tf/LNfRgwm3Nq6wXUTQkAIy6CnqzSgoFSPiECVeQ2TQ+eKsP7oBWTGhyAjztSlPuePY/hiXS46NA3Ffdcl43BeEXSVRsRo/PDbX2dxptB0924AuPe6pkgKD8Q5bTmW7TnLK9XI67waVLZs2YIbb7zRvD1+/HgAwKhRozBnzhwv1YqIyPdIkgTrq0zVCjliNJYLtbWICUaLGMsw9WivFDzaq3o47oYWkebvh3WId3jOl2/JwPkiHYp1lUiOCHDqMldH93A6W1iO3acK0TrOdK8of5UczSKrhwv1BiMMRmEOhQajwLebT+JwXjEe6dkcFZVGVBiMCA1Q4o+Defhg2U4UGNW4tX0cnu2fBpVChpX787ByXx5uzoxFeIAKJy6W4uj5Ery3wnKhvsggFfKLKxAVrMb5Ih2obm/f3vCQfaW8GlR69+4NH5nLS0REdkQFqxEVbNvL5IhMJsFPZnsn7tgQP/OwXFyNm5xWUcplqLk4rlwm4Z5u9nvWB2XGAie3YdCg3hZzHQa0jsWA1rHm7aqVeZ/q28Lp+jvLaBTQlutRaRT443A+YjR+uK55BABTr9apgjKkRgchVuOHJTtP49SlMtzeKcHiBq/acj32nylCWkww1EoZluw4DYVcglohx7ELJQjxV+K/G46bbxlye8d4RAWrUVCix7dbTlrUp0eLSKw9lO/y9wkAXaOMuL2WQOtunKNCRERUTzKZhNAAFQBgaHvLD3HrXq3bOybYPYbGT4muzapX1b2rS6JNmXuvS7L72rf/0bbedW6IquFMb+IiCkREROSzGFSIiIjIZzGoEBERkc9iUCEiIiKfxaBCREREPotBhYiIiHwWgwoRERH5LAYVIiIi8lkMKkREROSzGFSIiIjIZzGoEBERkc9iUCEiIiKfxaBCREREPqtR3z1ZCAEA0Gq1Lj+2Xq9HaWkptFqtxW3EybXYzp7BdvYMtrNnsJ09x11tXfW5XfU5XptGHVSKiooAAImJtrfGJiIiIt9WVFSEkJCQWstIwpk446OMRiNOnz6N4OBgSJLk0mNrtVokJibi5MmT0Gg0Lj02VWM7ewbb2TPYzp7BdvYcd7W1EAJFRUWIi4uDTFb7LJRG3aMik8mQkJDg1nNoNBr+IXgA29kz2M6ewXb2DLaz57ijrevqSanCybRERETksxhUiIiIyGcxqDigVqvx2muvQa1We7sqVzW2s2ewnT2D7ewZbGfP8YW2btSTaYmIiOjqxh4VIiIi8lkMKkREROSzGFSIiIjIZzGoEBERkc9iULHj448/RnJyMvz8/NCtWzds2rTJ21XyKWvWrMGQIUMQFxcHSZKwaNEii+eFEHj11VfRpEkT+Pv7o2/fvjh06JBFmYsXL2LkyJHQaDQIDQ3Fgw8+iOLiYosyu3btQo8ePeDn54fExERMnTrVpi7ff/890tPT4efnh8zMTCxdutTl79cbJk+ejC5duiA4OBjR0dEYNmwYDhw4YFGmvLwcY8eORUREBIKCgnDHHXfg3LlzFmVOnDiBwYMHIyAgANHR0XjuuedQWVlpUSYnJwcdO3aEWq1Gamoq5syZY1Ofq/VvYsaMGWjbtq15MausrCwsW7bM/Dzb2D2mTJkCSZIwbtw48z62tWtMmDABkiRZPNLT083PN8p2FmRh/vz5QqVSiS+//FLs3btXPPzwwyI0NFScO3fO21XzGUuXLhX//ve/xYIFCwQAsXDhQovnp0yZIkJCQsSiRYvEzp07xa233iqaNWsmysrKzGVuvvlm0a5dO7Fhwwaxdu1akZqaKkaMGGF+vrCwUMTExIiRI0eKPXv2iP/973/C399ffPbZZ+Yyf/zxh5DL5WLq1Knir7/+Ei+//LJQKpVi9+7dbm8DdxswYICYPXu22LNnj9ixY4cYNGiQaNq0qSguLjaXeeyxx0RiYqL4/fffxZYtW8R1110nrr/+evPzlZWVok2bNqJv375i+/btYunSpSIyMlK8+OKL5jJHjx4VAQEBYvz48eKvv/4SH374oZDL5WL58uXmMlfz38SSJUvEL7/8Ig4ePCgOHDggXnrpJaFUKsWePXuEEGxjd9i0aZNITk4Wbdu2FU899ZR5P9vaNV577TXRunVrcebMGfPj/Pnz5ucbYzszqFjp2rWrGDt2rHnbYDCIuLg4MXnyZC/WyndZBxWj0ShiY2PFO++8Y95XUFAg1Gq1+N///ieEEOKvv/4SAMTmzZvNZZYtWyYkSRKnTp0SQgjxySefiLCwMKHT6cxlXnjhBZGWlmbevuuuu8TgwYMt6tOtWzfx6KOPuvQ9+oK8vDwBQKxevVoIYWpTpVIpvv/+e3OZffv2CQBi/fr1QghToJTJZOLs2bPmMjNmzBAajcbcrs8//7xo3bq1xbmGDx8uBgwYYN6+1v4mwsLCxKxZs9jGblBUVCRatGghsrOzRa9evcxBhW3tOq+99ppo166d3ecaaztz6KeGiooKbN26FX379jXvk8lk6Nu3L9avX+/FmjUeubm5OHv2rEUbhoSEoFu3buY2XL9+PUJDQ9G5c2dzmb59+0Imk2Hjxo3mMj179oRKpTKXGTBgAA4cOIBLly6Zy9Q8T1WZq/FnVVhYCAAIDw8HAGzduhV6vd7i/aenp6Np06YW7ZyZmYmYmBhzmQEDBkCr1WLv3r3mMrW14bX0N2EwGDB//nyUlJQgKyuLbewGY8eOxeDBg23ag23tWocOHUJcXByaN2+OkSNH4sSJEwAabzszqNSQn58Pg8Fg8QMCgJiYGJw9e9ZLtWpcqtqptjY8e/YsoqOjLZ5XKBQIDw+3KGPvGDXP4ajM1fazMhqNGDduHLp37442bdoAML13lUqF0NBQi7LW7dzQNtRqtSgrK7sm/iZ2796NoKAgqNVqPPbYY1i4cCEyMjLYxi42f/58bNu2DZMnT7Z5jm3tOt26dcOcOXOwfPlyzJgxA7m5uejRoweKiooabTs36rsnE10Lxo4diz179mDdunXerspVKS0tDTt27EBhYSF++OEHjBo1CqtXr/Z2ta4qJ0+exFNPPYXs7Gz4+fl5uzpXtYEDB5q/b9u2Lbp164akpCR899138Pf392LNGo49KjVERkZCLpfbzIA+d+4cYmNjvVSrxqWqnWprw9jYWOTl5Vk8X1lZiYsXL1qUsXeMmudwVOZq+lk98cQT+Pnnn7Fq1SokJCSY98fGxqKiogIFBQUW5a3buaFtqNFo4O/vf038TahUKqSmpqJTp06YPHky2rVrh+nTp7ONXWjr1q3Iy8tDx44doVAooFAosHr1anzwwQdQKBSIiYlhW7tJaGgoWrZsicOHDzfa32kGlRpUKhU6deqE33//3bzPaDTi999/R1ZWlhdr1ng0a9YMsbGxFm2o1WqxceNGcxtmZWWhoKAAW7duNZdZuXIljEYjunXrZi6zZs0a6PV6c5ns7GykpaUhLCzMXKbmearKXA0/KyEEnnjiCSxcuBArV65Es2bNLJ7v1KkTlEqlxfs/cOAATpw4YdHOu3fvtgiF2dnZ0Gg0yMjIMJeprQ2vxb8Jo9EInU7HNnahPn36YPfu3dixY4f50blzZ4wcOdL8PdvaPYqLi3HkyBE0adKk8f5O13v67VVu/vz5Qq1Wizlz5oi//vpLPPLIIyI0NNRiBvS1rqioSGzfvl1s375dABDTpk0T27dvF8ePHxdCmC5PDg0NFYsXLxa7du0SQ4cOtXt5cocOHcTGjRvFunXrRIsWLSwuTy4oKBAxMTHivvvuE3v27BHz588XAQEBNpcnKxQK8Z///Efs27dPvPbaa1fN5cn//Oc/RUhIiMjJybG4zLC0tNRc5rHHHhNNmzYVK1euFFu2bBFZWVkiKyvL/HzVZYb9+/cXO3bsEMuXLxdRUVF2LzN87rnnxL59+8THH39s9zLDq/Vv4l//+pdYvXq1yM3NFbt27RL/+te/hCRJ4rfffhNCsI3dqeZVP0KwrV3lmWeeETk5OSI3N1f88ccfom/fviIyMlLk5eUJIRpnOzOo2PHhhx+Kpk2bCpVKJbp27So2bNjg7Sr5lFWrVgkANo9Ro0YJIUyXKL/yyisiJiZGqNVq0adPH3HgwAGLY1y4cEGMGDFCBAUFCY1GI8aMGSOKioosyuzcuVPccMMNQq1Wi/j4eDFlyhSbunz33XeiZcuWQqVSidatW4tffvnFbe/bk+y1LwAxe/Zsc5mysjLx+OOPi7CwMBEQECBuu+02cebMGYvjHDt2TAwcOFD4+/uLyMhI8cwzzwi9Xm9RZtWqVaJ9+/ZCpVKJ5s2bW5yjytX6N/HAAw+IpKQkoVKpRFRUlOjTp485pAjBNnYn66DCtnaN4cOHiyZNmgiVSiXi4+PF8OHDxeHDh83PN8Z2loQQov79MERERETuxzkqRERE5LMYVIiIiMhnMagQERGRz2JQISIiIp/FoEJEREQ+i0GFiIiIfBaDChEREfksBhUiIiLyWQwqRORRo0ePxrBhw7xdDSJqJBhUiIiIyGcxqBCRW/zwww/IzMyEv78/IiIi0LdvXzz33HP46quvsHjxYkiSBEmSkJOTAwA4efIk7rrrLoSGhiI8PBxDhw7FsWPHzMer6omZOHEioqKioNFo8Nhjj6GioqLWc5aUlHj4nRORKym8XQEiuvqcOXMGI0aMwNSpU3HbbbehqKgIa9euxf33348TJ05Aq9Vi9uzZAIDw8HDo9XoMGDAAWVlZWLt2LRQKBd544w3cfPPN2LVrF1QqFQDg999/h5+fH3JycnDs2DGMGTMGERERePPNNx2ek7czI2rcGFSIyOXOnDmDyspK3H777UhKSgIAZGZmAgD8/f2h0+kQGxtrLv/f//4XRqMRs2bNgiRJAIDZs2cjNDQUOTk56N+/PwBApVLhyy+/REBAAFq3bo3XX38dzz33HCZNmlTrOYmo8eLQDxG5XLt27dCnTx9kZmbizjvvxOeff45Lly45LL9z504cPnwYwcHBCAoKQlBQEMLDw1FeXo4jR45YHDcgIMC8nZWVheLiYpw8ebLe5ySixoFBhYhcTi6XIzs7G8uWLUNGRgY+/PBDpKWlITc312754uJidOrUCTt27LB4HDx4EPfcc49bzklEjQODChG5hSRJ6N69OyZOnIjt27dDpVJh4cKFUKlUMBgMFmU7duyIQ4cOITo6GqmpqRaPkJAQc7mdO3eirKzMvL1hwwYEBQUhMTGx1nMSUePFoEJELrdx40a89dZb2LJlC06cOIEFCxbg/PnzaNWqFZKTk7Fr1y4cOHAA+fn50Ov1GDlyJCIjIzF06FCsXbsWubm5yMnJwZNPPom///7bfNyKigo8+OCD+Ouvv7B06VK89tpreOKJJyCTyWo9JxE1XpxMS0Qup9FosGbNGrz//vvQarVISkrCu+++i4EDB6Jz587IyclB586dUVxcjFWrVqF3795Ys2YNXnjhBdx+++0oKipCfHw8+vTpA41GYz5unz590KJFC/Ts2RM6nQ4jRozAhAkT6jwnETVekuC1e0TUCIwePRoFBQVYtGiRt6tCRB7EoR8iIiLyWQwqRERE5LM49ENEREQ+iz0qRERE5LMYVIiIiMhnMagQERGRz2JQISIiIp/FoEJEREQ+i0GFiIiIfBaDChEREfksBhUiIiLyWQwqRERE5LP+H+tD8l6LrH6DAAAAAElFTkSuQmCC",
             "text/plain": [
-              "\u003cFigure size 640x480 with 1 Axes\u003e"
-            ],
-            "image/png": "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\n"
+              "<Figure size 640x480 with 1 Axes>"
+            ]
           },
-          "metadata": {}
+          "metadata": {},
+          "output_type": "display_data"
         }
       ],
       "source": [
@@ -667,8 +667,8 @@
       },
       "outputs": [
         {
-          "output_type": "stream",
           "name": "stdout",
+          "output_type": "stream",
           "text": [
             "GREMIO:\n",
             "So called, officer:\n",
diff --git a/examples/ogda_example.ipynb b/examples/ogda_example.ipynb
index 96e68199..92cf97ad 100644
--- a/examples/ogda_example.ipynb
+++ b/examples/ogda_example.ipynb
@@ -51,14 +51,14 @@
         "y_{k+1} = y_k + \\eta_k \\nabla_y f(x_k, y_k),\n",
         "$$\n",
         "\n",
-        "where $\\eta_k$ is a step size. However, it's well-documented that GDA can fail to converge in this setting. This is an important issue because gradient-based min-max optimisation is increasingly prevalent in machine learning (e.g., GANs, constrained RL). *Optimistic* GDA (OGDA) addresses this shortcoming by introducing a form of memory-based negative momentum:  \n",
+        "where $\\eta_k$ is a step size. However, it's well-documented that GDA can fail to converge in this setting. This is an important issue because gradient-based min-max optimization is increasingly prevalent in machine learning (e.g., GANs, constrained RL). *Optimistic* GDA (OGDA) addresses this shortcoming by introducing a form of memory-based negative momentum:  \n",
         "\n",
         "$$\n",
         "x_{k+1} = x_k - 2 \\eta_k \\nabla_x f(x_k, y_k) + \\eta_k  \\nabla_x f(x_{k-1}, y_{k-1})  \\\\\n",
         "y_{k+1} = y_k + 2 \\eta_k \\nabla_y f(x_k, y_k) - \\eta_k \\nabla_y f(x_{k-1}, y_{k-1})).\n",
         "$$\n",
         "\n",
-        "Thus, to implement OGD (or OGA), the optimiser needs to keep track of the gradient from the previous step. OGDA has been formally shown to converge to the optimum $(x_k, y_k) \\to (x^\\star, y^\\star)$ in this setting. The generalised form of the OGDA update rule is given by\n",
+        "Thus, to implement OGD (or OGA), the optimizer needs to keep track of the gradient from the previous step. OGDA has been formally shown to converge to the optimum $(x_k, y_k) \\to (x^\\star, y^\\star)$ in this setting. The generalized form of the OGDA update rule is given by\n",
         "\n",
         "$$\n",
         "x_{k+1} = x_k - (\\alpha + \\beta) \\eta_k \\nabla_x f(x_k, y_k) + \\beta \\eta_k \\nabla_x f(x_{k-1}, y_{k-1})  \\\\\n",
@@ -84,7 +84,7 @@
         "\\mu^{k+1} = \\mu^k + 2\\tau_\\mu^k \\nabla_\\mu \\mathcal L(\\pi^k_k, \\mu^k)+  \\tau_\\mu^k \\nabla_\\mu \\mathcal L(\\pi^{k-1}, \\mu^{k-1})\n",
         "$$\n",
         "\n",
-        "where $\\eta_k$ is a step size. However, it's well-documented that GDA can fail to converge in this setting. This is an important issue because gradient-based min-max optimisation is increasingly prevalent in machine learning (e.g., GANs, constrained RL). *Optimistic* GDA (OGDA) addresses this shortcoming by introducing a form of memory-based negative momentum:\n",
+        "where $\\eta_k$ is a step size. However, it's well-documented that GDA can fail to converge in this setting. This is an important issue because gradient-based min-max optimization is increasingly prevalent in machine learning (e.g., GANs, constrained RL). *Optimistic* GDA (OGDA) addresses this shortcoming by introducing a form of memory-based negative momentum:\n",
         "\n",
         "$$\n",
         "x_{k+1} = x_k - 2 \\eta_k \\nabla_x f(x_k, y_k) + \\eta_k  \\nabla_x f(x_{k-1}, y_{k-1})  \\\\\n",
@@ -120,7 +120,7 @@
         "id": "G-4JMKlgs-Lr"
       },
       "source": [
-        "Define an optimisation loop."
+        "Define an optimization loop."
       ]
     },
     {
@@ -131,20 +131,20 @@
       },
       "outputs": [],
       "source": [
-        "def optimise(params: optax.Params, x_optimiser: optax.GradientTransformation, y_optimiser: optax.GradientTransformation, n_steps: int = 1000, display_every: int = 100) -> optax.Params:\n",
-        "  \"\"\"An optimisation loop minimising x and maximising y.\"\"\"\n",
+        "def optimize(params: optax.Params, x_optimizer: optax.GradientTransformation, y_optimizer: optax.GradientTransformation, n_steps: int = 1000, display_every: int = 100) -> optax.Params:\n",
+        "  \"\"\"An optimization loop minimizing x and maximizing y.\"\"\"\n",
         "\n",
-        "  x_opt_state = x_optimiser.init(params[\"x\"])\n",
-        "  y_opt_state = y_optimiser.init(params[\"y\"])\n",
+        "  x_opt_state = x_optimizer.init(params[\"x\"])\n",
+        "  y_opt_state = y_optimizer.init(params[\"y\"])\n",
         "  param_hist = [params]\n",
         "  f_hist = []\n",
         "\n",
         "  @jax.jit\n",
         "  def step(params, x_opt_state, y_opt_state):\n",
         "    f_value, grads = jax.value_and_grad(f)(params)\n",
-        "    x_update, x_opt_state = x_optimiser.update(grads[\"x\"], x_opt_state, params[\"x\"])\n",
-        "    # note that we\"re maximising y so we feed in the negative gradient to the OGD update\n",
-        "    y_update, y_opt_state = y_optimiser.update(-grads[\"y\"], y_opt_state, params[\"y\"])\n",
+        "    x_update, x_opt_state = x_optimizer.update(grads[\"x\"], x_opt_state, params[\"x\"])\n",
+        "    # note that we\"re maximizing y so we feed in the negative gradient to the OGD update\n",
+        "    y_update, y_opt_state = y_optimizer.update(-grads[\"y\"], y_opt_state, params[\"y\"])\n",
         "    updates = {\"x\": x_update, \"y\": y_update}\n",
         "    params = optax.apply_updates(params, updates)\n",
         "    return params, x_opt_state, y_opt_state, f_value\n",
@@ -165,7 +165,7 @@
         "id": "gDtB7gJdtPZj"
       },
       "source": [
-        "Initialise $x$ and $y$, as well as optimisers for each. "
+        "Initialize $x$ and $y$, as well as optimizers for each. "
       ]
     },
     {
@@ -182,12 +182,12 @@
         "}\n",
         "\n",
         "# GDA\n",
-        "x_gd_optimiser = optax.sgd(learning_rate=0.1)\n",
-        "y_ga_optimiser = optax.sgd(learning_rate=0.1)\n",
+        "x_gd_optimizer = optax.sgd(learning_rate=0.1)\n",
+        "y_ga_optimizer = optax.sgd(learning_rate=0.1)\n",
         "\n",
         "# OGDA\n",
-        "x_ogd_optimiser = optax.optimistic_gradient_descent(learning_rate=0.1)\n",
-        "y_oga_optimiser = optax.optimistic_gradient_descent(learning_rate=0.1)"
+        "x_ogd_optimizer = optax.optimistic_gradient_descent(learning_rate=0.1)\n",
+        "y_oga_optimizer = optax.optimistic_gradient_descent(learning_rate=0.1)"
       ]
     },
     {
@@ -207,7 +207,7 @@
       },
       "outputs": [],
       "source": [
-        "gda_hist, gda_f_hist = optimise(initial_params, x_gd_optimiser, y_ga_optimiser)"
+        "gda_hist, gda_f_hist = optimize(initial_params, x_gd_optimizer, y_ga_optimizer)"
       ]
     },
     {
@@ -218,7 +218,7 @@
       },
       "outputs": [],
       "source": [
-        "ogda_hist, ogda_f_hist = optimise(initial_params, x_ogd_optimiser, y_oga_optimiser)"
+        "ogda_hist, ogda_f_hist = optimize(initial_params, x_ogd_optimizer, y_oga_optimizer)"
       ]
     },
     {
@@ -227,7 +227,7 @@
         "id": "S504XrZrtXNe"
       },
       "source": [
-        "Visualise the optimisation trajectories. The optimal solution is $(0, 0)$. "
+        "Visualize the optimization trajectories. The optimal solution is $(0, 0)$. "
       ]
     },
     {
diff --git a/optax/_src/alias.py b/optax/_src/alias.py
index 59c7ec63..44f68b31 100644
--- a/optax/_src/alias.py
+++ b/optax/_src/alias.py
@@ -832,7 +832,7 @@ def amsgrad(
     eps_root: float = 0.0,
     mu_dtype: Optional[Any] = None,
 ) -> base.GradientTransformation:
-  """The AMSGrad optimiser.
+  """The AMSGrad optimizer.
 
   The original Adam can fail to converge to the optimal solution in some cases.
   AMSGrad guarantees convergence by using a long-term memory of past gradients.
@@ -1192,7 +1192,7 @@ def sign_sgd(
 
 
   References:
-    Bernstein et al., `signSGD: Compressed Optimisation for Non-Convex Problems
+    Bernstein et al., `signSGD: Compressed optimization for Non-Convex Problems
     <https://arxiv.org/abs/1802.04434>`_, 2018
 
     Balles et al.`The Geometry of Sign Gradient Descent
diff --git a/optax/_src/base.py b/optax/_src/base.py
index 0e996f6c..15c77b2c 100644
--- a/optax/_src/base.py
+++ b/optax/_src/base.py
@@ -85,7 +85,7 @@ class TransformUpdateFn(Protocol):
 
   The `update` step takes a tree of candidate parameter `updates` (e.g. their
   gradient with respect to some loss), an arbitrary structured `state`, and the
-  current `params` of the model being optimised. The `params` argument is
+  current `params` of the model being optimized. The `params` argument is
   optional, it must however be provided when using transformations that require
   access to the current values of the parameters.
 
@@ -171,9 +171,9 @@ class GradientTransformation(NamedTuple):
   passed to the next call to the gradient transformation.
 
   Since gradient transformations are pure, idempotent functions, the only way
-  to change the behaviour of a gradient transformation between steps, is to
+  to change the behavior of a gradient transformation between steps, is to
   change the values in the optimizer state. To see an example of mutating the
-  optimizer state in order to control the behaviour of an optax gradient
+  optimizer state in order to control the behavior of an optax gradient
   transformation see the `meta-learning example <https://optax.readthedocs.io/en/latest/_collections/examples/meta_learning.html>`_ in the optax documentation.
 
   Attributes:
diff --git a/optax/_src/factorized.py b/optax/_src/factorized.py
index bd542b62..99c20114 100644
--- a/optax/_src/factorized.py
+++ b/optax/_src/factorized.py
@@ -62,7 +62,7 @@ def _factored_dims(
 
 @dataclasses.dataclass
 class _UpdateResult:
-  """Opaque containter that is not traversed by jax.tree.map."""
+  """Opaque container that is not traversed by jax.tree.map."""
 
   update: chex.Array  # the update to apply to params
   v_row: chex.Array  # used for factored params.
@@ -97,20 +97,20 @@ def scale_by_factored_rms(
     [Shazeer et al, 2018](https://arxiv.org/abs/1804.04235)
 
   Args:
-      factored: boolean: whether to use factored second-moment estimates..
-      decay_rate: float: controls second-moment exponential decay schedule.
-      step_offset: for finetuning, one may set this to the starting step-number
-        of the fine tuning phase.
-      min_dim_size_to_factor: only factor accumulator if two array dimensions
-        are at least this size.
-      epsilon: Regularization constant for squared gradient.
-      decay_rate_fn: A function that accepts the current step, the decay rate
-        parameter and controls the schedule for the second momentum. Defaults to
-        the original adafactor's power decay schedule. One potential shortcoming
-        of the orignal schedule is the fact that second momentum converges to 1,
-        which effectively freezes the second momentum. To prevent this the user
-        can opt for a custom schedule that sets an upper bound for the second
-        momentum, like in [Zhai et al., 2021](https://arxiv.org/abs/2106.04560).
+    factored: boolean: whether to use factored second-moment estimates..
+    decay_rate: float: controls second-moment exponential decay schedule.
+    step_offset: for finetuning, one may set this to the starting step-number
+      of the fine tuning phase.
+    min_dim_size_to_factor: only factor accumulator if two array dimensions
+      are at least this size.
+    epsilon: Regularization constant for squared gradient.
+    decay_rate_fn: A function that accepts the current step, the decay rate
+      parameter and controls the schedule for the second momentum. Defaults to
+      the original adafactor's power decay schedule. One potential shortcoming
+      of the original schedule is the fact that second momentum converges to 1,
+      which effectively freezes the second momentum. To prevent this the user
+      can opt for a custom schedule that sets an upper bound for the second
+      momentum, like in [Zhai et al., 2021](https://arxiv.org/abs/2106.04560).
 
   Returns:
     the corresponding `GradientTransformation`.
@@ -126,7 +126,7 @@ def _to_state(count: chex.Array, result_tree):
     )
 
   def init_fn(params):
-    """Initialise the optimiser's state."""
+    """Initialise the optimizer's state."""
 
     def _init(param):
       shape, dtype = param.shape, param.dtype
diff --git a/optax/_src/linear_algebra.py b/optax/_src/linear_algebra.py
index 9bf482cb..45ae11eb 100644
--- a/optax/_src/linear_algebra.py
+++ b/optax/_src/linear_algebra.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""Linear algebra utilities used in optimisation."""
+"""Linear algebra utilities used in optimization."""
 
 from collections.abc import Callable
 import functools
diff --git a/optax/_src/linesearch.py b/optax/_src/linesearch.py
index 38f88b5c..96c03ec4 100644
--- a/optax/_src/linesearch.py
+++ b/optax/_src/linesearch.py
@@ -225,7 +225,7 @@ def scale_by_backtracking_linesearch(
       optimize.
     * ``**extra_args``: additional keyword arguments, if the function needs
       additional arguments such as input data, they should be put there (
-      see example in this docstrihng).
+      see example in this docstring).
   """
 
   def init_fn(params: base.Params) -> ScaleByBacktrackingLinesearchState:
@@ -713,7 +713,7 @@ def _try_safe_step(
       jax.lax.cond(
           state.safe_stepsize > 0.0,
           lambda *_: jax.debug.print(
-              FLAG_CURVATURE_COND_NOT_SATSIFIED
+              FLAG_CURVATURE_COND_NOT_SATISFIED
           ),
           _failure_diagnostic,
           state,
@@ -826,7 +826,7 @@ def _search_interval(
           (max_stepsize_reached & ~interval_found),
           FLAG_INTERVAL_NOT_FOUND
           + "\n"
-          + FLAG_CURVATURE_COND_NOT_SATSIFIED,
+          + FLAG_CURVATURE_COND_NOT_SATISFIED,
       )
     failed = (iter_num + 1 >= max_linesearch_steps) & (~done)
 
@@ -1526,7 +1526,7 @@ def update_fn(
     WARNING_PREAMBLE
     + "Length of searched interval has been reduced below threshold."
 )
-FLAG_CURVATURE_COND_NOT_SATSIFIED = (
+FLAG_CURVATURE_COND_NOT_SATISFIED = (
     WARNING_PREAMBLE
     + "Returning stepsize with sufficient decrease "
     "but curvature condition not satisfied."
diff --git a/optax/_src/lookahead.py b/optax/_src/lookahead.py
index 74af5ade..c95facb9 100644
--- a/optax/_src/lookahead.py
+++ b/optax/_src/lookahead.py
@@ -83,8 +83,8 @@ def lookahead(
     sync_period: Number of fast optimizer steps to take before synchronizing
       parameters. Must be >= 1.
     slow_step_size: Step size of the slow parameter updates.
-    reset_state: Whether to reset the optimizer state of the fast opimizer after
-      each synchronization.
+    reset_state: Whether to reset the optimizer state of the fast optimizer
+      after each synchronization.
 
   Returns:
     A `GradientTransformation` with init and update functions. The updates
@@ -165,7 +165,7 @@ def _lookahead_update(
   # without change and the slow parameter updates are zero (i.e. fast_updates =
   # updates, slow_updates = 0).
   #
-  # Synchronisation step (sync_next == True):
+  # Synchronization step (sync_next == True):
   # This consists of two substeps: a last fast optimizer step and the
   # synchronization.
   #   Substep 1 (last fast optimizer step):
@@ -182,7 +182,7 @@ def _lookahead_update(
   #
   # To make the equations jittable, the two types of steps are merged. Defining
   # last_difference = fast_params + updates - slow_params, this yields the
-  # following equtions which are implemented below:
+  # following equations which are implemented below:
   #   slow_updates = slow_step_size * sync_next * last_difference
   #   fast_updates = updates - (
   #                  1 - slow_step_size) * sync_next * last_difference
diff --git a/optax/_src/transform.py b/optax/_src/transform.py
index fcb1f385..8a239176 100644
--- a/optax/_src/transform.py
+++ b/optax/_src/transform.py
@@ -548,7 +548,7 @@ def update_fn(updates, state, params):
 
 
 class ScaleByAdaDeltaState(NamedTuple):
-  """State for the rescaling by Adadelta algoritm."""
+  """State for the rescaling by Adadelta algorithm."""
 
   e_g: base.Updates
   e_x: base.Updates
@@ -778,7 +778,7 @@ def scale_by_rprop(
 ) -> base.GradientTransformation:
   """Scale with the Rprop optimizer.
 
-  Rprop, short for resillient backpropogation, is a first order variant of
+  Rprop, short for resillient backpropagation, is a first order variant of
   gradient descent. It responds only to the sign of the gradient by increasing
   or decreasing the step size selected per parameter exponentially to speed up
   convergence and avoid oscillations.
diff --git a/optax/_src/update.py b/optax/_src/update.py
index bb9f77ac..b6af2567 100644
--- a/optax/_src/update.py
+++ b/optax/_src/update.py
@@ -80,7 +80,7 @@ def periodic_update(
 
   A slow copy of a model's parameters, updated every K actual updates, can be
   used to implement forms of self-supervision (in supervised learning), or to
-  stabilise temporal difference learning updates (in reinforcement learning).
+  stabilize temporal difference learning updates (in reinforcement learning).
 
   References:
     [Grill et al., 2020](https://arxiv.org/abs/2006.07733)
diff --git a/optax/contrib/_mechanic.py b/optax/contrib/_mechanic.py
index 86b12d04..44b4a90e 100644
--- a/optax/contrib/_mechanic.py
+++ b/optax/contrib/_mechanic.py
@@ -143,7 +143,7 @@ def update_fn(
     # weights instead of what they were initialized with.
     x0 = jax.lax.cond(state.count == 0, lambda: params, lambda: state.x0)
 
-    # Add weight decay to raw gradients, note that this is othogonal to any
+    # Add weight decay to raw gradients, note that this is orthogonal to any
     # weight decay applied to inner_optimizer updates.
     s_sum = jnp.sum(state.s)
     grad_norm = otu.tree_l2_norm(updates)
diff --git a/optax/contrib/_sam.py b/optax/contrib/_sam.py
index 5bfdce96..4c54c5b0 100644
--- a/optax/contrib/_sam.py
+++ b/optax/contrib/_sam.py
@@ -32,7 +32,7 @@
 will do the individual steps, and then with a defined cadence, does the outer
 update steps.
 
-To use the SAM optimzier then, create an outer optimizer and an adversarial
+To use the SAM optimizer then, create an outer optimizer and an adversarial
 optimizer, here SGD with a normalized gradient and then wrap them both with SAM.
 
     ```
@@ -111,7 +111,7 @@ def sam(
 
   Performs steps with the inner adversarial optimizer and periodically
   updates an outer set of true parameters.  By default, resets
-  the state of the adversarial optimizer after syncronization.  For example::
+  the state of the adversarial optimizer after synchronization.  For example::
 
     >>> import optax
     >>> rho = 0.1
diff --git a/optax/losses/_smoothing.py b/optax/losses/_smoothing.py
index 585e28b4..72bab564 100644
--- a/optax/losses/_smoothing.py
+++ b/optax/losses/_smoothing.py
@@ -25,7 +25,7 @@ def smooth_labels(
   """Apply label smoothing.
 
   Label smoothing is often used in combination with a cross-entropy loss.
-  Smoothed labels favour small logit gaps, and it has been shown that this can
+  Smoothed labels favor small logit gaps, and it has been shown that this can
   provide better model calibration by preventing overconfident predictions.
 
   References:
diff --git a/optax/monte_carlo/control_variates.py b/optax/monte_carlo/control_variates.py
index 2d6065a0..6aa1152c 100644
--- a/optax/monte_carlo/control_variates.py
+++ b/optax/monte_carlo/control_variates.py
@@ -73,7 +73,7 @@
 @chex.warn_deprecated_function
 def control_delta_method(
     function: Callable[[chex.Array], float]) -> ControlVariate:
-  """The control delta covariate method.
+  """The control delta covariant method.
 
   Control variate obtained by performing a second order Taylor expansion
     on the cost function f at the mean of the input distribution.
@@ -163,7 +163,7 @@ def moving_avg_baseline(
     zero_debias: Whether or not to use zero debiasing for the moving average.
     use_decay_early_training_heuristic: Whether or not to use a heuristic which
       overrides the decay value early in training based on
-      min(decay, (1.0 + i) / (10.0 + i)). This stabilises training and was
+      min(decay, (1.0 + i) / (10.0 + i)). This stabilizes training and was
       adapted from the Tensorflow codebase.
 
   Returns:
@@ -316,7 +316,7 @@ def samples_fn(x):
   cv_jacobians = grad_estimator(
       samples_fn, params, dist_builder, rng, num_samples)
 
-  # The gradients of the stochastic covariate with respect to the parameters.
+  # The gradients of the stochastic covariant with respect to the parameters.
   def param_fn(x):
     return jnp.mean(_map(
         stochastic_cv, x,
diff --git a/optax/second_order/__init__.py b/optax/second_order/__init__.py
index 1df9fae5..56ac2894 100644
--- a/optax/second_order/__init__.py
+++ b/optax/second_order/__init__.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ==============================================================================
-"""The second order optimisation sub-package."""
+"""The second order optimization sub-package."""
 
 from optax.second_order._fisher import fisher_diag
 from optax.second_order._hessian import hessian_diag
diff --git a/optax/second_order/_fisher.py b/optax/second_order/_fisher.py
index 11d7d2e0..b2d15a0b 100644
--- a/optax/second_order/_fisher.py
+++ b/optax/second_order/_fisher.py
@@ -14,7 +14,7 @@
 # ==============================================================================
 """Functions for computing diagonals of the fisher information matrix.
 
-Computing the Fisher matrix for neural networks is typically intractible due to
+Computing the Fisher matrix for neural networks is typically intractable due to
 the quadratic memory requirements. Solving for the diagonal can be done cheaply,
 with sub-quadratic memory requirements.
 """
diff --git a/optax/second_order/_hessian.py b/optax/second_order/_hessian.py
index 688fcb70..bc6e7047 100644
--- a/optax/second_order/_hessian.py
+++ b/optax/second_order/_hessian.py
@@ -14,7 +14,7 @@
 # ==============================================================================
 """Functions for computing diagonals of the Hessian wrt to a set of parameters.
 
-Computing the Hessian for neural networks is typically intractible due to the
+Computing the Hessian for neural networks is typically intractable due to the
 quadratic memory requirements. Solving for the diagonal can be done cheaply,
 with sub-quadratic memory requirements.
 """
diff --git a/optax/transforms/_accumulation.py b/optax/transforms/_accumulation.py
index 3f182bf4..a077767a 100644
--- a/optax/transforms/_accumulation.py
+++ b/optax/transforms/_accumulation.py
@@ -216,7 +216,7 @@ class MultiStepsState(NamedTuple):
       1 or is reset to 0.
     gradient_step: gradient step counter. This only increases after enough
       mini-steps have been accumulated.
-    inner_opt_state: the state of the wrapped optimiser.
+    inner_opt_state: the state of the wrapped optimizer.
     acc_grads: accumulated gradients over multiple mini-steps.
     skip_state: an arbitrarily py tree. This is only relevant when passing
       a `should_skip_update_fn` to `MultiSteps`.
@@ -253,7 +253,7 @@ def __init__(
       use_grad_mean: bool = True,
       should_skip_update_fn: Optional[ShouldSkipUpdateFunction] = None):
     # pylint: disable=line-too-long
-    """Initialiser.
+    """Initializer.
 
     Args:
       opt: the wrapped optimizer.
diff --git a/optax/transforms/_clipping.py b/optax/transforms/_clipping.py
index a6f1ab69..d7c69c1a 100644
--- a/optax/transforms/_clipping.py
+++ b/optax/transforms/_clipping.py
@@ -91,7 +91,7 @@ def update_fn(updates, state, params=None):
     del params
     g_norm = linear_algebra.global_norm(updates)
     # TODO(b/163995078): revert back to the following (faster) implementation
-    # once analysed how it affects backprop through update (e.g. meta-gradients)
+    # once analyzed how it affects backprop through update (e.g. meta-gradients)
     # g_norm = jnp.maximum(max_norm, g_norm)
     # updates = jax.tree.map(lambda t: (t / g_norm) * max_norm, updates)
     trigger = jnp.squeeze(g_norm < max_norm)
@@ -169,7 +169,7 @@ def per_example_layer_norm_clip(
 ) -> tuple[chex.ArrayTree, chex.ArrayTree]:
   """Applies gradient clipping per-example using per-layer norms.
 
-  If len(grads) == 1, this function is equivent to
+  If len(grads) == 1, this function is equivalent to
   optax.per_example_global_norm_clip.  If len(grads) > 1, each array in grads
   will be independently clipped to a value ``C_i`` documented below.
 
diff --git a/optax/transforms/_conditionality.py b/optax/transforms/_conditionality.py
index f30f6758..5ee94589 100644
--- a/optax/transforms/_conditionality.py
+++ b/optax/transforms/_conditionality.py
@@ -61,7 +61,7 @@ def conditionally_transform(
 
   Creates a transformation wrapper that conditionally applies the inner gradient
   transformation, and if the condition is not met, just passes the updates and
-  inner state through unchanged. The behaviour is controlled by a user specified
+  inner state through unchanged. The behavior is controlled by a user specified
   function ``should_transform_fn`` that is called by ``conditionally_transform``
   passing as input a counter of the number of times that the ``update`` function
   has been previously called, the user specified function must returns a boolean
@@ -121,7 +121,7 @@ def conditionally_mask(
 
   Creates a transformation wrapper that conditionally applies the inner gradient
   transformation, and if the condition is not met, the updates are set to 0,
-  while the inner state is passed through unchanged. The behaviour is controlled
+  while the inner state is passed through unchanged. The behavior is controlled
   by a user specified function ``should_transform_fn`` that is called
   by ``conditionally_transform`` passing as input a counter of the number of
   times that the ``update`` function has been previously called, the user
diff --git a/pyproject.toml b/pyproject.toml
index fad1d9cf..7bccb6db 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,7 +5,7 @@ build-backend = "flit_core.buildapi"
 [project]
 name = "optax"
 dynamic = ["version"]
-description = "A gradient processing and optimisation library in JAX."
+description = "A gradient processing and optimization library in JAX."
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.9"


Test patch:
diff --git a/optax/_src/base_test.py b/optax/_src/base_test.py
index 9808f45d..997b7aed 100644
--- a/optax/_src/base_test.py
+++ b/optax/_src/base_test.py
@@ -65,7 +65,7 @@ def test_set_to_zero_is_stateless(self):
 class ExtraArgsTest(chex.TestCase):
 
   def test_isinstance(self):
-    """Locks in behaviour for comparing transformations."""
+    """Locks in behavior for comparing transformations."""
 
     def init_fn(params):
       del params
diff --git a/optax/_src/linesearch_test.py b/optax/_src/linesearch_test.py
index 4f8ec222..b82ed77e 100644
--- a/optax/_src/linesearch_test.py
+++ b/optax/_src/linesearch_test.py
@@ -555,7 +555,7 @@ def fn(x):
       self.assertEqual(stepsize, 10.0)
       self.assertIn(_linesearch.FLAG_INTERVAL_NOT_FOUND, stdout.getvalue())
       self.assertIn(
-          _linesearch.FLAG_CURVATURE_COND_NOT_SATSIFIED, stdout.getvalue()
+          _linesearch.FLAG_CURVATURE_COND_NOT_SATISFIED, stdout.getvalue()
       )
 
   def test_failure_not_enough_iter(self):
@@ -664,7 +664,7 @@ def fn(x):
     # Descent direction p chosen such that, with x+p
     # the first trial of the algorithm,
     # 1. u*f'(w) < 0 (valid descent direction)
-    # 2. w+u satisifies sufficient decrease
+    # 2. w+u satisfies sufficient decrease
     # 3. w+u does not satisfy small curvature
     # 4. f'(w+u) > 0
     # As a result, the first trial starts with high < low
diff --git a/optax/_src/lookahead_test.py b/optax/_src/lookahead_test.py
index 5e5df50f..7144b794 100644
--- a/optax/_src/lookahead_test.py
+++ b/optax/_src/lookahead_test.py
@@ -47,7 +47,7 @@ def _test_optimizer(step_size: float) -> base.GradientTransformation:
   """Fast optimizer for the lookahead tests."""
 
   # Use SGD for simplicity but add non-trivial optimizer state so that the
-  # resetting behaviour of lookahead can be tested.
+  # resetting behavior of lookahead can be tested.
   def init_fn(params):
     aggregate_grads = jax.tree.map(jnp.zeros_like, params)
     return OptimizerTestState(aggregate_grads, is_reset=True)
diff --git a/optax/contrib/_mechanic_test.py b/optax/contrib/_mechanic_test.py
index 7066950e..e98ac78b 100644
--- a/optax/contrib/_mechanic_test.py
+++ b/optax/contrib/_mechanic_test.py
@@ -36,7 +36,7 @@ def _test_optimizer(step_size: float) -> base.GradientTransformation:
   """Inner optimizer for the Mechanic tests."""
 
   # Use SGD for simplicity but add non-trivial optimizer state so that the
-  # resetting behaviour of lookahead can be tested.
+  # resetting behavior of lookahead can be tested.
   def init_fn(params):
     aggregate_grads = jax.tree.map(jnp.zeros_like, params)
     return OptimizerTestState(aggregate_grads)
diff --git a/optax/contrib/_privacy_test.py b/optax/contrib/_privacy_test.py
index 7a340f15..25738dd0 100644
--- a/optax/contrib/_privacy_test.py
+++ b/optax/contrib/_privacy_test.py
@@ -32,7 +32,7 @@ def setUp(self):
     self.params = {'key_a': (jnp.zeros((2, 3, 4)), jnp.zeros([])),
                    'key_b': jnp.zeros((6, 7))}
     # Example `i`'s grads are full of `i`s. Important to include 0 to ensure
-    # there are no divisons by 0 (e.g. in norm clipping)
+    # there are no divisions by 0 (e.g. in norm clipping)
     a = jnp.arange(self.batch_size)
     self.per_eg_grads = jax.tree.map(
         lambda p: jnp.moveaxis(a * jnp.ones(p.shape+(self.batch_size,)), -1, 0),
diff --git a/optax/monte_carlo/control_variates_test.py b/optax/monte_carlo/control_variates_test.py
index 1baf4bdc..d8966320 100644
--- a/optax/monte_carlo/control_variates_test.py
+++ b/optax/monte_carlo/control_variates_test.py
@@ -96,7 +96,7 @@ def testQuadraticFunction(self, effective_mean, effective_log_scale):
 
   @chex.all_variants
   @parameterized.parameters([(1.0, 1.0)])
-  def testPolinomialFunction(self, effective_mean, effective_log_scale):
+  def testPolynomialFunction(self, effective_mean, effective_log_scale):
     data_dims = 10
     num_samples = 10**3
 
diff --git a/optax/transforms/_accumulation_test.py b/optax/transforms/_accumulation_test.py
index 26e51ae2..1040fee8 100644
--- a/optax/transforms/_accumulation_test.py
+++ b/optax/transforms/_accumulation_test.py
@@ -141,7 +141,7 @@ def test_skip_large_updates(self):
   def test_multi_steps(self):
     batch_size = 32
     x_size = 7
-    # Parameters should be updated only every `k_steps` optimisation steps.
+    # Parameters should be updated only every `k_steps` optimization steps.
     k_steps = 4
     data = jnp.ones([batch_size, x_size])
 
@@ -158,7 +158,7 @@ def loss_apply(params, data):
       return loss.apply({'params': params}, data)
 
     ms_opt = _accumulation.MultiSteps(
-        # Use a non-trivial inner optimiser:
+        # Use a non-trivial inner optimizer:
         # * it has a state,
         # * it requires the params for the update.
         combine.chain(transform.scale_by_adam(),
diff --git a/optax/transforms/_conditionality_test.py b/optax/transforms/_conditionality_test.py
index 1276ef1d..bf92d8f5 100644
--- a/optax/transforms/_conditionality_test.py
+++ b/optax/transforms/_conditionality_test.py
@@ -113,7 +113,7 @@ def fn(p, x):
 
   def test_apply_if_finite_pmap(self):
     # Unlike in `test_apply_if_finite`:
-    # * pmap is applied to the gradient computation and the optimisation;
+    # * pmap is applied to the gradient computation and the optimization;
     # * the NaNs are caused inside the function and do not come from the inputs.
     half = jnp.ones([1]) / 2.
     two = jnp.ones([1]) * 2.  # Causes a NaN in arctanh
@@ -174,7 +174,7 @@ def should_update(step):
     for _ in range(ConditionallyTransformTest.NUM_STEPS):
       updates, state = update_fn(grads, state)
       self.assertEqual(updates, 2.)
-    # Further updates stop calling the inner optimiser.
+    # Further updates stop calling the inner optimizer.
     for _ in range(5):
       updates, state = update_fn(grads, state)
       self.assertEqual(updates, 1.)
@@ -199,7 +199,7 @@ def should_update(step):
     updates, state = update_fn(grads, state)
     self.assertEqual(updates, 1.)
     self.assertEqual(state.inner_state.found_nan, False)
-    # Further updates stop calling the inner optimiser.
+    # Further updates stop calling the inner optimizer.
     for _ in range(5):
       updates, state = update_fn(grads_with_nan, state)
       # Warning: do not use assertEqual with a NaN as NaN == NaN returns False.
@@ -228,7 +228,7 @@ def should_update(step):
     for _ in range(ConditionallyMaskTest.NUM_STEPS):
       updates, state = update_fn(grads, state)
       self.assertEqual(updates, 2.)
-    # Further updates stop calling the inner optimiser.
+    # Further updates stop calling the inner optimizer.
     for _ in range(5):
       updates, state = update_fn(grads, state)
       self.assertEqual(updates, 0.)
@@ -253,7 +253,7 @@ def should_update(step):
     updates, state = update_fn(grads, state)
     self.assertEqual(updates, 1.)
     self.assertEqual(state.inner_state.found_nan, False)
-    # Further updates stop calling the inner optimiser.
+    # Further updates stop calling the inner optimizer.
     for _ in range(5):
       updates, state = update_fn(grads_with_nan, state)
       self.assertEqual(updates, 0.)
@@ -276,7 +276,7 @@ def should_update(step, loss, **extra_args):
     for _ in range(ConditionallyMaskTest.NUM_STEPS):
       updates, state = update_fn(grads, state, loss=0.2)
       self.assertEqual(updates, 2.)
-    # Further updates stop calling the inner optimiser.
+    # Further updates stop calling the inner optimizer.
     for _ in range(5):
       updates, state = update_fn(grads, state, loss=0.)
       self.assertEqual(updates, 0.)
diff --git a/optax/transforms/_constraining_test.py b/optax/transforms/_constraining_test.py
index 45beb495..c812fc48 100644
--- a/optax/transforms/_constraining_test.py
+++ b/optax/transforms/_constraining_test.py
@@ -105,7 +105,7 @@ def test_zero_nans(self):
     chex.assert_trees_all_close(updates, (jnp.ones([3]), jnp.array(
         [1., 0., 0.]), jnp.array([float('inf'), 1., 1.])))
 
-    # Check an upate with only good values
+    # Check an update with only good values
     grads = (jnp.ones([3]), jnp.ones([3]), jnp.ones([3]))
     updates, opt_state = update_fn(grads, opt_state)
     chex.assert_trees_all_close(
diff --git a/optax/transforms/_masking_test.py b/optax/transforms/_masking_test.py
index 70d6b9b9..a2cdb6ad 100644
--- a/optax/transforms/_masking_test.py
+++ b/optax/transforms/_masking_test.py
@@ -357,7 +357,7 @@ class _MaskCompatibleModule():
       def __call__(self, x):
         return self.w.dot(x)
 
-    # Make it a pytree by registring it as a pytree node
+    # Make it a pytree by registering it as a pytree node
     jtu.register_pytree_node(
         _MaskCompatibleModule,
         lambda m: ((m.w,), None),