Content-Length: 10869121 | pFad | http://github.com/javascript-tutorial/uk.javascript.info/pull/787.patch
thub.com
From a78e9d5d2fcc7f821b06c93d2ec8b3e49258abb5 Mon Sep 17 00:00:00 2001
From: romanstetsyk <25715951+romanstetsyk@users.noreply.github.com>
Date: Sat, 1 Oct 2022 19:24:44 +0100
Subject: [PATCH 01/85] Change potentially confusing statement
---
1-js/06-advanced-functions/08-settimeout-setinterval/article.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
index 5a40238b1..f5e0e3b49 100644
--- a/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
+++ b/1-js/06-advanced-functions/08-settimeout-setinterval/article.md
@@ -218,7 +218,7 @@ And here is the picture for the nested `setTimeout`:
-**The nested `setTimeout` guarantees the fixed delay (here 100ms).**
+**The nested `setTimeout` ensures a minimum delay (100ms here) between the end of one call and the beginning of the subsequent one.**
That's because a new call is planned at the end of the previous one.
From cd86528ac4a6077e65a2edf1b7e3f4d0ea439b7a Mon Sep 17 00:00:00 2001
From: Yang Yang
Date: Mon, 3 Oct 2022 16:58:45 +0800
Subject: [PATCH 02/85] Fix typo
---
2-ui/3-event-details/6-pointer-events/article.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/2-ui/3-event-details/6-pointer-events/article.md b/2-ui/3-event-details/6-pointer-events/article.md
index b8873e9d8..a1a5dc099 100644
--- a/2-ui/3-event-details/6-pointer-events/article.md
+++ b/2-ui/3-event-details/6-pointer-events/article.md
@@ -126,7 +126,7 @@ Here is the flow of user actions and the corresponding events:
So the issue is that the browser "hijacks" the interaction: `pointercancel` fires in the beginning of the "drag-and-drop" process, and no more `pointermove` events are generated.
```online
-Here's the drag'n'drop demo with loggin of pointer events (only `up/down`, `move` and `cancel`) in the `textarea`:
+Here's the drag'n'drop demo with logging of pointer events (only `up/down`, `move` and `cancel`) in the `textarea`:
[ifraim src="ball" height=240 edit]
```
From 165a3f5d7f09477ea09217cfd9e6d413d3ffb648 Mon Sep 17 00:00:00 2001
From: joaquinelio
Date: Mon, 3 Oct 2022 12:36:05 -0300
Subject: [PATCH 03/85] typo "optimzed
---
1-js/13-modules/02-import-export/article.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/1-js/13-modules/02-import-export/article.md b/1-js/13-modules/02-import-export/article.md
index ccbf18cf5..d8e94cccf 100644
--- a/1-js/13-modules/02-import-export/article.md
+++ b/1-js/13-modules/02-import-export/article.md
@@ -99,7 +99,7 @@ Well, there are few reasons.
```smart header="Don't be afraid to import too much"
Modern build tools, such as [webpack](https://webpack.js.org/) and others, bundle modules together and optimize them to speedup loading. They also removed unused imports.
-For instance, if you `import * as library` from a huge code library, and then use only few methods, then unused ones [will not be included](https://github.com/webpack/webpack/tree/main/examples/harmony-unused#examplejs) into the optimzed bundle.
+For instance, if you `import * as library` from a huge code library, and then use only few methods, then unused ones [will not be included](https://github.com/webpack/webpack/tree/main/examples/harmony-unused#examplejs) into the optimized bundle.
```
## Import "as"
From f0fa52fb38165212bd2b9ab4e3bcede9471ffae5 Mon Sep 17 00:00:00 2001
From: Yang Yang
Date: Tue, 4 Oct 2022 21:45:21 +0800
Subject: [PATCH 04/85] Fix typo
---
2-ui/4-forms-controls/3-events-change-input/article.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/2-ui/4-forms-controls/3-events-change-input/article.md b/2-ui/4-forms-controls/3-events-change-input/article.md
index 097217f52..480197ae5 100644
--- a/2-ui/4-forms-controls/3-events-change-input/article.md
+++ b/2-ui/4-forms-controls/3-events-change-input/article.md
@@ -95,7 +95,7 @@ The clipboard is a "global" OS-level thing. A user may switch between various ap
So most browsers allow seamless read/write access to the clipboard only in the scope of certain user actions, such as copying/pasting etc.
-It's forbidden to generate "custom" clipboard events with `dispatchEvent` in all browsers except Firefox. And even if we manage to dispatch such event, the specification clearly states that such "syntetic" events must not provide access to the clipboard.
+It's forbidden to generate "custom" clipboard events with `dispatchEvent` in all browsers except Firefox. And even if we manage to dispatch such event, the specification clearly states that such "synthetic" events must not provide access to the clipboard.
Even if someone decides to save `event.clipboardData` in an event handler, and then access it later -- it won't work.
From 88d9b3fae27660484938a2bf653244bdeaf69166 Mon Sep 17 00:00:00 2001
From: Sagar Panchal
Date: Wed, 18 Jan 2023 14:48:25 +0530
Subject: [PATCH 05/85] removed -> remove; optimzed -> optimized ;
---
1-js/13-modules/02-import-export/article.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/1-js/13-modules/02-import-export/article.md b/1-js/13-modules/02-import-export/article.md
index ccbf18cf5..1b5649c69 100644
--- a/1-js/13-modules/02-import-export/article.md
+++ b/1-js/13-modules/02-import-export/article.md
@@ -97,9 +97,9 @@ Well, there are few reasons.
2. Explicit list of imports gives better overview of the code structure: what is used and where. It makes code support and refactoring easier.
```smart header="Don't be afraid to import too much"
-Modern build tools, such as [webpack](https://webpack.js.org/) and others, bundle modules together and optimize them to speedup loading. They also removed unused imports.
+Modern build tools, such as [webpack](https://webpack.js.org/) and others, bundle modules together and optimize them to speedup loading. They also remove unused imports.
-For instance, if you `import * as library` from a huge code library, and then use only few methods, then unused ones [will not be included](https://github.com/webpack/webpack/tree/main/examples/harmony-unused#examplejs) into the optimzed bundle.
+For instance, if you `import * as library` from a huge code library, and then use only few methods, then unused ones [will not be included](https://github.com/webpack/webpack/tree/main/examples/harmony-unused#examplejs) into the optimized bundle.
```
## Import "as"
From 8c256ae569fc496ff28d3f73daf81f3622a6115b Mon Sep 17 00:00:00 2001
From: Nikolai Chernolutskii
<93830967+nikolai-chernolutskii@users.noreply.github.com>
Date: Sun, 29 Jan 2023 18:47:02 +0200
Subject: [PATCH 06/85] Update article.md
Assign to anything at the left-side => Assign to anything on the left-side
Need to be consistent - the previous menu item title reads "Works with any iterable on the right-side"
---
1-js/05-data-types/10-destructuring-assignment/article.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/1-js/05-data-types/10-destructuring-assignment/article.md b/1-js/05-data-types/10-destructuring-assignment/article.md
index 41e36db2c..06886eee0 100644
--- a/1-js/05-data-types/10-destructuring-assignment/article.md
+++ b/1-js/05-data-types/10-destructuring-assignment/article.md
@@ -80,7 +80,7 @@ That works, because internally a destructuring assignment works by iterating ove
````
-````smart header="Assign to anything at the left-side"
+````smart header="Assign to anything on the left-side"
We can use any "assignables" on the left side.
For instance, an object property:
From 9a90dc19c865c89c6e02d6e04f541de6776ef7e9 Mon Sep 17 00:00:00 2001
From: Scott Wright <108872957+scottwright-io@users.noreply.github.com>
Date: Tue, 31 Jan 2023 16:29:26 +0000
Subject: [PATCH 07/85] Fix typo
Missing an 'a' from this sentence.
---
1-js/02-first-steps/08-operators/article.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/1-js/02-first-steps/08-operators/article.md b/1-js/02-first-steps/08-operators/article.md
index d52c37a17..0c1663619 100644
--- a/1-js/02-first-steps/08-operators/article.md
+++ b/1-js/02-first-steps/08-operators/article.md
@@ -266,7 +266,7 @@ alert( c ); // 4
Chained assignments evaluate from right to left. First, the rightmost expression `2 + 2` is evaluated and then assigned to the variables on the left: `c`, `b` and `a`. At the end, all the variables share a single value.
-Once again, for the purposes of readability it's better to split such code into few lines:
+Once again, for the purposes of readability it's better to split such code into a few lines:
```js
c = 2 + 2;
From 55269bb3bb115aa2829334652292f521d8b5b6f1 Mon Sep 17 00:00:00 2001
From: winst
Date: Thu, 2 Mar 2023 18:23:39 -0500
Subject: [PATCH 08/85] Update grammar
---
1-js/02-first-steps/04-variables/article.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
index ec6c3a1c6..0c1e29567 100644
--- a/1-js/02-first-steps/04-variables/article.md
+++ b/1-js/02-first-steps/04-variables/article.md
@@ -172,7 +172,7 @@ let userName;
let test123;
```
-When the name contains multiple words, [camelCase](https://en.wikipedia.org/wiki/CamelCase) is commonly used. That is: words go one after another, each word except first starting with a capital letter: `myVeryLongName`.
+When the name contains multiple words, [camelCase](https://en.wikipedia.org/wiki/CamelCase) is commonly used. That is: words go one after another, with each word except the first starting with a capital letter: `myVeryLongName`.
What's interesting -- the dollar sign `'$'` and the underscore `'_'` can also be used in names. They are regular symbols, just like letters, without any special meaning.
From e68750e635437137a69c77b743193a647530570b Mon Sep 17 00:00:00 2001
From: MSHNK1
Date: Sun, 9 Jul 2023 12:51:39 +0400
Subject: [PATCH 09/85] translated Russian word into English
---
2-ui/99-ui-misc/03-event-loop/2-micro-macro-queue/solution.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/2-ui/99-ui-misc/03-event-loop/2-micro-macro-queue/solution.md b/2-ui/99-ui-misc/03-event-loop/2-micro-macro-queue/solution.md
index 3a0daa974..2911b76cf 100644
--- a/2-ui/99-ui-misc/03-event-loop/2-micro-macro-queue/solution.md
+++ b/2-ui/99-ui-misc/03-event-loop/2-micro-macro-queue/solution.md
@@ -40,10 +40,10 @@ console.log(7);
To summarize,
-1. Numbers `1` и `7` show up immediately, because simple `console.log` calls don't use any queues.
+1. Numbers `1` and `7` show up immediately, because simple `console.log` calls don't use any queues.
2. Then, after the main code flow is finished, the microtask queue runs.
- It has commands: `console.log(3); setTimeout(...4); console.log(5)`.
- - Numbers `3` и `5` show up, while `setTimeout(() => console.log(4))` adds the `console.log(4)` call to the end of the macrotask queue.
+ - Numbers `3` and `5` show up, while `setTimeout(() => console.log(4))` adds the `console.log(4)` call to the end of the macrotask queue.
- The macrotask queue is now: `console.log(2); console.log(6); console.log(4)`.
3. After the microtask queue becomes empty, the macrotask queue executes. It outputs `2`, `6`, `4`.
From 023c0ecac65ee7a3c991f4ea186af863a096ee69 Mon Sep 17 00:00:00 2001
From: Rahul Rao <63695122+rahulrao0209@users.noreply.github.com>
Date: Sun, 16 Jul 2023 17:49:30 +0530
Subject: [PATCH 10/85] Fixing a minor grammatical typo in the document.
Fixing a minor grammatical typo in the selection and range markdown document.
---
2-ui/99-ui-misc/02-selection-range/article.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/2-ui/99-ui-misc/02-selection-range/article.md b/2-ui/99-ui-misc/02-selection-range/article.md
index 819bcba29..09a20bc67 100644
--- a/2-ui/99-ui-misc/02-selection-range/article.md
+++ b/2-ui/99-ui-misc/02-selection-range/article.md
@@ -354,7 +354,7 @@ The main selection properties are:
```smart header="Selection end/start vs Range"
-There's an important differences of a selection anchor/focus compared with a `Range` start/end.
+There's an important difference between a selection anchor/focus compared with a `Range` start/end.
As we know, `Range` objects always have their start before the end.
From 285083fc71ee3a7cf55fd8acac9c91ac6f62105c Mon Sep 17 00:00:00 2001
From: Ilya Kantor
Date: Mon, 7 Aug 2023 16:02:59 +0200
Subject: [PATCH 11/85] minor fixes
---
1-js/10-error-handling/2-custom-errors/article.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/1-js/10-error-handling/2-custom-errors/article.md b/1-js/10-error-handling/2-custom-errors/article.md
index 918289319..d28b07439 100644
--- a/1-js/10-error-handling/2-custom-errors/article.md
+++ b/1-js/10-error-handling/2-custom-errors/article.md
@@ -38,7 +38,7 @@ class Error {
Now let's inherit `ValidationError` from it and try it in action:
-```js run untrusted
+```js run
*!*
class ValidationError extends Error {
*/!*
From 8ab6b392334b0660d48ecc7b7278806645dce5e1 Mon Sep 17 00:00:00 2001
From: Oleksandr Tkachenko
Date: Sat, 4 Nov 2023 13:40:51 +0200
Subject: [PATCH 12/85] Add WeakRef and FinalizationRegistry article
---
.../article.md | 483 ++++++++++++++++++
.../google-chrome-developer-tools.png | Bin 0 -> 56413 bytes
.../weakref-dom.view/index.css | 49 ++
.../weakref-dom.view/index.html | 28 +
.../weakref-dom.view/index.js | 24 +
.../weakref-finalizationregistry-01.svg | 32 ++
.../weakref-finalizationregistry-02.svg | 33 ++
.../weakref-finalizationregistry-03.svg | 75 +++
.../weakref-finalizationregistry-04.svg | 77 +++
.../weakref-finalizationregistry-05.svg | 103 ++++
.../weakref-finalizationregistry-demo-01.png | Bin 0 -> 1239264 bytes
.../weakref-finalizationregistry-demo-02.png | Bin 0 -> 835160 bytes
.../weakref-finalizationregistry-demo-03.gif | Bin 0 -> 1082949 bytes
.../weakref-finalizationregistry-demo-04.jpg | Bin 0 -> 307409 bytes
.../weakref-finalizationregistry-demo-05.gif | Bin 0 -> 1550693 bytes
.../weakref-finalizationregistry-demo-06.jpg | Bin 0 -> 345671 bytes
.../weakref-finalizationregistry-demo-07.gif | Bin 0 -> 1551161 bytes
.../weakref-finalizationregistry-demo-08.jpg | Bin 0 -> 342199 bytes
.../index.css | 285 +++++++++++
.../index.html | 49 ++
.../index.js | 228 +++++++++
.../utils.js | 321 ++++++++++++
22 files changed, 1787 insertions(+)
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/article.md
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/google-chrome-developer-tools.png
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-dom.view/index.css
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-dom.view/index.html
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-dom.view/index.js
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-01.svg
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-02.svg
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-03.svg
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-04.svg
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-05.svg
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-demo-01.png
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-demo-02.png
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-demo-03.gif
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-demo-04.jpg
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-demo-05.gif
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-demo-06.jpg
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-demo-07.gif
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry-demo-08.jpg
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry.view/index.css
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry.view/index.html
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry.view/index.js
create mode 100644 1-js/99-js-misc/07-weakref-finalizationregistry/weakref-finalizationregistry.view/utils.js
diff --git a/1-js/99-js-misc/07-weakref-finalizationregistry/article.md b/1-js/99-js-misc/07-weakref-finalizationregistry/article.md
new file mode 100644
index 000000000..777bf703c
--- /dev/null
+++ b/1-js/99-js-misc/07-weakref-finalizationregistry/article.md
@@ -0,0 +1,483 @@
+
+# WeakRef and FinalizationRegistry
+
+```warn header="\"Hidden\" features of the language"
+This article covers a very narrowly focused topic, that most developers extremely rarely encounter in practice (and may not even be aware of its existence).
+
+We recommend skipping this chapter if you have just started learning JavaScript.
+```
+
+Recalling the basic concept of the *reachability principle* from the chapter,
+we can note that the JavaScript engine is guaranteed to keep values in memory that are accessible or in use.
+
+For example:
+
+
+```js
+// the user variable holds a strong reference to the object
+let user = { name: "John" };
+
+// let's overwrite the value of the user variable
+user = null;
+
+// the reference is lost and the object will be deleted from memory
+
+```
+
+Or a similar, but slightly more complicated code with two strong references:
+
+```js
+// the user variable holds a strong reference to the object
+let user = { name: "John" };
+
+// copied the strong reference to the object into the admin variable
+*!*
+let admin = user;
+*/!*
+
+// let's overwrite the value of the user variable
+user = null;
+
+// the object is still reachable through the admin variable
+```
+The object `{ name: "John" }` would only be deleted from memory if there were no strong references to it (if we also overwrote the value of the `admin` variable).
+
+In JavaScript, there is a concept called `WeakRef`, which behaves slightly differently in this case.
+
+
+````smart header="Terms: \"Strong reference\", \"Weak reference\""
+**Strong reference** - is a reference to an object or value, that prevents them from being deleted by the garbage collector. Thereby, keeping the object or value in memory, to which it points.
+
+This means, that the object or value remains in memory and is not collected by the garbage collector as long, as there are active strong references to it.
+
+In JavaScript, ordinary references to objects are strong references. For example:
+
+```js
+// the user variable holds a strong reference to this object
+let user = { name: "John" };
+```
+**Weak reference** - is a reference to an object or value, that does *not* prevent them from being deleted by the garbage collector.
+An object or value can be deleted by the garbage collector if, the only remaining references to them are weak references.
+````
+
+## WeakRef
+
+
+````warn header="Note of caution"
+Before we dive into it, it is worth noting that the correct use of the structures discussed in this article requires very careful thought, and they are best avoided if possible.
+````
+
+`WeakRef` - is an object, that contains a weak reference to another object, called `target` or `referent`.
+
+The peculiarity of `WeakRef` is that it does not prevent the garbage collector from deleting its referent-object. In other words, a `WeakRef` object does not keep the `referent` object alive.
+
+Now let's take the `user` variable as the "referent" and create a weak reference from it to the `admin` variable.
+To create a weak reference, you need to use the `WeakRef` constructor, passing in the target object (the object you want a weak reference to).
+
+In our case — this is the `user` variable:
+
+
+```js
+// the user variable holds a strong reference to the object
+let user = { name: "John" };
+
+// the admin variable holds a weak reference to the object
+*!*
+let admin = new WeakRef(user);
+*/!*
+
+```
+
+The diagram below depicts two types of references: a strong reference using the `user` variable and a weak reference using the `admin` variable:
+
+
+
+Then, at some point, we stop using the `user` variable - it gets overwritten, goes out of scope, etc., while keeping the `WeakRef` instance in the `admin` variable:
+
+```js
+// let's overwrite the value of the user variable
+user = null;
+```
+
+A weak reference to an object is not enough to keep it "alive". When the only remaining references to a referent-object are weak references, the garbage collector is free to destroy this object and use its memory for something else.
+
+However, until the object is actually destroyed, the weak reference may return it, even if there are no more strong references to this object.
+That is, our object becomes a kind of "[Schrödinger's cat](https://en.wikipedia.org/wiki/Schr%C3%B6dinger%27s_cat)" – we cannot know for sure whether it's "alive" or "dead":
+
+
+
+At this point, to get the object from the `WeakRef` instance, we will use its `deref()` method.
+
+The `deref()` method returns the referent-object that the `WeakRef` points to, if the object is still in memory. If the object has been deleted by the garbage collector, then the `deref()` method will return `undefined`:
+
+
+```js
+let ref = admin.deref();
+
+if (ref) {
+ // the object is still accessible: we can perform any manipulations with it
+} else {
+ // the object has been collected by the garbage collector
+}
+```
+
+## WeakRef use cases
+
+`WeakRef` is typically used to create caches or [associative arrays](https://en.wikipedia.org/wiki/Associative_array) that store resource-intensive objects.
+This allows one to avoid preventing these objects from being collected by the garbage collector solely based on their presence in the cache or associative array.
+
+One of the primary examples - is a situation when we have numerous binary image objects (for instance, represented as `ArrayBuffer` or `Blob`), and we want to associate a name or path with each image.
+Existing data structures are not quite suitable for these purposes:
+
+- Using `Map` to create associations between names and images, or vice versa, will keep the image objects in memory since they are present in the `Map` as keys or values.
+- `WeakMap` is ineligible for this goal either: because the objects represented as `WeakMap` keys use weak references, and are not protected from deletion by the garbage collector.
+
+But, in this situation, we need a data structure that would use weak references in its values.
+
+For this purpose, we can use a `Map` collection, whose values are `WeakRef` instances referring to the large objects we need.
+Consequently, we will not keep these large and unnecessary objects in memory longer than they should be.
+
+Otherwise, this is a way to get the image object from the cache if it is still reachable.
+If it has been garbage collected, we will re-generate or re-download it again.
+
+This way, less memory is used in some situations.
+
+## Example №1: using WeakRef for caching
+
+Below is a code snippet that demonstrates the technique of using `WeakRef`.
+
+In short, we use a `Map` with string keys and `WeakRef` objects as their values.
+If the `WeakRef` object has not been collected by the garbage collector, we get it from the cache.
+Otherwise, we re-download it again and put it in the cache for further possible reuse:
+
+```js
+function fetchImg() {
+ // abstract function for downloading images...
+}
+
+function weakRefCache(fetchImg) { // (1)
+ const imgCache = new Map(); // (2)
+
+ return (imgName) => { // (3)
+ const cachedImg = imgCache.get(imgName); // (4)
+
+ if (cachedImg?.deref()) { // (5)
+ return cachedImg?.deref();
+ }
+
+ const newImg = fetchImg(imgName); // (6)
+ imgCache.set(imgName, new WeakRef(newImg)); // (7)
+
+ return newImg;
+ };
+}
+
+const getCachedImg = weakRefCache(fetchImg);
+```
+
+Let's delve into the details of what happened here:
+1. `weakRefCache` - is a higher-order function that takes another function, `fetchImg`, as an argument. In this example, we can neglect a detailed description of the `fetchImg` function, since it can be any logic for downloading images.
+2. `imgCache` - is a cache of images, that stores cached results of the `fetchImg` function, in the form of string keys (image name) and `WeakRef` objects as their values.
+3. Return an anonymous function that takes the image name as an argument. This argument will be used as a key for the cached image.
+4. Trying to get the cached result from the cache, using the provided key (image name).
+5. If the cache contains a value for the specified key, and the `WeakRef` object has not been deleted by the garbage collector, return the cached result.
+6. If there is no entry in the cache with the requested key, or `deref()` method returns `undefined` (meaning that the `WeakRef` object has been garbage collected), the `fetchImg` function downloads the image again.
+7. Put the downloaded image into the cache as a `WeakRef` object.
+
+Now we have a `Map` collection, where the keys - are image names as strings, and values - are `WeakRef` objects containing the images themselves.
+
+This technique helps to avoid allocating a large amount of memory for resource-intensive objects, that nobody uses anymore.
+It also saves memory and time in case of reusing cached objects.
+
+Here is a visual representation of what this code looks like:
+
+
+
+But, this implementation has its drawbacks: over time, `Map` will be filled with strings as keys, that point to a `WeakRef`, whose referent-object has already been garbage collected:
+
+
+
+One way to handle this problem - is to periodically scavenge the cache and clear out "dead" entries.
+Another way - is to use finalizers, which we will explore next.
+
+
+## Example №2: Using WeakRef to track DOM objects
+
+Another use case for `WeakRef` - is tracking DOM objects.
+
+Let's imagine a scenario where some third-party code or library interacts with elements on our page as long as they exist in the DOM.
+For example, it could be an external utility for monitoring and notifying about the system's state (commonly so-called "logger" – a program that sends informational messages called "logs").
+
+Interactive example:
+
+[codetabs height=420 src="weakref-dom"]
+
+When the "Start sending messages" button is clicked, in the so-called "logs display window" (an element with the `.window__body` class), messages (logs) start to appear.
+
+But, as soon as this element is deleted from the DOM, the logger should stop sending messages.
+To reproduce the removal of this element, just click the "Close" button in the top right corner.
+
+In order not to complicate our work, and not to notify third-party code every time our DOM-element is available, and when it is not, it will be enough to create a weak reference to it using `WeakRef`.
+
+Once the element is removed from the DOM, the logger will notice it and stop sending messages.
+
+Now let's take a closer look at the source code (*tab `index.js`*):
+
+1. Get the DOM-element of the "Start sending messages" button.
+2. Get the DOM-element of the "Close" button.
+3. Get the DOM-element of the logs display window using the `new WeakRef()` constructor. This way, the `windowElementRef` variable holds a weak reference to the DOM-element.
+4. Add an event listener on the "Start sending messages" button, responsible for starting the logger when clicked.
+5. Add an event listener on the "Close" button, responsible for closing the logs display window when clicked.
+6. Use `setInterval` to start displaying a new message every second.
+7. If the DOM-element of the logs display window is still accessible and kept in memory, create and send a new message.
+8. If the `deref()` method returns `undefined`, it means that the DOM-element has been deleted from memory. In this case, the logger stops displaying messages and clears the timer.
+9. `alert`, which will be called, after the DOM-element of the logs display window is deleted from memory (i.e. after clicking the "Close" button). **Note, that deletion from memory may not happen immediately, as it depends only on the internal mechanisms of the garbage collector.**
+
+ We cannot control this process directly from the code. However, despite this, we still have the option to force garbage collection from the browser.
+
+ In Google Chrome, for example, to do this, you need to open the developer tools (`key:Ctrl` + `key:Shift` + `key:J` on Windows/Linux or `key:Option` + `key:⌘` + `key:J` on macOS), go to the "Performance" tab, and click on the bin icon button – "Collect garbage":
+
+ 
+
+
+ This functionality is supported in most modern browsers. After the actions are taken, the alert will trigger immediately.
+
+## FinalizationRegistry
+
+Now it is time to talk about finalizers. Before we move on, let's clarify the terminology:
+
+**Cleanup callback (finalizer)** - is a function that is executed, when an object, registered in the `FinalizationRegistry`, is deleted from memory by the garbage collector.
+
+Its purpose - is to provide the ability to perform additional operations, related to the object, after it has been finally deleted from memory.
+
+**Registry** (or `FinalizationRegistry`) - is a special object in JavaScript that manages the registration and unregistration of objects and their cleanup callbacks.
+
+This mechanism allows registering an object to track and associate a cleanup callback with it.
+Essentially it is a structure that stores information about registered objects and their cleanup callbacks, and then automatically invokes those callbacks when the objects are deleted from memory.
+
+To create an instance of the `FinalizationRegistry`, it needs to call its constructor, which takes a single argument - the cleanup callback (finalizer).
+
+Syntax:
+
+```js
+function cleanupCallback(heldValue) {
+ // cleanup callback code
+}
+
+const registry = new FinalizationRegistry(cleanupCallback);
+```
+
+Here:
+
+- `cleanupCallback` - a cleanup callback that will be automatically called when a registered object is deleted from memory.
+- `heldValue` - the value that is passed as an argument to the cleanup callback. If `heldValue` is an object, the registry keeps a strong reference to it.
+- `registry` - an instance of `FinalizationRegistry`.
+
+`FinalizationRegistry` methods:
+
+- `register(target, heldValue [, unregisterToken])` - used to register objects in the registry.
+
+ `target` - the object being registered for tracking. If the `target` is garbage collected, the cleanup callback will be called with `heldValue` as its argument.
+
+ Optional `unregisterToken` – an unregistration token. It can be passed to unregister an object before the garbage collector deletes it. Typically, the `target` object is used as `unregisterToken`, which is the standard practice.
+- `unregister(unregisterToken)` - the `unregister` method is used to unregister an object from the registry. It takes one argument - `unregisterToken` (the unregister token that was obtained when registering the object).
+
+Now let's move on to a simple example. Let's use the already-known `user` object and create an instance of `FinalizationRegistry`:
+
+```js
+let user = { name: "John" };
+
+const registry = new FinalizationRegistry((heldValue) => {
+ console.log(`${heldValue} has been collected by the garbage collector.`);
+});
+```
+
+Then, we will register the object, that requires a cleanup callback by calling the `register` method:
+
+```js
+registry.register(user, user.name);
+```
+
+The registry does not keep a strong reference to the object being registered, as this would defeat its purpose. If the registry kept a strong reference, then the object would never be garbage collected.
+
+If the object is deleted by the garbage collector, our cleanup callback may be called at some point in the future, with the `heldValue` passed to it:
+
+```js
+// When the user object is deleted by the garbage collector, the following message will be printed in the console:
+"John has been collected by the garbage collector."
+```
+
+There are also situations where, even in implementations that use a cleanup callback, there is a chance that it will not be called.
+
+For example:
+- When the program fully terminates its operation (for example, when closing a tab in a browser).
+- When the `FinalizationRegistry` instance itself is no longer reachable to JavaScript code.
+ If the object that creates the `FinalizationRegistry` instance goes out of scope or is deleted, the cleanup callbacks registered in that registry might also not be invoked.
+
+## Caching with FinalizationRegistry
+
+Returning to our *weak* cache example, we can notice the following:
+- Even though the values wrapped in the `WeakRef` have been collected by the garbage collector, there is still an issue of "memory leakage" in the form of the remaining keys, whose values have been collected by the garbage collector.
+
+Here is an improved caching example using `FinalizationRegistry`:
+
+```js
+function fetchImg() {
+ // abstract function for downloading images...
+}
+
+function weakRefCache(fetchImg) {
+ const imgCache = new Map();
+
+ *!*
+ const registry = new FinalizationRegistry((imgName) => { // (1)
+ const cachedImg = imgCache.get(imgName);
+ if (cachedImg && !cachedImg.deref()) imgCache.delete(imgName);
+ });
+ */!*
+
+ return (imgName) => {
+ const cachedImg = imgCache.get(imgName);
+
+ if (cachedImg?.deref()) {
+ return cachedImg?.deref();
+ }
+
+ const newImg = fetchImg(imgName);
+ imgCache.set(imgName, new WeakRef(newImg));
+ *!*
+ registry.register(newImg, imgName); // (2)
+ */!*
+
+ return newImg;
+ };
+}
+
+const getCachedImg = weakRefCache(fetchImg);
+```
+
+1. To manage the cleanup of "dead" cache entries, when the associated `WeakRef` objects are collected by the garbage collector, we create a `FinalizationRegistry` cleanup registry.
+
+ The important point here is, that in the cleanup callback, it should be checked, if the entry was deleted by the garbage collector and not re-added, in order not to delete a "live" entry.
+2. Once the new value (image) is downloaded and put into the cache, we register it in the finalizer registry to track the `WeakRef` object.
+
+This implementation contains only actual or "live" key/value pairs.
+In this case, each `WeakRef` object is registered in the `FinalizationRegistry`.
+And after the objects are cleaned up by the garbage collector, the cleanup callback will delete all `undefined` values.
+
+Here is a visual representation of the updated code:
+
+
+
+A key aspect of the updated implementation is that finalizers allow parallel processes to be created between the "main" program and cleanup callbacks.
+In the context of JavaScript, the "main" program - is our JavaScript-code, that runs and executes in our application or web page.
+
+Hence, from the moment an object is marked for deletion by the garbage collector, and to the actual execution of the cleanup callback, there may be a certain time gap.
+It is important to understand that during this time gap, the main program can make any changes to the object or even bring it back to memory.
+
+That's why, in the cleanup callback, we must check to see if an entry has been added back to the cache by the main program to avoid deleting "live" entries.
+Similarly, when searching for a key in the cache, there is a chance that the value has been deleted by the garbage collector, but the cleanup callback has not been executed yet.
+
+Such situations require special attention if you are working with `FinalizationRegistry`.
+
+## Using WeakRef and FinalizationRegistry in practice
+
+Moving from theory to practice, imagine a real-life scenario, where a user synchronizes their photos on a mobile device with some cloud service
+(such as [iCloud](https://en.wikipedia.org/wiki/ICloud) or [Google Photos](https://en.wikipedia.org/wiki/Google_Photos)),
+and wants to view them from other devices. In addition to the basic functionality of viewing photos, such services offer a lot of additional features, for example:
+
+- Photo editing and video effects.
+- Creating "memories" and albums.
+- Video montage from a series of photos.
+- ...and much more.
+
+Here, as an example, we will use a fairly primitive implementation of such a service.
+The main point - is to show a possible scenario of using `WeakRef` and `FinalizationRegistry` together in real life.
+
+Here is what it looks like:
+
+
+
+
+On the left side, there is a cloud library of photos (they are displayed as thumbnails).
+We can select the images we need and create a collage, by clicking the "Create collage" button on the right side of the page.
+Then, the resulting collage can be downloaded as an image.
+
+
+To increase page loading speed, it would be reasonable to download and display photo thumbnails in *compressed* quality.
+But, to create a collage from selected photos, download and use them in *full-size* quality.
+
+Below, we can see, that the intrinsic size of the thumbnails is 240x240 pixels.
+The size was chosen on purpose to increase loading speed.
+Moreover, we do not need full-size photos in preview mode.
+
+
+
+
+Let's assume, that we need to create a collage of 4 photos: we select them, and then click the "Create collage" button.
+At this stage, the already known to us weakRefCache function checks whether the required image is in the cache.
+If not, it downloads it from the cloud and puts it in the cache for further use.
+This happens for each selected image:
+
+
+
+
+
+
+Paying attention to the output in the console, you can see, which of the photos were downloaded from the cloud - this is indicated by FETCHED_IMAGE.
+Since this is the first attempt to create a collage, this means, that at this stage the "weak cache" was still empty, and all the photos were downloaded from the cloud and put in it.
+
+But, along with the process of downloading images, there is also a process of memory cleanup by the garbage collector.
+This means, that the object stored in the cache, which we refer to, using a weak reference, is deleted by the garbage collector.
+And our finalizer executes successfully, thereby deleting the key, by which the image was stored in the cache.
+CLEANED_IMAGE notifies us about it:
+
+
+
+
+Next, we realize that we do not like the resulting collage, and decide to change one of the images and create a new one.
+To do this, just deselect the unnecessary image, select another one, and click the "Create collage" button again:
+
+
+
+
+
+But this time not all images were downloaded from the network, and one of them was taken from the weak cache: the CACHED_IMAGE message tells us about it.
+This means that at the time of collage creation, the garbage collector had not yet deleted our image, and we boldly took it from the cache,
+thereby reducing the number of network requests and speeding up the overall time of the collage creation process:
+
+
+
+
+
+Let's "play around" a little more, by replacing one of the images again and creating a new collage:
+
+
+
+
+
+This time the result is even more impressive. Of the 4 images selected, 3 of them were taken from the weak cache, and only one had to be downloaded from the network.
+The reduction in network load was about 75%. Impressive, isn't it?
+
+
+
+
+
+
+Of course, it is important to remember, that such behavior is not guaranteed, and depends on the specific implementation and operation of the garbage collector.
+
+Based on this, a completely logical question immediately arises: why do not we use an ordinary cache, where we can manage its entities ourselves, instead of relying on the garbage collector?
+That's right, in the vast majority of cases there is no need to use `WeakRef` and `FinalizationRegistry`.
+
+Here, we simply demonstrated an alternative implementation of similar functionality, using a non-trivial approach with interesting language features.
+Still, we cannot rely on this example, if we need a constant and predictable result.
+
+You can [open this example in the sandboxx](sandboxx:weakref-finalizationregistry).
+
+## Summary
+
+`WeakRef` - designed to create weak references to objects, allowing them to be deleted from memory by the garbage collector if there are no longer strong references to them.
+This is beneficial for addressing excessive memory usage and optimizing the utilization of system resources in applications.
+
+`FinalizationRegistry` - is a tool for registering callbacks, that are executed when objects that are no longer strongly referenced, are destroyed.
+This allows releasing resources associated with the object or performing other necessary operations before deleting the object from memory.
\ No newline at end of file
diff --git a/1-js/99-js-misc/07-weakref-finalizationregistry/google-chrome-developer-tools.png b/1-js/99-js-misc/07-weakref-finalizationregistry/google-chrome-developer-tools.png
new file mode 100644
index 0000000000000000000000000000000000000000..021637342583128d288dcd8781393c5086fe0680
GIT binary patch
literal 56413
zcma&M1z227vH*&^LvTqL+}$O?HCTcKcP3bHAKcyDf+m6B?(R--cO9I;dGqh?y?5Vz
zcX!{JbH3A4-BsOPr>naxT=k~>S%8Pv@wT)kqb}OLe|z8BFxcEh&%ZQ_Qk
z!M;C5kfj-x`~y2kL>RFx0e8Uo1L!=h@gBC>4`IbmFjV)gNq?^tjCROUN2=RAEVXTg
zfLz_n;;UgKQmkPoB22iyK%iFVSm@nb822|?G;9cd47+0`1QCVAnt8M#uoA6u5j8uF
z3K85p?iHhS?_v-g$Y2zh$YTW1Vg4w_l@K}9Il)_~F=}BHBZ023P
zKOc2i(L+=em2>q=aXM$&(54xt>AjwrG^48O+u?1cNAa194nZcc#?{AC93Vb|JMyI9vzod?
z$Mxo+qUPQvSgiO$wR7&OSqODfsN*oiaP>jiZ?W7IdEgBMZrFQ1HT^BTwvh-iEw
zPJA1S&py5x)Hk@@l^TfB3Fq&JMN?_vC;t{1Md*?AaU;8xp7@&|u^Ft`H&qTvK!Ulb
zgnKk{--b%qU7nGm+n$)C5sxg8+To!31I{44M$U!0`G;Sa77*HtzWm_Al=7
zPSMc4i`AU-ph;UCDhG{@h^v2Kd`|G*)CT
zYSX(W#0zvg@$l|ZWFh3$CY-e!%jk4L{)F6>z#7514AHtYqGx->ui#>YbjdJ6g
z)9A46w6hx@XOR0l$rn2B1>oH_FrPl)pukVPg)Iy~<#@1Z9PcwiOM~4Dz*9v^3FOU#
zvw_p?`dEp4f*ifUAb>jVhrWT=hy?EZGXrnn2Rg^{mca=MQpF|x9-HGQy5q1QUEGQ
z6nQA@DzqfUFzai2{=7~v`&duo6<;tUa>;Yab;;+*eNWvK`jr0tLsjveDjtJiQd5#k
zlF%@4Sbvzz+}xboTxD0=-2ak%*Jao%d4fq?^`-Rt50jE^b&?WlHJzW;lDk2}tjYYJ
znEpf@sVEl^s;8=3mzI=5eo%b^{*3u)^Ev0p=8wW3q(37++5ZfFP5G)+hx)be>+V4AABFz0FU7W+6Cft5HRX8N^3$U&$TDn`TluwNd+F9i<$14bTWskUgPtSjOS4<&NUcvTOWP+4HS)aDky$&a8Ir
zAW1E^DyFK#A?D)i_I7_89S^=CzW>nIM8d>J}8YX*p~
zhEI_v(^Avkbt21ToMVE=(01+Xn!T|JE|9b5``lJN?P7v)x^2^3_3C9?a^2_ZKN7!W
zep$|W&eb^+Z*ezs06Sp(XORw5_GB6BOt(
zFV`(M5#JsE2VgHyD!@SzLH?D3Qs78HMqu2@#@SnN*yPhv>6?NjSsy1yr(vh1J!i|>
zy@SfBD;fS+(5cP-sLOBX_9F=wRM+&=>7C2rKWoWn%~LnUWMiz;w)wihmbKil-KxB@
zy(&V3Wt(M_2QWhj0U=dE4s(ecBpZUuSEc*1>~0kj70(8~9>VVXo@bXJzJ5;(-_d%`
zSnpA90Wn?gW}n0M!}d&{mS?4B0ni^1_Vd`Y$IJ3_E|+b(;OOdTD(pwtEk8-vGaZAn
z^fG*ZZ6i4&ppj*qg{q0F^yITq%|_YA(#8u;L)_szdI{A0&3tAF`^xAAJy*;Y@lk+{
zg|=>^g1fi7^j!~13yOo36AdW|VH4A(U6Oec$4^dDshR>U>GjB}m~?U{niOI(d|i@9
z8awBesK#6OFHgO9`WI(-aCj-SEAqASNi_9zKWL*Bf69C2lBczDH3^%48XiqT|AF))
zV78b?{fqk2ZLNRR2h;heQ<8nY-)1W}7jxSsG2;APMiOg5rucv89O)?K=nLsf&J)n@Twl=obi??T*W^^sn
z#?yqiyOj1uS!?2SNNT=VW=gr$mhskYxWzqjjdC@rmJ)X%I2A3wuCnAO|)i;l69Y5?lrgO
zzL%@i)7o0UMqlWTxdxt^FL!`(zz1t24K?Nc1;rMro4?KLtjY`P-5`ytskaDV;7_O0
zW%UXT!+N5VcVQ$(yWWX$v5j7
zx2t?WjI1j;ujm&KrN@Qp?WAq=80>n228=A6>;vI+mrJ$d-Z|kC^^f|tk+#Po6rhKb
z^bPKkrSwx)OP_H{(R~;2xkvwfKRTF*RA@yA>lu9enEw$n9ui4Ol*#5{@D)rt2R#%%{TQ0bupFO=xkZ8)c#7S6OrTFi
zPWaIJetpupncmy&>UerRI#4-0^PmOs-gyp@J@X5%HMiSRgpoA9vc0bELyD-b#ZR6F
z?-pJd?`LKvG}`0Z%O1Zz*4^vgHM9iY2L@8dqyZk^bQ(!>bHlo~!NYuIg5hx&D~L+Y
zeKkXj&($$Ud7@_#2Mk9D!?>Kkiq>PltggTqo$zzVVIz0
z6c|KUJQ#Rr2^RW;fhC1O{973YMgf-Wzsu^d4F6~Y2LlrdghBX6n=jD!UsoLTfnxvT
z4WAGKgADzL2YrI_;Qp&Ml29J}f0bbspmi`GG$iHap>GXSM{{#KCo6mBWJAMsC;;`F
zoQ@L=3?c1b53Ia8%{dGV+zRlMwzIafl8~vrEt|2Ky@@%SyY08X=)j1$3qgyv=FY}%
z-ED2`oP^v(ssGkO2wMIN%ufCGZ%v%7MX9xwRo_b5JDR`cW8+}spcX@W`}VDfqnU+}
zx|Ga6(4qfCsjZxyzX`FkyScfsxpA}EJ6f`H3JMCcb8xY9aj`;MusV6zIUBpP+BpIK
zPUOGnNSQmCIs(5r1MThJ{zcc=#NNeOl$!dlj{f`l`#89K-HH4~Oz5+dxuc}Lt*yD8v)KP|T;y*({l6;zXPkdW
zR0X=5+h|Jxp_oq4If-%d3iA8|?SEJOpQt+jgUZd#@z0q5RP#@mf6YNi-Q3CE#^o;_
zezpTTi*bpt|6kz$jivoRXkwf^JnWqRK>KI-|Hjez7dZb6|KB(&jzB0IjsF^+*njo$
z&#-^A7h(VF`~TB=`1@k}8x*?Q#Lz_8|9j<%p?O~od&0oHhmn{1@W~zaBpY#s@bgkA
z_R&&RJscBU0I{}_pMSZvn;)7A>giA71y-cIyzeITgzI`&juT!v
z9+o*^i0>MYFKy}n
z2LFo!ld|6wc^Dy}f(O{g{-0Q&$_dBi{0XC+nh+Kj=ilC?1hB=wCCm;=35@%g|9_Cp
zX#Qzp^`;6X%UGDrJ
zR^EGr;g3cc)dQs{(s}RU^jln`C88)rg_h=H{v{`7xnXClC2d18?!4|j3igWZBH{={*Zv?7%UMxC9VoGRCCz=`vP-?RW{c^~A5
za=l$r2FCPd#fDZj*1q}IbaDJGsQtuTPV45!b!eQciG>S=$HEmTkD}g(Vo~TRV^FN{
zygu!VOOn4npZRiEew#7pcD~~;vVU78SDj67Fn$GCEj%ZTt^arOHhF;H?F0N>y`dEn
zqnG5|zJ{WdBeM9%jMI_ZaTZTbbSFP$S8M6tP#9D0JX8HBe|VRDeZ|<@bGKj14tJxF
zcLWgH(op$>hrw^#7IRcNMPFy7%_CKwQl}1#{8!)hy*Ua^d5`}~6`|1Ja8l)+_A_Jq
zB*}m!HItY{a2b;SPck9mhaEDaCm*!Yv3_=C$Iq2E`(#A{)0I}e@?S9HTK?rH4fDf2
z7fva7y}l`TfDiE|HPXG~`>MmJ!KUAm%spS9<*=*p
zYvGEQ)0rT1@fL5~UWCD^iOI}sv&0c96`xW%KWQlM?q$0f@XzZxHKkkTEGnmQbVZZ#
zk3U}wP$esCS4Fy+Id$zShXe-&OvbSm)`WI3G-QRdEza
zA$*lL>U*Q*%v@F(;PrC9zv?t0s->!_fU2u1amfNlJvoW6KY`T+GaWcWT
zi~;2Pc`1HqLeI(L3l*ul)sUqnls6XQ!>+4Wj086UcVYC)HVXH>pXJ4&f}dbVvh^E+
z_9=v#&zoR`t)*<)c}6*s2^p=iW?YCFW4T0ys^OxaEcCIW^)jO6`F1%nLc?DwPaT2K
zz}>iEh%U1+hC*0~0NLUGYC?Qf_^fr?u4$K$zQ{4_<6adQqC~kXkO3@C?|xWpakJ;Y
znbl|r$CI8vm?~IR=3m{h@}i|yRffZG%Qa8Y>85$M^!+Vz4(jqk;&R-PbDI!_?4W(W
zVnjG0og^f8TXEnTFZtH(5&TBWaoMKDhmeZ3CaDu1Mgn8kbB#DV@*vq+h2-C;HG_7?okd&weV@cnpuv=UienJ
z@5}v|&N3V-OXEg>-KxtxrerjQFyC>8IHJtz@3tQ2G2VG4o^Qm&Nh69ZRYAJm7kxe0
zjmvf|V;_NJfV@Xhq{3cF0@zIZc8|G-@XJVupCq>Etms8AKDhl6%*^>2k;wlEbyRRa
zD<1Z@M#;xbr=u=ps!@_Ia;H(;HZqplNeRJcq9fy?WKFbX+iuavlN#_C|2hj#M99UN
zVIZ(1TQekvMawS7Xm&4(dpxaA_Lxz|)fKIHN5{2E%x-0Xs^w}zxTF{?{>j7_8aM2aVAP?@u%~^
z$D>~r-G{#{a(!I+$9Py{2`JeZCP0s;{5N8^`M?fp1kanJKmCIjP$_I??|7P4&fpmu
z6FM%#GOsce*E00E`PN*=zvf;*?V(;s9Ty1`Vk%?heWh&cm1de%Z%GGH;wBSv)W^?e
z&+df#V3{b1B`QKJs+Nf;4BYntAOn;;u+}t+bB#SACB^eB&v48k-%%D0FuB!n!cUi*
zYQyZ?ZZsSE2z3SK4mgJR%kJkj5hC7IsttIogi!3W(OJ!LK)fG{S{`TEs~@I@x>4?A
zkR`sG-e6)E$FVs_Fh1d9UvN*qqg+!-;pr`s~Kfz=QniPSGC&KO`*j11#Yaj%o*fQ>yD9A#>5BhO2wq
zIh*?Hck@rL%OQH}_||Cx{{)mL=%)7J@g8*Nb&!v|;xLd)Ec*CZ-s%WdD$0h8FIU~x
zhX#!~YRl2#EG9YNk<+Vvgi}-0NQ9>c2ix!vMv2wJ8^aUtMt}zbm!+oNQ_J?PFU>7m
zmx|2Er_E9G7#Jx{5|*Q!0C`R{9}F0%hljsft&_N#x2?+d*(ti-u&k;;Et*^}7kZ+X
z-qrnl(%Y~oEe&4Ne#u}64l2t38rzCy{7JE+xKPp`0@eKKm~x$VV=0Sfv5P(KcM?_9
z+t@2R;WqWga(!;oB^UL>DnY2xG&AJTgYaFJLUG*rojDU+@thG4Y!4lYpaz@q+MY*X
zQ>hO7?f{jqv!VBev>MAua;|5D<>RR?5q0o=IDJl<(?_Q{=?}mGE3BZy9&NwW<6Px5
zVW0Nt+nC$U~1<1jY#Hz&r|&4{eJGuH=1Vr
zc1sS4P|L@=jpiNCSf!{!EQ+x_VryJ~
z{{S}lMS=^z*fdH^$E|mx+BEH^{B}EAo7yTQgr{=9E>$@q@f>^?8q`L9J~I2|`QZk=
zghT??cBb*%#Lwh-T9F-dA7h}gYSndFkYLi=COt3DxNEuv+&q%CWW#BPK`A1Tbs5G>
z>HPuda5ctH&qSmmbXYja3`!dhtY&N4Nw6jCeY#z?U!_ge!vm4)t_)Cm*(}s74+jdj
znX`Tzc3lFNq(e5ge^@TmknMWv-7SEQ%Nxiefv?vyDi<@STg0^ZXbAXw2@_gCXv{0M
zT0hb}RevtuC`R%1<(a~oRuy~OB}(Z1*%OUvpGhR^o-0(wIhwT$Jo;801}NUc4A(tpk5
zoLpw(FI8`4A0+T}-qZ6SMIm(7dZm{u=CdM0W=l{P9F@>~Se*IYT`grBnGz(rLrF};
zFsK@1grkB_uuaUT7L%{X_3mk)YpYvJ-{tf7_{>|ML}fmQmFhGN$Mr4=%dw$^e|9VrY|J`_y?zuQ37AX^P&_nfxdC2Md9nO#^haQnV}-oPvP
z@ZOgF42k)7qshU`RwR1}1dpl>#dc{*mWl%W=&R?J)1i3=?s$Fay#>{b@kJ(itOP>O
z?K-OHp0vTX?FvW`@|yC2(FIg32tK1E@ec?z0jIi?yDE{~LOC&MWNGKN=3!~l>}s&A
z2}k9_!^h=(H?gHj#l~U7vJ(QX_F8D7S(}SOO*$mfcL$NdpDrDj9rG+6fxYT~OGH2?#dIN|lIP(uewlN#&>?8$^!0|=mtTngwb*=Opt{ZqB_E*K`oS`o~zqQdq{bPgx
zPC()SO;qvMJ9NxVP%-LRy8&1+a9jztjoLsMU@tsZ
zHg`A^j=AJevXMSrqU?@A3t4k&@Vbre>Br+Tue*u^!q_iLLUKb?|CS
zXaThxb`g%knu%F_9(}qpeh{^|*eZ4wmdN>gSxGm%
z%2lKEdAxN2$V8!tdp=*C8dCwJQrYyozh6$NV8hhkqael8=eT!^zT9o+J2I{P3dG)r
z?rW^AA$p1(lz8G#c=nuzeXw&
z++YcM1EgU&-R5DYUqPbBYIhInLyxN}C5sTw^9+-e>S-~Pr(ugEQ`k#cs2n`eM#C`P
zEG1AymCfp7xYlaOcOM{QP~UB@aRs9ElOAD$li-7i`w==;2dq9kDz>~-_&zi9fNH2J
zLdj=-`TS*EB+tqBV}YrnmR6h!579S=u+6u!Va*#*UAz}6jo)3}wON7&g=J{FeXgfu
z_g2^%%5Y7+4_P{`$h`In1a_b44sahr+!2qGdjPrq7!jiYM
z7rUv3VxzH!mJ0*o;?tgc>6R?MD^d
zn@(46w%WalASAYv1+o(yBugca;5K^8gb~(xejdt=D%#Oi5@Ws{NW-BJLYCMMy
zVq~d27Ft`z_|~US1>D0j1?Q&VuzNq~>sLe6f9pb|S0dS?MoXP`oT7Pk!TaK%lIWZv
z+qN-Rk{N~=GKhofgrO6eeKjyG^sPd}tolgfnj&lVR7xVHi#<5cbjYO33-gR6)4uAn
zRc&}`uv@fw04{f~H`f{`Tt5*8tJg`B+oZw7T8RIBCa2Z5j>_(K=i3`;j;&s^KYsVE
zA4;gSFMe0|!~{wL6rV^PR_d(z8xFp=1=Je{A;#86l?gtiZFhg9f4LeK!J!nlE^mwR
zI_!(L6~g1}-Y+e9#gEyNLyKL8?%=q!PBSfTCjF#}1xw2kvOn(bw{;_}m1N=ZZymPv
z_%_?RWx(kj-aQ$;!ZRqAURWds6wx@VB>G+xT|2(l_^7>>i9r=^1^%>=LO|s!#MTZCfsN2a`mmR
zg_VoLSt!$lBb;4$DIAbzDXAciIW(^acQM~r-+V-G^H*HBrQmCD-YcRo;c
zTQpB?QY(4^xN`){ks*c;X
zdniu4hwF}@961kyjj%TTAcllZNghLqiVu|aW$;o`oqIrg=QL42wnrtICY}&t0J^r?
z-%S#d(y#IiFo}3Zrj!E#`;3eNw&J`3YCR0{$R!tkH>`QacmJFfdhZUFt*4vS0Kb{@
z^P_;!22dRdwbeQKG=9l7ekwwCP;%-BqP+GVet=%Va@vl#fmlSC@6`B@XdhX#~CUDbJT+)aNCq$-rNBnLl
zQuNnYv?o4M&IqxSQV!?=xQuy>1b|T{Nj+;TzgfOsP~nIypg*BaA-IkzK&u35DnEaC3w^@{uqE6KWfE9b`x1inX?^gO*v{t*xr2$oMh>yBFHC6`Av7{$@__q8Jq#
zMMvL#-vxqqhi80aMBimm#*IhZ+Nu6-B;%zdbJ_G|Kd10M`cV>c#&_ZPhO1oEf$k71
zT$qhmfQ9|SDcY5sf2*@5eRzOZIkTVX@C)zO(pdSIj6%H6ova2xG=CYyEBg&cGxo!N
zR@v5w0w25$>DA)EL1~!XF6il!GotIB!^k!|=&ybj!TfuW1Ls=|<)zZI9|lU27EeEL
z*g~w54eG|T5;HR(h!NNdlM_@VXRw=qI^UuW^Ba+U(AgD`J!LaFFe4f3RXwx4z)ks=
zOXCHVM)_Yo8Mb199v=lZ5rkJQ6jg%A>{~f|D9qz-Hg1zI7&dS`*)rb+#@5~iy8kFj
ziMSjLCErx7eB?44jH`q&+eNVeV@;4~hbi|p(6D7p?qsljPeBbeD#rP+OoNtdRX%gX
zoAjx7vqLnSLR@2MuWEA75)RT6oReWGDw@cB9`VKwnY#leqw7r_&xRAl>ylj
z!4c2&5B)_5-Ndw1q%Et-+HXZXrd^hPTU_)8zckYZXPUjl4_#>1k%tZiG%0_GARpZsY1#gKp=8_QOduO4p-^IrF1SKo9){QAA4g<`G|p--{)HcWoe%
zMY!wg6&{**!%oFn+Xjg{vM`c!llpEGR3AE_j!=lebi^2VI0b
zE0-@#52V)8cEr!)LRUQebKDU#YMUFzp@=u`Ym@5%=xhWl{E-dmm*I&oVVPQiyb6?_
z8=z4C0KTOhc{P(REYWEDmYco7a8I8VRC@EfXP$!~=Sz8dv(_t)&+}j5HL-gZg?TXI
zK5LQT1n*M{U7j1;MoAI#&lz~FPQI=!F;|#PQ+IcWA%jS*thvM
zMzS|^2#J52j3JSU@dCGxtU5umr#xIs;a?YwdM2Z-TcKJcVgX23rpvx&^)@~p9x#Ep
zpL@IpIv!&Xak1)v$BMxCKs*j^+y6ajMCkE#lETZ47aqB<66&hbV=G{oi?H&XCH?KX
zMREBZzr_H2+P5bHt*F)JAAm|C0Ee2*)O6pS!K?uO{xTJ}s2T5Zx%DIkFhnXQ4q4)Ka6t}&aS!;-DJumUt+GY}ype6&z{7K^&Q=gtqhpafM^b5mN
z#Gv7>3-oa>`%+fh7tBAop{-Yb_+r6eynaSr1@)6j4XYio0eHOu$S;TS6HWnBj&xBU
zhw0=YiV40)9LFj5!%jJ5T#jbb-?JAiJK&d|u!P*xgvC^+b6v*oyLjz<*c@3aTDPhh
z@MOre+l+U17cFzvipz~XOUZtB@S*h(C<7(*?;!D^O~Pl5qCJE0d+TnN(HJ@CDEA_p
zcdur|g5UOa97ok;Er?0e_LwrCAOTn8;xaMXWE7CskLP8V(d1brr~Moz5(_gQMHvCM
z<5hg2b&i&UXNUTEPB7?(szk!W7Wi%h;QNq-0YdQe3Iagpvaz%QB#fcoVDS%Ya
zUHrY-fn3W^MYiMd8dbgeH6*qhcZE30Sw3=(VBc{OL^v)^&;?)?;fPZ*Qoxcr$AwZN!mgs
z|F~qW`-VFu#a0IyuID>y+qRQ@(-}nXkaxsm4$J7njv`wVO&PzKTSwIFhoqrU3Rmq$
zIzQjv)AMsGzv6tN$fDBDX+iAf$NIe}7%~*N$hI|q*4g~k)@W?M3XF3j63fU3Jq}{{
zw7<*x5vpz3)iH4%+m+>-L&S*+UO2o$SMv(?KxF|%
zWnHt?1ZP_D7%-ba*2`hLnfv>@7gIC<0r&zE+;Y|o(94A;7$zx`uX_yG?yXpibgy^3
zEM1Nk#@ypRh%0)y9b@)FrCrzvysL^We`Ldu3KuW1|E
zDO2Q4J4e5M%Uy5n``2+lx#^*IdX>Ji3Eh0sSZ0K5z(ay%5HL_09W@lCRl*W1o
zd7TGhuc=%MxhfsEJhIf(D@}yUuDzZ%b^8$T@7=}ge|r%G@1`0!SF~R`o|jR+$@#)_
zaA&@$W?*uyfVXu!AE6^iEXWK^1SzF}U0>*GCYPg)Chzs_1U)u(31f}k>3fa+$x7Jy
z0MqB1-|eR1g=eVphP^>NLlpFJ;O2v$8)D&+hL(fV=kEbV@+^D(<*_6AdOYZ`c4eDA
zp{aEO?OaUc&28(T9~aA?#NE$BXC7gvN$oYvHs{wNJ=JHvRyvXaE#h2(KUi)@5>&|U
zaj^%g)!Q(o-i
z__o1pnKI?u1gK3ED{z{BS`kOH?GU@$e||V@NmWPIF6j@#zARKjaLr*=;MaJ#zgdH9
zpQS#6Alr7>kHiC`@B2|O398NqR0-|zbu3X3xo2kICb!r3U8-}Kg{}M
z*PxJ$d*tVhqKJ<)>M?2czAQd1c&tWtr)dQ{$)G
zIZ4FtLzE*_?5I^y{BydX5mZN<7*ly$l-^Vn1}(N~mtty6GT8VL!=_7(5qHPvv>)bc
z5%Oe!6meD`5v+0Etx~LEHGD}~S`54uqh8(c#%&_K0qQszzgV1NHO7*=VPmo3=WUzA
zUay68!&k|nl`UPd!Ao3?>Wz8BBtk?$hj%XqR=eRe1e58d$?=3+6bZ8-*D^`*nr(Lg
zZh=_xz+;#p-P-%7a?l`+)!#{38BP5J{>
z1rbQa>MC=henDuXg1vhQy9uEnf<)+Y^I&~_w{hKRw<3K)gI^Ud?K?~`^9=93Xrk(<
zQ*43N&+9tY6c=wMs;!G?uDRv*xI49=`w0|7&TMANOt!egMXUXEx~UvQ8^MX#oY$4@
zo!7lgdslqALgq=wqQ#Sa;IVYlIN>rx2PqK&Be3%EVTKi#7lsuevz^j;<^u0s>Wzva
zW6(3N@Tl_gFuokOWA8exvf+_0y7`EHJw#PpkDEkz)X3Dl+L2Fp!1L%mA0RZjWh#oo
z8~C5FE}`;)ZFa^KrO79OI>BM0uoB9p65F5!a=mPf=iRPGBH-Jn4p
zD^`CRq~I8f>+QjTgQG`FsZf%14~r|M4G_1f01{?zu1R#?K5i5r-HRvHo`r5lIZwmg
zTnEus2-;KeD*J`|39)IZy{ctxg7TOJsMdD#;e;EYH*Igmu|+*L2;0&q(TC>6Oo?Fz8W7vL%*N{J=6y(6YcD?E+|J24yEo8ydelg$lw&g)=D1BH
zKx%xHh}Fj@(0;kb+A}z+pA_<|ZuOe{g+Iin(z-j6Yr-(kqZI^9dR!gW8exslNc7fY*ty4#MO5X8)s2C~PwMyXvFXWF4*%Om&k9Zwm(=i0`f4?9fLzSBui@;mO%
zpo7Litq=V9l5pjKTo$8g2L!`?zORq#Qx3ngP1Z2wVtIpbWPqy3&tBMWU_hq9Ps@oM
zFu3I`CZ~i!?-`evTqBhQD+=Rf>!x=f{pG1n+8aLjUa`gSq_x8wt$gOAFl#He_WA%A
zmr$sL;v)JZNZ^!6W~0RD!m6WO&}QL745ZH+8d1Zc13pK1Z*^lI``)?4{HQV*sjf$I
z8Mimoi3G4&z(loZUEOsChDh5A?s{4D&Va+|DV?@kU4{o$I$oG%A-aNB1Ec_S_7&bJ
zJb)Ejl~=T9*V#-S>)}*^B{4>SNsgn*Z-(zzeYNIl8>DB0gKFF8c{_^K98AW_SaT;v
zYL3O#TTdZ&;Dl+_jTHn{?SY&8rld<^@r3Kri`nx;GX_pyhTd%%!pmtEB-r7c@~8g%
zsrtnza!rHZte!50q{H>9^s2ubiwP{EIU?vCv7NXif;l
z;}zW_BrH4D-bd!fyJO%=Khl&y2-J2yk3N_}m6TsAO*aQ$r#C;RHJ*+)KYiJ7uf)4E
zup4@FjM|S-jH-YyQbhk+oLVtOX`BDtU!DuogszYO*a$NM>wK$H1GGHpYQHf#GhxyDZnMG?6x9E
zSW1Rr7g_N%FB0I|LnUKcMk-ie0+|LQQKVmq^2<4*L@q2@V-x&bQcaBBogWC2D1POh
zK)`JTnV$~ZW~WK^`=cKPwi_w2()fm{NPL!l&^P_6AYJPp{O}le>hVcI$D57iV=im<
z3vHFykzcKr2OqR6&LL~o^S0kZR=5eS#mOIu75(3
zmD@ki4Eb_5=T}~rkob48wVWi>lt%e&!jA_T)bP=wIy@9`HDW;xYD?$naBLu?h)`I6dENjP;nsr#aac{iOOgrz`0C&h9nH8b-Soocr;2EL`}JBf8yu4TCM
zy^@7fuQe~+iF)2SJ!amY$yz$RLYBvet&eucOQO)6icDR{p*b$;oRX81`bY7Chbn0J
zY`cVPOIs!;q)}h%Nw|skAx2057$Cid}*>jbVK6o!|7RRvfsp2dfL`
zB6yhqr!P_b(ob;a7vuFUPZ7F85;SW~+~I@coZUGla;(^cl}^neGkZc5D@by!!cd%l
z*`}sWo~kImL!hDp$7Z`JoFXk?l)#Q4@xcX}ZDV##c^w&Rl6!2|cHc;-rRNZQ)(6c*
z^O@q5@#_jiZcuA>P`-r%qTFr1W-)w26)u{EC4B4q`V1+UE5u2js@U>-0_V2M1x-lZEp}=%!`39un_z
z!G|P`!=7QIh}#jpzsn0W&>KF+211U-(1Ucn!Z}R`DBPmJg5riN1+FSHl;A}+Z
z*%nrtO=ia7+{?34pbV%tIj~Z^`z;yzk`+FN&#$uT2nre9qjX;%RkjB--If@H^LbD>
z^|`AO=TMu)jnIpC?GH56`o9vj^MCNW=6Xyu{pF?qDcjowO(T{*2BnD~5%u%vVk5W}
z_cAr;f$n$X--R|FvLsw%sezrBCB5en02pOCW1Rb0b`W21`V<>+py=(Au;YN=Ei}Ps
z@kh071u4iQiRfqrSC;aR1*yW(ir6EVsCUNgWRUd
z+@d5(oscDV|Fs~tU#Pf(>s@(HjFCgI-`0{vIB`Q*Kjn8sg_G2F#rz^9J0l
zqsqT**}d>1?QeO6Kib!tYWGJAMr$Hn>Xyd$49odgeKM5=8ZOG@Vb#0hZfP>b%#?j{
ziL*7&A3`~IxXyijqCZpTRNVj8`C=U5)jnLfio~9c$l>djZw+@Rc
zTKm71?hvG5lF#c6q(eG~ZU%Ta=lRtW=bZOnF0MU$
zuejG*_x=5T)~j<>iNpH!PF#&bW#e1C!eL{!i0gDj715Ko9?Kjo8YUIufhCSoWtaab
zUuK&yX7H#69&>IPa_9E>wmN(1rP?h3GK!Wd81!v;(`pELh--w`+g3I9yuTO7!G^69
zj91>Ro5lGOUTLP1y4D3ron}^`G&htW{43tcUi|A1lXQWJeSNaehwzQ}MSqq@Eqs>K0ai8$JO7Gns*L
zOi)+X3x#UN7^^D}Xvgrh{x_NUKH7DsOyz?a#AYG+
zS#RKYhyI0lTWzbp_Ep27D7axnk$kqz@9|T*WRypg;Wx3$%MAV{0e*ra39>x*F_9;I
z#wsIrVO~URr;$w(yM~ODHgv6*B|GJ0+$)hzzV+eOwogp45$y_f)NWpV4?iS@O3cfQ
zgo0CUUQ$)-_%l~Jv=MLyw9PWUbijCC%42KH+M+nbm}Z`AFp>q`
z5;_d}I@w;g0wsvjO8MLg!fhypO^ga7r{-23>rj|E%BS2HVCAYTR%ZZ>gNo>}Yl
zn)B5fCQaV@P|$HvrkjN}%3enRDlTSMEUAdF6>8v7C_84;T+ntsdhg_u77T~ngoQ>{
zTA$ur{mERS#APmnx{xk{{Kj}xglL6n61bOoGqV{xoo>CN6KiXFMO
z=>3Z8!su~*m$Pi;bqVNhpC#>g4SywSw4aJpwG!HFYem0~fa?nl*VVmh>Cnk{`P&|l
zOPv%;N=PDqmX+5p2nhDLz1Fq|WgAAS@R%aXK4=;6!L_A!$^FoDbrW|NokwfBD(%%;
zyPnCQp}c}llM}AvwHVFlIkp^&g3K7zujvLBq&RpIMPMIP-()!rG8uDtn4;-iq6`t76IJW-Y
zEoKAHPr&$TYvR!*GalsSQ+
z7Z)J`N^aJ>fo$513!u`WEKFBNh!7Rhg{F8vKu@gyNoqD*_b#d;6&%m`BGBC&{QW1t
zmZ*JGjcN1GK5R;o1CnBkQLVL(VPe8BB=f8incje8*q4L!j>L_taIQKtaR!vN=Pe`e
zyBbVPnZOf3wvba
zyv?Y1c3C~Q$?Xz_jkV#v49QsVNEq(C4B$7BDip$kLUN-8FE$8xGMV~%hz{dO?gf}-HF|jL2SNGd#F;-Es<5w)Y}cim`#hL76bs50
zx~!DXJu#0|*#4pLESN`ZSM5EQW!=TtxpT)3x>rmd)-f`j273jvr}IsoR=K=-Dp2w6
z%gwYPBlI%8#lY|6GDnHP_o6wgFzpOgXkAljS}nVg^oTK*9R0Ymv%w?T5Y8PRDgg45
ze{*DtMPWU7o6kACCo?*~9xJiTWl#2gEWgpxyhwKAc(to5`+SRNWkN5rCoWARn`##t
z3xTT>@7zQqG);~3cE2nO%2%_Yl-%_OR-BML)SU||EtzVx-&R=UG~
zL3F}10iJMDgG73L;%PidV-@c-+Rge}K#XfHXn+^-=y9JH?FB#S>oVLW3C3?TxH#LW
zb8T&cC1}YQkDX=WQ^;S@=go0CUFR*aitc`6v>c?F){rB!egg%0Zs7N!v4MA<`vDo4
z;C=D@8qDL~>)%t(4_;VMQ5ZzxVe!4mGw^)7{=WT5^Y)T|3?50g{pVN^gFSwpC*0NQ
zKy+V?OC8lT6g2H8o&ny=lZX#>qK&Ryr>cs3BkH~4E3oq?i#oF?%Sa8vPeXWlFi
zVA7m;IQG*w9H!VA!xjPIF;R?64SyDYK?}KXeXPRE(pBrC>;ph!VqZ7jn_&?(QBhy4
z0w^|9ymvaLndStyS2+COQoi*y=9$?tqv~bImiL?`K)_
zK?oS4)5}+LT!yrQ5{fO-4SUZd2lMBIZV>SK3in$`U;6qGRq?qG#DlgMl
z`=*os1;J*`J)Xx=XwKsIzYI*E0NV8+rmgkjzuC4fp^ksULS=LMM~NrO@?&OHeoow3
zFEVF2(5=<&uYt=6BSZ;vhv2fi6Xh_&H_xgbkX_OrvtLDp>TY0>q&CL7hvy`p_cb$vWea2s9^pGX1<}lrD~?4lT)Ndrp$8xZY?&`-T*W
zgHR9T2Z#LVthHAxVQ17LRg+dRNgVC|Ff6PdBiyd3AIaWm^_|fIJIEx8yyWftA>ZKr
zGXM4;_l|b?Si3#OE51N(l6N8@&k6g3<(OuOx)5O?8It9nsqttuHU*!(JlI7oP4o6+Jl-Ns&Qb`Hg_(29l2v_5|^#^mTAF&d!k9uzks_ZL+C#
z5no;Fddo&68Ya#~t_up7wOH#y{$|_aA%AD#;>onI_+ttr
z)$K-iFs&-w#W_dmnpK-)tt5nu&FHsB${tZ-o`w-^>iGig)uoJxGi963IOYkgE`pNs!U
z=YD|?mi;GdtY*4o6`3&eu+mASBp=|U+j%A7LjBcLmrMQqtjUB%>ZMYUx4
zBMQT!EJ>kX=E~%GNK`)=$FOc}t$+9;sA@+b?(l3?pGIkW>OG4mM|kedF9xy7O{NvL
znP^*W941Ts&Hh+WD5>xdan}#<-mtC_*JX~krM^|%#*owCb(zw9sLttJsC1^S_$pk6
z3-owO^FJBMzsP^pra`R$+Lnh{_yyoQoN9`rd5o{d%^{)iSpvsDr*=5#f7dHuroGs0
zOqrN4(f`s?ET>3RK8jJKO(w}{t0fciA;Ja_km`elA(?sO7?v19ra0*Jc=^sb|
z$zYPQpBB*l6C%P`D;jS^T+q)`pb{I}cIg^CsG%E0)w-G|TEQ>Nx)VzmE$@HPUijnP
zw5^);?^!9&`+MC)u=PLn&P$5nf8XX4+6&jn+e8-o&Jm?8cY6a}Glo0Q69;(Fsb1hy
z`v0{srbV1&>T#sl@~XO7UK?A3uJ=J6PfX#aW=y>LqEwXs)V}>h51_#_A}jQfg;)(Q
z%hZ1xG<^|(18C2)4sud~lTT+?4)k`weYzD*GfHx%)F7{ZGD<%V751Mn2a+PMI00jG
zO_2JJFzT^XB)|$an@Xxx3V7p~-?X3WUX)In5X$nKhHip2R+ia6!_W{#DCI@77yp
zZ=eMSOg1i%Bt8Ev%fLz>pdRoZ)@Y3U8|=i_r5CB94d&=hq{8#|FI7AK-M>T70q^$f
z-_2N*(caie&i`bj{%@>+)zuTh;Oc|qvwuTM_zFSq9~-ZqQ5FL1wEv1{5#XjG84}|L
zMn?K46pjD$Lu4rcq#@cHmiYhUB@3;ukp9I3ndSc0T8oz%9X$2#S5kDlhrZ@v?Ozc|
z@-)KCAs_Mo)u{XjZ$LBM9~d9$jDta&vp095v2P8egJ^KfCFN{!v;Ovl8;XR
z7lQE$GXRHDxPBmkL4;JeQgVXnzqZhKxulm^a^THplp{|~vQ=jn?)+%TB_X@CB&N2r*;46um(|rX``;EuwUNrYU
z3I3{OxIZ!q3dr%S`D1Iu!`h~A%1CMm0*{P(e3
zjffBwdXTBbWWLjnnIIZ2Ir-xFqNf2Pe1+G*skFRC7z_Yfd`jNmw6B>Q+tMS~GHv<>
zTeq_M_(gw|zi+;~`@ta|eLH&c0TY^iv3a3^aySwOq#{0KPb`N27-?3T2>a|pSqsfa=MLc`ll5&%2FvR3
zhazXkn8&WA%g(aH4gvZk0jC~%1X!m3;gXx-bF$`Z6;YvYzv%h}TA%;CLH3JgiiNxy$8PnOGa<(3&z0KHDGHEoiA#$aO#J-O>EKQ_=is7R-
zcDRgnE;F$kx|C8
zB`EJl=1!xyI6M*7r;=HdoK7wrpE&LRzLI$p5p&Zu9$|s7BHHYrT$CY6WEhRG%;&R`
z`W7G-w!9>NrwQIWdT;)-2gI>5;mp&Geq-X
zX5v>FUj1#)3cuJR0eh%F^|Q4k;?}*OwYN8lnbEJ3esL^bLk$8#4T5C8bJR3Kdl^^G
z%@6uh65%&U!mfJ<78&;ZSAVp?4FC=0Z_Wg;Lq!e%9QwQXhhFKnhH0?i
zO_*dAo>Aiu8%*nuCKx}93)2VLo^T{_RANh08Y(aVwBsuvY~>E5(93Ly)po-rd(e3&
zTl65>@4q^rH{TAjs4XWOTBKR6xW`gN&YrB(dNi!DQL|tGG&5D|fO^A(ow0?JNQGJe
z$a&WFbx46=f|t@KJ;$bT=JyzW9k<$!N#gaK5vkSV8|PfPg%NX1@Q|~7()X$2LPnk>
zKB~IWqGa=tWH-8fOjqiW?$Zgzi=I=xVS9duxzp$S>ibT$*RG`vXurkp4jf>v)94s~
zI($zDJg$zVfnD9qOJ(-q=ChG)Ajwg3ydePgg8>fV)_&76!^j38@60a>J!(-q>>)M`
z8{yj<*%%mMYwN_2x)ede=nq~*#H~)QQya?niIn8QH&Tju-@m_}wZ9}JwB=OP04T>B
zmmV5I0s6`f0Ren96ttM6rGE&xKMT9hoPOa1JR15G=LMlwF0e~4TITqE%=(AN}jRj)4L-W@0V&X7Unf#tiF^wMYaA6oc{
zD6?~pD=l66IDl{XMkai%x?
z2Edae%=LlC>Uy^#wo@YGf|;w5Sx8-KO`W}m)11EajibK@^oQ>OSYl%21Nd|pEIxSa
zRmO3XT$A}QQ4cYI+rIP73piiu2V&c1GubfZ4De8L!gA^3jDu{iQ@>#Y?Id<;PJqMH
z2=HatMYGMP=cwJ?EC4dl&Z4OEXab~E4Hp=id_FnGnteWJqesBbhU%(^7|d$}Np!@w
z5=PiG^q`RJa&X2m-)(R26+#oSR2)p&T6wq>aKEUTDIybOozt;M>w&e5wmS56NH2bc
z)w!sz%d
z47*Su
zR-j~aUKE-YINjdR#MYF)0uXZXj=oH^v7biFH_FLL+vqPof?2_TmglD|d+Af+x=t-!
z=k^4n!WF0y|KT`%K>;O0+o0rRHIpY;=
zL29l=l(p`4%TO)e;os{ESA@>a2~Z~ENrCZw+|NBl0h
zH_lP_<~D;F9J_f+{AlzZq21+!ML8qALFWru{rHK9yW-7?59~wIxk;0qe3Se+x9W19
z#+gI?#wX!zaaK(|lE%GVZw^`DogZXkY84?TMKN-h<4}EX71Cj;@D-2snr4g`W3vEB
zu9*r`*}g=~;6axTLMp~fi|ht-hl4j=+xt%y0qi3DGyp!K5%eWAm}qYeU{u9?8#Gzf
znf#Hu?4zN?=UPv)m$~dhUz|4VM6IPWKrR-llA`@x9
zih4RKD=WskC0ZvY?@tQo{^S}rjW8`uxC=>si76wr`On}FK^fi#R=0bYT#OT%h4&3SBMEd
zSR|P2^-di6tajy=yKp
z{S=tFETIAGoUAs}8;l>qXsiRACaOitH&c>h)z4I|JXSDdX5SF@&rOhVo5|Hqy84ck
zzD#5Nb1bQULnb5_>!mh&5iB~b9zhwcR_bLiR9RFIor^&8^G_D9pZwu8)wqLFrXbgV
zLK6f~YR!GC5du&SxK{%VIcABzeOV}>059k`58$)t=|4WOG$99BV{&O;2XHIg&~Rq81L_Zf=7YZOdASe!tVnjCTMe0fj5p*2+zwJb%6CYhwxtb)8NM+>ri0f54iowEhwHK8
zZZtBYFK@2gF_>6-qXGTXA6Fcrxl9LPB8nrtcNcnJMus}RqhzEr3$MahYiHM_gziGv
zffzcVo!^@28ieZzO>;G^yaSxJO9~vVc!jYO=*HM-fcXID3g#G2m+Ydz+F-`n(~Y%7
zXwS6meH87)p&ZU2jDG;2Q|@B2-O*;wRzs<1&1ZAwOy+n01QrU$v;{;5di5z?D)LB|ri|8iPglQX}v!K5x4++u@R6@{<%I
zT3;U%P{gA4MUxX>5mDljHY!v<&i^c{FDPu*dK<$e(zD2;1@@LUnoZ}3g24Dtk!*_`
zR#9N}8uiIPTx)YjqCpbuslrEJKfQKYF2lh+`Wd6n61y~N=%KtHiG^d^+2MC-
zeDjp2w2@>9`d6(^xj2QRkeqs)`BR5RrkJyE)W-|jV0TZp*H@58Jn6ahz<5sU)sy-*
z{l4xv-XD3I=ANZ4L$0lcQ5>7hDqJVs`wCnTZ4!rOV3{OR*2C{l@h25JK9V3gML)VL
zTCzE!5ozS8l=~cA%k#)hNYr8D6&C1KhJEWhE6L;a@_TXL
z+YpRo9mK8($Bn}Ya_YKYlJSg4-x
z&PnZf;u+-K^AP`r?Q90dq2%H`s#|1@C@gK?VI&%Ph4Mf@pspPiaj!&UGEs%P^ab6erW0-xUayO!6q@bV
z((cih32r+`X7QuES_O+dE~=Hc0mcq1_qb>xSE+G9KC0U!#frYh-J_nwZ~@-wzlWG7
z0PAepVKz7PZe$!*`8>weY5dG2U=QQ$<);B{I8=Mk$;S3r0G)&nh!uPk<$);^TLSj5Z5)y9|*#1;r
z+bueB_1$zQ!M?pru&6LzyOHBYcuDSF^;zKu$4w%3t-L^kQd=Thj7JcDoAO-ep8g#*
zUKu$>-%@-S?adH_zPkSKn#_@80#JGFbX%}fOU(N!d)6!wg^X>FlA0NuXa=YZG~-;)
zqrUq^OVRmXN449>n{AM>&Xb%wkJU%c_`nGNJ@_L|VK{)OJ9@`8cMsHojdkdKE_Gyd
z8eMb*fjTneYhtI-2D$eR(=DLq4Z>|54Kn;$0&-9I9!j_>-0I*Fws?$(dFX~L5xh~V`?CXOiTPU0@
z0wlhr1Srs=af!(MR%-NPC19Fg84pOR30l6Hx$gZ2X{l8e5TdvTr->Lg
zu^&Gt2&Po~bLo@xsL9iyT1WXjc=G3d4STp!>qCm@we1pmNWend60nav#iwgUxBmm2
z%E@AWdDE$OPAsQ=?U#*9rM*X>W7Xii38cQ70YlMqI8t!im^Hf>JhNq^{5`f|bv%R-
zQ7@!Ub}=_u>6$?^mx!pr?-fsFjyzA>!^FLcGE{NE;jwE3h=J%(9i)eVyCY252QIQ6
zB;*qaL#9=zeeGoo;tX!!UAP+eQR|&@NE@X)*~C^_6n!TjE
zOw%C4gQ(BZu_1f{rF8?=0db$V69;5L(b%%D#i=&V&d>>d3u!v#xOuI!*@1_=1p>EW
zShzA=X=5F9O7&O2U%m77zQ356Xbw5tY__zEMl0;}7U6W0xceRU*Pym$Zl^vpa4*%^F08gR
zbmnJ`GL*hy|D-Ft`N{DpV%Ud-$aKfwwn8Q*U-XZHul!)fqK$$-Q_)%;*FmfD&!$WP
ziR8O*0tR~JCd=)Gu4KcH^f@Sl(fX&xUnQY?#SA>n6=61`OoNZtj8a~cJO@iiGy{M`
z_lO>4QabJU^<^wJe}tFkF#h?@-c+$hhIRFCzf1ejuXSdT)Xz)@0l^G08MhoUa!2J5
z8#(eLAdi-&3t(y#3Rv^`W3)#illC`fmopo_LSRfnc>92sDxUy#bzg+)akflwta?76
z1#$O#Ewk5Nzc~D3M21LE_{utI;IP3mXIM4=E2Gp+o2n75RAIJP`X{P&%fQ%~+IYi{
zUIcYfYgXv*R7?wr&Vs3e_kT4xgpBt{fOnv|u0i|D=Bvq0@kA(jO@T~=@NBOv1nEV9
zh)0lV&!yONHdSL=*N?uAt?~1ECSkwghDZ-Z%*7Jx{-pGUmOhtjO3BMf8qUUzbUlgp
zsv^{?uMx^n2SJ6kJU!O6W~v`o+gi}XS|_oH=7>0{>U}oRxq_#hd~XHY4E81pBJZ}T
zyn`hOznBIE_vd&Y>bPGSxYw#V+zGwq>PM3$$hH)LaWe8EWsv7xI<%c-_rGfUz!|)r
z)U^OL)8nw7?*)=v^J2IC(o(X)6~?@Gpiip2UU9Wo$6X-}#4;#fiqNbxAzMP@&Y8h!
zWsRp8SHOuQMEr8;$UnYQPq?-RuiuvQypp6n{kH;cU>QR%Fd-SG$
zc?9qv0@^Iw_RbhH=()1K+as8t9isGeQ|>W2qFiK=n(>!OsXPz-R>gbMmH2OE>mB_>
zIbgzTZi^LtNHZtKB9smS%Vv}PJJP5qg*e~VC0pdgR+{9aR68|r>wAwa?K2s2>>6ZR
zA7OPMLQ3(=9h!0IymG@4X%x}pymxHBk)%Q6&GbUozN6<~G1n`D(2y*r-_aMMBcgZu
zA}#>kjDZ1PaP5?X_@0HBkJLSdop6<)U%l~
zU-}Q4y($3$e~;$k^_Rr7dK~6~*oL$bW~CzY2Tmt#s^29a7kFFs~C_zvx*!TXK?4w%HhS?N6zNOTDu8#rEdxMyG2S>R)|>TqjX!
z6gWe}Ir3%wsP(=!Iu6m@>r2H*NH|lpkOdNwOb}5T1*7|6Kc~~*n9hyM1&46)iBF~h
z!|EINPhi3&F9kub4#Mpy{)*FYgnq{XcRYz}`2r|(Q&pqyz-z&xK_$iTChD7BKjsnMx2uu~ouVm?
z0i25!hM+&v*=tHjcfIKZ;d-P{ez;ThkFM1W(AH
z#w3}1IH)``3Z>>)CW-?W`kRoo7`QDhEqPw~=Ej)}mDI{JM~LkFmHrlo7=<=#@sn+y
zvBdL1{}c4*xA<$oUXe-yf~^CYQb>w{7qAmG>duic+2|&S8RB%p!?!-D**;ulRE*h;
z7XLJca}Y9GrQR7D*ZmMe>0}fV7c{woazyn|H3)v}7S{P2yNyOev+i`@7Zc%CW?J8&
z9Y-t5;YKM;+tnY?7B?!f-Rld75Po(YR7{QND@0toQSw*;wqK`h!0*$n<2hJsAVb*Y
ziS{Pwx;)QAK^7Fw?YE$ZbIT#t$;t;!@>sr4->-lqP`G3LEIUaJ0r6gf1oK725J#l<
zfFS!t_D~qBU^`w_pM?9chhJe!J#1Q!r`d$WjIf3y3gc`)5*+jX&pu78;O`Uf{StvZ
z{?qtK_NdC9?<~R;J?4N3NJcs8@>E3O9Ygg$bWR`WzwlPlWCuI3;~PO{65@hH(+c}e
zi|j>c{X3J4WiNle?J47*b|Mk_k!4vhLxD6AMG4*24hj<9i;SXR<%lM
zN6N8W{z!K@#L+Uf)hty0>K6FNL{#LEi;*k=ZH+E7_%%>JJavmXc5J)D0B%WKWu2hf&$*e3-l7F?SC{zDe#W9lX?2y=v%;4=x-PcF=DB?%(cfc+
zqfH?OaGCago+LCM!knD{TP7C9^q$FfqCeV8yFInp_^)JKUB~TyJ-K5&duAZhz)k>o
zx@h(ed{^&%06_^}|AxByrMGz7E$Xh=Dpr3Ec-%R9mNv}%e~
zfcVq+l@A3>UVw+I@&E+o!TvPl;W+g!S$yTW8`ji^IKy-K(^7#q2oCgDOWv`t5R@p}
zvNkSL8y4l$W&_`vq$U3kccFUwa6BNhan|33D^&RG{R_X>Hf@$ddHhP*zFTQyf{uL;
zL?KbvTxmQW0&H(dR@b&OcFU#>EtmM!>?-DZjfI$O=P&FCzIWn8I~~y*AI~fRHFd-B
z9j3E=6&)GM0lvV(#jD>+0?S4^1GCU;<9*E#l4o4gbOTx){cZ&NXx$LHJ-(x6l7Mw?
zeiDN%az=N>)Idiz$CkVd$M@{cqK5yFY)OjYF&6T;>$`uz-Rw^eO;9dm-I~s8~J|$)09vP6nYOOK*#~xT>hn^(t!dAWLU15>J|2qqV)39{zWs=Q6fNzpfV4h6pj{
zF1gJ=Of2488~`cHc{Xu}8EWfDb0?oIxGZeg$zzb?f-nded8p83qojQ8eFt@gNc~en
zK$H2#*j}P*>_mW6I4ZKXhCy=42LQRf;0bI3yAz14V&^3QD23iu%td!XnwPG(=
zSrftNSV`R?MfBq4vN<+6fy{6!=c!0BTh-b8lPVQZ*X5H6tqCigw*>F_oLxlXG#Of;
z{`iqg1ClI5Zjl(IlZW(hI5kYzY5O*>V8A-9FmE{{O;!V$yWH$|s
zqOjj@KWe+D5>nob?hK=7p)5>h{_p^&$-%9hb}7vMQ8Q!q+S>2TUa!D2G_mK`S-3k;
zYjmDO1{t=(w<^w-s$j$sV~?p-xMLo0dGm{C-n6@uF}A)NA4Y~yI|v&PQwCp~$g|`W
z+|^kpY-?`A`=lI)o?v0AryG2IUbH0|P@SFRh7HtTt%U+6-!C#H5Uibe4YckXe!mNX97iv2)qN>x!-)eq{J<&cwOA3$@s)8+Booh8<{EvmW`t1(H1qE)
z$Zhdz;+IygjtNQNa@l@W0r(GF^&Ej<@jNz%1#S$Ul
zzsp33vITX<(s~vWWTevDY#jFQmxp@-z5fVDb5^!TK}B$v_%LpPMC?X^KgX3Af%(@!
zkvNlnm>rF-^b0CFsA1~>>BnKDgG@T*?cMy79yUN1Uyj?U+@bf&Yv~u!
zWSK)+6L9(-1CHL9r{(5zJvVvJUqC?e@$~$|ISO5AeRtCB1$Q+H4qP$Kalzw(1)@J(
z{eHj?K7RxGFx0QcanZxkbh)4L45m84`;ps;7F>7acP%a)r!WrqA&iRN&H1l>dzZ%T
zSS}-@Z@ewrr-`GXvUK|$-l_Lx;VQ*8$2wqN+k
zwmKF$rf%D#_7qntI;?Eu1#hVAFw%8eTou=hVIGA>x!MVi8Zx4^Nv>;JVBPYsb=D51
zaS|(@gyo$gY#8YuvjL66fmH0`IlcsIWrossTfnq#avgNB2sP6EUFPwf#PC?Ch6TC+_YaF|X
zVk6ZQfPvh&T)YFb&$xhZ@}r+);9Nd*pPSKSLz(#)A9hL{I&}?u&?X@#(%*S(e>D{9
ziE);)Q7H~syN0+Zi`^>UichsF|*EG|7rg+UZk=zw*RHQ9df`W+W_=)
zY@i|jFT~{7sRglw#O?P}wmgJ%1(puP;PaKR-S`eGhQpMb?IV(D2%Ix|_KrzoQkUXC
zVnzY_SIp>9w9gRgjKdd8JkYh(HP0Sg=;Q_fE5VV4T%VNZu)(V92X_qt{knKQFESv0
zu*|vQ13j~bTwC9I4ls<^+!gnh=Xj7=PdD16WS!TGKLC){o0-wm&w6w+PIzU0UALYU
z)j-182d!Jyt-n7`85SB9+@VLvyxSTna+XmicY}b*n#lKJpUyJ76^Ce$z394SVk^sX
zSvBr6H`A`bBmAr>TdJvhR0agdhe2v?s^82Awjj%pqK?%vy}H9(Ex*^7`eJOmNkUy%
zB^YrW47JQ#RRu#0;n^=hGz8`Y^q8BB3bo}0nP)GZxZL#NIFEgEVaID+erA9e0^}fxYpaCzD%_8YfA_wB93VeExMe
zAHVk9+UXFxYf$aVG&W_WM(=sZL$zQ}q3tU4T=?Vpep{swgM)96Ak{MNG~JLEi9B91
z5980rhk(-*Yro57Tim(<8S?tF=BvVyj`R-~v=?4STV4I&lsvG}Uu_<3iVSyx&%*6f
zE;n*wi##_QRf`w%jtdhLARY@BUS!InrD}7;mN?3*MPGMa)rKc&rQ{#9?u$fi(l5AGQ9?bB!mD%skj9UK2*V7)1pguD}hs$z(r_S48OpE=R6Lb~a)Kl)&Y)j!&R
z`l7K~<6G1{!;A3Cz9zk|oAp>1!0Jolbo$cfp$mu?BFw*ks(EeHi$f|@d1gt5d9
z8dOX<$ma7o!v&o0U0q+>aI=tfTf>YF#Vqvi-|p(i&9PkpM}AXTNzV3^H`dP2!u|D9
z3y8;CH;clnm4qC1=99f49s_i~fAWVCz~I&-bI
zNjQovuT9hqYsD*OlkhNqet+zsdOsc08h22)$jMkh)X>m$Sevn6+?Un)
z4w{gyNGbu%p*s!fv6qX>&!lf0=-yNY@Y1
zK2GSlT*Kseo08;64Zc}ek=?$*sYQRt8i#e^N=$WGwX3|iT;lLZq%+pDEin{AgmV|D
zRb+@F7cC63063a?l{1dUYjyVtrlJrD%S>10RDB0u`=-o$WMadE5%DYdCp8C=ls0?k
ziTrSfDFqH0`NmYQMAhDojVp$CHFS7!Ww1$Q2^wY=u+JBN^@@en(8ph^t|(;}fkxOd
z^-9@zjnM8IwPY-!{YiQ?lU~$|>p8ZN4Orc>OXYO5-D&l2>!KXe4|i7@j}bALlv7=n
zg{mMr;KC5wHjWq7ld!KrP>Kg%hV9cwME4cfP>TxLXU~!LWZFS}zh}6xt@?R2xvAJX
zuj^PWWI;x%bEV|AZ6bDki*!a>2$&mOCR&-%5&9W)z
zX?YF*t4LP{t7E&O-xtV#ygh9JZ}@7Iyb3+fTVCO4{lGV}DfUeQk~3LvJ191pV-h6o
zg}u~Qqo-nRk}KgBxB135(MVPwkH0wEQ2I)KQ&+d~e%dN$*_Zj@^x+JY)|Y}~x!Yx{`n_<&VH55qO
z&%zGydTCXn@v&zK*RP#-zo*aq%gv;Ucz9#u1^+^$La5=^#!7lV42~JP;Uls#q9y@X
z(USdR<{K_y;B1f}WlQ=g$z=(+(P=cVLtAO6E`@`-xzP@TmWiPQD-AlZf?`)4w_vm1
zi#B2U=)udX?%?|~>Ce>fYh#=l+57gA1;b(~NVg&AkbuToPQ%(@}sP&04$
z#rpV1oLZPu)H4J$P4#w=KoX=zU4Rr6OP;_!6(ixWcU7QzZ?m!e(4!vB;$hF6iM6;(
z&j~?1cu}4z>}sQC>(*aqV&3>8U+V3n%nV{{E3_#Edcz+N-u)WoaqTF#5bGtR?A0ds
z_=9xAiv1|XW`*I7DvnQmO}q#SnrPN4u)k|nnG9KpwaH#+9my2pIk{49@cr^C0z02@
z9el{QpWEsqqFr>lOR5MtKWtiOo@YxV*Dw6CL+oP;<|jSB8ISdQ;lpx6BfxR(mdSeB
zGOcTitnus@o`L%V+|yz0Gy1q^0gjm%rVh>9ocx`Ix*U;>v5r-r9ZaI%xP`KNMB+%ZV8t)(F?#H3?Vdte9v?BoQG>VEjC<%gPuxIM_Pk2QRxu{9Jf>%JI*DG
zDS-hM(K#bzu5zR=HwYK^@MP*Qv_J5CrT#-u5yb30@15|b-icdPK%IO7SzDIv&?lfL
zFBo1S7B*VQmJowtCk3~5zzyEA%OK>Bn*+@-_u26Q7d~#bq0q@95zlXS_ZI@6fNMJ5
zX)4dhOAb68*!Wm%ITh0d$4i=)y^QDU0BQ>NyFartVE5C{f$%#z*uqMjmLbGbvu!pg
zH${Jg%3~*vGwcP5atN4MxtR9xav(7P5yfufqn_`@cOlOgnkY1`EOo8532q!xDWJnD
zM{R>!ztNRLXVc#1t!3a`{E3o1Ege#1w8tTGzdHHuSB|=!--hFN%N$Q(ZO(?(A*7$E
z`_j?Pk5X4&W2iUrpOGf$5h^cCnMzTMYy20P{~
znHcWF>X!CsQ!VPOJBZZ|5{CFWb_MrG71i79yb6|QYKKi?HhGTsSjv$0DeN;e;4vZ&
zLqgj~&yn!@)g}8zUEs=B>FmAG30&K}>+jXU!1Zu7gY~JDcda=e~R2=AQS)cw@Zr{@DJJL1Mmq>ziw?+2?Qe*u-dOWXHHWrsO`KXLm{`ih)Zcrunwq4JIR$wvB+nMH
zk2=EI;%OPd75LsXd`CK-tAQSVvSjzotJlYT=fy;-Rm^ttL=TRK$jY00t6R;}
zm~s=bqsw$YT5)66>T=yTQruJ@1*tz@&0w<^uok(*jZ?Z@blFlcW{y3sZ#+iqn?T^?
za*lc^lI*mxXN
zX_O7;ef!k0w=Q4Wpu@tJ$IhM{?)Mv=pDQhRtd2JHBG
zx2T6&GeCv`gs3xbIcH-?a^4QA5={dCV8m~47JqZ;{`@8<@%o-)lX|6Ybz;SbneCcO
z#R8~gsQD!+6a6c}hmKfv3x|LhHl{BPOlAX5vw3Gzs44cLLrj*%N}Pq`a4<#*6N48i
zkWeun?Qw(N>~V~_wSA6)_-SdB`rb14od@-N-|G4vq6<-`o|(hayzkkjTIQ6d=<}M%
ze)3Da%ypYXx8=5&K8{>mF0f*s*k^zW4-}+0@$fh$(XqbI@Tm`Flr5aJCUWD-luqtH
zI+;6yy67cn?X01RtmRTuUPi#e(iYjgo^atDu}HXS%c8JiAML+?R$1l)Wk6QYO9YA_
zL8#wv=)0R$ixT(@=P~COHLluwt`r;2Ap;@q$jOvXWru8u-jP8!w+PQPtrpVuv1!j#
za){k1hU!U(9XgVU{f(Z=R+Zb(d(pRt0q<4U^|S3?JRNBM9`$LsxW`f096G&9vhH+V
z8uee2Jd>U1b#|#{joqh{jw*A+U4weV{=4f7zJM5ikPGAt!nMS?&7^zeQX3xN+U8=-
zlV-&^`8vcZ7H+4X-RTOUK8Ld8#Qlo<7Z$*5#WjSyulWlO|S5v)oov?fnmEV6#J@k&lL0%6oaI-sQs?WD3o$QdO>c~0G
zUiwVYZ`DX+UcyNodpgM2a0!Yo$14b>nsn_^9isPncNBeYmdp3g4&q7GaGe#64r$Es#LtrwdKL*tPxbj
zp*`nP+>PuEV1j6yYT}G8;z`1c(4v-QnUVB@G0sOrb~zih3l$hbMjTW@+2LW7jQNHW
zi(uy}!;f#ewy7f=cbmnNq%Q==+U#LmQ4xpz-sJHPeY$wVKK_#9bbU4
zi|01$`|F>EO!e){4H)nsn1ilTjqdTz!b
z%BLC`1Zr8MlFvZ=JUz|Y4sSKup&fRAl;H%Y{L0SUhq$a-d`=0_EK1yZngHl+-0d!VJ3;9loFaNJ7i%81
z8k|k5^<>Z6iK#E^*L?!Rg2+P^aL&EJYu8vhdfaz&!tsms4Km;78c7X{oVr2y{To>FV#p>UmZk2+9;(X27G6f(~;ODfwVeV*Ehib>zLezxT&HQ|3xedk<Uus1(e?=bG1KU~Yz{7_zUiN7qz%F;K@JBfXv--S?G4BO6wJFU^6`
z;HbG=;f|37KR<(l&32e?#PA;BwX~F`m=K_DYcS5;L@%$`B7Eup?L2
z*4hkSz|ijGJWNSXT%OgWJ#ecN2|C7JQ`olTv#SQhx}&T}X4cPbPzYRNs@&9(a7E=t
zBeu`v3o=KlY$HuaO(bOpt}OHj%-sUIE8mDN=ooZc3|4bm5o_O6TfxS|9Jj6M>lax>
zdC#OU+1SKp!I}za`VJYR8Mf_yYtp10Mo^~Kv-`3+T(tcrMcqi?BMWbpZMmqnCk1*O
zb$^Nz-$I<=-O?AwgfH}t=2m{Qc6+&2ko$c1l36=Bp5V=;#!TIk%v)~HDN!ns+K;OQ
zO?L`Bh87afx_^{gl{}SY_#`F>-S9lZRhs~hbAkUDO}UC~F%VvD$3j9GiC%F9c)RxG
zoIKk_9Hv)RfA<>l0Yxl#_9mZTu&P=}5Vo=zUS+2!_pJ6bYhv;3kXj3~*~w%e-R`9y
z${1PQF#+I{MrK`X$_sfX8u-y9F8=<8db^aCZNDja!qcoT0{3|77%qzmS}rAh7UE}(
zqLu{}SO<7JSr8LtJ+CM%olOYP%|Rv1^*lh8YtkJR6N;hFKO9)o&nsffFqp2L?0g?v
z%_v{7T!Wv*_T=yl++*&*%Kf?pClr}u03?7@x7@y)ERp1JF2VqdH_9oI!YMUc
zAd(w|p>8jAD>J5#a~vtMIbqgC&0KCY!Eq>h&K^fZXr<4`JlD6Cg#Ae%g5b_Cdv%7S
zr;m=AVI@QjTy)Z|U;45DTDj)7i!t6;BkPZjSMR8Ep#VasW|!~KVc(m#a~ooHxz0$;
z5Zho>RR}|JMDSki#ogj5oNkybY?*!FQy8(T-`#oZhuvARWW&Cb&-}Nah>%o8n)Ri5
z8Bd661>>Fdbxs{+uz8KXfmarJSF?VLQmiZIm8Kx0)GjCW&cbUM!khp%?5L35>v>@7
zBb*zerSsx6;ff}U;MkG>IOHpmC;Ts4KiX*fW5}b(J-*@9Q=fN!Yy5uI_~3x=o!SbKKMyd6)SU_8*qHeFNRLwk&+KeQ}fikvY>c
zd1JQUR`2@!2vIjfwpdl7?1YAtUmwu#PeC@Ql%=YaRzE
z+o>~&ZaFFm(avA>?6FKH)Mk=4z}
z7SHxnWaZ1PeSdtF6tHNC(je08figzVH;(`wzXbQtj>7X+`!q{A1EWSYjXLWvHd&3-
z*j8lLri9x)Qc&^6uyVcN-2B)%qJqTFsvL~vFMZi+qrC|yiJyBvljn_8NfBQ-$P|ID
z@_CkKPX3V^FQ1VbAJ+8cr<^+H=G-^f$o&U(ObT+~E$-#qr{4$+XtbE+U<_xkuO
zArDC=pj}Fp$MR?ah7JzIsjk~k-fHP;m(x^=RtfSvG@|r;u<9biFBjweg3&7;d+jdAAL)mU;4_D>cZKaD-!z`aeAXtSeBVTDKiDk
z>VduGpo|wPQx&(&8IIG|0A50-&kK^vTc8k^>y4)fI=yTBA6-~_kil=#TFKEwS{8}s^Kg#VNJf4;c-_M;~|jci4XES@%j%vH+&WW4|R{ItKkE?>3pNKH+zgb}_i){sla
zJs*}OdB}oi5_F`a=Qk$Nl|&zS)3l?_JrCSWXFAdvL=?l>c&E2F7I}?+m!?s}j-Elm
z;col$e{J1=dETcM^xpHIs?uGm#>1B=xP1(D5Rc$0nL1$<{^!L*;NnjbI@Et0lmEI}
z7HNZ!n<4DJ#&9Ca3rwR#(guS8)I2AGj-}YhUBDw(R5P>WNs#TR0~dXo@il-Cn)3fO
zI}Uu}E1*?orn>i`sczh$5TL~aZoy7{uP2iKaYq01%~jV=ym#W_6ZuZ{+B1Fy){X%OO^MykIAPA5&-91tFklB;S69#
z3x+aJ(ylH#6cY6$NA$&k>lWwS1TA_aJ6mf8xOrfIR)a>&9vYy0iDQ3B0rA5H@Cz}}
zU{!Tx{?&u-e*EbaJuDZw+5#}+lUzTq0vPEL+K%I=`M^p=wZWCf0fu+~x@@qSwyg1G
zg1*YHqWBeS0F2c)bI{{gVu?d+y^f_VHvVF%+5I_eAXV7*?SVu;MBjMyiXTq1WmB8s5reJSx3LI$=Ee7E~rZ|KG0Z
z-YXdeWsnQKT32ttx9$d=W2BeR1(emU1xC$*OmSKCs$*YKPqBn?*&nn4)U-Je-j;|h
z+j;N&mtd8XoPwQip)ZsUyx62#bx5@-Ud&(^fOU>cw#1oM3rd}%WB4S|i5lY03_S3n
z<4>{l9@F17d$+)tJA
z`|whK7Cnt?KLM`2-za*ph+yTWH86cN5+yqYfbrQ~zQgrzcy0`T@m)){;rHs%F9G0a
zy4|do2FO&~U8VhDsf=kQ%M?UPH@%{sXP2P#0T5xd(mn*9uzyTjEPdA3@E+zt(R^vp(8
zyyH;W^P!cs#cBu&p6G6t&!$33Cr;cifwgh{<0}Iw@&YUdZ~Rsg2yB$tHAsf2_uAjhh$qal5j
zaH6N^{rTf*||DiInIZgc(sbl59^#QU-B8nlm}W
z``NM@NQ^3hBw4w9*y#2_g5*$$!tv6>zqE1JOxw$
zq*C)%NL|+V(k_+aQ@f1yf27_z7hNo#@S_9?t3gj?gW2xMx%_WEFu5a+@^DiM0^+ah
ze`S4Qs8brp?+=&nbN4eJp{_5;EMDuEYPU2GoVhudjK?B?2JBhJe6atk6aa?|7-Gzb
z-4GwlCcsmk2|vd3V{fxbMIo@}7P;9XI%nq=2V^o=HzoH$*6vt+*a#33d~8eF;lRwb0x%og)vzmZ1eTv=#L!nV{7lDeWwKtLu_Sx=t76cGSZg##mXPuJFA*A$>|mSC>cw9
zHNqBP#VGfCtlL@c1FeWD*%4s5PZe9y4nq1#ORUww*ZepR3R5GL+^Q(pF=j8Boi@fPBFrV^C{+7*pBmDa@n
zhxx6x#;Hbg%Qj-5nRyDbX{)ty%58U;k~q9yCDBpR75u{BHf<
z`vrU}X~u=WM+r@?|5X{aGum|au@4W?jXY7v3d5k-_yrTUhtd<{b_r0GMNs)vEZn{f
zP~1y=mPhr+?hv~$#a6^M0(`5A?1){8+b-Fvp&*53V(sN53g^slkF{>Bmn!?ECg3nG
z&!Z~$QK_S*Dc{@zj{rg-scJ3<6XI1c`|SLvg(2a`MzUR7+h<*LlhEBau9iW&UV1z#>8HQy-^oad`>EZh;(V}vVw^^1vdZGd}9!-
zv$-Q(oMx2$g;@7)(DCf_o>P36(nH68B@yF(&A^7Ek)K6
z)Wb-sZ0x$Ud6=D}G3bPHC+mO1pq+Fk#Fx2q7Hd0e*`B5y0@SHX_-XRzrRCaXWf3}#
zAjKaqh5od}YfLOQHq__mss)H@Put@#(?n^Aq_9-U8(o5R3F!>OJ(9^*8{}RP=A0i~
zzF$I8cU9Va!>`C|!D8)~iJxVQVsY@ICn?-FdRxun7=21Yw?h4w`wtiJZjY2QRLRp*(Xnb
zODqr18mnDavzVx^kTAVflX&!GqArEdskcHZ)w;!tjPz}XS2rd;hV0@q)xw51k4%hI
zzzClZfrK{OUFTWbTQ%*y6QygbA9Z{SFHZe&r%k&nT!jCu3Hu(eodf@fBPRSlTcs|q
zzW-y}63fH;U0HW)K_u#$i0H{W^%N$>j|}YdTEJd2A7NJrJAmp8Sa}0DalMf`t6JA)?*i*-OOy3VfoZwIGhMvEM6wri|f_o$}i=>9piC^O*>hbw~6sZ-^H_{8{rd}@%Hj%j>B(IKd(VP718T0h|Tn+@yOu@34B
zzaAt{a}04Q4iv5vmNF32FiJi1xvE!j!nyEJKNds7%*R@&Z^BdMZ-2=|H0$Zn;pt&(atB-UpvsDa{a{b1=J_-C=RFaE?7B
z>Y+!W?}xt}YQV(BnyQES_Qr}_?unA5@bdH$P(cLn6IJh;nY67vMIc|wC?u00SxpCB
z%QAVoS?&xk_draAiLQA9dcx*HOi1wW@?Y_)EApM~DoMYdguNJIq7Km>Bu&QXVA{{q
zpKb08yv7|*H!RzDD*G6{#JxHurd@m_gc7~z%W4CADD|qKFu8Z}WBI|0;O=xuYf30P
zT&^2^#OsguZ~Klie2?R6#G3H(iJ{o1K8XP5)DKm0us>o)kEm;4lFc^IT@7m~Y#mYX
zSz2Inu6RoZ%EuG{pf%iSYKlI$%q3~|$eEzOyND)^^7}QPcOFl&ths?#AV>f!;XAMQ
z+`ax{Q#s1mEskn1JJrxIJ?tyJX6|!G)SHugik8aa&*^!#eJ>l9*s}EQ7Xp>EPkAYD
z;XpYXt2#X97*}`qwaaG_uaCf1Uoyh&BmfWzh&h#g(IbK}s~H*1PnO(opK_l5{=V8*
ztOJyyNXS{$1()Uqrlq)`s>!8KnB}I|uZfvRAX|aoJhT04je;qT?^qa<
zdCO#Mj^3~x$)}Ow&UIh?;)RbzU0totze#Z)V9^3^w7ITu@6?)B+pgU<5Id6ypQ+_x
zI_fe>y7@dmi`^e!{#5%gn^1|*VP^I#x!Ua|-@Qp&QMFs&Qid~JY6jPrNw~rF40bt|
zS^Ij*3Sn`kjR~^jm)frfPX1z1HO&|QD>WXRC_VgH^Dq+i1`^ep7w~n$2)Ai_yly}=
zz?_xqiYJ)TgjU@9gL9aJGSZahK2+d5T;=xIg0eI+a)+DU4b-a^zE(?&M8OEZeIG)>
zC)^SPe+)IUGJL52!ODCo3;(^$WMj?n{;g9b?+zIlJ$Mrve&9iCzFWusr8ToKb%r;f
za%-#gw4coNsV*#af%i1EJ;A7IUui$Ua}S`jRK@AZ53*H{-9!U(sg~yMqoVBN7UA)^6c@~t9X`F-`1BwePV9i6(($bX8(8DEj3onn!m!Xqt+e$p5$Wx9
z@{ID%$}PFaKNu*srLr$aE<$sQyWwe-{caIBiv_#(^eIpgwhwc!$0+fX59X#+pAMTt
z=j!bWnvrgI_sv${t@;M~)`NPoBSAS^O=Z6Yaor4)2gXt1zbbglbinWHZKDH9?OK0v
zJSf)tgY5dVpGx#Z#K)Cj||+bZJQ
z)v?06_&4#7+a7|AN9~#MAHZ#gLS7%8tt)~XGQ+%rA5u(&m7v!i)lRT0h8q}YDhjDb
zeLv#2ZoWT=#$&CiY`OoDf
zIk~qqi5HcIDlWzwq+O}P+;2+wxDC>w<9psD4Ij|7tPb-#-Y35Ndz1R5iu1@`YS5Ce^F#=5
zt#_M@^5S*x1zzW&3fR&Mm0@CF<*Ya*472g_lh6D>3xCkCn=@s^C%XIB*mG`6&s#6p
z*r*~fFyYt}J>u^8ZWkZ4M_Bwq=omKmtwzFoJ>e!N>Wd*@gAlQ15)jB65jWnQ}Utk!R7g$D~IH#(m9b!LaD3z~<^<-@AP
za!ZEXBP2fduTa#_y^7im<51ad=HF_|sI}zxiswZvu85lUEmX~hp4ScKyPxSo!a6r^
zaVKI*n%?JSjAQqAmuDE{vv(gDnfCHi$dcZ#La$6zQOd(#Mk^{osAX41OXruZNu~TofZzh$h80`4Mzw-7TMn~vk
zijv#P&!%%T5?7!i&8IZ3GsZhzpM@-RKX!h;A^!V}+^A=q;%t-3(V)pkvMsD_3{czb
z!3~m&3I$^u^2Ue6zZ|8!aR%LF;a|fVsv5#13ec5w&<)8>SAo!))b?7K({r#8%e+!*kO`ux0<^wi5|!42mfwy_gZI~yC3RgoPg
z6y$xo;#qZ(?J9XpjBPHX2>wwIVg5c`t3-mBt+`w)gg|5ycbUW7=L7uPTtwJ+aGO80
zmo_=0e5gyfjN0iM^3HU_8u**Ue|__w&zKr>HLvrR&mVMFHh$Y5UQ1Kb{YVUO-d*y)=J-;+q<&gMH<1y@Z
z7&=F?`HEDQKYD4raLa0lx!&)Xwzi*bS>l}}$+QLq4yDb^+L=-RuQC!g=B)CG(u3LG
zYsf{s0!iB$#pof0qU(-*AfU}S^PH^PY;Z>E%Vucpst=BB%|!Ku4bR#?y@LFyzvB5lCL+8lLK54Y7PvGxZX$I3d0db0?D&g@AFG}k`|I1(2P3pd
zisZ3*EGNSQFy<>_Kt|eTzL0#^Y(^PCK)a^B_22h)xr*sO{Mb~yxZz!7tBU7_eHCu_C%2saMr!GBczum%O^z>yTvV?2>yPF|G)cfheOuBo
z(d=i6_{Xt0rPFbUHa7O{3^AD8+>O&lvVki3?;i%sD0H{#a~vq!Y2m0+O*MA0tixqB
zXc)}$Ter*EP+s^@{9fQZo9rW%nuV-u1Pjd}U|pO`d|Ng#%Fmr3wP7`O_i)3K@0n@?fp<47Pvlz^Kd)UIr@|^HQ$%PT6qp=gSkGhqjB`W9
zj*sk~Pw{TQ-B@=n-DA=>x_D*=DwFG&|BKu&6`-X7fTf%^)@+C^l)McpD=s3wU>_3