From 4727f0f1a585cdac46b3beeaad3c3e4eb9776877 Mon Sep 17 00:00:00 2001
From: Frank Li <lgl88911@163.com>
Date: Tue, 8 Nov 2022 09:33:23 +0800
Subject: [PATCH 1/6] doc: shorten the name

shorten article name.

Signed-off-by: Frank Li <lgl88911@163.com>
---
 .../develop/osserivces/formated_output_userapi_backend.rst      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/source/develop/osserivces/formated_output_userapi_backend.rst b/doc/source/develop/osserivces/formated_output_userapi_backend.rst
index dfb0793..5db4c1e 100644
--- a/doc/source/develop/osserivces/formated_output_userapi_backend.rst
+++ b/doc/source/develop/osserivces/formated_output_userapi_backend.rst
@@ -1,6 +1,6 @@
 .. _osservices_formated_output_userapi_backend:
 
-Zephyr格式化输出-用户API和后端
+格式化输出-用户API和后端
 ###############################
 
 
-- 
Gitee


From 890731b92974e24503cb7bfa043508b4903ac9ea Mon Sep 17 00:00:00 2001
From: Frank Li <lgl88911@163.com>
Date: Tue, 8 Nov 2022 10:41:03 +0800
Subject: [PATCH 2/6] doc: shell usage

Explains how to use the zephyr shell system.

Signed-off-by: Frank Li <lgl88911@163.com>
---
 doc/source/develop/subsys/index.rst           |   1 +
 .../develop/subsys/shell/shell_usage.rst      | 631 ++++++++++++++++++
 2 files changed, 632 insertions(+)
 create mode 100644 doc/source/develop/subsys/shell/shell_usage.rst

diff --git a/doc/source/develop/subsys/index.rst b/doc/source/develop/subsys/index.rst
index 8ec4b54..b3443fc 100644
--- a/doc/source/develop/subsys/index.rst
+++ b/doc/source/develop/subsys/index.rst
@@ -13,3 +13,4 @@ Zephyr子系统使用方法和实现原理。
    storage/nvs.rst
    storage/nvs_analyze.rst
    logging/logging_usage.rst
+   shell/shell_usage.rst
diff --git a/doc/source/develop/subsys/shell/shell_usage.rst b/doc/source/develop/subsys/shell/shell_usage.rst
new file mode 100644
index 0000000..3eec977
--- /dev/null
+++ b/doc/source/develop/subsys/shell/shell_usage.rst
@@ -0,0 +1,631 @@
+.. _shell_shell_usage:
+
+Zephyr Shell系统使用指南
+#########################
+
+Zephyr的shell系统提供一个类Unix shell界面，用户可以自定义shell命令和处理函数，通过shell界面调用这些处理函数。shell系统可以作为软件系统普通功能的人机界面，也可以通过shell系统埋入调试命令，方便进行软件的调试和分析。
+
+Zephyr的shell系统提供以下功能：
+
+- 支持多实例：多个后端可以开多个shell。
+
+- 与log系统合作共存。
+
+- 支持静态和动态命令。
+
+- 支持字典命令。
+
+- 支持自动补全。
+
+- 内建命令。
+
+- 查看历史命令。
+
+- 支持在线编辑修改命令，支持多行命令。
+
+- 支持ANSI转义码。
+
+- 支持通配符。
+
+- 支持meta key。
+
+- 支持`getopt`和`getopt_long`。
+
+- 可配置剪裁。
+
+
+Shell系统中一些功能对内存和闪存有较大需求，可以通过禁用不需要的功能减少对内存和闪存的使用。配置`CONFIG_SHELL_MINIMAL=y`可以极大的降低存储的使用，在此基础上有选择地只启用想要的功能，以达到存储的最优使用。
+
+shell命令添加方法
+==================
+
+实现命令处理函数
+-------------------
+
+shell命令处理函数的参数形式是固定的
+
+.. code:: c
+
+   static int cmd_handler(const struct shell *shell, size_t argc, char **argv)
+
+-  **shell** – **[in]** shell的实例后端。
+
+-  **argc** – **[in]** 参数的个数，命令会被计入参数个数中。
+
+-  **argv** – **[in]** 参数字符串指针，所有参数都会以字符串的形式送到命令函数.
+
+例如执行shell命令\ *shell_sample 1 2 3*\ ，命令函数得到的参数如下:
+
+::
+
+   argc=4
+   argv[0]="sample"
+   argv[1]="1"
+   argv[2]="2"
+   argv[3]="3"
+
+实例：这里实现三个命令函数
+
+.. code:: c
+
+   static int cmd_info_board(const struct shell *sh, size_t argc, char **argv)
+   {
+       ARG_UNUSED(argc);
+       ARG_UNUSED(argv);
+
+       shell_print(sh, CONFIG_BOARD);
+
+       return 0;
+   }
+
+   static int cmd_info_version(const struct shell *sh, size_t argc, char **argv)
+   {
+       ARG_UNUSED(argc);
+       ARG_UNUSED(argv);
+
+       shell_print(sh, "Zephyr version %s", KERNEL_VERSION_STRING);
+
+       return 0;
+   }
+
+
+   static int cmd_shell_help(const struct shell *sh, size_t argc, char **argv)
+   {
+       shell_print(sh, "show help: %d", argc);
+       if(argc == 1){
+           shell_help(sh);
+           return SHELL_CMD_HELP_PRINTED;
+       }
+
+       for(size_t i=0; i< argc; i++){
+           shell_print(sh, "check arg %d: %s", i, argv[i]);
+       }
+
+       return 0;
+   }
+
+注册命令
+----------
+
+使用下面三个宏注册静态的shell命令，一旦注册后无法在运行时修改注册的shell命令
+**创建命令**
+
+.. code:: c
+
+   SHELL_CMD(_syntax, _subcmd, _help, _handler)
+
+-  \**_syntax\ ** – **\ [in]** 命令符号。
+
+-  \**_subcmd\ ** – **\ [in]** 指向子命令，为空表示没有子命令。子命令可以再嵌入子命令。
+
+-  \**_help\ ** – **\ [in]** 命令帮助信息。
+
+-  \**_handler\ ** – **\ [in]** 命令函数，，为空表示没有命令函数。
+
+**创建子命令集**
+
+.. code:: c
+
+   SHELL_STATIC_SUBCMD_SET_CREATE(name, ...)
+
+-  **name** – **[in]** 子命令集名.
+
+-  **…** – **[in]** 由多个\ ``SHELL_CMD``\ 或\ ``SHELL_ARG_CMD``\ 组成的，并由\ ``SHELL_SUBCMD_SET_END``\ 结束。
+
+**注册命令**
+
+.. code:: c
+
+   SHELL_CMD_REGISTER(syntax, subcmd, help, handler)
+
+-  **syntax** – **[in]** 命令符号
+
+-  **subcmd** – **[in]** 指向子命令，为空表示没有子命令。
+
+-  **help** – **[in]** 命令帮助信息。
+
+-  **handler** – **[in]** 命令函数，，为空表示没有命令函数。
+
+实例：这里使用上面三个宏注册命令
+
+.. code:: c
+
+   /* SHELL_CMD 注册两个子命令， board和version，执行时会调用cmd_info_board和cmd_info_version函数
+      SHELL_STATIC_SUBCMD_SET_CREATE 将子命令组装成子命令集subinfo
+      SHELL_SUBCMD_SET_END表示子命令集的结束
+    */
+   SHELL_STATIC_SUBCMD_SET_CREATE(subinfo,
+       SHELL_CMD(board, NULL, "Show board command.", cmd_info_board),
+       SHELL_CMD(version, NULL, "Show info command.", cmd_info_version),
+       SHELL_SUBCMD_SET_END /* Array terminated. */
+   );
+
+   /* 注册一个根命令shell_sample，执行根命令shell_sample时会调用cmd_shell_help
+       shell_sample的子命令集为
+    */
+   SHELL_CMD_REGISTER(shell_sample, &subinfo, "Sample commands", cmd_shell_help);
+
+执行命令
+--------
+
+上面实例中注册了根命令 *shell_sample*
+和其子命令集subinfo，其命令为树机构
+
+::
+
+   shell_sample
+       ├── board
+       └── version
+
+在shell中可以执行的命令如下: 执行\ *shell_sample*
+会调用\ ``cmd_shell_help``\ 显示出帮助信息和参数个数 执行\ *shell_sample
+board* 会调用\ ``cmd_info_board``\ 显示出开发板的字符串
+执行\ *shell_sample version*
+会调用\ ``cmd_info_version``\ 显示zephyr的版本
+
+命令参数
+---------
+
+使用\ ``SHELL_CMD_REGISTER``\ 和\ ``SHELL_CMD``\ 注册的命令，shell系统并不会为其检查参数个数。zephyr提供了另外两个宏注册命令，在注册时可以指定参数个数。在执行shell命令时shell系统会根据指定的参数个数进行检查，如果不匹配将不执行命令函数，并进行错误提示。
+**创建带参数命令**
+
+.. code:: c
+
+   SHELL_CMD_ARG(syntax, subcmd, help, handler, mand, opt)
+
+-  **syntax** – **[in]** 命令符号。
+
+-  **subcmd** – **[in]** 指向子命令，为空表示没有子命令。子命令可以再嵌入子命令。
+
+-  **help** – **[in]** Pointer to a command help string.
+
+-  **handler** – **[in]** 命令帮助信息。
+
+-  **mand** – **[in]** 必选参数个数，参数个数包含命令本身。
+
+-  **opt** – **[in]** 可选参数个数。
+
+.. code:: c
+
+   SHELL_CMD_ARG_REGISTER(syntax, subcmd, help, handler, mandatory, optional)
+
+-  **syntax** – **[in]** 命令符号
+
+-  **subcmd** – **[in]** 指向子命令，为空表示没有子命令。
+
+-  **help** – **[in]** 命令帮助信息。
+
+-  **handler** – **[in]** 命令函数，，为空表示没有命令函数。
+
+-  **mandatory** – **[in]** 必选参数个数，参数个数包含命令本身。
+
+-  **optional** – **[in]** 可选参数个数。
+
+注意无论由那种方式定义的shell命令，shell系统都会创建\ ``argc``\ 和\ ``argv``\ 并交由注册的命令函数处理。但由\ ``SHELL_CMD_ARG``\ 定义的命令会指定必选参数数量\ ``mandatory``\ 和可选参数数量\ ``optional``\ ，实际通过shell命令输入的参数数量(包含命令本身)要满足：
+
+::
+
+   mandatory <= argc <= mandatory + optional
+
+当不满足时，shell系统会检查参数数量出来并做如下提示
+
+.. code:: c
+
+   shell_sample_args: wrong parameter count
+
+当\ ``mandatory``\ 和\ ``optional``\ 均被设置为0时，Shell系统不会对参数数量进行检查。
+以下实例
+
+.. code:: c
+
+   SHELL_CMD_ARG_REGISTER(shell_sample_args, NULL, "Sample arg commands with handle", cmd_shell_help, 3, 4);
+
+表示\ *shell_sample_args*\ 必须有3个参数（包含shell_sample_args），但总计不能超过7个，例如
+*shell_sample_args 0* 非法 *shell_sample_args 0 1* 合法
+*shell_sample_args 0 1 2 3* 合法 *shell_sample_args 0 1 2 3 4 5 6* 非法
+
+
+动态命令
+==========
+
+
+动态命令使用方法
+----------------
+
+动态子命令由\ ``SHELL_DYNAMIC_CMD_CREATE``\ 生成
+
+.. code:: c
+
+   SHELL_DYNAMIC_CMD_CREATE(name, get)
+
+-  **name** – **[in]** 动态命令入口.
+
+-  **get** – **[in]** 一个\ ``typedef void (*shell_dynamic_get)(size_t idx, struct shell_static_entry *entry)``\ 类型的函数，根据\ ``idx``\ 返回不同的\ ``struct shell_static_entry``\ 类型的命令入口参数。
+
+   ``struct shell_static_entry``\ 和\ ``SHELL_CMD_ARG``\ 指定的静态命令格式一样，指定命令符号，帮助信息，子命令入口，命令函数，和参数个数
+
+   .. code:: c
+
+      struct shell_static_args {
+          uint8_t mandatory; /*!< 必选参数个数. */
+          uint8_t optional;  /*!< 可选参数个数. */
+      };
+
+   .. code:: c
+
+      struct shell_static_entry {
+          const char *syntax;            /*!< 命令符号字符串. */
+          const char *help;            /*!< 帮助信息字符串. */
+          const struct shell_cmd_entry *subcmd;    /*!< 子命令入口. */
+          shell_cmd_handler handler;        /*!< 命令函数. */
+          struct shell_static_args args;        /*!< 命令参数个数. */
+      };
+
+   从上面看到get函数返回的shell命令入口和静态命令对应的参数一模一样,
+
+
+动态命令示例
+------------
+
+如下代码片段演示了如何添加一个动态子命令:
+
+1. 准备一个\ ``typedef void (*shell_dynamic_get)(size_t idx, struct shell_static_entry *entry)``\ 类型的动态命令获取函数：
+
+   .. code:: c
+
+      static void dynamic_cmd_get(size_t idx, struct shell_static_entry *entry)
+      {
+          if(idx<dynamic_cmd_num){
+              entry->syntax = cmd_name_flag? change_name[idx]:dynamic_entrys[idx].syntax;
+              entry->handler  = dynamic_entrys[idx].handler;
+              entry->subcmd = dynamic_entrys[idx].subcmd;
+              entry->help = dynamic_entrys[idx].help;
+              entry->args.mandatory = dynamic_entrys[idx].args.mandatory;
+              entry->args.optional = dynamic_entrys[idx].args.optional;
+          }else{
+              entry->syntax = NULL;
+          }
+      }
+
+2. 生成为动态子命令\ ``dynamic_set``
+
+   .. code:: c
+
+      SHELL_DYNAMIC_CMD_CREATE(dynamic_set, dynamic_cmd_get);
+
+3. 将\ ``dynamic_set``\ 注册到根命令中
+
+   .. code:: c
+
+      SHELL_CMD_REGISTER(shell_dynamic, &dynamic_set,
+                 "Sample dynamic command usage.", NULL);
+
+根命令\ *shell_dynamic*\ 的子命令集为\ ``dynamic_set``\ ，子命令集中有哪些子命令是由\ ``dynamic_cmd_get``\ 的输出决定。shell系统在遍历根命令\ *shell_dynamic*\ 的子命令时，传入参数\ ``idx``\ 从0开始每次加一的循环调用\ ``dynamic_cmd_get``\ ，直到输出的\ ``entry->syntax``\ 为空。在上面的示例代码中动态子命令的个数由\ ``dynamic_cmd_num``\ 决定，默认情况下就是\ ``dynamic_entrys[]``\ 中的命令入口数量：
+
+.. code:: c
+
+   /* 动态命令数组 */
+   static struct shell_static_entry dynamic_entrys[]=
+   {
+       /* 改变动态命令总数 */
+       {
+           .syntax = "total",
+           .handler = cmd_dynamic_total,
+           .subcmd = NULL,
+           .help = "Set total cmd number, must more than 1.",
+           .args.mandatory = 0,
+           .args.optional = 0,
+       },
+
+       /* 使用默认子命令名 */
+       {
+           .syntax = "org_name",
+           .handler = cmd_dynamic_org_name,
+           .subcmd = NULL,
+           .help = "Change to org cmd name.",
+           .args.mandatory = 0,
+           .args.optional = 0,
+       },
+
+       /* 使用新的子命令名 */
+       {
+           .syntax = "new_name",
+           .handler = cmd_dynamic_new_name,
+           .subcmd = NULL,
+           .help = "Change to new cmd name.",
+           .args.mandatory = 0,
+           .args.optional = 0,
+       },
+
+       /* 动态子命令的子命令演示 */
+       {
+           .syntax = "subcmd",
+           .handler = NULL,
+           .subcmd = &shell_sample,
+           .help = "Show dynamic sub cmd.",
+           .args.mandatory = 0,
+           .args.optional = 0,
+       },
+       {
+           .syntax = "cmd1",
+           .handler = NULL,
+           .subcmd = NULL,
+           .help = "Show dynamic command cmd1.",
+           .args.mandatory = 0,
+           .args.optional = 0,
+       },
+       {
+           .syntax = "cmd2",
+           .handler = NULL,
+           .subcmd = NULL,
+           .help = "Show dynamic command cmd2.",
+           .args.mandatory = 0,
+           .args.optional = 0,
+       },
+       {
+           .syntax = NULL,
+       }
+   };
+
+   static uint32_t dynamic_cmd_num = sizeof(dynamic_entrys)/sizeof(struct shell_static_entry);
+
+开机后在shell中输入\ ``shell_dynamic``\ 后按tab后可以看到所有的子命令
+
+.. code:: c
+
+   uart:~$ shell_dynamic
+     total     org_name  new_name  subcmd    cmd1      cmd2
+
+可以在运行时改变\ ``dynamic_cmd_num``\ 的大小达到改变\ *shell_dynamic*\ 的子命令数量，例如\ *total*\ 子命令就可以达到这一目的，它对应的命令函数如下：
+
+.. code:: c
+
+   static int cmd_dynamic_total(const struct shell *sh, size_t argc, char **argv)
+   {
+       if(argc < 2){
+           shell_help(sh);
+           return SHELL_CMD_HELP_PRINTED;
+       }
+
+       uint32_t num = (uint32_t)atoi(argv[1]);
+       if(num<1 && num > sizeof(dynamic_entrys)/sizeof(struct shell_static_entry)){
+           shell_error(sh, "total set fail, must in 1~%d", sizeof(dynamic_entrys)/sizeof(struct shell_static_entry));
+           return -ENOEXEC;
+       }
+
+       /* 改变动态命令的数量 */
+       shell_print(sh, "set total cmd num %d", num);
+       dynamic_cmd_num = num;
+
+       return 0;
+   }
+
+如果执行shell命令\ *shell_dynamic total
+1*\ ，\ ``cmd_dynamic_total``\ 被调用将\ ``dynamic_cmd_num``\ 修改为3，此时在shell中输入\ *shell_dynamic*\ 后按tab后就只能看到只剩3个子命令：
+
+::
+
+   uart:~$ shell_dynamic
+     total     org_name  new_name
+
+也可以在运行时通过改变\ ``cmd_name_flag``\ 变量的值，让动态子命令的\ ``syntax``\ 发生改变，达到动态改变动态子命令符号的目的。例如执行\ *shell_dynamic
+new_name*\ 后\ ``cmd_name_flag``\ 被修改为1，\ ``dynamic_cmd_get``\ 输出的\ ``syntax``\ 将使用\ ``change_name``\ 的内容
+
+.. code:: c
+
+   char * change_name[] = {
+       "total_new",
+       "org_name_new",
+       "new_name_new",
+       "cmd1_new",
+       "cmd2_new",
+       "cmd3_new",
+   };
+
+此时在shell中输入\ *shell_dynamic*\ 后按tab后，看到的就是新的子命令名称
+
+::
+
+   uart:~$ shell_dynamic
+     total_new     org_name_new  new_name_new
+
+当然也可以修改\ ``dynamic_entrys``\ 的内容达到添加和删除动态子命令的目的，或者是修改其中的子命令函数达到修改子命令功能的目的。
+
+
+
+内置命令
+========
+
+shell系统自带内置命令，自带命令可以通过配置项进行配置是否启用来优化shell的空间占用，默认情况下\ ``CONFIG_SHELL_CMDS=y``\ 开启了部分内置命令，将其设置为\ ``n``\ 可以关闭内置命令。
+
+Shell的内置命令列表：
+
+-  **clear** ：清屏
+
+-  **help**\ ：显示shell所有根命令及帮助信息
+
+-  **history**\ ：显示最近执行了的命令
+
+-  **resize**\ ：改变终端尺寸。当执行较长命令后，为保证多行显示和←, →, End, Home正常，需要执行该命令重设终端尺寸，目前只有UART后端支持该命令。
+
+   -  *resize* 命令默认是开启的\ ``CONFIG_SHELL_CMDS_RESIZE=y``
+
+   -  默认情况下执行\ *resize*\ 后终端的尺寸为80x24，可以通过\ ``CONFIG_SHELL_DEFAULT_TERMINAL_WIDTH=80``\ 和\ ``CONFIG_SHELL_DEFAULT_TERMINAL_HEIGHT=24``\ 配置改变
+
+   -  *resize*\ 有一个\ *default*\ 子命令，无论默认配置为多少执行\ *resize
+      default*\ 后就会把终端大小设置为80X24。
+
+-  **select**\ ：设置根，通过alt+r可以退回到主根。
+
+   例如主根下按tab可以看到所有的根命令：
+
+   ::
+
+      uart:~$
+        clear                 device                devmem
+        help                  history               kernel
+        log                   logging               nrf_clock_control
+        resize                select                shell
+        shell_dict            shell_dynamic         shell_sample
+        shell_sample_args     shell_sample_handler  shell_sample_null
+        shell_sample_sub
+
+   当执行\ *select
+   shell_sample*\ 后，在主根下按tab就只能看到\ *shell_sample*\ 的子命令：
+
+   ::
+
+      uart:~$
+        info     subinfo  arginfo
+
+   再按看到下面提示表示退回到默认的主根
+
+   ::
+
+      Restored default root commands
+
+   *select*\ 命令默认是关闭的，需要配置\ ``CONFIG_SHELL_CMDS_SELECT=y``\ 开启
+
+       
+
+-  **shell**\ ：用于设置shell终端的属性，有如下子命令
+
+   -  *shell backspace_mode
+      backspace*\ ：设置Backspace按键为backspace模式，按该按键后不会删除已输入的内容
+
+   -  *shell backspace_mode
+      delete*\ ：设置Backspace按键为delete模式，按该按键删除已输入的内容
+
+   -  *shell color off*\ ：关闭shell终端颜色
+
+   -  *shell color on*\ ：开启shell终端颜色
+
+   -  *shell echo
+      off*\ ：关闭shell回显，输入的命令不会被回显。需要依赖使用的终端软件支持回显。在终端软件必须回显的情况下可以用该命令关闭shell系统的回显。
+
+   -  *shell echo on*\ ：开启shell回显，输入的命令被回显。
+
+   -  *shell stats reset*\ ：清除log系统丢消息的统计信息。
+
+   -  *shell stats show*\ ：显示log系统丢的消息。
+
+
+
+
+命令行特性
+==========
+
+
+Zephyr的shell系统提供一个类Unix shell界面，通过该命令行界面用户可以操作Zephyr或者用户自己定义的shell命令。Zephyr的shell系统提供了一系列命令行特性方便操作shell命令。
+
+文本编辑按键支持
+--------------------
+
+左右移动光标：←, → 删除光标所在字符：Backspace, Delete
+移动光标到行尾/首：End, Home 切换插入/覆盖模式：Insert
+
+自动补全
+----------
+
+默认\ ``CONFIG_SHELL_TAB=y``\ 开启了tab支持
+
+Tab按键支持以下特性：
+
+-  提示有效命令
+
+   当按下tab时，会自动提示出所有有效的命令。例如敲入\ *she*\ 后按下tab会将以\ *she*\ 开头的命令都提示出来
+
+   ::
+
+      uart:~$ she
+        shell                 shell_dict            shell_dynamic
+        shell_sample          shell_sample_args     shell_sample_handler
+        shell_sample_null     shell_sample_sub
+
+-  自动补全
+
+   默认\ ``CONFIG_SHELL_TAB_AUTOCOMPLETION=y``\ 开启了自动补全，当提示命令只有一条时就会自动补全被执行。例如敲入\ *shell_sample_s*
+   后按下tab会将命令自动补全到输入位置
+
+   ::
+
+      uart:~$ shell_sample_sub
+
+历史命令
+----------
+
+默认\ ``CONFIG_SHELL_HISTORY=y``\ 开启了命令历史记录。通过执行 *history*
+命令可以查看历史执行过的命令。以通过↑ 和↓ 按键切换选择已经执行过的命令。当启用meta按键后也可以通过 Ctrl + n 和 Ctrl + p来切换选择。
+
+通配符
+----------
+
+默认\ ``CONFIG_SHELL_WILDCARD=y``\ 开启了通配符支持，shell支持两个通配符：
+
+-  \* ：匹配字符串
+
+-  ? ：匹配单个字符
+
+MetaKey
+----------
+
+默认情况下\ ``CONFIG_SHELL_METAKEYS=y``\ 开启了metakey的支持。shell支持的metakey和作用如下表
+
++-----------+---------------------------------------------------------+
+| Meta keys | Action                                                  |
++===========+=========================================================+
+| Ctrl + a  | 移动光标到行首，等同于Home                              |
++-----------+---------------------------------------------------------+
+| Ctrl + b  | 将光标向左移动一个字符，等同于←                         |
++-----------+---------------------------------------------------------+
+| Ctrl + c  | 放弃当前行输入的内容，另外新开                          |
+|           | 一行用于输入命令。类似于回Enter但不执行已经输入了的命令 |
++-----------+---------------------------------------------------------+
+| Ctrl + d  | 删除光标下的字符，等同于Delete                          |
++-----------+---------------------------------------------------------+
+| Ctrl + e  | 移动光标到行尾，等同于End                               |
++-----------+---------------------------------------------------------+
+| Ctrl + f  | 将光标向右移动一个字符，等同于→                         |
++-----------+---------------------------------------------------------+
+| Ctrl + k  | 删除从光标到行尾的所有字符                              |
++-----------+---------------------------------------------------------+
+| Ctrl + l  | 保留当前正在输入的命令，清除屏幕其它的内容。            |
++-----------+---------------------------------------------------------+
+| Ctrl + n  | 切换到上一个历史执行的命令                              |
++-----------+---------------------------------------------------------+
+| Ctrl + p  | 切换到下一个历史执行的命令                              |
++-----------+---------------------------------------------------------+
+| Ctrl + u  | 清除当前正在输入的命令                                  |
++-----------+---------------------------------------------------------+
+| Ctrl + w  | 删除光标侧的一个单词                                    |
++-----------+---------------------------------------------------------+
+| Alt + b   | 移动光标到前一个词                                      |
++-----------+---------------------------------------------------------+
+| Alt + f   | 移动光标到后一个词                                      |
++-----------+---------------------------------------------------------+
+
+
+
+参考
+=====
+https://docs.zephyrproject.org/latest/services/shell/index.html
\ No newline at end of file
-- 
Gitee


From 321b15f1f32b7c23a9ac224d27c5d6d0b309dde6 Mon Sep 17 00:00:00 2001
From: Frank Li <lgl88911@163.com>
Date: Tue, 8 Nov 2022 11:11:54 +0800
Subject: [PATCH 3/6] doc: add kernel category

Add workq and system_thread docs.

Signed-off-by: Frank Li <lgl88911@163.com>
---
 doc/source/develop/index.rst                |   1 +
 doc/source/develop/kernel/index.rst         |  12 +
 doc/source/develop/kernel/system_thread.rst |  60 ++++
 doc/source/develop/kernel/workq.rst         | 303 ++++++++++++++++++++
 doc/source/images/develop/kernel/workq.png  | Bin 0 -> 19021 bytes
 5 files changed, 376 insertions(+)
 create mode 100644 doc/source/develop/kernel/index.rst
 create mode 100644 doc/source/develop/kernel/system_thread.rst
 create mode 100644 doc/source/develop/kernel/workq.rst
 create mode 100644 doc/source/images/develop/kernel/workq.png

diff --git a/doc/source/develop/index.rst b/doc/source/develop/index.rst
index 7227079..623186a 100644
--- a/doc/source/develop/index.rst
+++ b/doc/source/develop/index.rst
@@ -9,3 +9,4 @@
    subsys/index.rst
    driver/index.rst
    osserivces/index.rst
+   kernel/index.rst
diff --git a/doc/source/develop/kernel/index.rst b/doc/source/develop/kernel/index.rst
new file mode 100644
index 0000000..0250389
--- /dev/null
+++ b/doc/source/develop/kernel/index.rst
@@ -0,0 +1,12 @@
+.. _kernel:
+
+内核
+######
+
+Zephyr内核分析和使用方法。
+
+.. toctree::
+   :maxdepth: 1
+
+   workq.rst
+   system_thread.rst
diff --git a/doc/source/develop/kernel/system_thread.rst b/doc/source/develop/kernel/system_thread.rst
new file mode 100644
index 0000000..64889f3
--- /dev/null
+++ b/doc/source/develop/kernel/system_thread.rst
@@ -0,0 +1,60 @@
+.. _kernel_system_thread:
+
+系统线程
+#########
+
+系统线程是内核初始化过程中自动启动的两个线程，Zephyr内核自动启动两个线程。
+
+主线程
+======
+
+Zephyr在内核启动过程中，完成\ ``_SYS_INIT_LEVEL_PRE_KERNEL_1``\ 和\ ``_SYS_INIT_LEVEL_PRE_KERNEL_2``\ 等级的基础硬件初始化后就启动主线程\ ``bg_thread_main``\ ，主线程内在主要完成以下任务：
+
+-  ``_SYS_INIT_LEVEL_POST_KERNEL``\ 等级的设备初始化
+
+-  ``_SYS_INIT_LEVEL_APPLICATION``\ 等级的设备初始化
+
+-  启动静态初始化线程
+
+-  初始化SMP
+
+-  跳转到\ ``main()``\ 处理
+
+这里的\ ``main()``\ 就是Zephyr的应用程序\ ``main()``\ 入口。
+
+主线程的优先级由\ ``CONFIG_MAIN_THREAD_PRIORITY``\ 指定，默认配置为最高的可抢占优先级\ ``0``\ ，如果内核被配置为不支持抢占线程，则主线程优先级默认为最低的协作线程优先级\ ``-1``\ 。一般情况下不建议对主线程优先级进行配置。需要注意的是由于主线程的优先级默认比所有抢占优先级都高，应用程序在\ ``main()``\ 中不要随意做“busy
+loop”，否则会导致其它低优先级抢占式线程无法运行。
+
+主线程的堆栈由\ ``CONFIG_MAIN_STACK_SIZE``\ 指定，默认为1K。由于应用程序的\ ``main()``\ 是在主线程中执行，当应用程序在\ ``main()``\ 中使用大量堆栈时，需要增加\ ``CONFIG_MAIN_STACK_SIZE``\ 的大小。
+
+主线程是执行内核初始化和应用程序\ ``main()``\ 时必不可少的线程,
+因此在创建主线程时会指定\ ``K_ESSENTIAL``\ 表示其不能被中止，中止主线程会引发致命的系统错误。
+但是当\ ``main()``\ 返回后主线程会主动移掉\ ``K_ESSENTIAL``\ 标记此时主线程可以正常终止并且不会引发错误。
+
+
+空闲线程
+========
+
+当系统没有其他工作要做时，休眠线程将执行。在支持硬件休眠的SOC架构下空闲线程会通过电源管理系统让SOC进入休眠以节省电量，
+否则空闲线程只会执行“busy loop” 。
+只要系统在运行，空闲线程就一直存在并且永远不会终止。
+
+空闲线程始终使用系统配置的最低线程优先级。
+如果系统被配置为不支持可抢占优先级时，空闲线程将变成一个协作线程，因此空闲线程会重复让出
+CPU 以允许其他线程在需要时运行。
+
+空闲线程是必不可少的线程，在创建空闲线程时会指定\ ``K_ESSENTIAL``\ 表示其不能终止，中止空闲线程会引发致命的系统错误。
+
+空闲线程的堆栈由\ ``CONFIG_IDLE_STACK_SIZE``\ 指定，由于空闲线程内做的工作需要堆栈不大，因此默认配置为256字节，一些不同的CPU体系架构会有稍微大一点的堆栈，但都不会超过1K字节。
+
+
+其它
+====
+
+主线程和空闲线程是Zephyr系统不能缺少的系统线程，同时根据应用程序指定的内核和主板配置选项，也可能产生额外的系统线程。
+例如，启用系统系统工作队列会产生一个系统线程为提交给它的工作项提供服务。
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/kernel/services/threads/system_threads.html
diff --git a/doc/source/develop/kernel/workq.rst b/doc/source/develop/kernel/workq.rst
new file mode 100644
index 0000000..722a61d
--- /dev/null
+++ b/doc/source/develop/kernel/workq.rst
@@ -0,0 +1,303 @@
+.. _kernel_workq:
+
+工作队列
+########
+
+工作队列由一个专用线程和列队组成，专用线程以先进先出的方式处理发送到列队中的工作项。工作队列的线程通常被指定为低优先级线程，中断服务程序或者高优先级线程将非紧急事务转移到工作队列的专用线程中处理，以此降低对时间敏感事物的影响。在Zephyr中工作队列被作为内核对象提供出来，而其它大多数RTOS需要使用者自己使用线程和消息队列来实现工作队列。
+
+|image0|
+
+只要内存足够在Zephyr可以创建任意数量的工作队列，一个工作队列就会有一个工作线程，工作线程的优先级可以配置为协助或者抢占。当列队中无工作项时工作线程处于睡眠状态。当使用者向工作队列发送工作项时，工作项被加入到列队同时通知工作线程处理，工作线程从列队中取出工作项执行，工作线程在执行工作项之间会使用\ ``k_yield``\ 以防止协作类型的工作线程一直占用CPU饿死其它线程。
+
+一个工作队列的三大要素：
+
+-  工作项：中断服务程序或高优先级线程的非紧急事务
+
+-  列队：用于保存还没处理的工作项
+
+-  工作线程：处理工作项中携带的事务
+
+工作项
+======
+
+工作项带有一个工作处理函数，当工作线程处理该工作项时就调用该工作处理函数。工作项在生命周期内有如下状态：
+
+-  悬空：被发送者初始化
+
+-  排队(**queued**)：\ ``K_WORK_QUEUED``
+   工作项被发送放到列队中，但还未执行
+
+-  预约(**scheduled**): ``K_WORK_DELAYED``
+   延迟工作项(后文说明)在等待超时
+
+-  运行(**running**)：\ ``K_WORK_RUNNING`` 工作项正在被工作线程处理
+
+-  弃用(**canceling**): ``K_WORK_CANCELING`` 弃用正在被处理的工作项
+
+工作项可能会同时拥有以上几种状态的组合，例如启用一个正在执行的工作项，这个工作项的状态就是\ ``K_WORK_RUNNING | K_WORK_CANCELING``
+
+用户定义工作队列
+================
+
+只要内存足够用户可以定义任意数量的工作队列，创建一个工作队列需要通过初始化和启动两步完成，工作队列的线程是在启动工作队列时才创建
+
+.. code:: c
+
+   /* 工作队列线程的属性 */
+   #define USER_WQ_STACK_SIZE 4096
+   #define USER_WQ_PRIORITY 5
+
+   /* 定义工作队列线程的堆栈 */
+   K_THREAD_STACK_DEFINE(user_wq_stack_area, USER_WQ_STACK_SIZE);
+
+   /* 初始化工作队列 */
+   struct k_work_q user_work_q;
+   k_work_queue_init(&user_work_q);
+
+   /* 启动工作队列 */
+   k_work_queue_start(&user_work_q, user_wq_stack_area,
+                       K_THREAD_STACK_SIZEOF(user_wq_stack_area), USER_WQ_PRIORITY,
+                       NULL);
+
+发送工作项到指定的工作队列，工作队列线程一旦无其它前置的工作项时将立即处理该工作项。
+
+.. code:: c
+
+   /* 初始化工作项，为其指定工作函数user_work_handler */
+   struct k_work work;
+   k_work_init(&work, user_work_handler);
+
+   /* 将工作项发送到 user_work_q的工作队列处理 */
+   k_work_submit_to_queue(&user_work_q, &work);
+
+对用户定义的工作队列可以进行排空操作
+
+.. code:: c
+
+   /* 排空user_work_q的工作项，第二个参数plug设置未true表示排空后仍然不接受新的工作项提交 */
+   k_work_queue_drain(&user_work_q, true);
+
+排空函数会一直阻塞直到工作队列中所有工作项执行完成后才会返回，在排空执行期间被排空的工作队列只接受自己工作线程提交的工作项，不接受中断服务程序和其它线程提交的工作项。排空结束后工作队列会根据第二个参数\ ``plug``\ 判断是否接受新的工作项，如果\ ``false``\ 表示排空后可以立即接受新的工作项提交，如果为\ ``true``\ 需要做unplug动作做释放动作让工作队列可以继续接受新的工作项
+
+.. code:: c
+
+   /* 释放plug的工作队列，可以继续接受新的提交的工作项 */
+   k_work_queue_unplug(&user_work_q);
+
+系统工作队列
+============
+
+zephyr在\ ``POST_KERNEL``\ 初始化阶段会创建一个系统工作队列\ ``k_sys_work_q``
+
+.. code:: c
+
+   SYS_INIT(k_sys_work_q_init, POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEFAULT);
+
+该工作队列的线程优先级通过\ ``CONFIG_SYSTEM_WORKQUEUE_PRIORITY``\ 配置，默认\ ``-1``\ ，属于不可抢占的协作线程。通过\ ``CONFIG_SYSTEM_WORKQUEUE_NO_YIELD``\ 配置系统工作队列在处理完一个工作项后是否执行\ ``k_yield``\ ，默认为\ ``n``\ 表示需要执行
+
+.. code:: c
+
+   static int k_sys_work_q_init(const struct device *dev)
+   {
+       ARG_UNUSED(dev);
+       struct k_work_queue_config cfg = {
+           .name = "sysworkq",
+           .no_yield = IS_ENABLED(CONFIG_SYSTEM_WORKQUEUE_NO_YIELD),
+       };
+
+       k_work_queue_start(&k_sys_work_q,
+                   sys_work_q_stack,
+                   K_KERNEL_STACK_SIZEOF(sys_work_q_stack),
+                   CONFIG_SYSTEM_WORKQUEUE_PRIORITY, &cfg);
+       return 0;
+   }
+
+从上面的实现可以看到，系统工作队列也是使用的\ ``k_work_queue_start``\ 创建，因此其工作原理和用户定义的一致。
+
+由于新建一个工作队列要创建线程，需要较多内存资源，因此一般建议只使用系统工作队列。只有当工作项会影响到系统工作队列的时才另建立工作队列处理该工作项，例如一个工作项会长时间阻塞影响系统工作队列中后续的工作项，这就需要新建工作队列来单独处理。
+
+系统工作队列已经在zephyr初始化阶段创建好，因此只用初始化一个工作项进行发送执行即可，系统工作队列线程一旦无其它前置的工作项时将立即处理该工作项
+
+.. code:: c
+
+   struct k_work work;
+   k_work_init(&work, user_work_handler);
+   k_work_submit(&work);
+
+对工作项的操作
+==============
+
+无论是提交到系统工作队列还是用户工作队列的工作项都可以使用下列API进行操作
+
+.. code:: c
+
+   struct k_work_sync sync;
+
+   /* 等待work执行完成后才返回 */
+   k_work_flush(&work, &sync);
+
+   /* 异步取消work立即返回，列队等待的work将被移除，已经再执行的work依然执行完 */
+   k_work_cancel(&work);
+
+   /* 同步取消work，列队等待的work将被移除，已经再执行的work依然执行完,等到执行完后才会返回 */
+   k_work_cancel(&work, &sync);
+
+延迟工作项
+==========
+
+当中断服务程序或高优先级线程希望工作项在指定时间后才执行，可以通过延迟工作项来完成，通过设置预定时间，延迟工作项会在指定时间后才提交到工作队列中。
+前面提到过工作队列排空时不会接受工作队列线程以外的工作项提交，但延迟工作项在预约时间到时的提交不受到该限制。
+
+**注意**\ ：延迟工作项只是延迟提交到工作队列，因此只能保证在指定时间后执行，不能保证在指定时间点执行。例如指定20ms后执行，会在20ms后提交到工作队列，此时如果队列中有其它前置工作项，会等其它前置工作项完成后才会执行。
+
+延迟工作项的使用方法如下：
+
+初始化
+------
+
+.. code:: c
+
+   /* 初始化一个延迟工作项 */
+   struct k_work_delayable delay_work;
+   k_work_init_delayable(&delay_work, delay_work_handler);
+
+预约
+----
+
+一个延迟工作项既可以预约到系统工作队列也可以预约到用户工作队列，当预约时间到的适合工作项会被提交到工作队列中
+
+**系统工作队列**
+
+.. code:: c
+
+   /* 300ms后将延迟工作项提交到系统工作队列中*/
+   k_work_schedule(&delay_work, K_MSEC(300));
+
+**用户工作队列**
+
+.. code:: c
+
+   /* 300ms后将延迟工作项提交到user_work_q工作队列中*/
+   k_work_schedule_for_queue(&user_work_q, &delay_work, K_MSEC(300));
+
+
+对一个处于预约状态尚未提交的延迟工作项再次做`k_work_schedule/k_work_schedule_for_queue`不会改变其预约时间
+
+修改预约
+--------
+
+对一个处于预约中的延迟工作项使用下面方法可以更改其预约提交时间
+
+**系统工作队列**
+
+.. code:: c
+
+   /* 将系统工作队列delay_work的预约时间修改为3000ms */
+   k_work_reschedule(&delay_work, K_MSEC(3000));
+
+**用户工作队列**
+
+.. code:: c
+
+
+   /* 将用户工作队列user_work_q中delay_work的预约时间修改为3000ms */
+
+   k_work_reschedule_for_queue(&user_work_q, &delay_work, K_MSEC(3000));
+
+取消延迟工作项
+--------------
+
+取消分为三种状态处理：
+
+-  工作项处在预约等待状态，取消预约定时器
+
+-  工作项处于列队等待状态，从列队中移除
+
+-  工作项处于运行状态，标记取消，不会中止运行
+
+取消延迟工作项分为异步和同步两种，异步取消只是通知取消不会等待真正的取消就会退出。例如如果取消一个正在运行的工作项，同步取消函数会等到运行完毕后才会返回。
+
+**异步取消**
+
+.. code:: c
+
+   k_work_cancel_delayable(&delay_work);
+
+**同步取消**
+
+.. code:: c
+
+   k_work_cancel_delayable_sync(&delay_work);
+
+等待执行
+--------
+
+执行等待执行时如果延迟工作项在预约状态将取消预约并立即提交到工作队列，并等到执行完成后才返回
+
+.. code:: c
+
+   struct k_work_sync sync;
+
+   /* 延迟工作项被立即提交到工作队列，等待执行完后才返回 */
+   k_work_flush_delayable(&delay_work, &sync);
+
+延迟工作项状态获取
+------------------
+
+下列函数获取延迟工作项的状态
+
+.. code:: c
+
+   /* 返回0表示没有工作，非0表示延迟工作项在忙，非0是由工作项的四种状态组成 */
+   int busy = k_work_delayable_busy_get(&delaywork);
+
+   /* 返回false表示没有工作，返回true表示工作项在忙 */
+   bool pending = k_work_delayable_is_pending(&delaywork);
+
+   /* 返回延迟工作项在第几个绝对tick时被提交到工作队列 */
+   k_ticks_t expires = k_work_delayable_expires_get(&delaywork);
+
+   /* 返回延迟工作项还有多少个tick才被提交到工作队列中 */
+   k_ticks_t remaining = k_work_delayable_remaining_get(&delaywork);
+
+用户空间工作队列
+================
+
+用户空间工作队列是专用在用户空间的工作队列，其内存地址被保护和内核空间隔离，一般只用于zephyr应用程序中。用户空间工作队列的基本构成和工作队列一致：拥有一个队列和工作线程，但结构更为简单，只提供以下4个API，除提交工作项的处理外无法做其它额外的操作。用户空间的工作项也只拥有\ ``K_WORK_USER_STATE_PENDING``\ 和非pending两种状态，分别代表工作项等待运行和已经运行。
+
+.. code:: c
+
+   #define USER_SP_WQ_STACK_SIZE 4096
+   #define USER_SP_WQ_PRIORITY 5
+
+   /* 定义用户空间工作队列线程的堆栈 */
+   K_THREAD_STACK_DEFINE(user_wq_space_stack_area, USER_SP_WQ_STACK_SIZE );
+
+   /* 启动一个用户空间的工作队列 */
+   struct k_work_user_q user_space_work_q;
+   k_work_user_queue_start(&user_space_work_q,
+                       user_wq_space_stack_area,
+                       USER_SP_WQ_STACK_SIZE , USER_SP_WQ_PRIORITY ,
+                       NULL);
+
+   /* 初始化一个用户空间的工作项 */
+   struct k_work_user user_space_work;
+   k_work_user_init(&user_space_work, work_user_handler);
+
+   /* 发送工作项到用户空间工作队列 */
+   k_work_user_submit_to_queue(&user_space_work_q, &user_space_work);
+
+   /* 查询用户空间的工作项是否处于pending，还未执行处于pending，正在或已经执行完成为非pending */
+   bool pending = k_work_user_is_pending(&user_space_work);
+
+其它
+====
+
+工作队列中还有一种叫触发工作，其工作项和轮询内核对象绑定，这部分实现在轮询内核对象中，本文不做介绍。
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/kernel/services/threads/workqueue.html
+
+.. |image0| image:: ../../images/develop/kernel/workq.png
diff --git a/doc/source/images/develop/kernel/workq.png b/doc/source/images/develop/kernel/workq.png
new file mode 100644
index 0000000000000000000000000000000000000000..49c2fe42163b779808e0b4fc47187f075d454701
GIT binary patch
literal 19021
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%0D-6%K-<F~s$**_F
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

literal 0
HcmV?d00001

-- 
Gitee


From 0682b5c7e1a86db4b34be313e4089315ca3fc904 Mon Sep 17 00:00:00 2001
From: Frank Li <lgl88911@163.com>
Date: Wed, 9 Nov 2022 15:34:14 +0800
Subject: [PATCH 4/6] doc: add synchonization docs

Add sem,mutex,poll,event,cond doc.

Signed-off-by: Frank Li <lgl88911@163.com>
---
 .../develop/kernel/condition_variables.rst    | 272 +++++++
 doc/source/develop/kernel/event.rst           | 402 ++++++++++
 doc/source/develop/kernel/index.rst           |   6 +
 doc/source/develop/kernel/mutex.rst           | 306 +++++++
 doc/source/develop/kernel/poll.rst            | 754 ++++++++++++++++++
 doc/source/develop/kernel/sem.rst             | 277 +++++++
 doc/source/develop/kernel/synchronization.rst |  60 ++
 doc/source/images/develop/kernel/poll.png     | Bin 0 -> 76980 bytes
 .../images/develop/kernel/poll_list.png       | Bin 0 -> 24755 bytes
 9 files changed, 2077 insertions(+)
 create mode 100644 doc/source/develop/kernel/condition_variables.rst
 create mode 100644 doc/source/develop/kernel/event.rst
 create mode 100644 doc/source/develop/kernel/mutex.rst
 create mode 100644 doc/source/develop/kernel/poll.rst
 create mode 100644 doc/source/develop/kernel/sem.rst
 create mode 100644 doc/source/develop/kernel/synchronization.rst
 create mode 100644 doc/source/images/develop/kernel/poll.png
 create mode 100644 doc/source/images/develop/kernel/poll_list.png

diff --git a/doc/source/develop/kernel/condition_variables.rst b/doc/source/develop/kernel/condition_variables.rst
new file mode 100644
index 0000000..7d64eb2
--- /dev/null
+++ b/doc/source/develop/kernel/condition_variables.rst
@@ -0,0 +1,272 @@
+.. _kernel_condition_variables:
+
+同步-条件变量
+#############
+
+条件变量通常用于控制共享资源的访问，它允许一个线程等待其它线程创建共享资源需要的条件。
+
+使用
+====
+
+API
+---
+
+``#define K_CONDVAR_DEFINE(name)``
+
+- 作用:定义一个k_condvar，并初始化
+
+- name: k_condvar name
+
+``int k_condvar_init(struct k_condvar *condvar)``
+
+- 作用: 初始化条件变量
+
+- condvar: 要初始化的condvar 返回值: 0标示初始化成功
+
+``int k_condvar_signal(struct k_condvar *condvar)``
+
+- 作用：通知条件变量有效，最先加入条件变量列队的thread将优先获得该有效条件
+
+- condvar: 有效的条件变量 返回值: 0表示成功
+
+``int k_condvar_broadcast(struct k_condvar *condvar)``
+
+- 作用：广播条件变量有效，所有条件变量列队的thread将获得该有效条件
+
+- condvar: 有效的条件变量 返回值: 0表示成功
+
+``int k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex, k_timeout_t timeout)``
+
+- 作用：等待条件变量有效 condvar：等待的条件变量
+
+- mutex：资源锁，条件变量和mutex搭配使用，在等待条件变量期间该mutex会被unlock
+
+- timeout: 等待时间，单位ms。K_NO_WAIT不等待, K_FOREVER一直等
+
+- 返回值: 0表示等待成功，-EAGAIN表示等待超时
+
+使用说明
+--------
+
+初始化
+~~~~~~
+
+下面两种方法都可以定义&初始化一个条件变量 编译期初始化
+
+::
+
+   K_CONDVAR_DEFINE(my_condvar);
+
+运行期初始化
+
+::
+
+   struct k_condvar my_condvar;
+   k_condvar_init(&my_condvar);
+
+等待条件有效
+~~~~~~~~~~~~
+
+::
+
+   void thread_get(void)
+   {
+       k_mutex_lock(&mutex, K_FOREVER);
+
+       //等待使用资源的条件有效，等待器件会解锁mutex，当等到后会重新上锁Mutex
+       k_condvar_wait(&condvar, &mutex, K_FOREVER);
+
+       //条件变量有效，使用共享资源
+       ...
+       k_mutex_unlock(&mutex);
+   }
+
+通知条件变量有效
+~~~~~~~~~~~~~~~~
+
+通知条件变量有效有两种方法：
+
+通知一次，只有一个thread可以获得条件有效
+
+::
+
+   void worker_thread(void)
+   {
+       k_mutex_lock(&mutex, K_FOREVER);
+       //通知条件有效
+       k_condvar_signal(&condvar);
+       k_mutex_unlock(&mutex);
+   }
+
+广播，所有等待该条件的thread都会获得条件有效
+
+::
+
+   void worker_thread(void)
+   {
+       k_mutex_lock(&mutex, K_FOREVER);
+       //广播条件有效
+       k_condvar_broadcast(&condvar);
+       k_mutex_unlock(&mutex);
+   }
+
+使用条件变量需要搭配mutex来控制对共享资源的互斥访问。条件变量只是用来通知条件满足，条件变量不包含条件本身。
+
+实现
+====
+
+struct k_condvar的结构体如下:
+
+::
+
+   struct k_condvar {
+       _wait_q_t wait_q;
+   };
+
+条件变量就是由内核的wait_q实现的，条件变量的实现代码在kernel/condvar.c文件中，Zephyr中对内核对象的访问需要通过系统调用，Zephyr会将kernel.h中的API最后转化为调用系统调用的API例如:
+k_condvar_init->z_impl_k_condvar_init
+k_condvar_signal->z_impl_k_condvar_signal
+k_condvar_broadcast->z_impl_k_condvar_broadcast
+k_condvar_wait->z_impl_k_condvar_wait
+
+
+初始化
+------
+
+代码非常简单，无论是使用那种方式初始化都是初始化一个wait_q
+
+::
+
+   int z_impl_k_condvar_init(struct k_condvar *condvar)
+   {
+       //初始化wait_q
+       z_waitq_init(&condvar->wait_q);
+
+       //初始化object，给userspace用，非userspace无作用
+       z_object_init(condvar);
+
+       SYS_PORT_TRACING_OBJ_INIT(k_condvar, condvar, 0);
+
+       return 0;
+   }
+
+::
+
+   #define Z_CONDVAR_INITIALIZER(obj)                                             \
+       {                                                                      \
+           .wait_q = Z_WAIT_Q_INIT(&obj.wait_q),                          \
+       }
+
+等待条件满足
+------------
+
+等待条件满足，就是将thread加入到条件变量的wait_q内等待，等待过程中会将资源锁放掉，当条件满足后又重新拿资源锁
+
+::
+
+   int z_impl_k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex,
+                 k_timeout_t timeout)
+   {
+       k_spinlock_key_t key;
+       int ret;
+
+       //锁调度，避免后面放资源锁的时候引发调度
+       key = k_spin_lock(&lock);
+
+       //释放资源锁
+       k_mutex_unlock(mutex);
+
+       //将当前线程加入到wait_q中，挂起当前线程，切换上下文
+       ret = z_pend_curr(&lock, key, &condvar->wait_q, timeout);
+
+       //条件变量满足后，会从wait_q取出挂起的线程从这里恢复执行
+
+       //重新拿到资源锁
+       k_mutex_lock(mutex, K_FOREVER);
+
+
+       return ret;
+   }
+
+通知条件满足
+------------
+
+通知条件满足会从条件变量的wait_q中取出一个等待的thread恢复执行，实现分析如下
+
+::
+
+   int z_impl_k_condvar_signal(struct k_condvar *condvar)
+   {
+       //锁调度
+       k_spinlock_key_t key = k_spin_lock(&lock);
+
+       //从条件变量的wait_q中选出最合适的thread
+       struct k_thread *thread = z_unpend_first_thread(&condvar->wait_q);
+
+       if (thread != NULL) {
+           //如果存在等待条件变量的thread
+
+           //设置返回为0
+           arch_thread_return_value_set(thread, 0);
+
+           //将其转为就绪状态
+           z_ready_thread(thread);
+
+           //引发重新调度
+           z_reschedule(&lock, key);
+       } else {
+           //如果不存在等待条件变量的thread，解锁调度，退出
+           k_spin_unlock(&lock, key);
+       }
+       return 0;
+   }
+
+广播条件满足
+------------
+
+广播条件满足会从条件变量的wait_q中取出所有的thread恢复执行，实现分析如下
+
+::
+
+   int z_impl_k_condvar_broadcast(struct k_condvar *condvar)
+   {
+       struct k_thread *pending_thread;
+       k_spinlock_key_t key;
+       int woken = 0;
+
+       //锁调度
+       key = k_spin_lock(&lock);
+
+
+       //从wait_q中取出所有thread进行恢复
+       while ((pending_thread = z_unpend_first_thread(&condvar->wait_q)) !=
+              NULL) {
+           //设置返回为0
+           arch_thread_return_value_set(pending_thread, 0);
+           //将其转为就绪状态
+           z_ready_thread(pending_thread);
+       }
+
+       //引发调度
+       z_reschedule(&lock, key);
+
+       return woken;
+   }
+
+和信号量的区别
+==============
+
+初看条件变量总有一点信号量的影子，Zephyr中二者主要有如下区别:
+
+1. 信号量无法进行广播。
+
+2. 多值信号量可以积压，没有消费者发送的信号依然被保存，而条件变量发送后没有消费者接受条件就过期了。
+
+3. 条件变量必须搭配互斥锁使用。
+
+4. Zephyr中信号量可以用于Poll，条件变量则不行。
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/reference/kernel/synchronization/condvar.html
diff --git a/doc/source/develop/kernel/event.rst b/doc/source/develop/kernel/event.rst
new file mode 100644
index 0000000..bee9375
--- /dev/null
+++ b/doc/source/develop/kernel/event.rst
@@ -0,0 +1,402 @@
+.. _kernel_event:
+
+同步-事件
+##########
+
+事件对象是一种线程同步对象，允许一个或者多个线程等待同一个事件对象，当事件被传递到事件对象时，满足条件的线程都变为就绪。通常使用事件来通知一系列条件已满足。在Zephyr中每个事件对象使用一个32bit数来跟踪传递的事件集，每个bit表示一个事件。事件可以由ISR或者线程发送，发送事件有两种方法：
+
+* 设置：覆盖现有的事件集，重写这个32bit数
+
+* 发布：以bit方式\ **添加**\ 事件到事件基，注意这里只能添加，不能删除
+
+线程可以等待一个或多个事件。在等待多个事件时可以指定等待其中部分或者全部事件。线程在提出等待事件对象时，可以选择在等待前清空等待事件对象上的所有事件。
+
+
+API
+===
+
+宏定义
+------
+
+**K_EVENT_DEFINE(name)**
+
+- 静态的定义和初始化事件对象。
+
+-  **name**  事件对象名
+
+函数
+----
+
+**void k_event_init(struct k_event *event)**
+
+- 初始化事件对象，在使用事件对象前首先使用该函数对其进行初始化。
+
+- **event** 事件对象的地址
+
+**void k_event_post(struct k_event *event, uint32_t events)**
+
+- 发布一个或多个事件到事件对象。如果等待\ ``event``\ 的线程因为发布的事件满足等待条件，该线程被转为就绪，与设置事件不同，发布的事件是增加到事件对象中。
+
+-  **event**  事件对象的地址
+
+-  **events**  发布的事件集合
+
+**void k_event_set(struct k_event *event, uint32_t events)**
+
+设置事件集合到事件对象，将事件对象中的事件设置为\ ``events``\ 。如果等待\ ``event``\ 的线程因为设置的事件满足等待条件，该线程被转为就绪。与发布事件不同，设置事件会取代事件对象中的事件集。
+
+-  **event**  事件对象的地址
+-  **events**  设置的事件集合
+
+**uint32_t k_event_wait(struct k_event *event, uint32_t events, bool reset, k_timeout_t timeout)**
+
+等待任意指定事件，在\ ``event``\ 上等待，有任意指定的事件被发送，或者是等待时间超过\ ``timeout``\ 。一个线程最多可以等待32个事件，这些事件由\ ``events``\ 中的bit位置标识。
+
+**注意**
+``reset = true``\ 将在等待事件前，将\ ``event``\ 中已发生的事件，使用的时候请特别注意。
+
+- **event**  事件对象的地址
+- **events**  等待的事件集
+- **reset** 如果为\ ``true``\ ，等待前清空\ ``event``\ 中已发生的事件，如果为false则不清空
+- **timeout**  指定等待事件的最长事件，可以指定为\ ``K_NO_WAIT`` 和\ ``K_FOREVER``
+
+- 返回值  **事件集**  等待成功后返回收到匹配的事件集 **0** 指定时间内未收到匹配事件
+
+**uint32_t k_event_wait_all(struct k_event *event, uint32_t events, bool reset, k_timeout_t  timeout)**
+
+等待所有指定事件，在\ ``event``\ 上等待，指定的所有事件被发送，或者是等待时间超过\ ``timeout``\ 。一个线程最多可以等待32个事件，这些事件由\ ``events``\ 中的bit位置标识。
+
+**注意**
+``reset = true``\ 将在等待事件前，将\ ``event``\ 中已发生的事件，使用的时候请特别注意。
+
+- **event**  事件对象的地址
+- **events**  等待的事件集
+- **reset** 如果为\ ``true``\ ，等待前清空\ ``event``\ 中已发生的事件，如果为false则不清空
+- **timeout** 指定等待事件的最长事件，可以指定为\ ``K_NO_WAIT`` 和 ``K_FOREVER``
+
+返回值
+
+-  **事件集**  等待成功后返回收到匹配的事件集
+-  **0**  指定时间内未收到匹配事件
+
+使用
+====
+
+配置
+----
+
+事件对象的配置选项是\ ``CONFIG_EVENTS``\ ，zephyr内核没有给事件对象配置选项设置默认值，编译时将被识别为未配置，因此要使用事件对象需要增加配置\ ``CONFIG_EVENTS=y``\ 。
+
+示例
+----
+
+**初始化事件对象**
+
+使用函数
+
+.. code:: c
+
+   struct k_event my_event;
+   k_event_init(&my_event);
+
+等效于
+
+.. code:: c
+
+   K_EVENT_DEFINE(my_event);
+
+**设置事件**
+
+下列示例在中断服务程序中设置事件为0x001
+
+.. code:: c
+
+   void input_available_interrupt_handler(void *arg)
+   {
+       /* 通知线程数据有效 */
+       k_event_set(&my_event, 0x001);
+
+       ...
+   }
+
+**发布事件**
+
+下面示例在中断服务程序中发布事件0x120，如果前面的设置事件未被清除，此时\ ``my_event``\ 中的事件为0x121
+
+.. code:: c
+
+   void input_available_interrupt_handler(void *arg)
+   {
+       ...
+
+       /* notify threads that more data is available */
+
+       k_event_post(&my_event, 0x120);
+
+       ...
+   }
+
+**等待事件**
+
+下面示例等待事件50毫秒，在50毫秒内只要前面的设置和发布示例中任意一个发生都会等待成功
+
+.. code:: c
+
+   void consumer_thread(void)
+   {
+       uint32_t  events;
+
+       events = k_event_wait(&my_event, 0xFFF, false, K_MSEC(50));
+       if (events == 0) {
+           printk("No input devices are available!");
+       } else {
+           /* 收到事件，根据events进行处理 */
+           ...
+       }
+       ...
+   }
+
+下面示例等待事件50毫秒，在50毫秒没只有前面的设置和发布示例都发生了才会等待成功
+
+.. code:: c
+
+   void consumer_thread(void)
+   {
+       uint32_t  events;
+
+       events = k_event_wait_all(&my_event, 0x121, false, K_MSEC(50));
+       if (events == 0) {
+           printk("At least one input device is not available!");
+       } else {
+           /* 事件全部收齐，进行处理 */
+           ...
+       }
+       ...
+   }
+
+代码分析
+========
+
+.. raw:: html
+
+   <!--Zephyr version: 2.7.99 (/mnt/g/zpro/zephyr), build: e8df8a579033-->
+
+事件对象的代码实现在\ ``kernel\events.c``\ ，事件对象是由\ ``struct k_event``\ 进行管理
+
+.. code:: c
+
+   struct k_event {
+       _wait_q_t         wait_q;
+       uint32_t          events;
+       struct k_spinlock lock;
+   };
+
+-  ``wait_q`` 用于管理等待该事件对象的线程
+
+-  ``events`` 用于保存当前事件对象收到的事件
+
+-  ``lock`` 用于保护内核对事件对象的操作的原子性
+
+事件对象的所有操作都是围绕着\ ``struct k_event``\ 进行的。
+
+初始化
+------
+
+函数实现代码如下，就是对\ ``struct k_event``\ 定义事件的各个成员进行初始化
+
+.. code:: c
+
+   void z_impl_k_event_init(struct k_event *event)
+   {
+       event->events = 0;
+       event->lock = (struct k_spinlock) {};
+
+       z_waitq_init(&event->wait_q);
+
+       z_object_init(event);
+   }
+
+用宏可以达到同时定义和初始化的目的，实现如下
+
+.. code:: c
+
+   #define Z_EVENT_INITIALIZER(obj) \
+       { \
+       .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
+       .events = 0 \
+       }
+
+   #define K_EVENT_DEFINE(name)                               \
+       STRUCT_SECTION_ITERABLE(k_event, name) =               \
+           Z_EVENT_INITIALIZER(name);
+
+等待事件
+--------
+
+等待事件可以等待任意指定事件和全部事件，在\ ``events.c``\ 中都是由同一个内部函数\ ``k_event_wait_internal``\ 实现，只是指定的参数不一样
+
+.. code:: c
+
+   uint32_t z_impl_k_event_wait(struct k_event *event, uint32_t events,
+                    bool reset, k_timeout_t timeout)
+   {
+       uint32_t options = reset ? K_EVENT_WAIT_RESET : 0;
+
+       return k_event_wait_internal(event, events, options, timeout);
+   }
+
+   uint32_t z_impl_k_event_wait_all(struct k_event *event, uint32_t events,
+                    bool reset, k_timeout_t timeout)
+   {
+       /* 使用K_EVENT_WAIT_ALL选项，表示要等待所有的事件收齐 */
+       uint32_t options = reset ? (K_EVENT_WAIT_RESET | K_EVENT_WAIT_ALL)
+                    : K_EVENT_WAIT_ALL;
+
+       return k_event_wait_internal(event, events, options, timeout);
+   }
+
+内部函数\ ``k_event_wait_internal``\ 的第三个参数\ ``opetions``\ 用于指定等待的选项，选项定义在\ ``events.c``\ 中
+
+.. code:: c
+
+   #define K_EVENT_WAIT_ANY      0x00   /* 有1个或者以上事件满足就可退出等待 */
+   #define K_EVENT_WAIT_ALL      0x01   /* 所有事件满足才可退出等待 */
+   #define K_EVENT_WAIT_RESET    0x02   /* 等待事件前先清空已有事件 */
+
+   #define K_EVENT_WAIT_MASK     0x01    /* 用于获取等待类型 */
+
+.. code:: c
+
+   static uint32_t k_event_wait_internal(struct k_event *event, uint32_t events,
+                         unsigned int options, k_timeout_t timeout)
+   {
+       uint32_t  rv = 0;
+       unsigned int  wait_condition;
+       struct k_thread  *thread;
+
+       /* isr中只能不做任何等待的等待事件 */
+       __ASSERT(((arch_is_in_isr() == false) ||
+             K_TIMEOUT_EQ(timeout, K_NO_WAIT)), "");
+
+       /* 不允许等待的事件集为0，相当于未等待任何事件 */
+       if (events == 0) {
+           return 0;
+       }
+
+       wait_condition = options & K_EVENT_WAIT_MASK;
+       thread = z_current_get();
+
+       k_spinlock_key_t  key = k_spin_lock(&event->lock);
+
+       /* 检查是否需要清空已有事件 */
+       if (options & K_EVENT_WAIT_RESET) {
+           event->events = 0;
+       }
+
+       /* 检查事件对象已有的事件是否已经满足线程，如果满足则退出 */
+       if (are_wait_conditions_met(events, event->events, wait_condition)) {
+           rv = event->events;
+
+           k_spin_unlock(&event->lock, key);
+           goto out;
+       }
+
+       /* 如果等待的超时未立即退出，则不进行等待，此时rv=0 */
+       if (K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
+           k_spin_unlock(&event->lock, key);
+           goto out;
+       }
+
+       /* 将线程要等待的事件集和方式保存到线程中 */
+       thread->events = events;
+       thread->event_options = options;
+
+       /* 等待事件发生，如果等待超时rv仍然保持为0 */
+       if (z_pend_curr(&event->lock, key, &event->wait_q, timeout) == 0) {
+           /* 等待事件已发生，发送事件者将把满足的事件交换到线程内的events中，
+              rv中保存了等待到的事件
+            */
+           rv = thread->events;
+       }
+
+   out:
+       /* 由于发生的事件可能会超出等待的事件，因此需要做位与返回 */
+       return rv & events;
+   }
+
+发送事件
+--------
+
+发送事件分为设置和发布，在\ ``events.c``\ 中都是由同一个内部函数\ ``k_event_post_internal``\ 实现，只是指定的参数不一样
+
+.. code:: c
+
+   void z_impl_k_event_post(struct k_event *event, uint32_t events)
+   {
+       k_event_post_internal(event, events, true);
+   }
+
+   void z_impl_k_event_set(struct k_event *event, uint32_t events)
+   {
+       k_event_post_internal(event, events, false);
+   }
+
+内部函数\ ``k_event_post_internal``\ 的第三个参数\ ``accumulat``\ 为\ ``true``\ 时表示发送的\ ``events``\ 是添加到\ ``event``\ 内，为\ ``false``\ 时表示是覆盖\ ``event``\ 的已有事件
+
+.. code:: c
+
+   static void k_event_post_internal(struct k_event *event, uint32_t events,
+                     bool accumulate)
+   {
+       k_spinlock_key_t  key;
+       struct k_thread  *thread;
+       unsigned int      wait_condition;
+       struct k_thread  *head = NULL;
+
+       /* 上锁，保证内核对事件对象操作的原子性 */
+       key = k_spin_lock(&event->lock);
+
+       /* 检查是附加事件，还是要重置事件 */
+       if (accumulate) {
+           /* 附加事件 */
+           events |= event->events;
+       }
+       /* 对发生的事件进行更新 */
+       event->events = events;
+
+       /* 遍历事件对象中wait_q内存放等待的thread，并将事件能满足的线程加入到单链表中 */
+       _WAIT_Q_FOR_EACH(&event->wait_q, thread) {
+           /* 获取等待类型K_EVENT_WAIT_MASK为0x01，只取最低位，
+              这里wait_condition是K_EVENT_WAIT_ANY或K_EVENT_WAIT_ALL
+            */
+           wait_condition = thread->event_options & K_EVENT_WAIT_MASK;
+
+           /* 根据等待类型对线程进行事件匹配，匹配上的线程放入单链表head中 */
+           if (are_wait_conditions_met(thread->events, events,
+                           wait_condition)) {
+               thread->next_event_link = head;
+               head = thread;
+           }
+       }
+
+       /* 对事件匹配上的线程单链表进行遍历，通知线程就绪 */
+       if (head != NULL) {
+           thread = head;
+           do {
+               z_unpend_thread(thread);
+               arch_thread_return_value_set(thread, 0);
+               /* 更新线程收到的事件 */
+               thread->events = events;
+               /* 线程恢复就绪 */
+               z_ready_thread(thread);
+               thread = thread->next_event_link;
+           } while (thread != NULL);
+       }
+       /* 发送完事件后，引发调度，让刚变为就绪线程有机会执行 */
+       z_reschedule(&event->lock, key);
+   }
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/reference/kernel/synchronization/events.html
diff --git a/doc/source/develop/kernel/index.rst b/doc/source/develop/kernel/index.rst
index 0250389..6fcd7c3 100644
--- a/doc/source/develop/kernel/index.rst
+++ b/doc/source/develop/kernel/index.rst
@@ -10,3 +10,9 @@ Zephyr内核分析和使用方法。
 
    workq.rst
    system_thread.rst
+   synchronization.rst
+   sem.rst
+   mutex.rst
+   poll.rst
+   event.rst
+   condition_variables.rst
diff --git a/doc/source/develop/kernel/mutex.rst b/doc/source/develop/kernel/mutex.rst
new file mode 100644
index 0000000..e5528d6
--- /dev/null
+++ b/doc/source/develop/kernel/mutex.rst
@@ -0,0 +1,306 @@
+.. _kernel_mutex:
+
+
+同步-互斥量
+###########
+
+使用
+====
+
+API
+---
+
+**#define K_MUTEX_DEFINE(name)**
+
+* 作用:定义一个k_mutex，并初始化
+* name:k_mutex name
+
+**int k_mutex_init(struct k_mutex *mutex)**
+
+* 作用: 初始化mutex
+* mutex: 要初始化的mutex
+* 返回值: 0标示初始化成功
+
+**int k_mutex_lock(struct k_mutex *mutex, s32_t timeout)**
+
+* 作用：加锁
+* mutex: 加锁的互斥量
+* timeout: 等待时间，单位ms。K_NO_WAIT不等待,K_FOREVER一直等
+* 返回值: 0表示加锁成功
+
+**int k_mutex_unlock(struct k_mutex *mutex)**
+
+* 作用：解锁
+* mutex：解锁的互斥量
+* 返回值: 0表示解锁成功，-EPERM表示当前thread并不拥有这个互斥量，-EINVAL表示该互斥量没有被锁
+
+使用说明
+--------
+
+使用互斥量完成对资源的独占访问。 Mutex不能在ISR内使用。
+
+初始化
+~~~~~~
+
+先初始化一个互斥量，下面两种方式的效果是一样的
+
+方法1,使用宏
+
+::
+
+   K_MUTEX_DEFINE(my_mutex);
+
+方法2，使用函数
+
+::
+
+   struct k_mutex my_mutex;
+   k_mutex_init(&my_mutex);
+
+资源独占访问
+~~~~~~~~~~~~
+
+下列示例代码中Thread
+A和B都要去访问一个IO资源，但同一时间IO只能被独占访问，因此使用互斥量包含
+
+::
+
+   thread_A()
+   {
+       k_mutex_lock(&my_mutex, K_FOREVER);
+
+       //Read IO
+       ...
+
+       k_mutex_unlock(&my_mutex);
+   }
+
+   thread_b()
+   {
+       k_mutex_lock(&my_mutex, K_FOREVER);
+
+       //Write IO
+       ...
+
+       k_mutex_unlock(&my_mutex);
+   }
+
+实现
+====
+
+k_mutex结构体如下，可以看出其基本实现是用的wait_q
+
+::
+
+   struct k_mutex {
+       /** Mutex wait queue */
+       _wait_q_t wait_q;
+       /** Mutex owner */
+       struct k_thread *owner; //表示该mutex目前属于哪个线程
+
+       /** Current lock count */
+       u32_t lock_count;       //可重入锁用
+
+       /** Original thread priority */
+       int owner_orig_prio;    //优先级倒置用
+   };
+
+
+可重入锁是指如果一个线程已经拥有了互斥量，那么该线程可以继续多次对该互斥量加锁，同时也要做对应次数的解锁，才能完全释放该互斥量
+
+
+初始化
+------
+
+k_mutex_init->z_impl_k_mutex_init，详细分析见注释
+
+::
+
+   int z_impl_k_mutex_init(struct k_mutex *mutex)
+   {
+       mutex->owner = NULL;        //全新的mutex是无owner的
+       mutex->lock_count = 0U;     //次数也未加锁
+
+       z_waitq_init(&mutex->wait_q);
+
+       z_object_init(mutex);
+
+       return 0;
+   }
+
+用宏也可以进行初始化
+
+::
+
+   #define _K_MUTEX_INITIALIZER(obj) \
+       { \
+       .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \     //等同于z_waitq_init
+       .owner = NULL, \
+       .lock_count = 0, \
+       .owner_orig_prio = K_LOWEST_THREAD_PRIO, \
+       _OBJECT_TRACING_INIT \
+       }
+
+   #define K_MUTEX_DEFINE(name) \
+       Z_STRUCT_SECTION_ITERABLE(k_mutex, name) = \
+           _K_MUTEX_INITIALIZER(name)
+
+加锁
+----
+
+k_mutex_lock -> z_impl_k_mutex_unlock，会做下面几件事
+
+1. 如果互斥量没其它线程用，直接获得互斥量返回
+
+2. 如果互斥量是本线程在用，对可重入锁自加
+
+3. 如果互斥锁被其它线程用了，进行优先级倒置调整，等待其它线程解锁互斥量
+
+3. 如果超时内等到其它线程解锁互斥量，回去互斥量然后返回
+
+4. 如果等互斥量超时，则放弃等待，检查是否有其它线程还在等待，已等待线程的优先级重新计算要倒置的优先级，重设拥有互斥量线程的优先级
+
+::
+
+   int z_impl_k_mutex_lock(struct k_mutex *mutex, s32_t timeout)
+   {
+       int new_prio;
+       k_spinlock_key_t key;
+       bool resched = false;
+
+       key = k_spin_lock(&lock);
+
+
+       //当前互斥量没被锁(lock_count ==0) 或是 当前thread已经拥有该锁(mutex->owner == _current)
+       if (likely((mutex->lock_count == 0U) || (mutex->owner == _current))) {
+
+           //记录thread当前的优先级，用于之后优先级倒置用
+           mutex->owner_orig_prio = (mutex->lock_count == 0U) ?
+                       _current->base.prio :
+                       mutex->owner_orig_prio;
+
+           mutex->lock_count++;        //对于未使用的锁这里lock_count会变成1，对于重入锁，这里lock_count会在原来的基础上增加然后返回
+           mutex->owner = _current;    //更新owner
+
+           k_spin_unlock(&lock, key);
+
+           return 0;
+       }
+
+       //互斥量被其它thread占用，如果不等就立即返回
+       if (unlikely(timeout == (s32_t)K_NO_WAIT)) {
+           k_spin_unlock(&lock, key);
+           return -EBUSY;
+       }
+
+       //如果要等，就进行判断，看自己线程的优先级和拥有互斥量的线程优先级谁高，计算一个新的优先级
+       new_prio = new_prio_for_inheritance(_current->base.prio,
+                           mutex->owner->base.prio);
+
+       //如果互斥量拥有者线程的优先级比较低，则重设优先级，让优先级倒置
+       if (z_is_prio_higher(new_prio, mutex->owner->base.prio)) {
+           resched = adjust_owner_prio(mutex, new_prio);
+       }
+
+       //等待mutex释放，会引发调度
+       int got_mutex = z_pend_curr(&lock, key, &mutex->wait_q, timeout);
+
+       //等到mutex，返回
+       if (got_mutex == 0) {
+           return 0;
+       }
+
+       //等mutex超时
+       key = k_spin_lock(&lock);
+
+       //检查释放有其它线程在等待
+       struct k_thread *waiter = z_waitq_head(&mutex->wait_q);
+
+       //如果有其它线程在等待，比较Mutex拥有者线程和其它线程的优先级
+       new_prio = (waiter != NULL) ?
+           new_prio_for_inheritance(waiter->base.prio, mutex->owner_orig_prio) :
+           mutex->owner_orig_prio;
+
+       //重设拥有互斥量线程的优先级，并引发调度
+       resched = adjust_owner_prio(mutex, new_prio) || resched;
+
+       if (resched) {
+           z_reschedule(&lock, key);
+       } else {
+           k_spin_unlock(&lock, key);
+       }
+
+       return -EAGAIN;
+   }
+
+解锁
+----
+
+k_mutex_unlock->z_impl_k_mutex_unlock，做下面几件事
+
+1. 检查解锁者合法性
+2. 接触重入锁
+3. 恢复优先级倒置
+4. 等待锁的线程获取mutex
+
+::
+
+   int z_impl_k_mutex_unlock(struct k_mutex *mutex)
+   {
+       struct k_thread *new_owner;
+
+       //互斥量检查，不能解锁无owner的mutex
+       CHECKIF(mutex->owner == NULL) {
+           return -EINVAL;
+       }
+
+       //互斥量检查，不能解锁其它thread拥有的mutex
+       CHECKIF(mutex->owner != _current) {
+           return -EPERM;
+       }
+
+       //不允许解锁一个已经被完全
+       __ASSERT_NO_MSG(mutex->lock_count > 0U);
+
+       z_sched_lock();
+
+
+       //可重入锁检查，如果没有全部解锁，直接退出
+       if (mutex->lock_count - 1U != 0U) {
+           mutex->lock_count--;
+           goto k_mutex_unlock_return;
+       }
+
+
+       k_spinlock_key_t key = k_spin_lock(&lock);
+
+       //mutex可重入锁已全部解完，对优先级倒置进行恢复
+       adjust_owner_prio(mutex, mutex->owner_orig_prio);
+
+       //检查释放有线程在等mutex
+       new_owner = z_unpend_first_thread(&mutex->wait_q);
+
+       mutex->owner = new_owner;
+
+       if (new_owner != NULL) {
+           //如果有线程在等mutex，该线程获取mutex并开始调度
+           mutex->owner_orig_prio = new_owner->base.prio;
+           arch_thread_return_value_set(new_owner, 0);
+           z_ready_thread(new_owner);
+           z_reschedule(&lock, key);
+       } else {
+           //如果没有线程等mutex，mutex空闲
+           mutex->lock_count = 0U;
+           k_spin_unlock(&lock, key);
+       }
+
+
+   k_mutex_unlock_return:
+       k_sched_unlock();
+       return 0;
+   }
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/reference/kernel/synchronization/mutexes.html
diff --git a/doc/source/develop/kernel/poll.rst b/doc/source/develop/kernel/poll.rst
new file mode 100644
index 0000000..0178ebb
--- /dev/null
+++ b/doc/source/develop/kernel/poll.rst
@@ -0,0 +1,754 @@
+.. _kernel_poll:
+
+同步-轮询
+##########
+
+轮询API用于同时等待多个条件中的任意一个满足条件。
+
+使用
+=====
+
+API
+-----
+
+**void k_poll_event_init(struct k_poll_event event, u32_t type, int mode,void\ obj)**
+
+- 作用：初始化一个k_poll_event实例，这个实例将被k_poll轮询
+
+- event:要初始化的event
+
+- type：event轮询条件的类型，目前支援三种类型，当使用K_POLL_TYPE_IGNORE表示该event将被禁用
+
+    - K_POLL_TYPE_SIGNAL：poll event 信号
+    - K_POLL_TYPE_SEM_AVAILABLE: 信号量
+    - K_POLL_TYPE_FIFO_DATA_AVAILABLE：FIFO，实际上FIFO使用queue实现的，真正的等待条件是queue
+
+mode：触发模式，目前只支持K_POLL_MODE_NOTIFY_ONLY
+
+obj：轮询的条件，和type要对应，可以是内核对象或者event signal
+
+**int k_poll(struct k_poll_event *events, int num_events, s32_ttimeout)**
+
+- 作用：等待一个或者多个event条件有效。 events: 等待事件的数组
+
+- num_events: 等待事件的数量，也就是events的个数
+
+- timeout:等待超时，单位ms。K_NO_WAIT不等待, K_FOREVER一直等
+
+- 返回值：当返回0时表示一个或者多个条件有效
+
+注意事项：
+
+- k_poll收到条件有效时，仅仅是通知到线程该内核对象有效，还需要线程使用代码主动获取内核对象。
+
+- k_poll返回0时，有可能是多个条件有效，需要循环使用k_poll,每次循环后检查那个event有效，需要将其状态设置为K_POLL_STATE_NOT_READY。
+
+**void k_poll_signal_init(struct k_poll_signal *signal)**
+
+- 作用：初始化一个poll signal, 该信号可以作为poll event的条件
+
+- signal：要初始化的poll signal
+
+**int k_poll_signal_raise(struct k_poll_signal *signal, int result)**
+
+- 作用：发送poll signal
+
+- signal: 要发送的signal
+
+- result: 信号的一个标记值，poll收到信号后可以获得这个值
+
+**void k_poll_signal_reset(struct k_poll_signal *signal)**
+
+- 作用：reset signal，如果一个signal被发送，但未被poll前，可以使用该API reset掉
+
+- signal: 要reset的signal
+
+**void k_poll_signal_check(struct k_poll_signal *signal, unsigned int* signaled, int *result)**
+
+- 作用：获取被轮询信号的状态和值
+
+- signal: 要获取的signal
+
+- signaled: 是否已发送signal
+
+- result: 如果已发送，这里是发送的值
+
+使用说明
+--------
+
+poll由于可以等待多个条件，因此可以将每个条件一个线程等的形式转化为一个线程等多个条件，减少线程节约线程堆栈。
+由于poll被通知并未获取到内核对象，因此实际使用中应劲量避免有将有竞争的内核对象做为poll条件。
+
+内核对象作为poll条件
+~~~~~~~~~~~~~~~~~~~~
+
+初始化poll 条件
+
+::
+
+   struct k_poll_event events[2];
+
+   void poll_init(void)
+   {
+       //将my_sem做为poll条件，注意my_sem，需要单独初始化
+       k_poll_event_init(&events[0],
+                         K_POLL_TYPE_SEM_AVAILABLE,
+                         K_POLL_MODE_NOTIFY_ONLY,
+                         &my_sem);
+
+       //将my_fifo做为poll条件，注意my_fifo，需要单独初始化
+       k_poll_event_init(&events[1],
+                         K_POLL_TYPE_FIFO_DATA_AVAILABLE,
+                         K_POLL_MODE_NOTIFY_ONLY,
+                         &my_fifo);
+   }
+
+以上初始化也可以用下面方式代替, 同样注意my_sem和my_fifo需要单独初始化
+
+::
+
+   struct k_poll_event events[2] = {
+       K_POLL_EVENT_STATIC_INITIALIZER(K_POLL_TYPE_SEM_AVAILABLE,
+                                       K_POLL_MODE_NOTIFY_ONLY,
+                                       &my_sem, 0),
+       K_POLL_EVENT_STATIC_INITIALIZER(K_POLL_TYPE_FIFO_DATA_AVAILABLE,
+                                       K_POLL_MODE_NOTIFY_ONLY,
+                                       &my_fifo, 0),
+   };
+
+poll等待和处理
+
+::
+
+   void poll_thread(void)
+   {
+       for(;;) {
+           rc = k_poll(events, 2, K_FOREVER);
+           if (events[0].state == K_POLL_STATE_SEM_AVAILABLE) {
+               k_sem_take(events[0].sem, 0);
+               //handle sem
+           } else if (events[1].state == K_POLL_STATE_FIFO_DATA_AVAILABLE) {
+               data = k_fifo_get(events[1].fifo, 0);
+               // handle data
+           }
+           events[0].state = K_POLL_STATE_NOT_READY;
+           events[1].state = K_POLL_STATE_NOT_READY;
+       }
+   }
+
+poll 信号处理
+~~~~~~~~~~~~~
+
+初始化信号，并将其作为poll条件
+
+::
+
+   struct k_poll_signal signal;
+   void poll_init(void)
+   {
+       k_poll_signal_init(&signal);
+
+        struct k_poll_event events[1] = {
+           K_POLL_EVENT_INITIALIZER(K_POLL_TYPE_SIGNAL,
+                                    K_POLL_MODE_NOTIFY_ONLY,
+                                    &signal),
+       };
+   }
+
+线程A poll信号是否发生
+
+::
+
+   void thread_A(void){
+       while(1){
+               k_poll(events, 1, K_FOREVER);
+
+               if (events[0].signal->result == 0x1337) {
+                   // A-OK!
+               } else {
+                   // weird error
+               }
+
+               events[0].signal->signaled = 0;
+               events[0].state = K_POLL_STATE_NOT_READY;
+       }
+   }
+
+发送信号
+
+::
+
+   k_poll_signal_raise(&signal, 0x1337);
+
+实现
+====
+
+通知机制
+--------
+
+poll初始化时一个等待条件对应一个poll event poll将维护一个poll
+events链表，当一个thread进行k_poll等待某些条件时，这些条件对应的的poll
+event被加入到poll event链表中。同时会将等待的thread和一个poller
+存储在poll event中。然后thread进入超时等待，处于pending状态。
+当等待条件发生时，等待条件会主动呼叫对应自己poll
+event内poller中的callback，callback内会将poll
+event的thread从pending状态变为ready状态。
+之后thread继续运行，将已经就绪的poll event从链表中取出，完成k_poll轮询。
+
+数据结构及类型介绍
+------------------
+
+一个poll event的结构体如下
+
+::
+
+   struct k_poll_event {
+       sys_dnode_t _node;          // poll event链表用
+
+       struct _poller *poller;     //poller，存储回调和polling状态
+
+       u32_t tag:8;                        //zephyr内核没有使用，可以被用户设置
+
+       u32_t type:_POLL_NUM_TYPES;     //poll 条件类型
+
+       u32_t state:_POLL_NUM_STATES;   //poll event的状态
+
+       u32_t mode:1;       //poll 模式，目前只有一种
+
+       u32_t unused:_POLL_EVENT_NUM_UNUSED_BITS;
+
+       union {             //保存poll条件的句柄
+           void *obj;
+           struct k_poll_signal *signal;
+           struct k_sem *sem;
+           struct k_fifo *fifo;
+           struct k_queue *queue;
+       };
+   };
+
+poll条件类型定义如下：
+
+::
+
+   enum _poll_types_bits {
+       /* can be used to ignore an event */
+       _POLL_TYPE_IGNORE,
+
+       /* to be signaled by k_poll_signal_raise() */
+       _POLL_TYPE_SIGNAL,
+
+       /* semaphore availability */
+       _POLL_TYPE_SEM_AVAILABLE,
+
+       /* queue/fifo/lifo data availability */
+       _POLL_TYPE_DATA_AVAILABLE,
+
+       _POLL_NUM_TYPES
+   };
+
+可以看出等待条件有3种poll signal, sem, queue(fifo/lifo是由queue实现)
+
+poll状态类型定义如下
+
+::
+
+   enum _poll_states_bits {
+       /* default state when creating event */
+       _POLL_STATE_NOT_READY,
+
+       /* signaled by k_poll_signal_raise() */
+       _POLL_STATE_SIGNALED,
+
+       /* semaphore is available */
+       _POLL_STATE_SEM_AVAILABLE,
+
+       /* data is available to read on queue/fifo/lifo */
+       _POLL_STATE_DATA_AVAILABLE,
+
+       /* queue/fifo/lifo wait was cancelled */
+       _POLL_STATE_CANCELLED,
+
+       _POLL_NUM_STATES
+   };
+
+一个poller的结构体如下
+
+::
+
+   struct _poller {
+       volatile bool is_polling;       //是否需要polling
+       struct k_thread *thread;     //是那个thread在polling
+       _poller_cb_t cb;                    // 条件满足时使用这个cb通知条件已发生
+   };
+
+初始化
+------
+
+k_poll_event_init其实就是将k_poll_event和等待条件建立联系，然后初始化类型和状态
+
+::
+
+   void k_poll_event_init(struct k_poll_event *event, u32_t type,
+                  int mode, void *obj)
+   {
+       event->poller = NULL;
+       /* event->tag is left uninitialized: the user will set it if needed */
+       event->type = type;
+       event->state = K_POLL_STATE_NOT_READY;
+       event->mode = mode;
+       event->unused = 0U;
+       event->obj = obj;       //将等待条件和poll event建立联系
+   }
+
+等待及通知
+----------
+
+k_poll等待
+~~~~~~~~~~
+
+k_poll首先给要poll
+的event注册poller，然后等待条件发生，细节代码比较多，这里只列出主要的分析
+k_poll->z_impl_k_poll
+
+::
+
+   int z_impl_k_poll(struct k_poll_event *events, int num_events, s32_t timeout)
+   {
+       int events_registered;
+       k_spinlock_key_t key;
+       //为poll event准备poller
+       struct _poller poller = { .is_polling = true,
+                     .thread     = _current,                       //将当前thread提供给poller，将来callback时让该thread退出pending
+                     .cb         = k_poll_poller_cb };
+
+       __ASSERT(!arch_is_in_isr(), "");        // isr中不允许使用k_poll
+       __ASSERT(events != NULL, "NULL events\n");
+       __ASSERT(num_events >= 0, "<0 events\n");
+
+       //注册poller给poll event，并检查是否已经有就绪的条件
+       events_registered = register_events(events, num_events, &poller,
+                           (timeout == K_NO_WAIT));
+
+       key = k_spin_lock(&lock);
+
+       //如果已经有就绪的条件，清除注册的poll event，并返回表示已经有条件满足
+       if (!poller.is_polling) {
+           clear_event_registrations(events, events_registered, key);
+           k_spin_unlock(&lock, key);
+           return 0;
+       }
+
+       poller.is_polling = false;
+       //如果不等待条件满足，直接退出
+       if (timeout == K_NO_WAIT) {
+           k_spin_unlock(&lock, key);
+           return -EAGAIN;
+       }
+
+       //等待条件满足，条件满足时会通过poller的callback通知该thread退出等待状态
+       //等待超时会发生调度
+       _wait_q_t wait_q = Z_WAIT_Q_INIT(&wait_q);
+       int swap_rc = z_pend_curr(&lock, key, &wait_q, timeout);
+
+       //等待结束后将清楚掉已经注册的event
+       key = k_spin_lock(&lock);
+       clear_event_registrations(events, events_registered, key);
+       k_spin_unlock(&lock, key);
+
+       return swap_rc;
+   }
+
+这里也可以看到条件满足后只是k_poll不再阻塞直接退出，也就是前面提到的k_poll等到内核对象条件满足后并不会获取内核对象(sem/queue/poll signal)。
+
+条件满足通知
+~~~~~~~~~~~~
+
+前面说过3种内核对象条件都会通知，3个对内对象最后都是使用signal_poll_event进行通知，k_sem_give中会通知poll，流程是z_impl_k_sem_give->handle_poll_events其实现如下
+
+::
+
+   static inline void handle_poll_events(struct k_sem *sem)
+   {
+   #ifdef CONFIG_POLL
+       z_handle_obj_poll_events(&sem->poll_events, K_POLL_STATE_SEM_AVAILABLE);
+   #else
+       ARG_UNUSED(sem);
+   #endif
+   }
+
+k_queue在k_queue_insert/k_queue_append->queue_insert->handle_poll_events其实现如下
+
+::
+
+   static inline void handle_poll_events(struct k_queue *queue, u32_t state)
+   {
+       z_handle_obj_poll_events(&queue->poll_events, state);
+   }
+
+::
+
+   void z_handle_obj_poll_events(sys_dlist_t *events, u32_t state)
+   {
+       struct k_poll_event *poll_event;
+
+       poll_event = (struct k_poll_event *)sys_dlist_get(events);
+       if (poll_event != NULL) {
+           (void) signal_poll_event(poll_event, state);    //通知条件满足
+       }
+   }
+
+k_poll_signal在z_impl_k_poll_signal_raise->signal_poll_event因此无论那种条件最后都是通过signal_poll_event通知等待线程条件已经就绪，signal_poll_event中使用poller中callback对thread进行通知，前面分析可以看到callback是k_poll_poller_cb
+
+::
+
+   static int k_poll_poller_cb(struct k_poll_event *event, u32_t state)
+   {
+       struct k_thread *thread = event->poller->thread;
+
+       if (!z_is_thread_pending(thread)) {
+           return 0;
+       }
+
+       if (z_is_thread_timeout_expired(thread)) {
+           return -EAGAIN;
+       }
+
+       z_unpend_thread(thread);
+       arch_thread_return_value_set(thread,
+           state == K_POLL_STATE_CANCELLED ? -EINTR : 0);
+
+       if (!z_is_thread_ready(thread)) {
+           return 0;
+       }
+       //在这里让等待k_poll的线程就绪，上一节的等待thread就在这里被通知退出等待
+       z_ready_thread(thread);
+
+       return 0;
+   }
+
+整体流程
+~~~~~~~~
+
+再向下分析就是poll
+event的管理，这些API比较繁杂，如果分析代码那面陷入细节，下面通过两张附图说明poll的event管理过程。
+当创建一个条件对象时(sem/queue/poll signal), 会有一个对应的poll event
+list, 每有一个thread对该条件对象进行poll就会加入对应的Poll
+event到该链表，加入链表的顺序是按优先级由高到底排列。也就是说一旦条件对象就绪，高优先级thread会先被通知。如下图
+|poll_list|
+
+下图为k_poll的整体流程图，说明了操作和poll event管理的对应 |poll|
+说明以上流程：
+1. 初始化条件对象(sem/Queue/pollsignal)，初始化对象时，该对象的poll_events链表为空
+2. 初始化poll_event，将poll_event和条件对象关联(相互指向)，并初始化poll_event相关字段
+3. k_poll注册要等待的poll_event，也就是将poll_event加入到条件对象的poll_events链表中，一个条件对象一条链表，每当多一个thread等待这个条件对象时，就会插入一个节点，插入节点
+ 3.a 为poller指定callback  3.b 为poller指定callback会通知的thread  3.c
+将等待的poll_event按线程的优先级顺序插入到条件对象的poll_events链表中
+ 3.d 为poll_event指定poller
+4. k_poll的thread被z_pend_curr开始等待通知
+5. 当条件对象发生时(sem/queue/poll signal),会先从这些条件对象的结构体中找到poll_events链表，然后移除第一个节点得到poll_event再通过poller中的callback通知pending的thread就绪，到此时k_poll等待的thread等到条件恢复执行
+
+poll信号
+--------
+
+三个等待条件中sem和queue是对外的内核对象，会有其它文章进行分析，这里说一下专门给poll用的poll
+signal实现. 数据结构如下
+
+::
+
+   struct k_poll_signal {
+       /** PRIVATE - DO NOT TOUCH */
+       sys_dlist_t poll_events;    //前面介绍过用于串接等待该signal的poll_event为链表
+
+       unsigned int signaled;      //是否已经发送信号
+
+       int result;     //信号值，就是前面示例中的0x1337
+   };
+
+
+初始化
+~~~~~~
+
+k_poll_signal_init->z_impl_k_poll_signal_init
+
+::
+
+   void z_impl_k_poll_signal_init(struct k_poll_signal *signal)
+   {
+       sys_dlist_init(&signal->poll_events);   //初始化链表
+       signal->signaled = 0U;                                  //无信号发送
+       /* signal->result is left unitialized */
+       z_object_init(signal);
+   }
+
+发送信号
+~~~~~~~~
+
+k_poll_signal_raise->z_impl_k_poll_signal_raise
+
+::
+
+   int z_impl_k_poll_signal_raise(struct k_poll_signal *signal, int result)
+   {
+       k_spinlock_key_t key = k_spin_lock(&lock);
+       struct k_poll_event *poll_event;
+
+       signal->result = result;    //设置信号值
+       signal->signaled = 1U;    //有信号发送
+
+       //从等待的poll event list中取出第一个poll event
+       poll_event = (struct k_poll_event *)sys_dlist_get(&signal->poll_events);
+       if (poll_event == NULL) {
+           k_spin_unlock(&lock, key);
+           return 0;
+       }
+
+       //通知等待该poll event的信号条件已满足，这里也就会通过poll event中poller->cb 回调k_poll_poller_cb
+       int rc = signal_poll_event(poll_event, K_POLL_STATE_SIGNALED);
+
+       z_reschedule(&lock, key);
+       return rc;
+   }
+
+poll event
+----------
+
+register_events
+~~~~~~~~~~~~~~~
+
+将等待的poll event加入到条件对象的链表中
+
+::
+
+   static inline int register_events(struct k_poll_event *events,
+                     int num_events,
+                     struct _poller *poller,
+                     bool just_check)
+   {
+       int events_registered = 0;
+
+       for (int ii = 0; ii < num_events; ii++) {
+           k_spinlock_key_t key;
+           u32_t state;
+
+           key = k_spin_lock(&lock);
+           //使用is_condition_met查询是否条件对象已经满足
+           //一些情况下在k_poll前sem/queue/poll signal已经就绪
+           if (is_condition_met(&events[ii], &state)) {
+               //如果有条件对象就绪，就不再polling，将event状态设置为ready
+               set_event_ready(&events[ii], state);
+               //将is_polling设置为false，表示无需再polling
+               poller->is_polling = false;
+           } else if (!just_check && poller->is_polling) {     //对于K_NO_WAIT的k_poll，just_check会传false进来，也就是说只执行前面的检查，看是否有条件对象就绪，如果没有不会进行event注册
+               //注册poll event
+               int rc = register_event(&events[ii], poller);
+               if (rc == 0) {
+                   events_registered += 1;
+               } else {
+                   __ASSERT(false, "unexpected return code\n");
+               }
+           }
+           k_spin_unlock(&lock, key);
+       }
+
+条件就绪检查
+
+::
+
+   static inline bool is_condition_met(struct k_poll_event *event, u32_t *state)
+   {
+       switch (event->type) {
+       case K_POLL_TYPE_SEM_AVAILABLE:
+           //检查是否有信号
+           if (k_sem_count_get(event->sem) > 0) {
+               *state = K_POLL_STATE_SEM_AVAILABLE;
+               return true;
+           }
+           break;
+       case K_POLL_TYPE_DATA_AVAILABLE:
+           //检查queue中是否有数据
+           if (!k_queue_is_empty(event->queue)) {
+               *state = K_POLL_STATE_FIFO_DATA_AVAILABLE;
+               return true;
+           }
+           break;
+       case K_POLL_TYPE_SIGNAL:
+           //检查是否已发出poll signal
+           if (event->signal->signaled != 0U) {
+               *state = K_POLL_STATE_SIGNALED;
+               return true;
+           }
+           break;
+       case K_POLL_TYPE_IGNORE:
+           break;
+       default:
+           __ASSERT(false, "invalid event type (0x%x)\n", event->type);
+           break;
+       }
+
+       return false;
+   }
+
+注册event register_event->add_event
+
+::
+
+   static inline int register_event(struct k_poll_event *event,
+                    struct _poller *poller)
+   {
+       //根据不同的条件类型，使用add_event将event注册到条件对象的poll events链表中
+       switch (event->type) {
+       case K_POLL_TYPE_SEM_AVAILABLE:
+           __ASSERT(event->sem != NULL, "invalid semaphore\n");
+           add_event(&event->sem->poll_events, event, poller);
+           break;
+       case K_POLL_TYPE_DATA_AVAILABLE:
+           __ASSERT(event->queue != NULL, "invalid queue\n");
+           add_event(&event->queue->poll_events, event, poller);
+           break;
+       case K_POLL_TYPE_SIGNAL:
+           __ASSERT(event->signal != NULL, "invalid poll signal\n");
+           add_event(&event->signal->poll_events, event, poller);
+           break;
+       case K_POLL_TYPE_IGNORE:
+           /* nothing to do */
+           break;
+       default:
+           __ASSERT(false, "invalid event type\n");
+           break;
+       }
+
+       //根系poller，之后这个event就会使用这个poller内的callback通知等待thread就绪
+       event->poller = poller;
+
+       return 0;
+   }
+
+   static inline void add_event(sys_dlist_t *events, struct k_poll_event *event,
+                    struct _poller *poller)
+   {
+       struct k_poll_event *pending;
+       //events是一个双向循环链表，里面放的poll event是按等待它thread的优先级从高到底排序
+       //这里取最后一个节点，也就是优先级最低的节点
+       //如果链表中没有节点，或者是要注册的event所属thread优先级比最低的节点的线程优先级都低，就将注册的event插入到最后
+       pending = (struct k_poll_event *)sys_dlist_peek_tail(events);
+       if ((pending == NULL) ||
+           z_is_t1_higher_prio_than_t2(pending->poller->thread,
+                           poller->thread)) {
+           sys_dlist_append(events, &event->_node);
+           return;
+       }
+
+       //遍历整个链表，将Poll event按thread优先级进行插入
+       SYS_DLIST_FOR_EACH_CONTAINER(events, pending, _node) {
+           if (z_is_t1_higher_prio_than_t2(poller->thread,
+                           pending->poller->thread)) {
+               sys_dlist_insert(&pending->_node, &event->_node);
+               return;
+           }
+       }
+
+       sys_dlist_append(events, &event->_node);
+   }
+
+clear_event_registrations
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+清除event，当poll条件满足后,
+k_poll恢复执行，会使用clear_event_registrations将所有注册的event全部清除
+
+::
+
+   static inline void clear_event_registrations(struct k_poll_event *events,
+                             int num_events,
+                             k_spinlock_key_t key)
+   {
+       //使用clear_event_registration清除event
+       while (num_events--) {
+           clear_event_registration(&events[num_events]);
+           k_spin_unlock(&lock, key);
+           key = k_spin_lock(&lock);
+       }
+   }
+   static inline void clear_event_registration(struct k_poll_event *event)
+   {
+       bool remove = false;
+
+       //移除poller
+       event->poller = NULL;
+
+       //将poll event从链表中移除
+       if (remove && sys_dnode_is_linked(&event->_node)) {
+           sys_dlist_remove(&event->_node);
+       }
+   }
+
+再谈k_poll
+----------
+
+有了poll event的管理，我们再结合之前的原理来再来分析一次k_poll
+k_poll->z_impl_k_poll
+
+::
+
+   int z_impl_k_poll(struct k_poll_event *events, int num_events, s32_t timeout)
+   {
+       int events_registered;
+       k_spinlock_key_t key;
+
+       //为poll event初始化poller，里面包含通知的callback函数k_poll_poller_cb
+       struct _poller poller = { .is_polling = true,
+                     .thread     = _current,
+                     .cb         = k_poll_poller_cb };
+
+       //ISR中不允许k_poll
+       __ASSERT(!arch_is_in_isr(), "");
+
+       //检查要poll event的参数
+       __ASSERT(events != NULL, "NULL events\n");
+       __ASSERT(num_events >= 0, "<0 events\n");
+
+       //注册poll event
+       //这里会根据timeout，通知register_events是否只是检查条件就绪，而不真正的注册poll event
+       events_registered = register_events(events, num_events, &poller,
+                           (timeout == K_NO_WAIT));
+
+       key = k_spin_lock(&lock);
+
+       //前面分析过在register_events时会检查条件对象, 如果条件对象满足会将is_polling设置为false
+       //因此检查is_polling为false时，表面已经有条件对象满足，这里就清楚已注册的event，然后直接返回表示已经等到条件对象
+       if (!poller.is_polling) {
+           clear_event_registrations(events, events_registered, key);
+           k_spin_unlock(&lock, key);
+           return 0;
+       }
+
+       poller.is_polling = false;
+
+       //如果没有条件对象满足，而又不等待就直接退出
+       if (timeout == K_NO_WAIT) {
+           k_spin_unlock(&lock, key);
+           return -EAGAIN;
+       }
+
+       _wait_q_t wait_q = Z_WAIT_Q_INIT(&wait_q);
+       //将当前线程pending住等待条件满足
+       //条件对象满足后会通过poller中的callback让这个等待的thread ready继续执行
+       //在timeout 后都没有等待条件对象满足，thread也会继续执行
+       int swap_rc = z_pend_curr(&lock, key, &wait_q, timeout);
+
+       //等待到条件满足或者超时，线程退出pending继续执行
+       //清除本次注册的Poll event
+       key = k_spin_lock(&lock);
+       clear_event_registrations(events, events_registered, key);
+       k_spin_unlock(&lock, key);
+
+       return swap_rc;
+   }
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/reference/kernel/other/polling.html
+
+.. |poll_list| image:: ../../images/develop/kernel/poll_list.png
+.. |poll| image:: ../../images/develop/kernel/poll.png
diff --git a/doc/source/develop/kernel/sem.rst b/doc/source/develop/kernel/sem.rst
new file mode 100644
index 0000000..7611e04
--- /dev/null
+++ b/doc/source/develop/kernel/sem.rst
@@ -0,0 +1,277 @@
+.. _kernel_sem:
+
+同步-信号量
+############
+
+使用
+====
+
+API
+---
+
+**#define K_SEM_DEFINE(name, initial_count, count_limit)**
+
+* 作用:声明一个k_sem，并初始化
+* name: 声明一个name的k_sem
+* initial_count:初始化count
+* count_limit: 允许最大的count
+* 无返回值，如果初始化有问题，会在编译期间出错
+
+**int k_sem_init(struct k_sem *sem, unsigned int initial_count,unsigned int limit)**
+
+* 作用: 初始化sem sem, 要初始化的sem
+* initial_count:初始化
+* count count_limit: 允许最大的count 返回值: 0表示初始化成功
+
+**int k_sem_take(struct k_sem *sem, s32_t timeout)**
+
+* 作用：获取信号
+* sem: 要等待的信号量
+* timeout: 等待时间，单位ms。K_NO_WAIT不等待,K_FOREVER一直等
+* 返回值: 0表示拿到sem
+
+**void k_sem_give(struct k_sem *sem)**
+
+* 作用：发送信号
+
+**void k_sem_reset(struct k_sem *sem)**
+
+* 作用：将信号的量的count reset为0
+
+**unsigned int k_sem_count_get(struct k_sem *sem)**
+
+* 作用：获取指定信号量当前的count值
+
+使用说明
+--------
+
+使用信号量来控制多个线程对一组资源的访问。
+使用信号量在生产线程和消耗线程或ISR之间同步处理。
+
+初始化
+~~~~~~
+
+先初始化一个信号量，下面两种方式的效果是一样的
+
+方法1,使用宏
+
+::
+
+   K_SEM_DEFINE(my_sem, 0, 10);
+
+方法2，使用函数
+
+::
+
+   struct k_sem my_sem;
+   k_sem_init(&my_sem, 0, 10);
+
+发送信号量
+~~~~~~~~~~
+
+允许在thread或者ISR中发送信号量，一般情况下发送信号量的thread或者ISR都是资源的生产者。
+例如中断被触发时数据有效，在ISR中通过发信号量通知接收线程接收数据。
+
+::
+
+   void input_data_isr_handler(void *arg)
+   {
+       /* notify thread that data is available */
+       k_sem_give(&my_sem);
+
+       ...
+   }
+
+::
+
+   void productor_thread(void *arg)
+   {
+       while(1){
+           /* prepare data */
+           ...
+           /* notify thread that data is available */
+           k_sem_give(&my_sem);
+       }
+   }
+
+接收信号量
+~~~~~~~~~~
+
+允许在thread中接收信号量，但实际过程中ISR中接收信号量的情况几乎没有，如果一定要用，timeout只能用K_NO_WAIT。
+一般情况下接收信号量的thread是消费者。
+
+::
+
+   void consumer_thread(void)
+   {
+       ...
+       while(1){
+
+           if (k_sem_take(&my_sem, K_MSEC(50)) != 0) {
+               printk("Input data not available!");
+           } else {
+               /* fetch available data */
+               ...
+           }
+       }
+   }
+
+实现
+====
+
+sem结构体如下,可以看出其基本实现是用的wait_q
+
+::
+
+   struct k_sem {
+       _wait_q_t wait_q;
+       u32_t count;        //记录当前sem cnt
+       u32_t limit;        //最大cnt限制
+       _POLL_EVENT;        //提供给poll用
+   };
+
+.. _初始化-1:
+
+初始化
+------
+
+k_sem_init -> z_impl_k_sem_init ，流程分析见注释
+
+::
+
+   int z_impl_k_sem_init(struct k_sem *sem, unsigned int initial_count,
+                 unsigned int limit)
+   {
+       //参数检测
+       CHECKIF(limit == 0U || initial_count > limit) {
+           return -EINVAL;
+       }
+
+       sem->count = initial_count;     //设置初始化的sem cnt
+       sem->limit = limit;             //设置sem cnt最大限制
+       z_waitq_init(&sem->wait_q);     //初始化wait_q
+   #if defined(CONFIG_POLL)
+       sys_dlist_init(&sem->poll_events);  //如果配置了poll，由于sem可以作为poll的条件，因此这里要初始化sem的poll_event
+   #endif
+
+       z_object_init(sem);
+
+       return 0;
+   }
+
+再看一下使用宏初始化信号量的实现方法
+
+::
+
+   #define Z_SEM_INITIALIZER(obj, initial_count, count_limit) \
+       { \
+       .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
+       .count = initial_count, \
+       .limit = count_limit, \
+       _POLL_EVENT_OBJ_INIT(obj) \
+       _OBJECT_TRACING_INIT \
+       }
+
+   #define K_SEM_DEFINE(name, initial_count, count_limit) \
+       Z_STRUCT_SECTION_ITERABLE(k_sem, name) = \          定义一个k_sem变量
+           Z_SEM_INITIALIZER(name, initial_count, count_limit); \   初始化这个变量
+       BUILD_ASSERT(((count_limit) != 0) && \
+                ((initial_count) <= (count_limit)));
+
+发送
+----
+
+k_sem_give -> z_impl_k_sem_give，流程分析见注释
+
+::
+
+   void z_impl_k_sem_give(struct k_sem *sem)
+   {
+       k_spinlock_key_t key = k_spin_lock(&lock);
+
+       //获取正在等待该sem的thread
+       struct k_thread *thread = z_unpend_first_thread(&sem->wait_q);
+
+       if (thread != NULL) {
+           //如果存在等待sem的thread，将该thread转为就绪
+           arch_thread_return_value_set(thread, 0);
+           z_ready_thread(thread);
+       } else {
+           //如果不存在等待sem的thread, sem cnt +1, 将资源累计，但不能藏limit
+           sem->count += (sem->count != sem->limit) ? 1U : 0U;
+
+           //这里是通知poll该sem的对象条件已满足，这部分在poll分析
+           handle_poll_events(sem);
+       }
+
+       //重新调度，切换ready的thread上
+       z_reschedule(&lock, key);
+   }
+
+接收
+----
+
+k_sem_take->z_impl_k_sem_take，流程分析见注释
+
+::
+
+   int z_impl_k_sem_take(struct k_sem *sem, s32_t timeout)
+   {
+       int ret = 0;
+
+       //ISR中只能不等待的收取sem
+       __ASSERT(((arch_is_in_isr() == false) || (timeout == K_NO_WAIT)), "");
+
+       k_spinlock_key_t key = k_spin_lock(&lock);
+
+       //如果sem cnt不为0，可获取信号，直接返回
+       if (likely(sem->count > 0U)) {
+           sem->count--;
+           k_spin_unlock(&lock, key);
+           ret = 0;
+           goto out;
+       }
+
+       //如果没有信号，且不愿意等待，直接返回
+       if (timeout == K_NO_WAIT) {
+           k_spin_unlock(&lock, key);
+           ret = -EBUSY;
+           goto out;
+       }
+
+       //没有信号，有要等待，会将等待的线程加入了等待列表中，然后重新调度切换到其它thread运行
+       //等待超时或者等到sem后会从这里返回继续运行
+       ret = z_pend_curr(&lock, key, &sem->wait_q, timeout);
+
+   out:
+       return ret;
+   }
+
+Reset
+-----
+
+k_sem_reset->z_impl_k_sem_reset 非常简单，将计数请0
+
+::
+
+   static inline void z_impl_k_sem_reset(struct k_sem *sem)
+   {
+       sem->count = 0U;
+   }
+
+Get cnt
+-------
+
+k_sem_count_get->z_impl_k_sem_count_get 也非常简单直接返回count
+
+::
+
+   static inline unsigned int z_impl_k_sem_count_get(struct k_sem *sem)
+   {
+       return sem->count;
+   }
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/reference/kernel/synchronization/semaphores.html
diff --git a/doc/source/develop/kernel/synchronization.rst b/doc/source/develop/kernel/synchronization.rst
new file mode 100644
index 0000000..414e7a9
--- /dev/null
+++ b/doc/source/develop/kernel/synchronization.rst
@@ -0,0 +1,60 @@
+.. _kernel_synchronization:
+
+同步
+#########
+
+本文简要介绍Zephyr内核提供的同步手段，说明主要属性和特点。
+
+因为操作系统同步手段的共性，因此本文中有一大部分内容都是操作系统的基本概念。
+
+概述
+====
+
+在嵌入式操作系统中，多线程被调度器同时调度，从宏观上看是线程是并行执行的，对于并行的线程当有执行步骤有先后顺序要求，执行线程任务间有配合需求以及线程间有源共享的情况时，就需要各线程能够同步。
+所有的嵌入式操作系统都会提供线程同步手段，Zephyr也不例外，Zephyr提供了信号量,互斥锁，轮询, 事件，条件变量五种内核对象作为同步手段。
+
+信号量(k_sem)
+=============
+
+信号量是用于控制多个线程对一组资源的访问，使用信号量在生产者(ISR/Thread)和消费者(thread)之间同步。
+Zephyr的信号量没有比较特殊的地方，标准的信号量接口定义在include/kernel.h中，代码实现在kernel/sem.c中，可查看k_sem相关代码。有以下特性：
+* Zephyr的信号量在初始化时可以指定初始化计数值和最大计数值，生产者give时计数值+1，但不会超过最大值，消费者take时计数值-1，直到为0。一些其它的操作系统不会设置最大计数值。
+* 每次信号量give都会引发调度。
+* 如果多个线程都在等待信号量，新产生的信号量会被等待时间最长的最高优先级线程接收。
+
+互斥量(k_mutex)
+===============
+
+Mutex主要是用于解决多线程之间资源保护的问题，当线程打算访问一个共享资源时，需要先拿到该资源的互斥锁。
+当线程拥有锁后正在访问共享资源，其它线程尝试获取锁时会被阻塞，直到访问资源的线程释放锁。
+Zephyr的互斥量没有比较特殊的地方，标准的接口定义在include/kernel.h中，代码实现在kernel/mutex.c中，可查看k_mutex相关代码。有以下特性：
+* Mutex只能用于线程之间，不能用于ISR中。
+* Mutex unlock时会引发调度。
+* 低优先级线程获取锁后有高优先级线程等锁时会引起优先级倒置。
+
+轮询(k_poll)
+============
+
+poll算是一个比较特殊的内核对象，和一般操作系统中的事件对象相似，也有点类似于posix中的poll().
+polling API对内核对象进行轮询，允许单个线程等待一个或者多个条件满足。条件类型只能是内核对象，目前支持的是Semaphore,
+FIFO, poll signal三种。 例如一个线程使用polling API同时等待3个semaphore，只要有1个semaphore发生时polling API就会得到通知，之后可以由用户根据需求决定要做什么样的操作。
+接口定义在include/kernel.h中，代码实现在kernel/mutex.c中，可查看k_poll相关代码。有以下特性：
+* 等待多个条件时，有一个条件满足k_poll就会返回，因此如果要组合条件，还需要使用代码配合
+* Sem/FIFO满足条件后, k_poll只是接到通知返回，线程并未获取到Sem/FIFO,还需要使用代码主动获取
+
+事件(k_event)
+==============
+事件对象是一种线程同步对象，允许一个或者多个线程等待同一个事件对象，当事件被传递到事件对象时，满足条件的线程都变为就绪。通常使用事件来通知一系列条件已满足。
+接口定义在include/kernel.h中，代码实现在kernel/event.c中，可查看k_event相关代码。有以下特性：
+* 事件可以由线程或ISR发送
+* 事件对象由32bit来标识，一个bit对应一个特定的事件，线程可以等待一个或者多个事件
+
+条件变量(k_condvar)
+======================
+条件变量通常用于控制共享资源的访问，它允许一个线程等待其它线程创建共享资源需要的条件
+接口定义在include/kernel.h中，代码实现在kernel/condvar.c中，可查看k_condvar相关代码
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/reference/kernel/index.html
diff --git a/doc/source/images/develop/kernel/poll.png b/doc/source/images/develop/kernel/poll.png
new file mode 100644
index 0000000000000000000000000000000000000000..764e51aa880feca6400ddfbbc2a6aad54f9a7dd5
GIT binary patch
literal 76980
zcmdqIi91y98$aH@@Ge?tl~PLf*$g3>m0@O#*+<cgS<S{6vmx!aHWf*zNFpUgrIHp>
zmPAS^iONzUA=$r2@6Yo7{C?N<{R6(&b<CW3&N=tFpZmF&*L~lQSRVp*f!<2JY15`H
z@bp0WPMbE<YTC3JLG$JSBUT$))=iscC|9BxN~wk~lJKUPLy&);nS<?x@=&EY1Z55e
zqb0mRr9v(PPJwZ$oGapsc-+6Qf$hQeHug{(dl1Fm!5rcaf&KZgg*w4mf8Wm*@MQlY
zgqQ0?5((QJjDgwO1EehIA{ke%4h2pL6yO774-7*Pz!`AC0s8l;#sRt+7;z5{mhk92
zj+aO|^*jV_3vmF3ExbG^cyDts5;&KL#5~{&%L^3Cryk)d*lJsm9Jn0>wso?F07FQj
zLM{bv!Z-r2vV}M~!fin?N8rML=ZJB%1^?lW%;vKdqJO+>YW6%OTk!YHMQSdVjR5n>
zK`0F0o9gbPpb7t;v5Kb%6#?S<BfNjVdg@`NHkkMKD3_-a1p<74%^_$&=v)z7pkPaZ
zTSWhoE8SZx!BWsvFC;bq!odj`2=Kq;FJl7}_(R$p4L5g3P91>gfIoAzles&{90B{A
zE}RA;NE~oj3@`;K$XgkT!XU^{8BvDEc`9)_g_h;0WwRtCo`gp5^hC&z4l<fK7{Mor
zQ9_6q=Y?P@!gO9C5|SrH<|Cs6R6-!ZNDoDz%Eyr(#!(RzFmH^2DGlOjp%g~~3XNwl
z@Ke%;5eXhXp1!`?P%KE{p~Cp`xCl5L3IWMrIy%lC4hannp@Esc5-bULpF-sTMR|IW
z;4C~FObGKp^L?BGm2@f%P(2KY1%|VvK?1FlC&7^@;;VwWVIoDK8t&r*^>)<oIgY`6
zP?$K>2TlNKp<&(xdofrc40NJFIi5nb1Qz54=p4mK$<V-9VowYM8jJ&|!ofZ$FqeqZ
zkTrM~2d)MKnuHO0KppwOw-$v6b_kRKLc~n{<gg%9Ul1oK-ZKnX0t}Cd1-J$dFM`N{
zOF(I<XkZkNfq<#NjR-0jN(x0H*c#v*1|})tDmqc4q6Y?xctp4k7!0JqVNftXROATf
z!em@1OQI8cIw|d?5cePmU<C*<unL$k;DoQnc!b~uA~~R-7+;vs8v~<g1GRv;V30^f
zkQbPblZb&|2w8})#tBafVQJVz7ER9f0TCUMP$e*LFHf-yj+6xx>Arjo0;(ng&j$Ml
zklt)xnmvK8mHFtP00FYb5kl66foUWRM?*((#8{{kPey0KWNH+Y##9KAz6y!N(^m{U
zu4Ax#ozV7zkRTOXsDXQN*gOacrbE($@h~h+f@NZY2&5?~>zF9M2BdX&L@LE{jH5)P
zM0ukfeULDB5ri3p0)bUXD4DJSj53g?<-yP%>?wsrg1s34M?PMd5Sb?f#$&LRYy^`_
z)ezx;j$<$y1kx8o6cK{mMO0p(P^o6v<0WjIPbgHa=3^mHu{T_R_jPv+;e_$9D2gXc
zNfp6@fhXx;Hs4;2penIq5SgH%;yI2y54Z!G$keC;xe_Ne6G{aZ9f2S@@#$2@Kp2_G
zhQipMu&^K}VHiiQhCqX)bRscKAq&AmctkM|q>`Wza77TA$WsIo#DRnmts{g4Q3i?O
zBm@+V=W3i-IIvK~1A954$le|#9xM<8R_Qz`B)BkC03}R0A`gm68^TwC*`5@Y)EmYO
z1jbapBu@{uBN0aR@bmzFJE$DQ9w4@pY)YvZDvv26!!uM&C*UU)5$Np*LZVR`5}FSK
z$vw1AtT4dUAvj?wEStgdlyO-0YKeGCV_~!)yn7HIq;jJ2X<7;uDg@q!@YPM}x|rkR
z<Ick)L%el5kX8$f)2Q||0V32F#Z`L(KSd-MDolv=g*tE<s!$?WiUFPi#;F`Oo5Em&
zSzh*lPe+8=hr$@XL1G125$ZuiQSopH2@@L1QwLMgBCQ4$2Ezq{Ar8Sx2QV7&<OpA1
zg-;;NhhR?+3MNjG45A0>G!)E~k!ga^bRotQq{Bg+m{=G?ho>TR-V8jP$^mW!QH4;k
z7Dv}Abu6|H1;T_1DGo47phlvi&_ZDx4<ACPlo%?6%e?tSAx#pB4s{S>JUrb!cwTaf
zmye3)8%RVjCHN_=<}%<4#FWu_qd_X3BOJ>^^JP#cba0Som`?~p?FeO&Fj|tmFH@rQ
zP<bOYQjr|5@BlHX5Kpx`CqxF3pq1{vV4OGvAOi9X^p#;9L|m4ygFBP23&FcfRCtig
z0Vk(92FW-uwp8fgC7LolI3)y+@$d->l`$Mt>@YmdH-sg^D4ggN9fgUM2E%y}EQ^KV
z!rakd8J9n0SR@3G1yiDNDlr#AP!NSA2X9XyPwwNvV>>F43@;oF2@}B-NC%-~uw-gZ
zT4b<~L?$P4$RxZypCNE?vR5gltO@M{Ty@9Uv$^hgxLoNW;@DHb@E}4cO+zD~xDqi3
z;)Efw)JUC!!U2Lt5>ez}4uM8OhiQdO9?O9SLgCb6M>0bcs+6b!f}RQ|-w-?#qmwE;
z$xdh)B{&pM524$G<WiPbh&@)MQuC=ywNB#>qmbcvK7bJr?kIZ^LZtI?Lg)}^oLZvO
zDD7ckYK|8Kt_>CWaMdg|h(r@2ypT{H*wcqdrxU3xfjb?hWN_S>o^X+vB|>NrbO!+#
zL8Jzg)l`KRi56jaU<8&V3PDR4II@)MspPXgrCJ;#NaU`D%jv#Y6*`Q><s!rc6hT47
zg|NLze2D_ZXG7^^o=l@r%6$Rm!r%@Bp3qSQk%Tb_p%f}fsuUn7K|GBY8sgv(gmelO
zVS|03A`J%44OAf{&=3X=8cGR;a^MJ00w58E2h9;f=7oYlbO^;u$l;0wDkX}{#(`)Q
z4oSh{2L`(nxKIa}JJ$(8meJ?}kgq}x3-hI5cp|{5f;2oBm4)yQ7DK(Efk;rOki?@S
z0W^UL=Gsdr_z*sdN?~wdq7d*@+<@VNY2FloafFw|$5$9imk~rdA(ur9Bnibhsv2-7
z2oMD+3+3~qO0h&D6@YkNT<;()I8aDds4zG-9YqCeWi+gZmhTf5ilfL`ATk<8Vz8#%
zGH`e}DR`c0gcsA19}1VC04WL~6elSg#-!K>0ZYVZf`uU-aspnXz%kW4xe!hv$yEZ7
z0|H0FU;-Twd?k*?bi^@vOoTVU2G$+{QURC{5vFj!vOy9&lf`ie;Yt9P;zXo)5lF}&
zPZo%c7h<7OqAz&rTPJqV64^|hmlVtA`UYW~pad^~039UIID`d3s7$dE>rUY)6utx)
zT8tFal-_&}QmK$Aro0LqjwASZ2Knkl?iiBPUP?wHr7*dINzoCdln`bR93-JSP;j9j
zCk|Qc&SK#ms4z7a8$=eeq&_~LN+*IZI8+|OXOI;RM243m#7o9xdP1ZUxjn%P#pgo2
z2w;z3cbZq2md{mj`5=swiY*GI(Lxwf5DUZ-d($uyM|TttB9MiO$<#m(xjRgVW*~!P
z61psiMw8hykPMs}A{B&sDrKQ$k^%#g6X6h^7>mVWgS_lL>0FQlT>-*}gsB)JE|f0Q
z2<(I9G6kRkh(NHD1i_*LXE1c21_CBgrNK%s44BLggu~rcG=(A*NeIISp|P?sC{d>X
zlf86&lEMk*>j|bHI5>qp1{p{IRvJSlc@Whk%@pzr#mS()FeZeE^d+D)2)S<vSExpN
zh*UHLP3evb4uNv{2;>y}#^^k_d^Uhs5K}A!sT?^ZAxf#%N#$rP6Ur7Mm_UG_+T-b5
z53Dak?4$$K3gZseYFTV05$nLgas~JhoVU9tf{7r@k#x9&5{Owrz)dU?OePGL5t$q=
zMve!F%PCxK7|A`*3B>Xh=_vS62SN~>#1i<Z&~%-Srt^YJWKymKxYGk85z&}(i31(V
z=gJ{cEQ3v#@dCZTfdC@I{E1sSddL*u3}W-)KC&<fE0`2Ubf-f^3VS@n3kib@pllvk
zf@F%tp-gXr7sK1fLkp-poE}UN+CvHIAa$@e+T9*66+-Pp5poA_2-Xp=!I9))0;Rwk
zfeQ`NqA@;!cw!I(E|5s=!4wq(=cADd1LaVDh(a!udO(p_B{W#fmI{KUAt<PtP7(ML
zgPn*F5}NIe43&#XL0)V=6Ab`XjEuxlL)cJ|0E`s}Ghm@mv;*A%@8~3w@u(PICJg03
z3lw{}3vfCuZpvBkC`5`9>x&c;9WY7?8p`rvDk%sDbQm+(iR&aGsNi&(ueValKuB;5
zxEzX}LW&HI0?pC7Qy6e3UkFIWVF%)+K`b(wsUZWIls5vb;v(F^Y$pKL;gx7zFf{}x
zm!fFi7#|8+=B>tY$=>d)FcsX#GmM8);YA{qLLJBlvNc2?%S)n^`M@PaU0^7Z2_#O4
z&?%h(4ks?t7cSt7MLs+@z=Hr2roh0VQ_hE|#!6X0c*Q75aHIoMMplEdNDZ(K47iv`
z7U=>VJg6KU!H3AvLPB^F42LF@1~Ys#1V<;ngU-<_lq@9C6<!Dc<4Sx&#bHu+4nRzy
zB7nWcU<LuqP=rv`e2fE#HwCIiG`g6<cM1{(Qm{A)hVH|p3XlXS0O<og=?n}e7$wzW
z6aWFW3ZdXa8GxG%!BJUC2~GrLZ6pUTd#;oif)n`KW0VXzo<Q&o1e2JK3Ir4m<_qaz
zK?(r=VC*?kp~itCCx?aMgHgfgARjQ7&qvUG+<}Y1S_y<Dpu!zs_+WSt!V$(1aG(GJ
zm=crJn<EM$0UlCnk8yHzg2^E)7MB1#HFc3G1MCAMmxmBUAu1u1!PTg#f-ne!jdUO@
zK^$KX9-k(lgkq@nD2j&<l|x`7gXLHO@FX5hbkI790qx;<xnnR`ELjnZL4yP^yo?+o
z0=rAtB(Tg=zzeYtLDAI&7#^*21Qrf}wQ2@BNXCaFh(0Q{H;~f;ga1xz|Kzy9?|;=6
zAm|5Xy5-ZRt)1qHa;IqgyVK@tsIOiP(H|X4*uSBAkKvs8`@pkioh-H#7R8n0tm@tU
z>JZxa_4#^cm&y}%-CN6fb>C*^<@_7IDADN|Gr(0#pBT<VV&)y&WBAim+>%;VvhG>h
z^TMIwvmLE<-FIt0h{s=V9qOKJCNrp1s!{8V>4ww(=Qy)y-abYF6SZ^Uyxr6OaqM0@
ztzhrLX*1UT^VsP%!_eyHU;2msKV)_@+*kcCS;K4Q(_@VM4$j8x`6tzB^S0%kTkt<G
znl|sv@!dQQuPkO!VbCi}Kg1r=|GabB4BHuxqYbhXt>~=1kHH0tjg2vmZRN+4GkyPO
zDnHKbP8?Uo7?nQWf9QV*d~^Yreje}SGUtCLz8PS}W6{Rt^Z#dx&(}{YXuFsEIPiaH
zAKN>vEN&@#Z^Hk(glDa|820UTT?RT{_&n8VsgaQpcXL?FP42VBth=f!>@VMB_Ik7a
zA;4oP5Av8dE(KN`fy&<B-ZE}sW0SR+eDTHazE3&K8+>TslfP2n@-^n><}2Eq%W%gS
z>u7stMZeoNZPtGdiRS~;f;N$c&)--Uw<w_jd0xaZx3xXuA2~=}2@6`<C!BW~hYzvc
ze%mMcY(j$jzBvmPPu31CSmW~MJ573a@awC1%#qce<>lqenV^j6=e+;9W_B~)A1#@j
z7)3X=mB*KN#tBvq5#4@&oQd=FeE2l3PKvcFc$BfP9HZ0Sna5Hn!1yx`hZ%`K%O`8w
zxNT*zX162o=`N?+pQm|=M52u8LUPIV8#hGVZwjDM6A@}{YRe@N9|OS*|5GCri+-$T
zwr;hayfVH#e^723H5L+Ml=(RK6r=C2wR3;|Xni~|+A`^HK{B><NojM+C$8F2H`bqu
zyBYS4mJhSn5g@BToLN^`MU}!l3)BA!YTJXI|2Bb@zFv_p9~9oVEsI;%S)%{SD^Fv4
zEq^mD$u6LWn&XiA<nYdsfv%p~jo!&?F~qIIpO@s%9@NDdxsJisSzns*PnvV5uOAId
z=VY~CpW`5IuRcAifP+}_YW-7K`TlIiX{hKpLsCXAami14EaD%|>uk-R&vrNZ=X4zw
zS;5p7%b&)@;>ky!hwlJLr5JrMclV2bWE(`T$jHnrk8r!M;bvX9Q05xx?Kd+s()jD^
zr@G%_j>gC6AHHUr$*e=&joKr5nmD5?XDhu{+F$1&UN)?MIvAUn@|fSW)V@~vfz&$O
zaW*?@qW^49Nsg;p?^9aY!Zj`yKey#2zp(I`{a<n(+qNCuCD|bhx*HYJGWgn0Zsc~M
zzkbe#!Cwj3HRpL%Np)U!B`BiXIP^Iabp6Wm72NgT7v7X)53jP`^nUJty@6`e$HHA{
zi4z9_$4O<@t<6)eoM5?63)}l2hqim=tQSXNc1H}YHWsK@nGW-<a;N{-L|)E!yb>VD
zDg~~><W~D6$Kx-}`LFy}yFU<(Z?PIbzyNh6Tn9hhSR51dAIsSGV9~79*ZDW<17eI$
ztl9j3f4FU}fX6Eqi(BrOc)~JQ{?iCt=QG}F8($hkRb9Vss$bA1KZ&SrEEJJ*^YWHv
zoji5w<=)x)oe$@l{#8JEzwo~^U%S&`dUmXl)o200dy!1m&}6h|k-Ju_ZMfjM<U|k_
z_D?O)EecLy6ikuNpkE#&9Wnl#oV;Au7Q3mlxFa2s!>7#r2jO#@rf0_)S&aaMbvNJZ
zD(lN|T<(T1?d=>&`G%f<%4cBXM@j()?PknD_rCVSYTsYF;*+_tIQpML0?kUbpyhq7
zK;$J4FhVkKA`Yi~Uh~f-s4xu9U=-v6ym9IS%Ma_G99qG+%vmh|Cr_9~|G9@^b(Pd}
z&V66!xBSv4ETa>ee@fFnZuiTwxWsYB2jZ>DOWQKGhZ|nXJ?>VP?$`cypJm>QGrRS^
zQ{)>h4F0U~xm`0lO)s?|_A}f!xi@dSoH0i2LpCQFrwC%?!m(iZl)5@5PWxaQgiZeh
zh)#9LGclTB<hE2UbH5w?d(Pp7@F_jpT|euHad-AF&mCU}7WEorJ+_+?T~GyMWr3pS
zeX*{w|6`TM_k(f2b4>y?e{}bup(FV?QJ?0DeTH{_@uKjoPmpgDwfy7wqQ98ho;{3&
zO*D5u%g4xwflgA}0l(7G=HAXatmzeM;nR=U7w(S^*T)3y*ZVVv2QD)NI6Yx&N=H{)
zmLg8L+|#D5ss5U++xdkxckUeCHu>P5hCy0V7H8Ceze+wBom`F^>S;zt57uXS4YW*-
zx6osaSB%*^72>GTzb%ajj(;@aj-jI;Yn%LvD%R*br>_2<=c;wAEe`5IlWV_N%iiC#
zp2aCoV%IfVtXRV_wrcbbw@Gu0@^`G=bb&^r)i>mjn={aJ+y)M(-oPOv(v0MHb$;b%
z0^@3yluwd0jNA4_KNVTdhjVi;vG-xjN-}<CSe1;VKUuIItz)8d!ZY!<n{!ErJnV{}
zwuD^0K727b#xY^n{qDRZ%L&=yx0JD4w+pZ7?h@!G_{<Y19mzBOcRo$d@z(ECKO82n
zc^6J2-FWlb%ynq{5&h!e{5aN=BBQAEE#cj9t`zi@Pw(OfmI$ur-ngsTut{kcWootM
zbNMFof*T$ku-RAJb~qD*$YDo5_lAvDcD*n7{LQDQ=j*+z&R0btX&x<6y6k0V3uz_j
zk^AI#E?Y9G4OhYf67G+dwOgfL&h2daJYhB-oqAXnFx;Ciof|h`Qt>*xuloep<AS`#
z->;^EM{N0pEN?k;gQgu0i~KsTZ|LIs$>PQNxt1$m^zjq!xBj>#b1uHH%K7l(u5Sx>
zMP{V}S0ZYTmbZuvtOwg5g;geIk%JR<m#cCzeq5XL`Lw@w`1tQU(!MADU00t+7@?tu
ze&XydTP)%!Rt;EZUl>ch<m_Pf+-iLL+Z73Jw%~_W;}X$%VK6@Pj5cf8j;Bkkk8@bM
ztd6s8=G~$-@19t>-b#LFcI%<azbpGWUq8I5?A8#j<7U{s&SO6s!-^dWz6g#p3-O((
z(lrCK%5X3fqsf^C861lEcbR)TGNL;o%{4p;h{sm5;yPYkBCYS6t*kInzYv^_JZQJx
zc`gX`u17nD9e6SGXbgLoKdxigw<Mz2_g>k`gYW^II&5j|N_fl<oZT`LbjDLmoqt!>
zvf6kBXC=H3=N8~^?f>Y#`#>JB`X2X|e#$(4uU@+lcIw3P=J!@5AIC%_`HeR;|1NC@
zA!fiBf4rogxXg5!^iEhr9DO7ff<>2bj@-m{e9_dg6F%6Uzd_fj9!{@geq5L#n8+K8
zeDwTC%^hu4C^jMgxy{u<oLjIi`{~)&*H6*6sFx1!lU;dPQa_aX#;m)mu3eWuu*2!h
zeplBMb9Gt0j=$2Lw%l!An?E3ZyW&y$z{z#~U4GYT`r%iJCOwH0C7l+F7jy=n_?ynE
zEr$ni0a3xl*95^G@9xz%uK9iHnxGS=zWuVXdou3z>fbnJ%)#ybfqhjr0jcRB!KXVn
zHoqCB<qz~Oj9foLoay|bE%AQe)6(*iap$q8R^y|2)Qr^oIgjtv-{R&kl9m!Hcjga#
zuXsH_Tvv4Wp;cr@--5Pfyq<I6O~s>SLm3}>q$Ap_Ue{vko3}+&)BJ(zm(KfLcLbG<
z`}Ek7@&(T9h0*;(F#{>z<D3&EZg%^BNun$C4CXt(Ggs!;J!cvoASqrptW0|yxYQWa
zVEKHs_|iA0+;7E!?iIf_G-wFSX^N6QQtXG8nLI(Pm2B~%-o)oKPE^IpR)1?8^4`(n
z^}e88@#yiYdi$Z!aU;?z9?9<Ag{&Jfbz9oUVmHd5b(zvvmt)t-_FaWGBDi=L>0;?I
z^6fbL`m!WL_N(}$;ZS^PfiN_2ZO>YKwbbqAheXSs`JwS{>-3t7j{8|(kIB1ArL>f=
zw)Z#}UujxRw@F#v9HpyB^nLW`ecRwpV2&-%+A<q9Zhe(l!HcPSZlB?mxU4HB$+gaH
zUZ07i<J~%1_iB?g$qDzoYnR{MlxA*?9NGRQ%-??vO#J##denqAVntWO#%@M6GXL;J
z)eb-3cl(bt*cL#V-%AhKL-skJTx0jjJxy-Z_07Ph^r!Cv{mfNcKA6?R*Z7mh+tejX
zM%A}HFGQU!s{fRTYp@Hu?a`t*=^S(QlzqT^w()mRcv{kiuU)TtFbU61P>q-C!)n8x
z%`9tq@7}n@a7=X6VH`E`;l%s%rS;5@N6Z3FXWzVAnbWgVDSAsDi(ESt{q^ULp<qCT
zA8X&cD_>RLQVL(=#}cW>x)KB4fi~U!agHw7;~W=J@UgC&TiOKuvT$16vm4gO3T3$E
zMRD>?^-Ld8+Kh=avzG-7cM$yxqGOJ8{9;S>?LPY#Y&wL(CfKE`{hMzEtCu?M7&W@p
z1c^I*XxXscwcP_T&VZFzUb+48)#*6NQuF#MyTsz}-0-3RwjGs5Y5dmqcJ00Mzk9#r
zR{2L<Rldk=eiQ`&sSE3NCul_oqm$<it=!oszHOwg;ZVnpT^>vp*i@Xtf`2#mEr_PS
zcyI(BACOzrW#7)+oANjQ>PGBt%tJZEEz0Z(+tF#deI41yXWOSIhciVlFUB5@r`%pk
zqr_wwm{PPc)V{~l@wOJrTt8Kn-b5D8I<N>nmG18Lo%NyS_X&m{6@4m)v~S)zmSzWm
z@=2(tufOc&?%q}QD<F2cnF|XtDE;}(E2#VO9@(xiwE8-!@V$|SD0KYjwaj)Z_-}Ka
zrP1rHj655glb*gT{^XAzb50)DEEvBxi83$4@%a}SfvZhTiTcZIm-g_v+}l`>*H`?o
z`{o)LcP-iIea<Pg-G@S1nwXSSe{wUq%r!MVG4ab9W-GYjh>4f8s{0%%6H|BG+{<F~
zvm#Qo^)d`C2&Km<zmH$WDc5q){mV1T@7J1J&zwTE>*xPCI6L2VGV{%Nyc+Y#WJIIh
z@&UCQKC{&;abnL#>vT=qd{CnJbsqENi4*Hlo+{N%LzDiF+U$V=<vPOg6DJN>^i|&i
z(wucd#%JaCrdMKIvS6#R)AjARSR;%2rZZ`l1_hS8&ZW(1A*^F@wM7pIQ#kfT^tSdK
zlYzmjQ7;a}ca%M`h$J8M^_6(#Kcap$^-gzTb{|PeO2W7tzb>pZTSsH;7f#k9_PGW2
z_4VBCjhj4T>gIpwfiTm03?49c+94%l(5=1Z%%)eJaSF}>>ZYYRL(BI6dGE(lCq9<z
zVORs&;moB|FTMtu{=qioR(E^Uy(Meq>gSVR?@+#){(#!!y)|)(Kwh=~_0=8U(nqr9
zA3Y5b)SFKHm^)OMpTa?(akyCU?bYRFkv|^JMf~+lv3V2ioJYP)m+MlN`}<*ly)b*E
zkbJ1{>CfCfX;Ucr<CzBqkM@-b?p*Vzn}xfJYP|VvaEIlf!PmuB4}pB>$dlh~!p7Rf
zC00HcMwBzYzuB4ggZFtLfUviD-i(a$BSdS-pHj@^ycp8S?l6jP$R6FTyQFzW-zDZz
zxM0NOx%)6Hmm05CVL9>|y^g>>vv+3U6){HHR`olb_e?~1CMQ<R55NesBW$%lmZ7|U
zbO&#mf~Luy=RS^Y2JOB6{f!Ri*@-G4&mo=qI=g>QQ|tbTJvRyEXPY0iwY7C#z1y=`
z%y3c9JQ1R|{MPJ0lzn3ox0Q|@stO3*bEYGeQuy*kS)4H}#`sf{9qvyFCTf0g%f4D{
z>!iaxxrOXqWLtQXHe%+NR3}8^%`ReN_7Ow<_V}te)cxGtsxq}X3chT(|9P77)Wfqy
zal}Pk74Zx2_Agwu_0W-Sm)3md(@iU;|LeU*qb{chV~q;Qk!5<Q_{b(_>*>==<_BYw
zT158_*aR3Qeo-=&iXA4OE@41s;}OHmJJlvFUl#_y?BttGh53Zquv%WwibmRnvyLae
zR0izWh2sbkc5R5tw?K||rx-WJ4n$_(j2$gfT*dd;)vH(g_2Mq~To{tNQ7*{0{FKw3
zGRCTuf!QRp$eKM_R|)DOBJ%G0b@lY#N#9hPM`sI&>0RYn=ts{ll05ypG6Dm>pGb<T
znaJ;C)U6|J&7WNU`pc%Px}hla+<sN;0Du+3vO`P436e#>ZY2N6Q~Rk7K0W(kR}9^$
z#bkok5RS}F@bB6_R}IykVW+<?U%&a3rB%$b7jVf7k9kJK@ZX_ZI|~Hw_V{;&6J<tU
zE);$Jp18{~%HROWar{&B(avvbcxQ8i(yq4O<z&i%sx4p7J6~YwQE++5)4iW;p{!U#
zEjL*4?$`>4&<J&h<RXCieJO!-0Wx2Iy^StGiE%n*OV^A)s><f|hn*iwy*sngr1AG9
zRD!=|U1Kw;{mAzIjZ)Oevm4mURUu*9-)+2YtS2zy`fo1HjoVVxxvm~Ul;-zX+}(1u
z`Q5;ht}&~^Ut&o1kY|XAUPbg5?Zjf&YoBb)Tt7W1eQzSW`t}AyQ*eFz$yc}87wB8u
z)=L6UJe`$4FxLNm_(}#J&kE1#&u>e8-mycI6y+#C+IdJF^kF>r`NmT%SHfB@Z^^Dc
z9{JN+@F~G4<FVVdPc`&<1M93;rvvm%qgBPgeF_a@`Cu=Aq()wM7a<x3g4CJxk)9=I
z&>gq@E^mcee<zSO#veo$-?cdOsBGw%V2j;Yy8=M4>g;^iYbO=)p(rO$kWI<YWv7f|
z2ucYml@6pE^AC`h!-8JCu}aI$&CR~EzwV=WmvuLL`U7oo|MRfmigdf0O*hHk-h_^%
z2c1RjQiOF6Z%Mv;Ci!sZj{^tDLC3|*E`35r?>~HXz&^;N#s5M_nlnin|LsOuva#6|
z*53K?tK&hkH)=_O|E?TLL-yOZ_V*GzI;`Hz?(dlqF=o);5}|~Z{K|%Ry7kI`4LN*1
zacDP%Gdm7?`*jv>Q-HDC3&K8mc79a<?ce3nr!Y6;(k(yrchpu{);)?oUA*f`SQugz
z{E(q6(f{6q(%w7Hsd%$9aRU(Z;a8;(?raqszr$TPYq_=k)i7Sx<bFZ0Y|W36*~NkV
zJ!X-UU1|PlodB>!k6cZ~(|^9?4JDoPJ971xWpvbnFXHBh`6b<ryF_1}H<f#RX@m5f
z`zya^AmmQx7>!Euo)X@~Fxf24d0YB$(Q`X>vdc?@j_*ckoedYRPAT)9U9Z{~o)+x-
z;2HBW{ALM&L<0x&o8GtfSJ#$~T_4})JPC+Avi*7E?uBq|mi#%(W{ddVv^O_WO%)Dt
z3s*yad3P)io&Yd;c$TTn8@tMm<+^sauwTg@9m(MrmnD9VU%2kpqFUuHf5)g#a}J9%
zO*_o|#Rg;XmUaOOH6hwR^sYxhl(6_NIVY^!DecqMu;8L2C9esE3oRP26rG(}?50V4
zd7gRet4i~txz*TY^kR<LxUw%K!FJ1?r5Mjw-%r0QrfrQfUbU!KXKQJD+qq66$eeSv
z;{f{b<(G>ub~MhY1n=H<Nxwbvw9+xkPWp^xgE=%(WQw_EaQoDAqr~5L7M%6MZL=&e
z+Z<R`)4tYi=zZwPvuBAlXYRJ|*7^SnSu$kVb~82EaHESihJU`yIUDLc-e}PKGAUD>
zd)JJ8GWD3{Md1&-y!WlG0d~WUlG^7hCv$7klJ|G={nLt0xMc0iy+qyamp=gHFJ+s|
zLd~7f*fP6YZ1w_+%eveOm`#3vW$7nJ^{&gEcRo+}ceR)fAGIhA7(MUb^`6u*wr|VP
zpSW7bYZPVm?X9(hFF-1~s8sjUt}4CD`DoOpExhKYfviQZ(tIY$Q?t{9ovb}vULO72
zyTqjU^Zq0LU7McsV~?0lf_qMvetaaNcfc)y>@q@IU=baq9jdOaE<BR;OaJ$seO2$%
zw%5RAr9jeK+^;Zc@_1lS0pIRvpr74yWi+n+{^Y>I`~bc)Onn%7d&|JpfRN!*>5?sR
z17yJs*Ghxzc04P7AVXi<vv5nt(Rgpet_-BzuHmrpkyUl}z8CH~54`%~Jot8B%i42u
zr@JnzZsZwET0Ag2fSosb(-hOR)S0=fx?$gqB~`l_A=?_9o@Qc?Ud+F*s4=;6>C%s%
zcYu0z+xw%xHI4Z!Rmoaf_sSKK-EB9ATZi;f6^Z588Y`E)J;}}{FCCNWFL&(jz0~tU
zOkScZEcSoDam&C`f7iiv+p8<uy}rGO2AWOUg`)=_x6~heYz4@BIwxHz;kpzFk6Zr?
zjrOmq`c;lKk5%@(h!+{X`T{^#<1SY8hki(8=efVp%%(j+E>?E)vCEa}Fo(*+J#`RQ
z>-Jvin(<Ghn*GV`hzrUq>1`Ji4GJ>mibj*B7jRnMbn;LCGCb?7KJr2HX+er>xI@9V
z;^5Z3m)1KtB&ohPp})Vo+kUxe@X@J+9qTiX?qEgO?YNJM@|)C4a|~^`ymKOgamu-T
zDX7Hm^2O+`?{h2vz(~lvS-M9N_6~gwSmVuOc2}sTptvhnMst~KM&>>=OzKz@W2EI6
z6=uOqIrze{E@D*1!3C@0Hd}@N>fXbcpJFd-*te}lwWZgs7T6`0Zn4GX-k#;HAItBJ
z9sfLN?V^`4G`lVXPC5w`!p<$8p1G_VV)fy8^6bj{C*EC>=ZbSr-8>w!!+LmpkC$}D
z>Q>9V**@^6VdHJ*Vv|b8zSxxsB6o7p%?@k#31IIw+ufe{c89*d%O&NyRY&-Ub~2W;
z<B>Z0{`vSso)Vc&>IpN@jm)dd*n~ehd&b(e&VOEK`eDIQ^{=*Gjqzre;~CPcALC6i
zw1`E=M?(+gJvDJF%^Mmtydf0Tmle%EpJo@Z>&;u$oAxu?q<vq?zea3))VbAQJ9S#V
z7rX9}n5mIZ+S-JVT;1?swV}=Q8Aug?OL_Bz`t92264knN`vB9WA1DWaeFVurp8Gcz
znHbt52MlIlHojV5Xytpr$}x~Sm7lD?ZIK&Azt;Cfs%bPG!E_Ht1!gB)kY?s?0>v1+
ziZZMLs?JO7bq`%ep9_pd-$)u0J>p>f&FuyU@z;8f?)>`5wSCEM2Iy>Y7cBRu;pMjI
zt_9nU>md)@5y?C29=%%yOotvhQkdR@EbR1L!UNKuHwSjF&~JZB|89siwrqO+_?~Oz
zCHke_qdwm%#-A(>jyDRt?A}FN;={%-Hh#fujyseea8xxC`Py=%=Y=9<<J^3a$mDFs
z-Bv@JJL}PV0FZ2K=t$GVl<7_ee#^aOvIg~iv2&Nqvj(|ZyWxPrp;zDbGV0<lxK;se
z9oJ78m#KfC_IYuzk)?O<@1Hv3iN@kDMVz5){DQ0dW)9w4%Nn>4dmTvis?Byj*{l7P
zbrrdK@E5svDEh;%^Y>l=UBUfNh;euSNDmo@3EY!_DLYjwX(bt_uXz%^_2+>7)_K0Y
z`Wa|>##F6$n|ub}Cb@LPu;P3JQ1vKj?z60o8HzqXC-cW{fYz-2UeBxlaI{Wf1^y7U
z{*xb#WQJif3b(hg_Z!+2Eb6=C3}~&h@6vfQ)*6~khZtAih~2ZgZFz<ly;=5o6e;&3
z`G1_XmNrAMvDxHrN;_tPpY4RSh2I~`Gqi3oWp19OpD&7)EX}$b{U4!CH?$W&bUCxM
zdfk!fx7+A6$OqG1EB1OHGz1oN*5wjC>X&u2a)a=qg`<o>enjob&-!(b`g53tKT?wB
zv@QsXp8jv1d<>@F0C<}3AMFTuy>Z`hw=z=i+LYmm7w=RjJI(-&Q8}i*!{-mVu2m=9
z7cv&L+zZ`Qo|3e$_->g+)q*q`sLVOW7<nzj$8g%7peb>6e7$E7vKj|ytx&r<PZP!H
zDctwhlo!4BN9=zm)mIMn0^qSc#W?->gG}pj-{`qt_T`^h%Zga^r~}Z7iN(P-$pLmZ
zP1^Svjb8XG12C51@bGQJ16#{L=PJjaO1_LfHt0WQjsm*B>t>v6RsCH6IA6nHXPUHy
z=lwXByoMIsdeYFQ<lO@Btl6mebqtclJjcDenfmQ3E|Q`hznWM$-*X!n*bIT3;8!QR
z_qW$%UbwKqH9qOOb&S#G$HvKZf7W9WV<7d!J3^o9@ltw>@dPZPv2gpD_btb^Z7W>9
z*XY3B-HKV&+wE(A9NG#<Zra<f@$=DgL#q!<6PJ=teqZ_Ty#QA8e!g;l{fQgwy5@mT
z<%3fsi-GQ_e3MUiCkF^1*KP&Xy!nOb0$VV9Tj871$gjNCf(&F~M;X7;@(mHa?B}J7
z>!~YYG3Nkxeln%uz@1xN*zb!6+}yX@jgpQO|6w3qYue^`a^$8d|LSA+*Zhhh?6Ipp
z?(WkMuYw-|`iF!}%;5}kucR0EBS(clK0fR*gMh)p7i$}zx<&1p93LX*`<DnmKTViw
z0;M=eS=U~@`?+<h$Bz!k{8I}-#@nKbTrzaEu{HzEtzQ~$yI)9N^EwA@5NTTfwSFz@
zuZKbL2%vJBZ4~ad&R_7tp>Ji-qEiTb#$upI@}w-fGtJ88!uvMK7Jtodpg2@l)4U63
z^Qo!nk!m@6>vYJnYQK<}%nvAPkLl-*j+dXGoe%*nkdsMC8_S+G6^TVa+xlc$+V=^d
zEzL)Kz815GQFr%1*Y-6_yIyVkqgMOY?^jt0oSU^{&LCIot(K&iB%raPoR|}8G`Eg3
zk5;AE4CJAa_s8=atauh-vbXQDP398i*(PtromW4Uo=<mpBYKwo@aZ}IDQ0dwq^)VY
zq;G!|0aOOA`3;UI7t5NrunL6<hE``Ie$F@98u7-4z<8>exB?ekt|af`&W=0j@u$fX
zw2JBOoOn4+=6VMclSJ$LUN&&;^F@=th8IQ)0prX$aNTEERf~n5dnrA+{9R@59sSy~
z8Hb~j>TH^O_w4LDlajik22iN|-NAr75`2rJ9_V)qYEsZIvx(}!GxqGghF19{zfwG2
zVtm)q24u`RNpsO(7tsHH_Y$CKI~x4eZqxNESDG}RTR3>HAm0>28w~#49wF$*0rt*1
zm%(q}VK;=RTj4VoTc&tgGiW{I$JVUeQgiJl@7$=xoi#J~cFD_1U!QFvoH=^cSeymu
z6b>-Z*g;>*?Uq9Zni9QuBV)7o^x&Y$wTEJIx!*Q43<bYh3KTKet9N#l9;HlxAK7hE
z9M02h^`=r!m0ReW+P*CcyOX>oY5B`X$2t~dlpE$9G`hq6v_0eJJeGanqAPyIgogf~
zV{ere$<AX}Ph{^0l;vE=%#EXw2H>VsyWi@!pWbg`5Ypg`02pv7$0?Oi{An=y<Kq;g
z62F9JU$k*X7QR~NJ+L!}$@dSXj#b50XN+)o#mjljD52A!2+oK}x_xOD^8WagqUMUv
z-}}}W-C}bAZ@N0`{>=IV+nf{@@oU06K`Fno1v$jYt-Bg;aT*ujaUOT?Ufd1`jq;Z2
zw;#Qdc|3mECH37^<tqqvhXWTt8hQXf^8I$u_)O^zt5Drgv%36g<)Z`o<wpW)-6mbe
z`_E1)&pyofKIe&ZbYCe@F$>&N@?k-B%uk>IM4(*&t7jBBWHg;x)RZ&yG9MSA)y>s6
zHnz29XmrV>w8b&T>p!d=IawSrG*{WmnI9$%{c<S%`gMg)J5nX<Ym?(g36hNDCw0)=
z3PzONed{X2OT|0yt1H*yAf5ZQH9MFK0fD*X-g85=`m$J-m>mcIT4AP|P44nl>~US1
zlajXW)%`;+2(KjBDRiK4fhd$XC$$>e9A1!Oy0DH@+W7Mk?8YVR&%^#=s)qX|OW>c8
z9T1VSMTxues`J(dP5eYhqPFdZn~PKInq33zwj!&$p|4-=KOdBqwzKq7S6~9LYHx#T
zk*mvfCx1P**l0#Djox5^E}Ga=`cyj}*D-7b5j>~JC<mApn`vVUt_!xlGTMxx?G+jQ
zx;yuK!!A%CkJNhLB?n)1|Ab%HK|*Hd6T<q<*4FPErS6dn>lQC{K*~}|B;e-P-{5Vl
zjijhAk4vLEjn@`YM_yF~)FmDE>&iJzj6GUJN+xAu>#v(cW#!zeftAsguH3T6O2564
zto*bbR1-hBBJ!CIFtzQemb8I(VdKx$Hnh|W9zZ>RWZuY4{qGI%^(z!Vp8L4KtS_%6
zdoNh^qIKir>VrbiUsqaY*Nz0uI9&W8oOEv^i*++-9md<mE`VINbz+w-{%+v;mcjLz
zPP6hD_W6(29noRuasXWM%d)nPQ|^D>{`ty3LCfB@UU91X<nQ)WC$o#uX<Ng$AG&_w
zmT3^<BcQ9uZ#Q<<CK%OLzjKgg&JO*MLH`hOI%Oj?EJ}H?^Do!o(d^EI%?1HQztf$w
zmoxif-#7dPSg)XivIU4nJDt9apNGSlmHQY8=DzFR<WwT_;!M}=_wDjaGj7S8J$gXs
z<j1mjUASE9>x7CQK1z^^X>asubNmw$=+AFol5=N^Y1Kyqq%c;&&h+m-eTLYQ^|_Bm
zGw(xY47Qv5X$`HeqpjzKQ#CPfrPQ%`X8VuaF3;(6O}^`wTBj(u?wu#<`fw+o-8Uty
z@6_4-vYqIT=P$DLCq8``_gdvz+@F57LH8PmU-vlv`|!$%er5L@zJKS{+-GsK`z8A;
zr-C%W=!2=DRoE>(UYXwB?NP@H_~_pJCm$=3&eYPhIgQ|$UujJnUl;C=h8c=kcM7{#
zNJv|I_X+!AEk6Gh@w_tIuO(~Ovs>|9JDScPYg!nveL8XeXj`UT`Cgs$WO*q3T6mN;
z|F`w0k61^6`RABfwB1xdYjK+Zh{k|MbR_M_6W-lt8*qPnYGQph(e%!*CULW$VL#I{
zV(?qz(J9<8K01_*HI1aC-u(&eweVrFQhvV=J^XF|{3T@%6G$Y|{pn3EbIamtW?qQa
zUUw^7In!utH)9W@Z_vB9^6dtdL42&x>~$f~Z>edtagPG@8oH%a_IXM78I(DxBdKJ(
zGQe+R>P}PWopZ86&O?_~xh8G5hdYBpes7Yyy)V!Xor?%=!{-hf{NC1&jyIlP@USto
z))i~8_4m2olLdhl^~s>XGUIY<4p7n#e<k|0dGqGB>cr2Vx#l;)G(_IEgx8a=E<8e3
zuc_>r+mr)o%JDau?f;-k%mVtm^Xuwu3vT$M1E>p8@gSjg?(JKR)ftPLdj_}2%UhZ>
zS1Kz@OzV+AzEpMl=ER4C5$=Z902a@5H6T~-n@1|S_4I?=&JLHT>d&QTwe2f(edWtG
zySW9Va%wj<3Iu|G2YC+kz^KuQjrhfxHfP{+mHx6dcmR*%e>~lKCu2V&X9d^7w^zVA
z5Y3ofuvev5u((=(1ZZ9Ykqzje0iWM~pWGSO_ias#ajE_6lOmvRIq*IGsBl~MyBUkE
zttk#`SeRSN(ux-~%VsDr1=Td0WWgcA6wJMN0pXV2UL6l0in^n_2G&<rRxZB%n=+E3
z4T?(~?JaH5w;^u+RCfwMg(V4RSn0=s>e^CHc|*3v?#drkp3T=NnzyrFES>SZ@*DGa
zKu1zzT=V0U@|z29{}m<QE$lmWGHRG{E#hy$aVdcONb|MvNH<JL?`_$3>36i_x$RS|
ztPhC^+;;w_^9{Y;qbZ2}Sj^VRvCxORvv>D-=ymk1X7-Jp!O|9*Zp|wLIuLv4zIoU7
z?l&u09AvbH^9wWE?MK!8vbYv`3kyv1zrW$)!M>EFZ^!4xbg_X({Q+NY$q=HjGdd}I
z|CKkR^ZW9LrAzY98;5Le*kDOY4X*9Dl=}a}WN|qGBdwdPmQ{Z;#G1@xVo8?23<`5T
z<>ch_9QgS@`XkJW=+d`;xhO|mqo=>BXKu&m&lUww{h0+b(0T=&vBtoUu#cyf#3VlO
zt9hk9Nj({t!?tE!?X^e5B)y5zxW-*A`YXnG{KZdOHc<M$n74PFqFi^>(z0r*lZJ~C
z5pq0tTnaz4i?au28##|rv@`um#kwOSWiQV9QVgw99NAGtIeylTTU6bhAB?=eA<HT%
zUQPwv=j`;C_kd0XnWvZhD==*NBI>jIMN(=1Z$=m*As1wJ{_9h{T}~t-Wwf93%Bptw
z=MBWQh$wEBq4m9s=GPNK-cbNS89AK{gieKqT5_*yUs-AAlL8FgsuEz};?7^WsM!U+
zCsI0eOQm8?c8^7F^;5m2IU}Wv%RhMgRk^#IVUsYt^5TX7Z-dcwf)j=|_bz6+Ymkq<
z0o?VMjo!jNyAuJ=(w!3R_zQ1>IlKzB|KlRr;Hlku<1>i?V!}}U)_she+@H7b9tj3<
zl#+lv>L|Ev-ublLM#7b`z140}$6uRnCrtGYNJ&6vm~+X=(B@zpx^>s$H&ME|(kg!}
z&^n<W&3JF|dOSI-)ew8b<5Pw0H&4I7J>c~KHv8&UmK$p{rf6&CQ{(et0bN&F#Pk|t
zF-x;W@96abFB93nDHa+2VA;1=9MomszNkC>H>pv&!3WcckmImZ$2sWNJD2lr{b{W&
zHxj(9LPrc9{Rs5A09$+r#A{u0U7C|Cs%rPD=&uGd%$wpKJQ)=4y;)HS_;h7Y@#?13
zqLiDfci<!687$dU^Xb9!bB}Z09o9s39;{EA?Vk4rY(26v>rbQ_!O+v{4Ff)Lv_O-_
z(8l~rN9RGp`YvFz%o8dGH4&3^sx;jjDEZaho<8}7ryrj<JK(+OQl!QEEi;b3AD%sX
zJuMFa(uFPtA>DKvUyfN@-ptsPl6jYYPh66wXr$~R_}Oaw91gm@b69lu&wPHbaH!xR
zBMuu3PrP(4AGlUUJ#|3X)s%bmeBx_!)=hqXR#fkJvL@?uP4g2UU8UhI6GN+m2g`mw
znz_h|2E<*4V_DtLjh{|Ux4iE*X0&diy<h(V9<tdAz&Gio!;+P5rPaQFa_QQ0!|x`>
zYC7oqu8B4peG-!!3Oha<7lboV`#cIRW|8C998CGT*v3luxK%FNS#bt%YlkU{zSO(V
zTNY{$vMRD;O4rf;T5#aYfzkD}d&{a@EH2um6z^OU?a2DzJ;Pz!uc5hTv%!%g%GROk
z(~z#d3e#+0|8C3;if-^L+BD+FbYNG4cj~R{5yL-q{lFH^+r3{7tyr-FDm<qBRy<>2
zx+#2H-qNKnE_j|00^8~?d=LCS7oKzd>4c&98ntgGC+k-Qw)}U~csvJiw}`?rthruY
z{nniL^BZpnnd%?nw#}|CcgVmNqf2(6i?i{oLHe9>pOIe{_iPI|gL}0XAN%c=Z@rUp
zlY8Z2;p@mtKxLVeYi2vT<k;}|!?{kjtU`}eXzhOjnc*hZBxT83<iWod?L7eRJnf<d
z*Q7Z&TAfuXTu(uyP0+UMn+T~EWk;$bx0{#gEftLiYybm$_tKyJE2fPHe53o_9_(BR
zh?W{Ll^+(1<|3P4psI$LR^?jzF^O87NXQ&@*_~j7eC8LR!T(`%<6h+IEAnOMS!+Wl
zACU7<=p9ZCx9+bnN<XWOTPYnla6s?qMIb|sBPI2Hs_=5XV^+f0V>UP*Q#EFI*^Ksr
zkoJ-g86MQKdezafGxwbb7G!PAnqS8mu*IflWU)2Kl}V~i_!X08#&6!;irp_cy^)sZ
zZ(n=lqhZCd$D%VcxV;_L%<KDmN+)+c4DD+x=L}r9$Y|YF_VMAq=4#jMXwiCmSazJ~
zbP-s(<l3|aB-~UmUlaM(lv87Mdi;Uiru(I*xkvKly`P_vs8n+xHk1NAoALqs^ozXD
z<r!bjxK3h$y1(#Q;a@RE>)C$Wf4z5;pZj+3=CYTUe@jjlCY5;KniuVua^(FFJ*qZJ
zb7cQiYu|N2UVDsZ<a#ShTj??XydO)Zp;?ndy8-Lz1{(ZZGSgO0&>V91##JgnutR9C
zv#Naugt75B`@&y8y?9V%r$>wta<iY`??V;z`hboS@mHWow;a&gRq9OfDInL4+z0$S
zKs;=tH7&^RhA%nqhim@*k=*dslI(4*n>!*xv`wuqfkdhTYM;64eCZct0*71Pa+AZ`
zT1YN>my;;1in*h0g~-*_j}FY%CmO`dR*O;83~vBfE@$~I?XH#W)UAvIYJwL;E!Vlm
zR;;tT)e~)AXRc>u$=_Uak2zj*27Wg?F66@%zguxd7F}IkoE>pV`R%fu*NM{uH`X5o
zggi3w^VsmZUjqa_&|~|v#+HI3ZS`iL%In`52mK16GQ;zCA%<3W))!It@MDcuw+Sy_
zTO~VGJwEestA)>=0RTrdsI4ep)+N0)C?t0jl3UU%(=vY`t{U2m5@bs<t>LPbo@{pO
z9jDm^irHV@K3c46ZyoAVA8qk28Oi?o<W1$?L&jEstEuc{(Qg4{zg>DpzA?Z-uW5MA
z%>Cm!Ul+{^Z#?w7$$2a6it~<$?cJ-BsK+(~PI)1`t8H4DUK#G(g89*ob8y}zW16T-
z%gDr|YiSKf@_!Ki)Dc#{_`FxKsBeMZnJ;jlb#M0iM(WmZ?>~9T%H#Oln8eJv{lZqO
z79Yv>4UuEF7VLc%?zQO-)<Y$!%$O@XYgb<}7PQv&*Q2zhi{8dmR#|oq3Q7%!f=6Pz
z&4!-popKty6)&3XS)zO#1J(6i8MW97+OpvTza_8Zsoug6sI%_Z6@y-b(I*&#Dxk!1
zPS_9rdpk~hO*y#VFreziH{ZUxz2h9+o454{z@~vdxO?K|;|w;tugddr=gsi?uCzwF
zPtUU(h?A*Xc41<U<mA7{?+D+hA5xzY<}&`P;7rNS@9$2ppS2)9wc$Ass`qP?D$KA+
zUIqn#&GTY!YE^CH>@{MmpuLQOy?364{aqb@)_UsVmNI&Z&nt1~`FqWU6CV|K7)%UY
zxf0#%H?-g>D6y>4iWr3<-iM|%sbvIU>&n1m8${l<d36(K56p@Bb*ho}V!&<k&<Abc
z?B-qa0MLxg!`FYbM1-u7LeZ;=wL!m{eGgyVZ$_J{pkgA)(Z?5^ahcVyGvTfAtREA>
z2ll}GnRit-HK!rbF12e4(Z>+>GdSk6G}qt%z3kTuSKauIim2HrlSGaZq|5x)ME^T6
z>Y^X8j5SK1b1`;4vEb*~{9WgytB%~x-X(hUDIq7b^GnXz;_OJEiqljGTEIQEMk@T}
zJfsiWP-S$8@o?Rd>!`*p&V3WR83k7dPjA0b8F!MHl{60YheiT0mWAZEXCWouTM}=0
z=80neozGnPV41p>w%3H&xB76MGl8Gjkv~O=k47EVal1`_>^ThKSD%|0AAOm5bSthz
zH)yu?UV=f`_WKb|HK|VI)!k1|scwHdV&W`pxJ2U2GT*$}GvX#tgj?yNxpq4WC{<Fn
zZ@0$Kez*103;X@RVDJUk<%`!_t*PBy7FSYQ$Q=WN_gXaNETWJu*3G(U>bL22;fC_U
z#bQ>Ixhl5^w<#uZ<aM6)sPJ-lLl&@)CRN@Q?U&`p?e)t0Y~1mpJ@c}ts_s?8t#SLW
z?{--f9TJO`{ixyNOO6#potuAbQ@UpFlf$bvp(-m(qpTP1{w)6a`59E*v%Q{>-!XG-
zQG}C|6XF;bNOIm31Ri)=w=nv1`0x#2!!!Qm<Gs<dYszAmpx*-jds2_~V*$|lYn0!K
zzI9h?oL7u*a}M)&9&8B|w7*X+!o?)roNoeD+h6x>_FoH#voOqZqI-_<%MHg5w!B8>
zvHRXH@P4v+=jzToWtFY>N(O4u4Pp&UP2TkJ*G&PQ)Zt?fzU`j>w8`zotoi!$Y9D9n
z>*)#WFL-i3AF!L~y{GLj6Y33F6^{Pw@Bcrny>(Po-P<)RA(E1ZQd;uR-6<ela_9zW
z0YN|-q(cO0q*FbVbcb|GND2r@OG@Xrj^6kC{hs%GzGsYgjCTzGQDpD6*IxU&=9<^M
z=CTFtLA!h`tcqt&#7uwok9$BZ|3qXv<}U6n+Z=tht{ESO>{er6-x=PgM<BiV)@lsr
zD2g1982r50-LE~GZ(p6LUwvurr3+Nl$dN4OckxRzBvmR7zZ}F=?SAEEVHcBGO;%+7
z2N9e}Qd1*yw@6e`@$lhmChM9>b>y+nPH?EvRKEKC3^cazbz!P8{%#`XFlLprwrtEN
z1}OH1Pk@ZdJh2mV_Cw|D2mb|H62jspABE`8pt1orKIo&|TWeWkK^(hPV$>tQ)$Pck
z+r?pIU-jT{qf0hWY?oQ2Fjh@WhJJwOb{f63{K7<@aYJo1zAVf$C`A#8_qHNyrA&7T
z?=H{h!?Tsxs7uTDC)$;Iifk~^*Y{-gPX*pY<5nn|-`$yLt<7QCnUHXb8+a!PwCB@8
z(Xs>WF|Uro`cUpX(LiQ}`JFFwvas|Og@U5GXcH3dCr#bz*6+lC`X1X08+n>==R0>$
zK=dB2f0v@KJxozivGWOr+UZB9p~xEX(5V_z@)Ufw@;BVqINU@ZgvadxsVXg^U6he_
z##d~py*?1NxsDrMkb1kvu<G+#h8^56>Go2~MO;zVN=W;uvD<Z{TO2#=mV%O4)waY7
zg$(^nMRN59DK`47@&W0W<&0L)Uh@Qyluf4V^$$|uT5Z#~tMWk2_H7gO;}v2<qbhQI
zxf2;(P0*GGseTYzHs3aJLb*UDE7^S$sKNS_Rp%90w;xp*)w?<9{N?YAs(!OAVrgL-
zJi;*VQl4F#x?5o`?#ej9WO3Vu;W9cPZ`&1VeCNITn?E>PFlXrQ3f=MpY`$aAwV=UK
zm`N!GFQzd0)b!=@3(Mi!1nB9wZ>?mn@dqp`J$M}hmG^Oc_>fTLwJsNa&0TFNxbB^K
zB<<zv9QU_0|83%WAs_{3BGKds`;*tS7nZKgAg^4vKu1nkWkGfEpK518OnY}CT?_yH
zHxY$W@D%j9ppVor)_~mrmV+C0kzPbE1_>SXes~!R`?6J@;v<>gue&hWt1%o5Tjd<@
zEoE$ipv*~8{{aGeR3hin`u}FBG??kFKEBCiPcJqW*JpDytL?3}-pH4~v`fkMa1-;O
z2SQN0Fj<qmzh#xhjgMO7%b!$PWe!ly>505fT7g3IhAVzlx=F$^I_;L<!m`UBHns-f
z0x0R(K8SA*rE5V$Ny_&OhbSOJ@>78VHt37vF+tm<%nlkdXg2W)@%U4@S_)twNr(z}
zQlCy}#4wkwf9oZLiuiHK;r%__Prd0{Wd`sREegAeNJ(w&L~ZSD7>5AN(2h_YY&t1u
zR+_<7XI3QgNy2p%Oy(O#CDa9K(yYIuz@`86yc|ZoX7MYY8<YNxeSi~_#o{3YFDB@l
zy$;aT5NUzE3Ofzc{yFr4WV~%~$-$QG&w$KqEy`V1!^>h`Tjbh;=A(|9Y?g2cR<=mC
zVw1$geeTZ4*#pSJhd-|dCCyNsowh~FOly}R9I`6CwTg%Madkf^+QDg^RGaajYtA)Q
z#D6H%@+z+Bx)+^O-R)eXyx|Z+GXr%<XXM?l6zcS#2j?D{x$Mpvz==o)+Fi0u4o@R2
zZTyNEU~eb~^FqpeWYmUQ(w7PIWM1dB&Er8aQAb1Be_We=$=<Lb=!|^Bxuc)(XU$Gm
zXXrYTEZe_C{iPw%87a1GngGFr%Ei5OuLlT<!ap2Ry%H4%x!0)!AvyT0K_8!Uo)fPt
zWS}cOB6=n6Tg(0KIcc06N6SkpD~iDafRgq?j~2!vCO-LpJoBEBH`tt!zmYQXs>%tZ
zYfx8qKt-Sw85Fz9MjDs{F`n#T`=v~r<m3_>Vj4m~HPuJk1)t-AHZ55i6-ew1OF}rm
zl$Y*$t!|EN^d-w_T@DY02+q_jp(9|J+twM`skI8BMR4z?7&XM4zG^MFkwW^;9&R-X
z4q{Evz#ih6Xd8A8$R$1rT?^|+bo(Vzq<^*nNikUWd_+e=eRx#5R?v)Q<=n&O>5i*_
z9PAe%Rw64HRe_E14%UA&s*h2L9>yk8SkE{-WXOMi3Y3PkrnTzl+m5$T!=&xy>*n;p
z=c6vN@P-h&Jz0_m*vrxPLat0KEd3PoV`G|W+*X(|R1%qJIOO?HC;pa>v${jvw{Yoy
zYQzQfn}<w&x>~J<nC}4o0%$wBh_SQa)B!h0aa-5ZoU}ld_wjSCZ>q7iQHJC=4p)Wr
zpQW<Tcw|#_qb^Me!4Q;%Kb8~7oyxkF4#u;GJ$2~Y?^6biT`3B4R}BdidVPa~`3MH}
z9|%$fx@AF_rY#{PB_WYV>`E>xH#Tgd;VFwZ$R9PjIOwXzp(>JHXJ`{`ae8>_DsUT-
zpbDq)+bbTg^%%&}!6JV+MJt0SUwq5CTjM1*v7-Rzg3zx}s+T!qSR@r~lp}Z1&!i-~
zPVZgZTewD9m4jh|T>ZVy#axl(*5e=Xb)lc*d_y7{E~Ro535UCXw;<)8HdKigJow<>
zN|J}YCR+<k9LhaalBSEnK)h-NF`p<HX}j+>C$`y6WH#qr-nLMa6F1BGZGj31;O8aO
zRpI628C(`<VDF<AUAVvaj!~_!-gRBm&#wiKWA;f@(rNXSG2y0erTO9>^iRzQ6h|(r
z^sH00x-iR34n+M|0fbC=puGeGQGdR&;Kk4e)gbk^%Zh%0IJZ`rpXlbOrtvDElM+KS
zv3}9Oex6@w?hK&s5Shzn7LAB1Ww5{o=^PwY@Su~2I@Rt+xYV$G`?<g?^OBdOi@v8u
z(eP=}v5&rFIT_OM>8rTPPSJ3PQh7QIAU)e+3T^z0dzDX){opU?pf`iZ1HHX?21LKn
zu}#2$Z}<5A9q{c$suN9T<oVzb93PRQhCg6kqa6Pkqo3&YysTMAFoyY(n2Dfu*Mf<|
zzjwQgsO%PoboP(FepR)f==8nOM^9!fvl@(phyAlb$W7qIwJv>^Vm5B(R@i2-^P4x3
z2*I@uI(1864I1BX5ERLDhM?iG7BY|i)dGMxVV~&X>HkCh$*0*&+he;tPLzB1o3<>y
z$D=vRY5y!!bp8pOqW1VNzTEh4K@DR4qYsE5XH5yEV(&g^O(pHJg`cxRS{hEDGs>BG
z<=5s36#6m`8>L<kUr)5Sx*pW8@0wcp@u@$2NQOW2q)>g*4%!)cL{n9OvO!fhO#HN-
z3PdUcajy%qf0#B|SV=sdN%b-rT;OvQ<Ydm3Tz9hFQ2%0yn1=t%YkSqn=BVyw`L^iB
zoooK+-S(e~LXD%~3s6xgndOIAmsZ(Oly$<o@u2PEWOZfY$RH%nizkS+8}F3gUHhy5
zM<o_p|0(B_LAZS(s;vSqFZ*qxFGrZw5;II>oIR4{kQ<gou2A$QD@P~uCOXr{wu)3`
z2|qQt$WM_l^Pz%w4VCMEmIjb3g4VyIgZq$5eG|6=?}L#zR4@0><~Q`N{$UWlNgqn_
zyYr6`iD#WQUhBsYx9hjVZnTZ+>dRW2_Us*?tvb{9CzbKzSBf)HPV@4HnS&&qk%Oa^
zWjmh!(*pcnx@bT!C!3y}^XHoUPV7mkVQ2cG3oythCYYzC<+soCK|E?mD{(|%RntK;
z{eSl=f*46(==;sV5Ev<VeNW&*+rzbz*84<<KoUBhMSrez-{yr>efSw#h)R9>Q?TF4
zz2s-c0OUHWs^?HY2O|z49ox$iJu|Z}bUgKpBP<oYlpuG@PZHk;2qub?^ciYrq?yf*
zR{7tgRAe<hK+rj5d{Ev`4ssrYYDy0O%c#5ZFD@USmYUA;mQU9`xj1ur(D@$>Iq7e(
zkK5|gY%~UGH<rU4MN6ccR8K>+<zrn~atuox_7E<lQ&9yub6caTBqGDh`BA5$&B(po
z(hNjPYb|y(0;(yaxc+Af0`r_U-pnhE2hFJ_{Ema1iHPluVs%}Sv(Gz3v{lRHAAMuU
z1`t+6y4$-b4M2+&Lp~6-OFjF{**u=Pd{DVF-Zt@uqcD(}(nS0F7Y>V$kGXjzK&Du+
zJ_RZ87bT6*&X-G>;kt8szQVwBCB<c*zj`SbE$#`o&MEb#F{1kwv?|3x+(hQ|Ob&H@
z_mIHjJ*WL2=DwP(yo}BHX6>EO1|F1Kex#*l<=PCWBhAP<BPod-jYI#=aZ|nSGs<Oq
zGA{#d?21EX;Qy2_D5%+mWiH!QtiMONKsDLZ_5_O>7M*YZ?(^S7#W2+2{*1b%1}lOd
zt&bgcCYpG+G8xM~R+&O}h4FqKBImp>7%Px}kcRkVdAUL}U!D10Jhyt*e6C;ZxYd%(
z(^Bh3d%Trpr(k&W5yVN3c&46rf2RK)0%$;+wEp11d%X48hL3$-cNBhC;f{ic_qu?D
z-Kp@~r}_9$fY-~=pGMU<bBmm76!l3~AVnuqTvN!wKMcj}U;gy>T+ed`cJGsSS(p`c
zzl%X4e-R63d)RULh1iU95Ir37<?C#b>0g+oHc*~SA70kHY?jCeNTBdux#z*hC9(%s
zgIW_dc^s|YSI@Z8G>u_2a(d5OYs)6`pm<Q2n4aBK)M?noLDyuLT@NW8G_pqra=QN)
zA<<OonvEp;RwW|7MdS`FEI%4KHM>X%CH<=(C+E-AGsnMF;isf&byW@Or{-wX>^={N
zY)^kO1cEmf`6)gbbO7y0W#CMI*33WP<ripgT5x^zsM;0ll(#&Mj^Q{4Zqp&VW^2M{
zfbw5g^8YZEl-hklpf;XTuKU4pNKvJt<MhgR!S1xfTP?67>iB&5(9>~XVv)TNFiSDE
zrv24kf<!D}!AaBG>|IhY!Vt|`QN(Py$;Mt0nSK|x<Pv_OIOM#&3mTZC!v7$V_x~c1
zURGGuDAB@s6o+GfQqs+rH3u5S69<X4OqP?uZ3~;l;fEE(1@<GB73{JDI<5koGerSh
zgy1VYn*hu2;@;M&1qB}tc8273>(ij>J0@~l{$#+_;O?BLa~3TsU^yd$+tdZ9Vc1>U
z(;WcExB62T=raGc^icQm5^g?UORuu%xv$^k$pz$Ms-p1J)Kp&gU%GMPb`wncpDi(f
z(T4_bfM~e_l8t;IL>g}kL_tWhfRhOQH<BRmnM4Ej_u{s=m(=98Sw__#LlS<bq&Vz@
z2Yt~!v<n+Jy8#X5w=nu0UQV`NJv}|?@c&SGO~CbdKo?!){|j@1yTSaGrJ+q$+v~(R
z%~si(E9wqi5i+Xg17adzY;5d`(LV1zw|Hmu(z{W>q25xVlC5mFdh~8`0Am_|g}zi=
zbJ^j#nRz?1MF4Wn7C+{bKtcV$CAP4<cVoJO?%(P?Q2i0+F^k&eVvrH@@lC-w*;{lT
z_%2<|USFQ<{Jt3UuR7^tUXg*P=}L(lUyBxx0Y*Ra;W0kg<uv+A{@t>^JGjn?fE?la
z)RJ#@MXn>iQi10e7J6Ys2L&Og0jCW->X#9T?XT~7k8XYYluW8JdN?3>t>pToJ4}}k
zRJ6Ailkq3vXKVRh_rY?c!~VNPQ|<P9!vOm#u|IDIhMq=y{Is||8oqC%<QVkWU<J8i
zxsi)3LuL(tPOZffneMZT6HFmwdSGuu+igJZH0K;l>Aj>H8SX&DBsaGfrd#1?lh3c*
zeJVc`2RX9XejYRy1#yoFc???lp4-Dbg-N4GZaCCXJ}LF~9$F3nf`|Vz7}=$*MnT5K
z36aniFwOx9mk|{enVx#(QihNbOzNAOBXfEoq0~aPEOybM-d^XdRD%BJrohm{SUoll
zvKZ3~f5`0*K-&dym+hXa)#=4&LL%$Jq?)b+NUB)gOT^1!HhBUBK^M;z6JrCZ#gf5%
z`NB5@_e2g0D0b`oPca(I9+NkpP5KgLk+O-;RWL_U*7>&7`Tq!KcUv+{CDmJs8Zj9i
zc6#Ns`PddWw6j++TMhN_Qbw}-H0;mhQJ8@@LU{k>5k>cfYwy30)d>0Y_dR|DfdTnv
z^1IMc$J2bmEYaIN4u8CRl849r<5{EcIAR!fjxOf*R6N!P#9qPB<F$H5>ePy-{&IP;
zzjdNs=<b(ir(XXo%Kdeck*+kA0&pu<DiIo3?!}HnkwoQeoCM}w$Q#dez#77?Fn5Pm
zw1{iZemH)#S|d3b2T^%j9`NIsK}a4eq)rfQ6gkwc6BtB=G*Lt4O*7McYe`ki;_~J_
z3ipxOuAQU2V=$u#Zqf%*&P{IR|1;K}b$Z_z)PQtU6W(W51~{c~$n9KGm3fyxNt_l~
zWsr)X$#n@NaN}D_I%`K%O9(WRHlMwsBPh5i)K;riG-NPyr>BW{Vu}bVnlbp>%dDNF
zb0gXT;2{V6cV7TX_!+KM4%8y3N~*b+e`$-{LW_?d!plC?IU1z)o6}FnB}zz~CX%Mc
zxy<Seg`!oM&&jLVec8WxE9@g46Q+9*@#F^kZ@%`A;_gQ2oFXm#ocQsxF6dlT)Kj=C
z_Iv-*yg>&rVO7UmO#xKnZI<@)<x@-ud?!0exeD+d-ThGgzgR33&0x6$-z4I7QQjs?
z6oiuOz*>N_`y7PIjp;aKuQTQ;eUg#+Hp>j;Za)Aqdcy9?)?@qtRFTCWast2+M7OZB
z<U6c>*-il_hyM9TdAb_x=xD;gC5PJZ9!bn;*lc?kg2=%8FYFJBIX$nRd+P)9u3h~2
zad9v&(dn%)8APc2KS3k^8>jT&U$wC-vQ>aO>pd#i$NuE~{>AP&yl&!uA*g#5=Asr*
zdw}EOTN+;G`DZ_O;2Y`q_*F(-qJJL`Ves(?SbWh+fdT<OqCijwL4Bxv$Goe(J!~7%
znQF=igwyVkp*J;>@Qo27`k(+ppl27P>EFlyzwpa#=6924QTa<v@@ii1-v=^!4{*1C
z^#0)P?RagyikuTa>+jJ)4?8iFf&wzY&8L~k%kLs?ju@!y&JVD4`eS<{2ZAkEBy0cO
zKju5=;deR}CF}ABuq$YddQCaerxEU5Y#n##z;A*-fbDyZ@`t!v2n^5we~qS%dLi}a
zN655yDhTk{H@RitPe`~)v5{-Q6q!eHwxJ`Mg71LDQ9TE)1=tl2YEvTc*Sy|b!#_U?
z{73BHFo*{o3&BQv9l(YdFfBIcKb}iqy!>|%fqRJpom3XgGt*}#62x#295)^mX(^ta
zr!&%x=5;%@DHiyL8g!KCzm{r<M1u1tkpPF6|NT(|-gWlBQPHacMWmx?EDvB<Oeauu
z_!-mddWK`;#QRdS?B)Z~L8bSza7d#(`bl7b7|6R|V_N>l;^m<{VjkcA|IK4Sr1|Pb
zyJ*_QTvye94Yew>y^6~3o?KiuY448E<~=a8q|b)E9t3ahBj^^<5bN0gV}tXECOhqa
z@mrvpB|Pu0Cfxk{0<#}POXcg?TAnZvuEm?ne~|2s2r2{I3v`J2%^e6QFIO;sDPPE{
z|C+^}QG+WjX(ax`#u*?;h%(V@GO_b98(}Taz?;Ka%u@sp5evErJr;Cxex)V0w%n4v
zR8#4!1grTDvL6`O!2<|4qO<-EI;nyrUquJ7x4MfFTh%0btd+L^69_s*Nv1_);n;N^
z#9}W_Urv;Wp+?1x5cH!VC4$iu6RDgbBQ8Zi2&fxW?$5ax>6`vHsbh4|J=Tlhg=;$j
zu@@d{ib@J^>#954z%x`Lo<WxU`0q1JD1mz}kEA7@CaDqu{=tj5<$d`xtDbhBi$(t(
z{GbA*#zIdP#FEH11}ngZ8r%x}sX;utS@F#-8vmLON>_(>%X{bH{u7i}RU6yB0QIcb
z;IY<t-Z4W(pH2w)U~UC?AYLHr;2;78v)q5c(3b2|eSJl(LggG9nNamsziXR+icwjo
zGYKMWKtuq<e@d=vgE_^;OdLE@0GbX){(eMHKlAPGH0W=-gWN!%t^r5I>{SSpem<Y2
zwCA6$5F5R#kP*LvA{%lA{=<D5(*|9$((ytS*Ok@#=fFtL$9-^z1;)+8^O`_4Co&OW
z9dd!^?@fh3PeB;3P8~4b%jQNZih?*2tu^>D>tr~TNq@H&A$p<ojNNyC?^?Rt&4#cj
zD19FZga>Qnq$r5L$h;~6^rmy#<oQiPh$v!uOz$D9l0e<V1LOE7UItyCdaI4gf4U#e
z$NHg!S~ofx3A{QojA>Q4O~(G}Kr&V)P_UT)q{gf0$Rj>o^lz>6M^HK+AttlD+>~)Y
zKCQVyM{Ml?gmsI(<Km^Ndf&>*3V*IZ#Rym%q>|3>D-Vo}6ak<Xb-10rytW4l)dBzn
z&sJE3rON{+xqYjpju7MMXuAMNBBaWFPk$@zd*bY)Dz1;@30R=n-x<7CJAr_PPE7A+
z+Y#mqw;>uDT}^#{jR&Yrpg|5jJYdzl3lJ-AZdJ+Ird(Vu%a1Dx0kZBY<AYXX;4yTJ
z7uaE<64O-s!nCHHTVf?{rkiWz2sv1TfH~d#c$;pMavE<0(45jtj+L{Cc9qn;WWEVc
z^jP%Ofg6!Y_%-1<h^|HtWC}QCmd_R2nx-;x+m7d`Bvf#`p4>H1@^(GZe4K|){>_!h
z_oj0liI3CrpN9Q^usUe2Ke73;t92yXZC0_-VuXcGER=`+NlMZmxiBj6f_Qq$@ODWk
z?QlHnW&-%@Wn2PcH1dt8NhXC4Wx-eCwaT+syY=e`$1yi78Wo~_-%RNhKpeV8k>60M
z<!ETZots%%MW<FLh-)M}F&9m=_DQ*L9Imboj{3UQm_$Y2gG{#}eSX)>Yb7+s_Gy{M
zQ5T`f#v-ytZXU)%sPN<eQ7|~cp7Sn`OsMY_h~jxWO7Qa2#T{V<r70?WI@Z1+i*IPi
zd*Iu<qD3s@Pg`5PQx72+PvJJ_)tegRNF$rNX(>w-U7kOe5jJ%3@dT%C>}qzPWrm>R
z=a9hSkrF`OibJ*znd5z;11IuuXG+H^h2IM4lZ7+zb>vHlo1NIBH326AwaYPfN{!92
z2CN+)t0EH|%v8xXD&(T5*zw5bEOlTqHSu5DVxDTeiW^QO)_m^5Pr)H7sZdd}vG!b|
zAj!q?nwk97BL<MdUG}dy=cy_>y5N^fsJ_hy#ky{bg?iCc^mJIji=-dbfgTo3s`r6R
z)Uh*o%D1z#6Fn|B;vqsaekocM<>F;T2j#0ZdFJog+;?^UyKJ^%z@%ci{$&M2@bs{O
zQ}egCwx%Y}&*OJfU2%<?+%%|d2xfv8{5Bjf&SNBs-pMlBDs&T&Px_J?EpB=xW?`K@
zqYljI5%{`3cdOW}8L9~+%D$6s`$z7xam}H-Th|Y^X56z!u6n5v8?jdw>#?ghkq~yM
z#X82t$)$sr<<ZLt7L1@Ss+L|9<c|d9iMj_570mE+deRcp4Cw4B{8Zd*%(H8bS(}P8
zi%iZ%aH0o}L~ld34-LO8&xBv$LvMde+{*Z$eWCh3N9Y~-vDB!MoEA3SJrpJ|zQeJo
z+C|^>6rA-?xtk$7a&x42;knXNWjDg2-|WFh-^DQ6zX=Ud0>Vs#7XsQ@_-6%lNW?6Q
zyXWC(ZVfR676#`=FP6@=st&$#Hxyio;j#K@z2l(kjP&8c>Rbj(Ho5Vc{QYa|0WPkN
zF>Ws5w;$hv94|?OTtfgI)ZUwKvzv?iwDu%|SPg*BDrQsGXIl^Smb|Mo>OI%FTdL;U
z&TdIKjDHzRXla4cK+>y1dn=nT>B;XvQN?c6gjQTCENxpP6e8rd{>fu(_*VvR@c^~{
z@pqQ8WmTdK=RNF`$;eupHF=({aI9PJv$Zgp59FsTiUCD_&CSn<V>aBKB&B7)v<F$O
zF5qtF<cxFDE06MndZ3Nzr+Lh$@O{TmwG>6)=3G0;lh#z4an)hz#E7u;6+MLo7GT7V
z+|=uLHn>!E&?d*C_f&exZ0V)2^P|&nQWqiDCG6{i9)F^9<C|qGJNzkW^prPj!u_kF
z@NXGy@iDHOp3jg}uD>a3xa-IAdR^~KeUK@7n)Nb+Sy)Ex=7#yAugod8##Vv%d7EX{
zDfMd~R9*NF&2)q;6xrQ*b#ldApLCC4l9e)u-ZY>N3H1>pSoW{(3~^@3>%|kkLn+<b
zfjEtSZ2n|(ocZl&d75N%>We>HKYC4508SfD4NY64AKTRxME|_j=;$a)4J+^v(f>h0
z<*QKEbk5DEVxwOMN+GW-`@cNJYYy90^~Y-ro?&RXAPb6vT!ZkQZz>1ll>mF-J)&+p
z)(Dq4cQ;&q(CSM17yvoya;C}jJF!h}HltFH76f<Xgmv8CguZ+rCt&13IPZHs-&P<P
zxY{U@jYXnVY@dGfTrKute{OQ-t3Ed4Etwz8u-sXgy7Gz*`8Nyr^2GafN&qmqaAo0~
zsgU&8h%a<{<&StH)F1qL70v*}NLiEz-{DwZ$4_3wzQv*MX25(vX>gQcKd)44Mnpy7
z6k$|6L5hq8boi8g0$wHBOL2*84{FD>c(QVPdq0U#BKkxw_a1U!H=HJ)Y7SRCT#idT
znKu~UeSgerw!v!=E&Cw}0O|_tW@bnj3vBwy0*!;xv(jmLR&nB>u7tK60=)7RfP%Y_
zB#+sVdobUOE>}kxHOB1dsgT_G1(F8~;AJHmvF7!5lb$5kmkb*7r#|04e&F&3Gqzat
z<f}zOy~sOa|BCR7qdnI|`%F6KD<Q1(A_i5+dD+g~>!h7Cs7kYA>EIJnZ?->Jo!BcJ
z!cgTit}*LJt@ew6m}Fen(FU<+2%v_2MR$-7AUO#O3BhRe6FfmV_R1x}+2Ma0-5`2f
zx$bDqfqkfAI;lfwGkClZwaholy`wf_Ot0(t)T;e`?e}dxyU66&)-0v*UEPgF^Pg`c
z!DBsL!kpG^?!?r&Iu6Y{`m*Fhqide`;I4xbwZKDhm!z7Vkvx>15%q;s%?4c!g_s9?
zc#ZFj#%q|5H^<%!*R(qXNT$$oprcCPF{j7V@3qH365kGyH}I^jNcOvlFQ>6E2|e@n
zJYC{ta(qkgo}+n-;R$?x7LF$$I7LWM`Av8?Zl`H=f<}YQ)lH7^jMFPrP_nW}W@kif
z4zPMn#k#=A%Jx3nsKIi;D`C*|Z;yZHktseRC|xg0@1}A|oG```NU)L@qHfl%=~)x}
zSq(B8m{&hROOv)s{yi{0y$7umH5Kf4d=P+m2wlkG$q!%%hl%v1G3HodN5=ov21iH#
z9<Hz2lt;rtD6z;~{_G?mLGt$k+!`zfDU1U^%xX`Ayqp8I?}iGikt1TL;o8`-JQGjj
z6V`^<NSopZlE%HQHs|8xv$cfBs`e|D-*-|OZHAI$c>SL0Y%R{;qB!{yM`Hv0mVy?_
zPc0GHv@B{zIb|q#*tyKO(X71}flrdj&wmbk-(wbr4tj#_olq6}4_@~-Uy@+O>)l>U
zmspqBjJJ3`3JHm>na-Son+kA>Jf0wZ05)?=cFCGCc+g*S$=h$fwy#(Rn?^YN(%&ZS
z?~-1vtPb0(X`la~UCH1_@{;BDA=|*TOkS8<FleeI2Vxs1WY8f6rsNS_+j`wTQAJ&`
zU<2L!an!Yplf>gqit&)}&Dp|FmXv)?>{*qEo0A^QAMzW$!#Ga*T?56`u7&-M>bw<G
z)}^ngVp~)s>-GXKorfc@hH_LvxsvF9sT3WQyn=)K{&*Z=m$@RT+BoLP@&}Vj5~o6M
z`IGxkifxW7OwaezcX*F){89*r9q^o~&?gW++zd<T$hVCb{zl{7C-B@>wJQ;vP2tC9
zzJjNmFC9il@v-6V@oMEx1c{F`3{LLPCcG}H9j_llMl=OUc`u?@nD3nh+hu6bLDP(~
zO2i(|6pcj4p2m=e-m}_G&$^KudY5L*cf75vfh2Zvc~IrPDv<j<>-Lbw%WG|$h>Yx|
zwwNeAYuOL%>zm!}pwCDMk26n1Ac}J44g4t|&&<yaQzlF2wIeuI-rTgIloR%EI1~IQ
z<&;gmg5FH(dEO9}e7~d-<8>nkLb>fd$6iK!B*ut;1q3!@m9?WyBuS$?rzZu**IM+E
zupfowY_REEwW)`+loU&@y5zj*%H{i|CjPfxR56XsS;?+eRs~06M?J-h0qt(<DVI+!
z8?8R^^B#;^+uyCQ+<bPiT4Ge8r2AtC)gz!y8-$XtOb^vetxr_BwhqG#ZmD$*OB<Bm
z-Fk52?5*ja=9YxHh%!;!`6b#C*fRecA7{hOKr$#Kq`zBcU?XYwRDGld<z+dl>~tJL
z8yiWvbGV{?Z}X{H1Rm?sQmNzqb^Te(=YF(_+gYNlnbxy2-`OUvyy4MAmB!D^pQY$y
z$QEX-^?JdMMO^~Go+>=NVky(#OGCTN7GbJXxngB|_(GBFM8LvSuuI-T;#!>?2P<i$
z_BPS00Q=Y;td;A3(Gz;2dYh7SS+sdU6FkV+{{(AmmM8UQuX)b~$YqZ@f=s>wrV?ve
z9(QdN6d#B;1)`tikt{aE0{zN|(zwKn!&b2GewyN)S-PDp9oy{8C`(#yR2DbX865{1
zx`~BR;#ueJ=X(2d7=Pj}R<mxM{CGwHZF0AouXzo06zrgd|F1^^u7^l?oAsi<oJ7{8
ztK!~U)h`V=c@o#lYWEL~O>|x<PXB-LY!}8U1Xv;(+S05NTaO=fpd=8@MLyp>(Nex1
z6F{wDRe4tNg0}GqdK^y($wp$4L>{9FxeAb^Y@~)Q76F!(WO?;p(XP#}xm4G0yyZZe
z`}k&2%&#(q0LF9si&3IrX79V&j!2`sM8XcY7MwF3_trH4GiqRCY4oOq;+4aKzL)9I
zoh+=Q>SL(KylZO;F>J1Dy}apkM$XGO-rn~S;t78Mk_2_+zK8HzgziZ<f21*HsLnc+
zx-IH7_9vx_Q}SRQN8J@&TVwE!P(|uz%oDBA5YdmttVMD-v`jRGLIn&jbATJBMq{w*
z4J6c1lfbmyi_=MfqJLiH)~R2<>PM7F!J*6py-l9-*WSD#vT~pnyS30r!RE92zzZmR
zZx~$}{?!72-Zyy_UYaktg}`0g{feWk#5uOb*$?!&zpgjVQn>qJR<{!5gv<8U)A5<#
zt4CjrTJ8=|t-*8qPQP)mR~@q$x*K8rs-7P7^=G>tNm$|z#pHh-P=a8mSRQi9$srGT
zu#zl?$PQ-s?&W{*P=P#$4;ae79z*NfAaFoKlEHX5ya?^=17hZ<ejlQR`SzqT(oeHZ
zV$L~$UhhvSqe?;Hh=9}@O9>$n9t&oakHk-z?d(UX9XT~$1l&DWTJCDH%SH0qTZnnc
z_DxTuvapH1RO@A5^>K~82^};L9TE*Ey?_LDP{;v1Wrh^i*iFF1&PKf6xc~BW+haVE
z3Kou^Om%wBCH7)~t{e7dOscIAbvQ8tzvD3>6I<FNts-Kv;3u}@NBy}kQi}p@L9LyR
z4HQGl13sv{wXrt@B4hiX2+E>hHF=|5#A`xN67a}ZGf0D#rf@wBcGWs8R69_>2y#b4
zMkDBzNam0;^s3sCnvZXcNb7FmlKaKo4YH%d-tDp)%FyFc>THp~_dN37mml3;DbOf)
zwi1gm@#mhXuz*S$_S=xo4=dJg29=+G<&^+pt^|PBKXsE0O3~MtRd$xLuGR+vm*MiF
zly%MS?V5|vO@A+X2C8NWFS%|d!${mwc#83Jbma+vA%^AjQk6DpKS$zt&jShfJ^q>(
z7m9Z8zRIOk?sbZ9fn20rm}88G9?=GTv`R<cH5s{adI-q!MY_ahy4kFmG$!f6f$TyJ
z2&_o37Y&3*eV-{ZH3r&hwRuX3$-$)UGI!HSe4CS5ICMtK{J&p+MBWy*E?5hEI~yY-
z7o9(~X!ux#Fus%pYaPBp$dQ1I40zYOJ9khWB&ll!lhH(Z0zMWiM%Oi+|41jIz;{F$
zFhxe6PzjJ%)=epYA{5^`Wq<UDxzMU@1I&x6-~`u?fXTY{Ef8nkx3bMaZ%%b;>*X57
z${JM5aXURgwnAt7c^7FBglZoi>HBz`F_LQ$%3O{P9YchVGw!KUWb3qge&ch5UpgzQ
zD)SE!KSf2Z#urSeE%LhVWB*tT$ID}E63i^}<a7AS^vDL-ek@g954qz*vA6thtHa2H
z!$!{xn(r#9F1!M*=%;Uf?SS0Gm-Aac5w~@QeOO1~Ii>w&N}D9!+dzN=u{DBX-q7#M
zoZ#-3#1BCGHwPG7iC9}Cj>HQ1)e6>JUS!t(m<~|f@O06O^WMRT&8~{JUngK>^HSeF
zJ8AF&^@34Iz;eip0-ST}G-)@d8|TaBjmE+_k-(0SEXcyjwK%(!Z%xf|KC@cj#!!yM
zU3fSZc=9e$qNe~>wo7!f7z5RfZhuy%Y;-WzS~D4D)LA^Ry<##|;y{Foj4(m;*kh@4
zP7|)Jn-uGUGUP^>0YHo`V;>c?!vG`gZ#3B{EDjHKTV%5}j@B(_)o+OnJ=uBOJZ`v+
zx!njlP1D%IY_5t+@mN|+mt67C-vZV=pzSRM>aWM9*Eh#i>t~b~JF$My!L*Yl-iD{I
z`otVrKWpS?42H1r)3;e?JnWyRN5!Q2N;+N_;k{lu@n}!=eH^<aoK#`z;`0s@ET!M1
z<-2T!M$86@fOqZ7OoEeF-T3`%EIIbGwb=<Uj093DHr2Xyqb|&mB=wUIw8GB3$@-5T
zj~l%fG2Kc&9>OMOdIH$#_UsP&b%Gzq>{m{Rz1?M8Yf%=?Rcb)Ri&I4!(~d748Cdr+
zz43cRJUZxAUwDj<1}UEo8#SFg;wlWGuL4@#_UHNq?hq*Uj~xzo4IgC-a&N8VPoDei
zW^*U&qk${dOnb^7@K{)N(*$C2?PvK5#EsIldiblIdK}3O!2-hsKu1Hc&Ut7CwV$Q`
z$pgK5my4LH)qUcMC$|S8ltl(!3(F3I_m4Ait$xN4E*RGV|8ei5;Hhk0bSE1jNH}Cb
z#<Up8of!J-%pmJp66_t__F_x95>PPj0m3gDOuA{)+Xtxm^y-HCta65O$K<jx5BQ1w
zu6`zFeJy|f1-$g*jMC&u0a9a;z{-LUW5%A}L1)9?7<+0X)ha0X!y$7ak9A)EVuyVM
zt;7vl(J9|~kb`8We&liDp@Vg-h`#R(MekLnzBOzC-wiRBh{^n>yY>2L#zdvBTI#$j
ze5WV!emz)AEPZ*yLuD`34kDjB?3FwPn(5~??j%s<+rw2B{rwr-2^OxjZtOj{yW|fF
z^e13{BO5Q-u8hYS)#h>8nrFgs#+LyVVU#nv;X0>!rXAxIM6C|fSmyI007iGjj63g2
zGySO^Lkj1SE6mC5lvv`W;G8K+iOF3F<v*WQxSf`(CY4JUfIWc@NKM&%fHI#@{PAQL
zA3@Aqdrg;htq;_2<oTE07U`aLjCTvyY@oj&#_ttNUZE80V;5C#E-AN1rKf2~m4$^E
zvqeFGOnJJ_FNWwo%&<WjOMFg&nJxY61`QsoCMu2`ixL?A%-0SsysycKAVXseHfTu)
zY_`K3>*1KXZP=T_!GKseF2O6P$9M{q5>C)2rEsE~^bm}_?_Kul9bd=;hyl4ajOsbX
zkx4L_^YY=m5UIrQMl?xRU;rY5UCD(Yj-jc>_xw38zj4cdMOFQL7R(>149{*VlDaU$
z1)sVGvbGbVmkrF~owFW}6!oqEGgr<`$(b%i{ryeVt?xC=*Ouz{R-lh@5c2{y<x+VF
zSKN@cwJ+(LhMPj<qZYwTdoA^+8lQq;rM4FHp&CBC!!-MMg@GTl!TWOE15qLIk1o+=
za|c3Tv`DCm0~{Fb@k#NLwTtNO=6B4AFp!Tyo{>TU=T>kAw_RLs&jYB_;=~Vjf^=Kw
zUOiL1O>@qX4i9agG;>4r^<CPVPlDyumuU&VTW94zGT(lhYK~#>jlnqw9z^VOfda}c
z`BaN<Kh{)&4Y~s&n?FMe6r#=+4qW01!@~a(b+qVxCf36?Az|e6UCgUv4%_=pCU1<Y
zrq~sz80FJDx8zH+Hnf&n5X=kX1<B4zb~tZ><?y!{cSy+eiOH2py>DUvsDjJ2I~<>c
zm<s_^_AIOKC4XWc&-rfj4eO_e7HP<<jE7Xj#HG<?&ZwwQ8P$E3a`9N3MFfg8P-Z{v
zvR|Pf82}%w3RzN9RCK{~Nf+A+JdP`;p%%WX%`O$>-ija#x2-|uhL-VTO(bEh_&owf
zaNRk2_gvMXG6>dBgHE$4-VZ?-7E;-0ftBk6UF>GQ<N9COriub^!8Esn*N=@By$tr)
zL5$^|JLX>JQOTP>Q{S1#-SouzJ@hd{TYOdZBf#EEXW=;@i@KXjIGs2i&M?jXnAH#k
z7f3~o9Ih~(QMhib&QHITDo^R7d?^$Qa?)?}`>|4z!pMLET#in@M4M-H$g1_BEEzCd
z7tj7|pI%yc30i=gruq&JG!&Kx3BhMaAd>zZmj#|K2~OD=O5u9FHgtIl4xKWDS)KIY
zMqw5+r57{Nve)e?q2<q*M`_uq!0h<O2UBc^7st|Ahuj=k*cf~0)8E@o$YqS#u~v5(
zel^rEl)}gF!cphfyL*%M`|EG7S9cdeJn9Gb{KWl!t~Q^(8a~gw?6`Irew8UpMD(+%
zg?d#qA|e8)4KVe~O_9zoE*khmfx?H^cI;6*H4t-`)NI%ueyW!>Pb`<3*Z=ypMOW2O
zts;bD3zTDXOFi2VXPQ9K-`BtBu9C89?e*ieoqpu<jnO~?UyLJe=zV42T)}tO!f%aZ
zl_TnxZ~Ki_^s;#maH=|9ykEW#DlXvkr-nUlSIo^XfTU=US8AwKgIcS+c9ClPig;5L
zeuB8j7qo5OjSgZJiR72Og=BfpzD`e9ynIm(zmiM*g|SD((S>n4GIS_7q1I*y2kp{f
zW8>rYLtekW*K1kIU0q+>E;PO3b(rSVueM9<9V8+qMp$m!%zU=$IIpV{jC}Kk!J8ZE
zGqf?9$4o=h&Ks7Ml||~05N;caPp|d%J|X9MhF#&v#l^LJxzZCWaNfTDb9HqTRH!(*
zS56naw%O9eeH+TFtw%Deo(+*(>OAxrcxFiwi9PVc*o?PM05$6Mfw>?abvWcZDu@&f
zbk2f1oOgM#vnQnz3&>E6A4sCi;&M8wlPyze=8a5Yax2deK7Z>(I1xC@_sQW6uI+bC
z4|w#Cx0;VZKXK>LSCjNTO+2_^y(T&;F|yBK3YUxzTbHVjkEqIfL5=V`;+FNPd{(B0
znOzpYQ&<%fR!R+O-)L%Tc6#@7vu9d>(qfhKk~AhRE=eu}E9;;o$=pyb3lEQ0cy?D5
ziB^$nhC15X&j;6s-;gi%KYekt&YE<S=U~lUviwfEV2XGp#LjhC$a0U$C9GO)U-xTs
zz-j$W`~#QLQ5M6yuYYw6Bn%E6=)4&{UN(#qGjr*<71(!oY7N9+S+&V3&?VzEy|cQ$
z9(B)K>7K+<rRUojBB5?j*yuX7nv{8_XKrEf!KBrXAE;5+ek_m^i@fkF*f+zk1nM>|
ze%WUMbpoM|?}8L(yWFMWx{);&3#|z+jo<{`(BQ74HY)yyGLXE0J2aI+>7Y*A=81}_
zcxYp=jLUm1!LzwB^Vn{jH9AS{EUY)X3e#D&HR^!rQ;&t7-SN@5T9jr9kj(2lROv+C
zdHy!p-0I}l%uxpxN6KfKUj?kApXK4bFW427lI-r@yO;i%#(t`l&+4_VXbgoxb(2O?
zF>|FH9(1?<mfg~rgp7FMHGP8!YLs_wfZnm(om5D(EYS@}nNO8|n5(9JxczB9tT#S<
z5JzLgBu*c=`wJK~?3!*#r5)}u)2?vm58#cT25L8=CRmxK^E+}U>U>*^do?N3V%*|W
zFT(?^E+OrvW#Z*c0LJZ`GuBy<X3%VH`6{LUy1#`u9CA8ewn=tQ`{l4L8@-{~0PB=2
zC{;?55xh7zf+uxI$a2(gJvXWOo_`JQfcN@+XX4;H&fH&MG|oI$E--5H(oq3N)5d}K
zIuZT!!sl>(d7`AJR#U9Zi-<ydW<Od+1U11tq@?B<naNBgZTh;=Xk~|Va90$o*gJlv
z^o<#knaYl3*_rhYE7Q*yROVgHr|b35S0HpOc0L|+G)ixrA|1SsOb#jpxd(STeDF9i
z11t3yZNFuPOiXZuXHp$LtA1|M>{rmgWrW|ZVZQFUD~4hFw6@iG_`;mnQLsEv)mT))
z!o2(Im;@^yrq|G=Z3}tIs|cN!_YZ}>i*)n=h2AH4!z%n++n~;NJkHs7kB*qLL-kU$
zLc;=h;h<ucxbI`So89@w3i1@Jy|t<V#MtmXs`3Jj0Ob@;skI3}U*s?{rUy8u3RTru
zT-pAVqaZT!MdZ#tHBN+A@6Ts;&*Jfz`pD!zl>cm){{5K0ck1-SMexmFlX9HZE4Lqc
z<__#+N(0J-myOOdy0QC|_p=C58Zra;g1V1kW^yI?Pnr{;+^n(KwrbZRVRl14(^$wK
z0gad&`A5hSn1=pPWl_n5>LR!w+W$dH%%q{{H{H+GO_e4%XH-IVXijV7yXQp2Unf_o
z$IA+%a9C<77Uk$JVzV#3=Q$j7Pgb~TOogj|{d|$mnPY|Af2}e&viA8?52bf>T}3my
z$k%jh(}drqBZLE7V*_N?>_5XPlX^nk^Zhc?HoMr)kdWCCXY6rLq@aTj2!?!MT|2&J
zVIOg+c2>NuoyEe!QY>SGYj?Xnd=TTCHY*HQ8uov-$s^sie{hbKHJ<(EwIMeL1Hdcl
zRDt80LSS+kcO!DeDQI*jNN9BPpCL-@Z|*ywAfXVRF)Z;2`z_r`OoHg-{4f}a&5ZC1
z33_0ghbFoyO(0tx&3%r?N3UpU_|wk9EO1(KxUE*mPyjFR=kFQXFWm0Bj9c?LYcaMs
z!KkG{0SE>W-Vyu`)QAmLOpUI364DYMhtQw@+|kY|&J9xZgRtXlUyf7lrl{VCBbD-h
z8vae8Dq>haJ00P8)Rn-|=}9l3sQln*=-CQQ;qY6oJLts;ZGEobPKQU=M#a{briuC(
zm6DQ1;64)&TwQQjlBrw(4>Z|zd{fa_*l18(X>;a7LaKk<MR3oU?>yzy-7=~-SCUu)
z>_oJMGEw*4emLC=HmMJ(|GBqahDEi63Qmxq56rK!M|>N&dx~PSQsqBd?jR|F8?fSc
zT!KXL@zGl?&&0Gdw2xyo4W!lEKiM0aS9Z+9IZk|}_MALhKRdt&OdHD9eP5E1PXXaf
zad2BirA`-%nZHl*gO^d*ni1NZD5w((08D4N1ZsmTQd7eu-_ctD*#xik(L<@#6*elZ
z#;@+uZJu79K|}!CpkX|ea7|3|dzq5?U^JtlCd72q6y5A|6hL`(=)8r0&QFuaPr1q3
ztUB(53BP?2uqG~^TzEfgt2l=XoKYEoh4E0OFE_SDNRd#^t!NnkVt}X-kG^n>3(%?*
z_ee?sIlYm7=d^0y&f<FRnB>jP+Wcbp?W&!{;pIi)ojpm(In+1rhx1n-ycu<+^Hwi%
z-eDupb-XAy#sc$Fg-1UPd|2-w!|-~0hd{;@I&bOA)ys+vNhcnA%Pvza?}-bQYi9=k
zqm<$8+xH4teje``qJODU7|4{@rAe%534md|?724yh7ll{flfq3^7Z!m^7iqblCcIQ
zh1Vq>pM8+Z<`yc1<TVh~Jrquqg7Py)QYPImnW&#BA^hI`mf93h%#pH>1%dA64(gHA
zkHJKqi5fkFrNJ(H65FqXQoQ-U@ih2PEC=6Bv^55bKMWzE&elLaU@ZH(F7aqI7+<W|
zNSE*(NpczS*O<>QFtKd&HAYPN(Wlh_9QSjtBLEd?der#%cpIP;ssaaRC@L%GL!hv)
z;4rw}sVN<L;*aCeomdft-@3*9mt4($MjR0m`7;<N#Dv@p{V?vVdly-l!I^p!v*dg;
zzqkBx4V;Ko>!u<jx3M-`KJ00d`!YB$1fj^&tXhJiZzO<+SwX&B!lfc`(yZU<<d57T
zQrb4r=RjNcOToLv>rn}g1J7yqsC=)}>cZUqvo1Zn_-Ck1o6}E&tc9~{Np%#YFNn(-
z_AYUv7pJ!kXNbr?>s(yS0%v*1e+k9O)BXh0P*=x;{0Hia_=~y<(>f#1qAYRN)xcRH
z(MwB9X5=RGmWEFAE#sHU(3s}y<GCYHj)IVpus`rF-jgX6K<5bx2t@xS<`*&PB%y*o
zbiKKe%KFh{B&twsCOPfi1z9+<;awzJ0JQERz8~5)b9x4bP*|y<f<<?9j*u&hfb@GV
zi_kM+F)^bA&o1CS1^W1Hhtl|#uebW!)<&|N8j^anGbOx^Y=D-&0#8H`PFK!jThv=u
zg>9oSg6$_~c(mnj%!fgm<t09e6I=<VhLr#Wbfv{z#e(tm$`4iW_f5^Bn>SMUZcew(
zQB%vPcwY&@q7#!PYzYXsk6vDEszF=H%x&M%@w!#w`FBAYPRk^E;M#q0yzLRCYv%I%
zSLFz1T%KrF8Sef248w3%!@9S*xw&qVL%!^T7v@PD-ZNf4&=PN3ikM##nxtCB8mgI;
znY%pLJg)=fFn&FGQslI(2_jx`T@^f%WC+>Ewws6P?zoMOSxpA`gnprh4S+$vmyt{g
z>_dCS40|?`slw5;AEe;3|BKa_mX6LI0tGH^rRGf54hhSl0|U+z8Il^d_>d$bP026)
zVzdn{6Nw!`9m=0#WaVjIYkTyQwxgqZjwJ4cjWMrE-+$%(N?oH*rCoDm?wv8kRF-s_
z`2il?cdY%2cu<<zMFpD$ZG6rVc<<CeGDodYCHKp%r*SS^BbiLzfCzq1c=Nr(P^;T&
zVfs}e>%bMx?~s7asnRT0hVEkOY(ivk@TnV<(7O|g*2g`XWtzTD94z%3a;J;LQl~f$
zd4wEGXz02?bYq^1KMc0w&NN7WKnlgT$_`}NlMl{hDZg9-bzO{{WAiC;V*M_jBt#qa
z)k`N!H2iAl<03@2Nx8FE@nYjC!}UY|Hx0E|p}M2atY!^6VB#FCL!pR?dlJxvxtIJ0
zXxLtz9TbXbZ8eamILyjF>xw|Cda-fzX|vGR(EZVF_9#_!sl&vcXiE2@*h0UCGdV)p
z7!a@ksuvr7B$&K%ZB5p)7HeM&MKHkjNzT&HJ>$FV?bWzM7t@1ff$(c1-Oeh<$;sh3
z7qY*<n*@H>M#!t20+siPWReB_qetJ(#jG_by?=3mb70xrv!_fQC>#$zQzb_f#Orm6
zl3hO<qB5u_s^*5SYzT2t{=G^Ah~~vm%5pT+t;eQ6c049Fy$s=g$lmUbI<0Z4<@?UF
zW?T3RGSOE(u{Tc|)pq!I_6|4N<TE(wLjRsI3%>bq2;XBQ{(ykj=;gXImD^JHVnWR(
z<iOPy<2AY>U$LHKEvOl&ITQr$+|zU@(mgm)f*R+x8=+z0uYmklv)@h$76SMq0>(0p
zgp(W)pbws{n2-BS1(tb%`x__U<0M`7)Y~0zd#abXd+h8##7up*&IK9JN&je!CEE(X
zOEHXm@GdaG75t`Pa#^E1Xp>+^UWKd{`Wp2Q4D_8cn~+bqyzQ;K^6TAW78U&75a<kO
zA;e3V1HV!yhRO-V$_P5wh4q^tsF(X{EDd5>8`NpsI;mZ$V87tIW$``x5|-=0D$Fw5
z66o^xRMdcR#Qi9^815iVfyn1VVec`BTCps+bt|$DoRdAPD=v(WZKvKFnL8UxlMOr)
zdBY=zI0h)N0dP4Vpi+jo$SjDhbFQgiJ5e}<QIej(yFU0VEWBM}{)Ab@i0fO`*fiE@
z^N;rmIHDiP1*}%DGin@Wq-DbH7l1@y^J3F&f%h~<U;$6u=VZp(+;u)Xo4RP;wqKBe
zfnj!NDD@QOWaowcnUOGOXQYyg1vj2EJ9uB~hc8b-mt1MYoxPO~D~t8d!=q5#R$7MZ
zOAmj>#fz3)2e{UNYAM&_qDsNvOB2SHKyQkVd+uYS4d<K!>dbLqM7gn3yEqxGTOsgl
z(hw-vap;e;z$t(?r0vpp<!K<3d@JUCMcWy9*>SQtsn(_0$7*i;Y6If6o4Fp$#q^+3
zjA6|@Bt+WF%d2Dtdzf4~l{+Mf&47Wyu>M7XC)4_CswWoa=ABbb6~92T>zwlO18Ci*
zFP^?L{p%qgFuvq<T~j9KcOV64@G4qTTFNbh-A}>bpz=H2IE&zrkkM!|9y>Q)C{$_s
zGjJdQF4*MY?9#D1mlY;K!IWo1X;uU{Yq-PJGecAI^74eSVu0b`QU!-_F$;XtzMvLz
zb`KYr)E>6SF|kc=ZIuAs)Mc1dl<7UD&lOKjEMW;NgPCFm&U~#@g6!a6<$_Ex@3H37
z1trjNMZA7c4Gv&Ex;|Zu^6b~WytshX-<$3RX|5gDyz6A7h`bE&)D}-o3DKtk9P3hb
zCa=dfm!$|)Y<g?cUy7X}mM~UU5cRo&#whG7VJ$eqlTO<q<Zvk=<guk?zJlk3CBH=5
z=dVA)V15DqJJnM*z*<|{5FD|UO3ZHf1Y}O>?DD!4;g=uJ(r}464h{~azm}Vl@!2JK
za`5xR2BACzPA%t!g0VbMQT`DcSs6#cbDA{V8Wl`DKiyK$?Nm_k&CcVcc}S0i_bW<2
zJOL6KZjt==Q~E7q&zX@E#kstnb=>mojpoUZgX5Y%oms1prDzIra<J=J1onmz>GXRl
z`p@Vv!#tz6e!V@tgC*?e4^A;Fth49SDqM~&9{{EwE<!Jq(UJe0-z{2WM+zJra5U<^
zg?_OOlkHxO3yf7C2uNBER>)G$rO5~j|I9Umo2R;M<djGRMM1;PzPh^7uOuE5F3{D`
zhx>3Q`kSqXjn^)CMS<2OW7)SU)(`TZEOVWi(qs>E?wg!gofI-Ca(|+|8$5VNuOALK
zs2x6%G|HI&76I{lYmHCCBds{vbHaT0;iVmx$w^~j#n9bYBJO_dHznpFzDZ$YvEaDr
z)W^)NWzmhAlFUMtDH@cD8jrddv0$t3OIx?OEQ~<Znh2pRy^EBHul`O~L9stuuhK7H
zHj1(^n_43I?QH#T))HNOHK%62=t8wc<(2N^oFAqV$#YAr)-<s9vXd1n#(mAw(3-Mh
zL&sld{J{5?;GD1c3i~JV&-m7?Rtv_7X`9apo0~;h#CkZx=DOqPrK~jZR^p#6pF{)<
z<kfk+9!bW%{+5`jP(jN>@Yx}phtu$R();(y?;Stv&`dQc4-i*$6sRWsg1s3rmrZKy
z+tyVt(W{hevdo$>9-ehR`9j>XwyGIF1(=t+@~I)3nCJ#wkxj4*wo1XZRDN-_r1{h+
z2pNxSMQ)S8nU@|d=%ucpy3dya4#SNV?7+gqL!Ed8`;H&K)d{@3A9$oJCkTND3;JgD
zI<v_$-b;B~%9r-?>yP2rD&8%1gLe{@pU#<#m2hdC-)Z%~y<zc>NS;cU7@T|r14qG$
zYsm%OeRr6XK{dgaSUeN2r|~RMu#$FQHbGp+x|Y>N^JF{)i^<Bpm$GFo6|!nCZw0eE
z)Y7YY#$2hHp}XXgs7GT7gP#-GZa)l%ICf!821%A6hL?~Ek!bbewdzOHuW^Vi_h0QF
z<$b2SNA3$us3Gg8n}l*oNmtSs7$lzzzgWal0*%N`xfzA+w~syl4_$v57FG9#jl)WZ
z0@7Uy0z*h62uO)^4+GMj5+WTU(j`bqOUKaN9g<3S3DVvDuDS2~_dNgS!+RX_f#YCi
z@3pVJ*45{ENu718nlW&4`Vq4g%qbb4ZlP>VSD+SY9Y2$j@>hmJABK}vB=Xsb$oz?!
z`kwW_UVt9ltmI_+MBeT9hpE~KETCk&w-5;8rK<h!2d{QnIe!7i)<WV2ZPf86@Y&9k
z(tRO={qZr6S9!k=<7OU-Rpq1-?P-4XqAY(j0PasuFV3pPdLLcl`D^Wwf4LK!Z*~>w
zVLAVsGkEVE&ifP1vtLXe(1MD0e5Vx{%K<J!sR`%sUOoJwJWnv+F5_N;Z&|Kk+RXZb
z#lzM_^pSqQ4&``7#y~U^3Gb2{d{?XN85A6>_nR8x!y#ziOfY~nlDg*nf=+8dpAIc6
zw^YN=&eF*y<KDy1SgM-j8=b4`uwupiX2igInutgL{rjZl(W;%ra(f_?K<y7aBCyGc
zKbsFFr!ff&#}l)XDjpt^Sg|1+m*Eps#H_3^DyNCC`O{)yACovA3dFV~?`LQf;*2!9
z%_@k$VXGnS4AG`vh6(XKw;^8f*QBr}nTdeP>(DVyeXsnMky$YDN66XiJj^V0t<<cG
zaV_MXO%*FLK{8>X?@yxgRf$4|GI~rVO=2~Xxrs4I=CfR#{2f4=Nn%&_dMVI*tq+Qz
zO0rmrza<!-9-O9H3(?<ixfj`;Z>X6WZ#BUr4JDl}p)V=1B`V*_7^*&KX7z;YHP!dY
zzPk~YhND48L*DZip>>z7`jnT*FvDWWn3z%OoFc#5GgDr--oZxY{-i2BG^_FlHju5-
zo*g4E`4e$x2rou9EI2&;g{c8dUh)l^YKwPK!AZJ(oD|mgfdQmYpl_qTlM*wqW~BOf
z<0&MbR55>R|15hsL!PATfYTWQVQO%RNd8P|wK6G5dU%yMx#<^9lfcEU7O3>G#35mx
z-gkz)g-vg#n*jbKte8)!T>Y%Sb_Q)A7m-%q3POfIco>MMTnJmnXCubsHov32Ssi#|
z+w@EoZtvIlN+~2ZDCjk393iEwp<y^|8O?L3{o-nZfDF(fL<&!IJaaXX0WU@3z04z3
zX(X~bvPuvga`t5+(-7Ua9Q?!{`yqu+XXO6nJnzq=ty-P$3NLEj)};jq!8OcY53I*~
z`1kG?YQSMD{ewp!Sz7e5gu;3%iN79FqGHxzMc$uW^-|y3ruF3&NH=A)B(y(8CQz<`
zMH!YcS{tTnsWcZ`n`H}@eI5w$73Cp!x;;)w(~JwJT9gg-ZVB4k^o~3bue%RLoB#Y1
zk=9UV0}jp{DQ)^wBr77w+_PZ@ojGG8xnZopfC^em%W0f#t$amzy1A4z4U%7-s$=Gt
zEsseOJ?Ta~G3r&iGw1KF`;uFW#Vu_Xt-8P|6$XylZ)5f4Z-$t88gTp9t6&>cRhb&h
z-RS9V!gQg?g)(p^O=OSz+vQ4^{g-ewvni!$XR7rbEOT9iv%lJzc6a%_Or0wp5tLg_
zzJ!7C?FMhbTM2k1lso}>$QvA6|Dw3qJe&Q`v^yJzFMKDo?9|;nB@)fUJZgNuHgFUt
zDNa@-!TqZu$1ApEHdf}Wn+#8^L(SolxvOxbSD@`X5Bp(IZ2hl}Dge_#(#D6dVz`nm
zZ{e`_*E=%k@4Vg*QJ~5eh`w%RI@ecG3j*b0!pF9=<%hrCxbN&os;KufMSXO$oAa1)
z#+dK}Ihi=HbKgr~_k_KDEoamfbeLZ_3|QM4g0=@S5A@g@XQob`jCQ>%bScXDQh}MV
z@891IyzvMBgfz9W;J5D%jUDmqS;1@QIZ~em-5pk;L3cZsms7*yjrNOx+Lxc&t0UuE
z+K{&0A!Ty9Ez<A+dA=>WK~oNJrY!_LUr?hIAf$dy^{^~s|Ds^9A!CHTkP9N0dl$Ip
ze&byA9oK_Waw&Jb!J_@<IVG32n<cgG+?kLS=LNwLd~%A;*a+_yGz0wh30wZ*3(WI|
z&=elzDxw71WL$Q%w7)-Aa9KKw<ZE|-TG7!d+uf|WxfONJRC+B(IC5`ifQtkLu6!95
zfg;jFTTp!b{U&**3P6AL9BYTZgFqu$X7bipNEU7nT^sAeD`0{!;+CL|8QP$gL-ue>
z7+JwDBohptVZad4grK6fFaYxwMvc}0J}R(=%uZQT=$cmn69*mc@D<_It(1x8iPyHk
zfKU)o;E&GNv`gM#Z|p_-a<hSWf>Afj76HES_-Xk^P&$an6e{H&z7xW?Qi28n?-37m
z3c$HQ0I@>*m4ynhA7}e=)@p(KG(V)IgT`nPeS?WPOD*z8AOiw02U__@s7QN^0MHrO
zjJY#irMrmJE;I<9^|wy14OeZkk(7xB6eTJ!ki^aPT1D$n<H!n6a*ZD=h~>R<po7+i
zZW%Luw-A|8mn&yrk09fxfshD4Imuoi-e&Dn9K=Ib4DHp25b51QjPJL{;P<nHzjlXX
zF3Qk9UP++p3SB+aojxbQ+C0}R6C}mK%L_&%0UqQ1dIBDh3ble<6Yzsl=@+@@GL%I-
z{^enVaiy8HoDrvpe3Rd9zT_D6H08UzxTqz%uiCNZ`LO4dcyyy4Vlz8bRGpxtrwJ(P
zQVAgij`-bqi14GJ1NqPERz4uh>cf$lX*`H_XaeVsKP=xPnGU)&g!gnK9(>E&7<>2;
zqIqReED-kF#j|QFrJ=L$&hJ{%EK4P`yK+Zg&cgl#?`mnDf$$g4r;v~kK&8oTIX**#
zv>gv=`QhDk{Z05gQS;x+`0ml*EaRM)o?f0^7n#&oMWpeO{xt0A2T)s!&I6UsYGJN3
zy2D$}$Z&#b3XzM%zdzVEntU1|dMzjI{U^ERj0rZol;g2+jWuD#X8OFkB`5t<=NMd&
zz4VBev0&HPi+=hPf!NDT3FEZ@39^4-H7?{5LPU&0(^vrm)jw=cdGGfj7gr-|q2kXd
zg&n@=r5zXGJ@lMXMe8Pu6m7YArI31%fydD2z<+x|m7O9A`KxC3#x;U}!99E-StMS&
z8iN~?kXiP^>q7$)5|V<cL0?JTvz@}n+h68)GKGK-<D%S?j0dSjfBiZaEXav`N`D><
z^!i6=LS23B+51W5AenVEGxl9vy%!!hQ2uDcgW_~!W|Xn4oh*9m?^j`tBVp5f?9hZJ
zbmt^@Lld-(wfiK+{kvN>BO#b86RM)EQP=!AYG+8p(@&RCT5ZA)kOUFYai#%%MaI6t
z7HAy`Au{!AB!qA%xNDg(oA7;6>BndD=nP?9kEZ*Utu5<YW_Zk>ga2aa%gtqMum=4=
zw$A>LTT4h#fehT9PfE+3vA=h&3In|P2oX5>M^q!JOkclgT4gG*1-%wY{@cq#DMnJ?
zPrqv6eNa)J9FVnz1e9T5;b8q3tK>ep$a~%;tM^ZljVosa=lfy40-UL&(DIe$JO_xV
z>BHTuz>+_EAfq?|$cdD6o1~f4V%u1h%N`*l`Sk1Haq)(h;d1MW6yH(*8+X$)zY6+t
zbN{Z;oexo_25|sNM_yhMK!W{x7_5-hzKb1fU}wV)DcW>J@YhyYXeM0TtV`t?XT(#?
zS~a-m*=5TY$fD<YtmQZxd%WX>l|ea*{GLBO#evo*CW@t4;1Z2D4rt=3nL$mSdV7jD
z!Z4N&%23pp$@*F;-D-?j*$|r6Xv}~cW9&6h_Y9E2PmBsziDrZKN$nj;pg2weXv;(h
zsph*k57+8?!n72)&F0pkFDVfmewlBLD5df3b73m|IS~=7`PF60XgSqEq{Co5;GZr^
z>TLx2<YSvZtSo|H2<f3UhJ_Y90o0uC63tcMhCg~ffD=!uVS5Rv42xXbwDIy{KS4Wz
z3zFZP#rm!~(EZFtEY0hTlufrj>FNYClR?h=$Codmm5yr`<lH&@3=F2fR(~#Hv<Sa?
zWdS^OX6|FbaNxQN0QTpI6%R2n@0DbPTRBx`-8uQ{ERk19Rb3r}d7V<!n>IT~Pr?i}
z?Kz(PgNH7`MCb_-bZ`WM9Q9f9iaL<AVpnLJSZftZB|S7j_M@r6%`GZ+fSTtGYNEg)
zgpTLJz_8r)5JRQhG?nN(_xf{LrD0y(o|0_W<&w)KM~>rTBcnJ~ojH^k-?}s6E*rsT
zU>A3!v*`SLUY4l9oaGD@3bAx@B>p~G<`#j#qtFkV?hfp0#HOQJ&&@|tb#bjeYko8W
z*<f)KwV3@f?qn^k+5@^My6L)OI3Bg?SNp#JK1>66UIP`Ti7-D^urf1iT5gRA6`XYT
zvW6DAn@|$roxlY`o^?As1DjiVM12tkHc)8rZ`RK+PVLU+5;IIn`Or+N+~&-q5Jwi)
zpSedNTt{aG($uReo8JP_y)MlfbGkwZasL`gF~5NUb0_K6>&P*kH@s$glpuUf4Mx9;
zX^?NxL3yq@KP|H$9<e=L;McPtBJ}o7WoLv9#in3KdN@fS@U=eN`I(QjfA(Z>1xsIM
zvkNl$^tBc_{}HN0P%IGy6p7<Y?3!381-_LVOBZYkn?QAZ(v05xLD(jj0Xl?PU~@$;
z%kXDvdxNKp7bLgvR`j{I=~YC0F8@c1i4^bI{g)%|!y&xiiH=i=h@U~Al!T^+Nqh|7
zJ7vYh@_Tda)3DFsO#Y9~JJZckX&`v^kAO^i?A5oKfOire=CA`~q6lBk$H6f9tDnIZ
zyuGP9^pb^jFgKc_Yjty3isMm=++Fj-M0`j&q4oJ5&#0BbL=X|q)ARh^@zxlKw+w>k
zR;EmL>I-Jg@9uCJ`qB149p5lb<l}R@*SMl{M32t|FLYW_&+!e)@TXq2HoY-$&V5qr
zzDcf-aQ~&FTj^%XPw@6fyWt;0+W+IaC}P;ZF|{6<<f$Bei)BqN_HXqWi+t{opXbHV
z`{nF7E{GszsNDQ(za~U(4}w_=+x*o~6l?y6r|5~m$Ad?mArqf-xIO5gPQ=Q!nW9L{
zWX~n}vh(%7;<5NXPI_Vv6PXc__Pm{2;+I#HfNyZz$pYr^e{66d*NdVzLxK$|Xl7K;
zlh<B>BQazg8YPylh!P@;?f+J$*-<hm=Di`Z{GT;q-Avq?W|_=uQ6<~Yg5vP8;7Vt9
zkS<q*hnWCYzvfK9N(szW8}M-0Br*BOBU*oaX!xSMIZ-b9c=uIwqi|udy9NQC3G~FP
z5aF!-UvC0I5GAn8x(@b%1NFPGM@W1Gy}b>uMHz~7Ge)-Qlklmh+HyESLcTq_?i<*M
zBwP}tfOBX61$Y>6nFHXIV1wr10NT>qu^K{`t#@>)??W4V*wX+9S$od+P+BMt0gD6~
z7Wj$%|NE1AMti|Oq_<8+!l?XMMB+eZrSo@yxFlSWfJ7W_K`$S`jSsvAx_`Zf{~hR$
zGU=cZU_<WZH#hO17<RVn@oA-?Siz_2rw{NT1vrt0;eKF4Z~VU-dj5$(0`c=Nvcph6
zNn~NWosA%5qpl}}<3fNP)ZN(F1VNil<pu0hk0$nl7~FzRwp4{5g?&Ahgx=pJ)jVoM
zFg-=W3;1_TisO$#Zl?ZgD=j@xH0QS9ME-x|zV*4a`rCb`ZZ3albcwI+zGH|IE7X1?
zsWnx1_H>uFag-9Ai9!DXMn6DO+V1}?<u&kMF_k%=VK8AP*E@cxPKGHB-gJCXwp^ju
z;CbB(7kFI6f;ORQmYx1AZAe!krx2A)-7zz0%i~%(T_2+g$41Hflp_E0^RWMar!5py
zhhvC<LElnS2{US>PKqY?9dKoxI^U<f#x`1$H>2NGyo^%iCSb0V5dfXyUmBaXeutN<
z*6Srp#D5rJqOT>GCwAkndc3y^O--2N1WpNMhe}cAKedByP&?=nC=1ACe`de5<4mUx
zYVlY<RzQ9<dYTTZ^Lg6#Tb?f5MxgPtqW;S_yGiFif|l6F7tTRdDJIb^IhvzOt-(y!
z(lyfI{h#1qDhVJ9PRemX04UOaYE0Px;A;fdu3Jb*Bp*h;yk+L#Ab5OYs4!b^Fp;DN
z$_a!u{m<1vv<?4RAWZYMrUv&E3ou;^nE!TUvW3josz@56-D#QV+gp4C29ocOS<yJ4
z%ZzS!8$$T<tmUMW_9)(pSBYn-mog@*SJHEv#P@X2xzF>a-wHI~H|G2FM<;OU`FA~2
z11r6C0xTRH+0W7B%P+Nc(*KS3{VL$#$PjCVStFuhYnkO&czM39Kl?F_(68bYW-)$@
zOy%a!!o=XUkDKHep_#BthBb6SheO)=i94|dvK_^{xcbTsg&L^^<8#v5UtU18b3F@0
z+!FBG&s=}=!V#W3E?()k*WL~hc+4c_!x&Nc<BjntPhakF0mWLT{^zX~0YvBS^bS`o
zU&dS7eXl0=dsJSr%E^NCzRIlg6X??c=7B7#;O&hrkH49e16EdBFG0#lxXeC)0jQev
z5Kdb<V2-iblChCm@Tb!1W4&c{l#uE7vV?@fl^>G?5siOoXAa0yfFFqCi|$RoU1XhC
z99>r=K{D-#r`Sm1xRc&zcMD8JgQc0y`TX_Rn#tfewe@TIoa}fk;GhgjE$td@zwjU|
z7@yk|K*{>z@q=^Qr}lJ08a%%|z6M&P+x^Z8w?!7Xv;kj5c0N7;k26<@KUParg|%Zq
z|KYC_OVjDhJH|sJw(?_5B^Bs`+etADTV84%a9=Z#D!xGd=j>!D0LdW^)3)r=T-B)4
zO}n@3prFiTvAMFP7U%e})$50kC79^*o_@5Pj?_l4EZpW%tV@;ZyQ`R${HfW(=a<4I
zt&0w#7KqqK{Sv;i@}<CdW<INDm%Io3zJCV#e1#8B`gSyXdve>@UgPcwzcr?*uhTgc
z3SG=uj(n8+c|~W&!BJSD?ppUF`ooENL@W3rKX9;{{}iI`|I<W4HRby9{MD_i5tZqh
zKE98??Oz(ja4+QiR821yHpq|0_ChBH{_u;ELb33~(fJf<l{_DahHI+pX8M$Gvxb2X
zojN%)^?<rzdOJpDaBPau@JI;JVWmNv{n6?8{YVWEo6oH?QuvOL3aiEdS#12>2|fdr
zTt@67JbeM#eevk9w>eJXgMNzKuu>9}Y&WcyRrlZr6PfkMSlR>)OuR(2R^65cGG&Ya
zdNkWT`Twdx@|weg%lVVjA4+-V7gS>+V~zywM{5!>U#nB7_fCbjesA&BxTU>wQV5EX
zt6Tr_c9V3b!?qeG#Mv2Al~w7MD%jO`yt=$>iNqq+AJ)>OS7e|Pt$9|%V>$B$+#1-C
zws!<ZQhs6;Z6-lP6b8%cxgZ<hfCYWTf?2A3xqLywQ#yZ3IF(m7Zcq%o2H{-(5n)~G
zkD&(B9%i8%3d`B*fs(=|Rr7lyD#J!#<bmIt$h%~GeD;xxLu4sF29dkZz3_``{&ctF
z>e2s_&CE=_!}CAv`)+{Tu)RIM8wo){*0e{|^Il^4{sV`IroV)W3TG4dF_rf9e$~qL
zxu_=%sA~le$a;w?%|unE=FItVy~v$=rAP^;n+4lzyx{2!!TM}qPXKx~y^#e*z1VNB
zEUqc*D~^r%Fo`S)u;bE{;Mt<{oE@eNhU+ES7*Q*`T1qBriTswk@{%|-?@IokkRT&N
z+yar+<>LBEPmjdRXvSQm^D?nJY?G~dxF?Lv<z;daIhuMBEWfx-4=cJE`8r6CaP0@{
z^-64eOvy2X>z6@EK+*sXK>zN1%K0G&>@Oi}N+PhoqpbyPMH(K&BbQmMSN)?E{x7R`
zTMX{-p6;$kmo~Pul5^XatLd_oFp<!&DbFaD^=YOZz;cJy;ccfZP^&G4<^77+QPYG&
z%>#+2Pua9jO4%zQK!)RNx&vuzFH7#KW}2We`&Ag$bmgp@>myQT3@<%6;@F)haM7Me
zVwbI$w7#dNHtHID*m{Ce_BpAQ8O3$H#8kgUPSnSFtl*Z!3Lj!K7b&gzyH{jb&^EU8
z4+(D2LQK#SQ<TDC;bJedybfocURPg%2D)WW#MnFX%|R*PeL?ohlRl`|Fh6T4v?*P0
zjyX0T4vl_cN=ABrXf#q8e3GW5Il4+luwnC4#0G0~=HR6bpKxfb_4K60-?>emwaa|M
z>1ryr8~ca;HC7T&10pkGxN|MrqAz)_t7@3iEkAX*7TAJT;wq_5*E4|U;rPpb=z3hn
z>(rF>NwA92AhDzxtegN6Ome2$aplbe-?j*xNmWZ=0IVJZEliTK*JksSg3Ur`qlK_C
zz6zsMO9$yk$uDzfxF9>*doeT{7hQf%@2=5zoxNO+YR2lM?8ph-BIk{l#Lu7ns(?Ar
zXq*m!W0DFZ9mfX@TW=PAdUMQ*1l9-4>t$<ZgL`Meg30g|_8V2E4IuY|{Y{Xb5trW=
zLS_O3Tf)quAyga2GmA<tPH=6_{Zg5^7hm<du*~HdmF@zF**$y5D%xEGacnu<p@@P3
zs4ShpYnN01FxR<sjaE>9w4*YvK$RZqQgL%*=JTukp6t#J>Z(et$%bHx9(SIR{5wQD
zfjIWMw!+eG__xiw)E0v4JXpp3=Q*Z5|M=&@j!#T&Jqm;3Dmj-4uKI7Wi&9&12!?eP
zi0Qj}W;MYPxC|V3ljnV$u36R|_7XJde2GkiB7a+)+)jm94Z!VR)l%Awr{ea`&IY>s
z<371Ah6#d}$PMKgXuU&bQ1_!7Za0rjpEOE2`N}Ji&JgHR^AwN*oN#E@`mgjEK<zdZ
zaCq|ezChs+vD+77teZ1_#a|PTge~{)m}x`3C3t?(ylj!?`E_nZWqS^@YE}jnyumqL
z(<JS#kQ1MdWg@4mK2EE}MqDWrmwaet>06n>SBgL5SMqf$ig_A)2IqHlyPg~iATqkf
zZUweHRl%|C{X)$913vjn?R+dh6>^R!E>}0_gSM_~p0>nE<T=bPM%(3y`1BO+F4)Hk
zBQhGcrEZ{lmc7lp+oG&HjFmQ9pa3D~TUih^g+}O3JtyCIn)ETdK`{JTn)}t9pWjR1
zNMHNqIG44b44W{HfNjLg%N-@2^hK=$O+j+vO9jVd=!XqQMRKs@j9L2qoa(le6RH<}
zi1=>*b)giTP+uWEtjXs`bn>^cthE<M*wn8dlS@VCx=66JIHZIetL4#t;8@d{l0Qvy
z%KG}yPR*}1^$I6KtP#vOc$==fYxYqXQoYlX{_6b9@OEcQs}A~=PO@+O^COj`arUgx
zLe5%GFbq5XsmtaUR_KcJ&D(6#F5tH&$o7TgpS+P-yKnK1l;g-uJa^339an%VM=R+#
z|4eI%rjSx!oDD>}70>%<;Gs}byY5`d!UGJdznDY1j1?Z_W$v8<NsX|=58WKq*Rwrr
z?k>9nR`s5qB2}a}WW1XPF<r+FpX))2J5NX?u_{6nS?D8||6PT>pXH{J+%-p-mjz{0
z#f5EIRPxcB(ISMe1nsPUb6;wDl8VYlqKu0A7pwHU$DpkxHlcdRyo~E^9(~jCJ-M5!
zD}EHZo4adJNu69)<qcYu%}hWlHIK%-h&F8nL>AoXf|Y##eObFWgYiBO*7h;ZCExD*
z-+FH1hG$P?BYphE(FXhs$`TU=mA=4K%yoF|i1sVWMZ9045;@Tk(;ekm-uur$kt<Bo
zVnKJd|68E$U?ytf<Tbxu$-SclLB4<7*^p`3(Pq3)ZV9fJc(y5n2IZ1!AsrP>hS=`j
zc&c$JY!rAwJX9i~-3@>^YIE}Y$EG}mljpzyWgEO~ICdFx9;1u-q7_!@t^|&-oehs2
z*}lQz6o1f6;EaB>(Js!}%~Ci0+J!%IhHtZZp;+R&c_iQkJX0PW;w?8fo!lI(yj`uy
zI0?nI8+IRKvw1MTc#C<+i-Tv+0K8w#5$9VSkbPU{pI3T(+c2(u#cSTyLpaSC)*V*g
zqAj3<?<{=IR8?=6xxH-oCJ<rcG2T2<rSk2sTi?vw{jf1K6sa+7*QKr9*wQ!rd}1VR
zFG1|bU6EDe&f6<$I(5N-Gs5W@v;~m~#UBmFATdfZ!h*w0vC|@R5fhQRC}&D!y85mq
zYU8Ki$4iV;+Yf;klVcpP#TQE{RzO4LF%l|rcIq1WYu?t^o-&6t8rz0@mnnaLxi6tz
zXQ3Ew<j<iveMeeFdSnO3{~IIJdFdw(7f37nVJ_h5&3|iugH1lQ=beOtjUD@+1CmW$
z^u938aN@K-!&jtcBN2}oriD@HyLsDT)=WOtva*l^yrJIy(NMiQJ38GaZ-1QRdG@=*
zhy$;gIk6(-nN2F}n-APTaQx`4KSvwn;5yT{KC2qq;$pjLO<f&u>z6!cE8Ae6V417k
zg>YF_NGyDHO&wYy!rQRBubAV%oFWE-B{FqRGa@8bSZ#MRaL%ByUmP|y#b=z|YbW=u
z2w8-_@dw*rg~n{0o%>#tpnTQ(eO_e14h4y*jm+JO{JhGqdLH({Ki%}GSno7{k96|C
zHPIHV*~qjLI2f`;1S0_p3<O|lS;gB@KT_^XX7q@NAvYx-`;`-qx;+SmN?kzvM$#@v
z+QldOH&jlT-0~|hkiv*q3;u0I+sa@lnhKNFx{S}$FhIBZ*WvBLIiItO)^v?6Ud{P^
zS(wX|r}Ck`;W*DquElj9ZNYb8@%d|v*z`9)42lsA`unp#>b;;N<%%Q2GWw&VHA;mO
zmzkR$QaRbBJZV?eWPJ~Qp#HBHK;ElkpH@kU!^`ip3p;|=S9Oj(Z9vy(Z8bMM|5kS~
z#7o^u5GypK2(UNc${i`;s`i*4=?vi#Or!u*=scMb3I)aii(wDPPVN}|o71j)fCXOh
z`uHa#@&IK?W$CSva{Ve(NTU+6xoR{!14h(H)A(x&Gv1;6{}bNtI=<kA$e6rSG^Z>f
zWV78%XKeNbjKQI=Un3gA7tj3~I%QXSsK++jZmZg>pzs6Q;Kj2{MW4K1E~QReAX}-3
zT=={OC+%L!L=D7+auPz}cq?e=pn1*<MWBKCTDv~rG_!fxkC`>S$jfh;1&<c=-Fhve
z?cqZ}O8vUIybI)h-dQZ`#N+n@$D^G2vdhg$Gxy0DBU4}YG3ZMB#qGO7A?38R!$+rs
zM8QWe9jC}Lb*VQzaJog&8KU>}-DW&k;#U0v;mqZ5)n18_tyy-t`Px1q=hoL|zic%S
z%Q%t4iW-PqwuENfk9;y#x1DVqb5HHty<-Uk9KCDs*jNo%;zg+Csi~=1YRLcQ`#%Vc
z#c7I4QImT`Y1@<UXZ}wukq^$aU!Fl(SUujF#W@i|1V{T@dQfKye5@LSo-E!cZ+{A~
zmoqEeic9_^x$h!DNWdB+`KLVLbR0rCS}bQrx^ZGt(kfH<-Y(Lh(xwn>xY+Rrx>*##
z%FNP;th=zzv>ad;b6g;K{;t$m^#hVrHmZ2mGyRv0l34rQ;m81JA&kOx#6IF%X`4aU
z;xT0_UR!BHzD#ZW0s?MUi~)l{r!1|VOKVWjg{I!oXWgBHIv~x{`FE}xbBc88_5P0u
z#k*!JQun+9{Aklrk#3~F^qJk*5{}en<FQdmcv!VLA^PUiRgtQLVpj?=oy>GOtO#yp
zikcw2b$v}N<}P;;GZBK4kC6^5<g#nNNL2s~0)0E?5WPJEhi(wz!mkJ^Syuyea|M3~
z0Gr%;OS^o-AznMj1i7s$LG3r0e8S9*{!jwH6wqR&C#&7(gf)#a!H0$TFo}s-HV;db
zdq262Wp$_pm=uxZf<zd;O!#Hl?J8P`+yawipKa8+#ejPPHc~f3tCuOOw(D>fSiMl5
ziXUS)D$+2xp$)x3AuQ_i+DdgUb7j9emc?~#*JbU=_R-<xn9+eb9t*K${yj<%(P__H
zO=3p<mn`MXZQ+TbvCWBBsM~#_0?0^j=vu$4)alFZPyEgxYmxe9pIM753a-5K%pelB
zoL~El)p%b&@7ek@UdxwZH=og!{oX_w1$r#}XciFl$KnD+T>gXVEi%$rWCwh*EjwXR
zGwgmam3NX(R!U+r&3MfD-(~2N+J(mdAOOH3zU|ST-z+d~N3?+k<Jm6u>REaSUZfhv
z6a<>Z*(eKJ_<pb2=3k^9?UC4LxB4yD<!QnGV(N`HPENP2k6iPQ--=~ae)WOCgY&4R
zu$u6*6zaq|Y0{ooln{!1ri9BOafxd#*2;w9TJ~tDT3tORv`O1Nu!pqk;{~AYG+^)r
z1zAXLo8^Cnw1UA{VAd?;Ry5VMp{%ma+NhOkNx`M)VBcY))XsgA>i17p-=ff~`)SgF
z7M}8g0MX|AiyT;kBB_DfGjVvWC|Z4`!MhRu6S+Rzj8*H`vkgw0Pm@7YYhFt0+T5|x
z^q+voiNBU2I()Gas0a)rRDRzgL>7c0;MkhMe(T6EO2P6k4I?;4p2%X4z>Swsib>Y#
zDvS<19_;yj0(FGX9&J#dt*h}nF30g}^^zfyvNPjq;#p4bf1_uCYyS61#{$cm!>a}r
ztg=|rp%(uK@ouHcn*`Jl@(tl$<e2~a%_U-Rxmso$pnQ!WoXK|d_MGc*JmxhbQ;<WR
zsAStfGy?zoc^wYcYX4zM7T7STk$^tl#mi0W8IQlu=@5B1Ocq3o$-kfffj`;+N(}2g
zW)j9TUBPGN0J~oOL_E7pNiC_k2hou7@%h)77)it!9)D~SP=HdON3VP#ZfHoS09s!E
zgE%Utd8`km@R$!#0$3^$AbFL9@f&wP%Dw(cz_gBoh2{7&IROPF48dXd_P29b39w|#
zdDkjOA?5yW>%Mxu35v=4+vK#*O^Ncb3P{62&jhq7^bkMwdjK53HZKDR5Y)S1vV$A1
z{CAdeEAHfY4$tSOEx$a(Y&FGGCISCl?*d6@Hycha;F2s+mm;>C@Yo|q1@|*D5aFI2
z;7!L6E6k8~egI^!Ta3U|*P4XTl-Jo5RF5!R(ux2;En*_P|2GE*2SO?;w&tO}z6?&|
z?q2};QP^m%M3&GP&_Cw->W<(0#`QmFameBH0vO2@QWCpA4n>2`@`4cy_{J#$4xa(q
z#kfo|q7E@SQit2)%tpn^EI6uu{}BuwY3n)YJGe5=;==}dkNAnkl$w|*gSQmGrhyc4
z&7gq>3>Cp1&4S6))i+aR-E|J%++0FGOh`yz!Tk${4iMs=fgEs7Ga)gn=lhTQTC)}O
zU3~xpSQrLi=uj!b(u;%RV}cKw=c(o9U9Yy=j3lnuz0^WVX7)%@T|g(R_^U%Y4@Y`>
zdMlIFkUQGBKeXuxLTvZQ(m%H#2meY<Au_@BFrDerifT#`BR1gi4eu^)7&_=9`U)CK
zjSmgOm6t!nB7LE0wC+z}TBHDtxr2|-j@+4Fuio(T4nh3i8W|Z?JwEfa1>L^AcW;05
zSx>O8goPZD%Y`4xF0R6kMDoL<F6-PIYnBKABp$q|3e0Ug&mf}Pt}*sVN9>Z2=n~-I
zZ4@g$%?I$jhVC{gunUKtw;GwAZ2Tr9Cud=-aMmc@y5h`wuoU*05dWrhpQ)@J67)SZ
z^zwK;v@T{}3m*cozeJxc0W4bM!THX#n#p@W4qP~;|Ble4jw1Ax7E&%DL>A}9>qFG)
z4Tdoq-Y-Ox%5C?AR;n0WAQT?ZJr7b~y*YElZnyv_`Bowh&^5kbd}vBG1!jaQtjU*?
zWHGY1_rsZPE3-KlKna2Icfddhr>Nb*Oc^+Tl>MU^nPPBKx<1|u*E{VHJm!VeQwxjr
zsIj@0DqqXik9fau9%jQh_j&UNv8N}?9M@!{cJuN%x}t<3V7h%qRC9GRp@#?5bq+Mi
z2OZinBOAZz1BF4i@_W;bUq3P`iv{0oX#E~CM~N#yw1K!AXF@@lWsIEc`HY613ZrZ@
zPRcCvl`5zi2s-dRdW=N7WP$Xz(D%E!yj4H^K;mV*=TAo#^Afbb`}<0ZKKH@^eIek<
z`$7w;o4!46AY?UD=dpb88)6z7jxTZwkeru-aiq8?VF;E5izg)wEufvsJTL!AguVc6
zIWxevisxO7+hs9d8?pk^aEr3zmR{phJtJGRLq#wN;As|VV2x+S8&-gvPDf!*;n<YK
z1T!l7yN^mx%-LXl-A{aZ1ZOd#S747m(hb-$M9Fs!`(MqNfHu6Ca+Hb3!nwPjD<p_B
znU4N~45(dlq`q>-<Kw!4&9WZqOu#%mx$-w^Vt_&O*`K50t%x-5t6*1LQqUba5w;!l
zfpyw!SC2KK6xA3gN_C(}KMS@0tE5MNU0P~>1A*b;8PVgDLGnP$UiSp7|7po|e#Ger
z%{#sYU>gzR_+k6Zn*cm!>Cy9`=n}o6Ox^d$jQ=7@{=tBJKq%_x|0(L&G@p}pkr_uL
z;VQcc4Gf|*cW;&&(!U76-aj8wM31Ek{jPv07<tz-QuI`}Ar)wY;@q9jkLXnCCF*O(
zspUbt-Tzc}FHmiHKo`c=<Eyuwwj|%_#dtm5yPyc!Jotpg`Wf^8e38~3^3Vioulb)9
zU=h5xnUJAVz1iX?etbd~uASE_nD7t3_`ko<073myL@A>8t*BGo-rG_u7>~KJ?P+LC
zY7ts~D@(%v7686ph0w@UM*nK$y33oVn;w$LUOj(>rR-#p?P&Plec1%>??2PkDhR}Z
z$Qbb>I^$N~_x820mNVB$O#%uniaD95aUBT$b-Y@crHeh2`qX!CZ})fi>{-8)6stIh
zVe;Dk1p%)Ym52x$kZ_(5;=#FjW-#y|<iQtb-zY!~n3OTQnENEukP#tKb%xU2P_Gz=
zJC?`Zm7@NYSWW_|r=i~IVaJob9exNLnS+4@mc?JCHp7QwJXxHVd`CY@&wk*fkst%a
zDGUKxbcYI5{2y!=SXwT=fp5FGKPnbBkvY{Q`})YtIlro#)+L*o>*O*1F;JB?6*)b%
zKrT=O%?DC+c&>@5>2ClpL5!*=q|*KP^x)-(zsf)ty7~YU`G1)y1VyhKt;SgZp|^C(
zx*x3UFranw-?uSAuvE@L%)+W#KR2;(g}wXg+q&#bnz$)H3o3Rf;T`|dUFz7!ugB{(
zqc%EdNCBYCv~r;=0T)PRe)I1}eDUC+dAyfKU@2|M*E`{L>jI_{JUb6pSLL1F=CRW=
z95h-S60z5}C}FHnfqqVaLwS-lU11(7k3l0NBf|smg0gSlrW<wyJTZUv`SWK<MiVfM
zcO`keP*ZI<RTzOV1e128{QdnwH##BcMkhlIMpRW(v-=4@5CC8jqRA4Sx@cfwB+a`1
z#ZH<h0y1-@u-KFow(iK#&`c4ptAy_L?Mn|X>kj9x&d!AQ)msb3@AjL{_4)<}rOc#m
zY2;x4fMdJqmkP>D67%-%&hV(_KZZ0mHsuZfVvliLrR2r3cw6@LDq5)nts4ui5dmL#
zQ2<kkGjMpj;QHsWJAe~03kcN8Vv=Ado}4%xexd=|Oww2N6+qWus;G{-#r3roP}psa
z<%=iumQ9OLr{SiC+NKFOWZ-dm{s%{4lKfUa24Q1U2r34A5=osnY5J4p+%dlSI}(pR
zAolp{eiR+uGYzW3athOvP57z0o}OZ)JoOvj!K7cQ`}j<otz;oozawXy?Xpcf5l}aU
z2S(XeEg0AjiP5-{+O^`eD$IhzWP!<yJ-<kfi6M+$F#=>A^s{sotVdNxXq@|6Dnq6s
zdNww2JjK7Jrd8o3godoeF~Xb?TT#BS-zU=4-Js?5(<gU~+RU9o#(muVw;3t=J);*c
zZ@%Tm=L)c~9U|?*d_K|Fe^EK<@ESwLiTea#r=*}2IB2lH++?(&JS$}Q+nOGjvZO(M
zmtE_6ce!3@Vr=sSBFm}r?IOy^6pSU(*pp{xFiwhHv++cV|KV_EGGG7kpVpa2Cv5?R
zh;5s0hP20iT@b9`?fj6}YD;r%cO;sEu;%W8sc!8X&ZpNZ$3X_Xnf|tb&kpGgF@!5Y
z)}d{&(9)m%IM7QPARdSy-xw9}$*9>+RjL1er!|2(oj>uH_~*(TNLEbO<$)F}&4eM>
zTMtf~3L&S|GhL~4_K(4XQ=x>hK(l@=QR5Lqcu(O6ZmdifKJ3VaiaH0ReR@w!?LxCt
ziL5)Z0yO}9lH|dX9^obRFbBo)rAM+BGZWJbQ%@7WX3r9KIfl$f0};51mkhH01L3OW
z6JIqQzoO@kWywAU>>}av<Kx7Ft;z2K@@!><%m)HFfszXod#zxqe}*?a*hgY&=y?!g
zcqbOVLxwg9bkWr7);usO&z<B?G=s)Xl_T#9V2F54p;=2R#c16SPryRdQL|G)FE<<m
zTHFH86S;V8)D+HGT868e!2~R$Y_7esC`iK3az4F$)|W4}l99`dIs!Y%azXOUkEI(N
zbY;lHsyMId{_Ul>KTb<M#)RDE93Qu6Ecaj3;sEQ2h4cpa4(V;oym+t8x*mn;_#3u<
zdU&!D$^q3HO;pk-W@DoWxwz(1Q`I%=(((5O$EDI~Q?(2}8_gisSwEv{czo0NjFP5N
z^g*HC`_h8<x3(hE({R)6tJw>6g!%eZgi@(}X8LnjF8@2>`M5Wh)e~Atxu&ayIQBLK
z;@=se5RntxIDBFGZ{VdbTvwx{J7-4XCL;gx=EutQPJ_Nqwf>KlvD=#cyajc8zZ$>v
zd+OS*;XCzRiCa%D@?G5Go&zb{(59c3b6D%F5p}9Y=Bn-VdJ`_>`}4*xQ3Cx;fnn0!
zBGcxzP`ZqjY~=*3%{Um)YsTNFM{vxrx*CE3fVm{$Z|D4sLSZV!=4{tmQ<Q5rRYfgD
zJHb&}#P7guuFxOcfg=QCOs^^DkfY9}e92MHs^T>}(u(e`El9PGI9?Ah1OQTAmKQL2
z(UuTGuFv;N%DpRD$&y5Unstq&_@*H11|MRMA^k&H`Q>wRd|Mxozr8}Bk*nb?yPY1`
z5{S0+PoMPqn_2yHHrzRPFSZ`6={K;KvjS7}pS*y`6hUTAH5{g5#%F^2v)vzCYCq_5
zC^=cBjK9LD2$pYoYik-zUQ%u_d^M|BoBQG!cnOLaq(650Rr4Zt1sNp!cUv|UgpCUK
z_zgC-8*%?}9F!5>JrK$s*>^tML>Oe|yD$W_et|Z#wX0bKC5x&1>deI4x>5ht?8g@W
z7f9fu3mBwD;G#FhdVNnk%6SfoI1=|Mu0WOy<$uyZ48Gwt^6xJNGsVPp^msx1L<ckR
z2@)>!JtTCLDxGg|`KI%DfV`}Ia-#CCnve^?u!)@&6JGf8y`N)BJi9D4yR}81mnKC6
zI`lb87}!V(7iV5RUn2HiF`SuLE*6IW_l5!1R1k!O`C{<iLEEiflK6krof(GBwGoGD
za?2Y(nq4KjA|zhp8pvY>(T`d&{#7=U@<GIUM${m?h1jRZAS47J*ZsZrULfN{+E3*i
zv+e47Q1-rd_SB#02~oF9a9!?MwAN{ax&fA)Ksg(h&jiWz;?~Qy&Q;Xf#ZXiy@%?m0
zm3Oay|AtymZ;R{E1h}+19k|rBU6303u<G2^?U*oM$kqJl;GM5M!#{Thp}0CT)KN`w
zG^(XV`Zo1a*zS*_x{B{TZztXU3aa2`2d>lgXa9>0;1K2|Jm_oQqE5cqL5ebEW@9JP
ziu+`C_mPJ1DdHI(U?gDVslv1FZwO4gyHv)Iaf95KLPD@^O6YJ%2yj&N-m`zaKMuXf
zLtN=AxDq8z%$MEZ%IjH_-#sI1)n^fD51s-aXG%W3vGFr8Tp@idbec~;6nji8-L^j`
zOSUZfqQocK#euVm`h_x8mVv(lO0>^aFuC)d{F4^9shn+lE`%g8=UA`FU+ccNUcbS7
z%!3@-O0|vq)kpa$uyOI^7vub2&+Um&#-x|#)?QuNsL>1a!IeyZ;5<2uCe8Uw)d=N{
z?AJWDyuMT0B7}IDH_9#xd#H^D1tn=1cz!rkU?^-q(5`xgQ=}!a+an?+ChT6Y|D1#s
z=^-*+(ETAPY7JJ_fg)RhYiK#gB#O^@O<>TqmeHG&?CN>#Iy2P);LqA)`_A{UkF>2?
z^EequAJO6#r2iwL9#wXg_wNz?5^=dbzdo7Yzg=i<j$PAdT)Vb@Nvd~W@MZj`@w%u;
zdV&vY_SIe9eD^-6z3}=*XQ*D8{EZ)TGZ3o(6Ln|g9^+Lfh$U&Rq?2BIiv9&wcl%?Z
znEwGcknArXAH^KU$g43(!CJ}iw-ynVzB8oDFTs-qs})c0c&Z+sYNWxKYdwR{nt*$H
zGx~wvMK%A+n(w65x=Kun1g1VbyRAR&PY>cugKW9}X`N4oTN0l8#bpDAss4M6_7b%?
z!g#DU$5Y1$CTwh5f*ld#7u*=6Ut2#{1?GA5K*v}rE!Sw=)@T|ITNqtEZ;zk23owd%
z8Lb^H%sbs}m*mX`MOnZnm)eoEe&%i*ediuqulkO5Q-%>Q*4l(3P<XUSv7HBpCwr3f
zrT6X?mHy21kf1jcE#sGBb(p(f*c;m(8e%EMVEpun6GQ$TzO<6auXs<2F|}TT&4w5b
zS6!LcUa#UxuKf`_8mGart5t=Y-IpH-pAdvHg!0y!eAp^ZSsiag{pe~G#_5gUE{CW5
z<l#^O<wBICDSzM3hEx(%K0DdSn@c?+EejnrN3LVZ<EGqP^sa~<>2PEUauT#x=nqNo
zdIy-ZT1tc^jj2~1VRZ%YWYQ9d=Bx%sWaD<%NlTHm#Sjg8z7m|$(}Nu~&|l?k4^!+`
zV;>K_lk2JA%|*byN<Vsl+Ob$o!;<uq91wYYMFAj_OX2;i1@X$0rUuAqP|?lzkd7vl
z6(7Mj=rzeeJ9se{=)XHB_nYRGTI%fnomfuNJtLOB&f*ZIgRztolV{`iVq}|py+n1!
zAHriO=>i^pm*DR0JPo;6^TUVZqK^wX<WNsDl<ho3wG?m72I*Re*>*2tR`7xO^1x)O
zU~zn;#G$m}W14MB-+@2E@@rw)Aq5#z=hZhlcP(*k)S&QZTFQXvL=H@<aEfr79<g-Q
z&qPt|Y?31qh8hu^=*QpAyX;V+@*brx*VJgl!<Yw$b8UxjeT^8KK21DVs1(t#)o4&r
zf7>8>m$0XINfUmT_i36oT>&Xs<8o*4bR}L#%IzgD=6m_UcE3EW?bldVzhjWz@nm0R
zm{9~KVjK*eTLzPKy@@W$EMVs@ViYnA6-3nip5hFZf9{fXi;U%uhsGuO_Gbq?KD!Fk
z$G5Z}{yWwn5mevVH*PGwx!NL<qZfGxox^@3@0V?M-=UR;99D>rl(Mg%i7#gmkcyE-
z`SSS}Ol%^`8M?2I7nBI&2pkz1<o*30R2_!-{UCO%rL2>CPH2=ZWDb2_Z3BTqiLW1#
zZ=NQGqi^_2d#F}Ch-K6DJZpFy<FY|pMdP?WD24f`8hiD7vJdUx_6QAbaY`7N%?z)N
zdufLJu!?|bfCJyuaPkAT6o;IBzkYxE_<Mn!56mFx5WnJlX>#MKJdwf;nL=sGTSdEF
zZ@A_0QH2NjNlSGNRz1+6Cab`VWWV}EK2az=*zmDrF8Ph0-1)@#-q@TJNMJNSNf8k3
z3?W!HvcUT#;F~F=^dvq&N^~x;zQ<{-mjA`#Z$yGfL0$LH;c;8|d&r~fn?g@-#g=FV
zX{FTMc<PclWlaqu(@D8|X{wCOd<TmUhRGX2$~<Ef%e-I=g14){3_0kBC+KpeP3J(;
zBB}5<IJBL5&9ivTd-glt@1XlVF!;`yqn-Y-M%m?$<l)S$ETJaYHD!7<FWr0_^S->n
z-A(5zQ&kaL6uo2Wl24YTPSuO$j4tE+b)WAR8m0BSGm_{!><g?clA;*tVdj&mhD{8r
z#T3@W{n^t;{E62GHRMRegb;uKE}pgVbEdPi1)jfU*SrLgDGdY`Lqas81#3Rp>8*^s
zGq#(JS!(8%mn|(h{JD|O^%v3D57W|cWgCj}lI32Vy9X`UK5dQ=`YPWvgZgWC9zsH`
zqF~0rar%g1z$5TV_%JKKOpkAhV)K5i5j0h@UzRPU%51SfqleAaM(V89Rkg(=uBx(+
zj<5vXuduT9dUGD!UyWre&{o-vj|mSMLcs|O#24^6ineIB8>dsZc^2F;1%%JqvlxvL
z^^|G2f1oet=jh+x?QWw?1rihvSS>B4vm%LyeKf2}Tj|_iV4L;rrNXoP6@-%db}!|X
z9&f+3O}s7y73HZjZrz0=f{*prsY(4*a|1qPX3T%aZnD9M#;c`5hlKi|SmXRji|Zeu
ztBbvX+BF#I#BH%OE9K>m^<SeT$R>-`BxpG58|+9g#~SL~V#r^%GJ?f!W5moe<<^#*
zjjmN_Wn4C!ns9HkcWTumSj>{YIudv3!0nyQHkR%Pz1}IU%WDtjft}iJ<d3U$$1u!2
zwY|3O{o`Ceh{29S>0@wgmeRcx_4FiDqg{(W#kMI~f=wlV_x9K}kmU8xrGVfaB8X;*
zrZUvKZk!mM_b4l)9m$Gp?$?&JJv}f&?wHA8N<@%=Q_8vEtA%-urhs;?+$R7kvn($$
z&;%Tw^L}fuPw{KU{dZN0_6fH$A2iAdSdq+zZV%$lFRtA#QDc(gl{|M#8_<H~(L;j<
zMQ`c#-m&bih{ck9W4OQJ$kuNZ&o}1?;dFQ2e`_sro79`ydwj=vZ|ZKi)u6F}i(@5Q
zGN>p2!CVnu6*KVLm)Iy<&eTk*T8z{(-)K5BHTFY_GnIVKWZIscI6RT7)Qej`vlNGl
zDP5tnBzh!)>MS3XhQ4BDBkchT`7nThuU|0q^)-l5(c8?vV1M2cbVe;A;RRa9T8m?`
zp-YHb7oYEq^`w;6RQL$j@BR^<EUt!-4pNjk1}J^|JMD4wb`@Ba^V95P84@HZtayh=
zQ6?0emKx(pG3|qzc*#}}le0pbZ_GmR2$qWyL(gF*rLUKb2P#TNYoAk>PKg?`Lst`6
zm0fX&IbQjAif8<Me$4g4<)pAQ61>E@wZ(w^XR2cj8u@vGv2kLTb#*5V=nZ*FaGT3{
zfvxK)i-N^cL(?lc%8+r~M@NEH24E_9gwOsIJyex_^;b<xa`w=!wrUb_^?rl>*$S_q
z_Z3ojkfq%6k0~Z)wwiIkWQ7=!TnRExSXfvE6<UZ)kK2)ncC9^~l$6xC+be5yCRWxg
zX0;q;8ynVeGVbnz{++t+0^i5Zs(l?{r2p#$Xs?!>so)fY6Hk~L2>H3$>A1|(LCZfJ
zF$)O|7r+AuA;%&x!#;yvi|^PZcOuxKM1?IxD~5ONeMirypSHJ)H&<s*FY3UVdelR*
zXF9Rco})yEk`OPg`(?1-7tginy`L8&3h-#!@6`&i*^_WNZ>TE`V&Q`LlaW=fbEsLi
z*5*F0k;uJ_$TG*Ce-14uoOSwJg1UyAuF^tgHQx8M`sSDFUFnA$n(8pyP}p?s^YG%o
z@xMR4*U&`jYmSrR5EhMazPV{ixH`<elN>c~krokYu1Sba^p35U;>jTPt!Xw7ofnvN
zKmqVm*v8IOnIADL?6sw(W#SVE>qr0&mF(}|zmb?)BErH5jRNc7url$B)$Q$@YmJ{T
zL_`*{KM1Y7uXkjZi}B~hw3G+wDOIn<s|ZqJ<1ydYZCyp`_72!8mUO5tNwVrHZ|clj
zGCqgt_ZF&HTaogG-Dp3m_CRw9ik-iXP_=kVD}1`@2Ni8R?zo#09l-PM8-cJFt?XdL
z8#Ci-Ep#!wvw8yA+t4&zyu3^=<qjq43h6={sJJQJ77!+!4-l-u<e6tFz=LR>?Ppf#
z!+*R#KRj~n#!<6cmVVz4-_U~RN!5bg!@d@yrWeIL$Rtt;=pare2IBJ;TS?tFqMj?1
zNF>!{1#>j(?Q*nri%^d>%9ws5$2lheSvJF#8bIR1ZKf{LnI{7;6)-w%53JInKVOuI
zCB7+N#!FFro0;&$i#fwOL3@BJnF@8CPvxwvOMS71f%j2exF@nZ1{#qmgS!1LEzx@F
zGu*TXSR0(-d8uiDtC<e!y1C-r)G#;l>3tD$`N>uhKjZHcev&9wOzxJ28<)xk04m+m
zR0$#a`NjnHK8{?&4EE^2{nX`JswKpyBgyBJia+e-?V3;i#h6S8slYG7M`VPVw?5Sy
zX#f`Yw#iBX9;1nu(yVGWzVBz(e3N{(A6&@U(C$}h{Z}d#O@}s&<~693z4QNbarlSr
z?lhGKPQs@BtXRll1qINK1bp`M>+;(Hb-}LlKPxNpWJp>Il{V8{hYO{K9R)FN4rqpd
z2fnW~Au_70?MG|<Qf7uAqnG0_wGa~%!-5M&^F7q3ARu_!JlHG`;$c1SOAvvB)QI&<
z^iU*AO&Ba8A#MHd{)f$}e>r@8-OqNIZ@w{@^qt2TA5Qk2Q~TUFa84d9cd&^p$q5a3
z#g=K+IWkB|N(Su&{7dyS-1!USTVs+;&CRiezIy=Xq0aMXcBZT`o&$fLEgGl&muTgk
z#|GTUCo|S1zvt>cP^qSxj|WbQJ<q0ABGHO-7JfIHz8otg^2eUe_a;=*jRc-n>LAC$
zKA3^_a30<g;6rRnxm&)De9VGoim73H9g%QftZ`PF5cy+=PDPH4^t`0j{il%|!2u07
zw&2eJ*{%|y>3-2=ia#G0PK~a-*Hsd)b7u=Z`2hVpPSZ6%)*}nqwq3#WM{t<1k-yJZ
z``g@XA_0@|jnW46-=QVV`j@o1FwSS&R*JDFC7vb4fRoi}pvB?om3RMpSpmoLz7V>j
zKr@rs7izLIo~HOo-f99%Cf3{#nRUnffziM%HxI4k@o3o3fo4VXVf~z*{en5ni9B@C
zu=1&;z>iu1>IB%A$`G2*gC1-H*OD>x9XC3rj8Y=5xj8vloE4U%jNb(E_k5cfuLt^D
zVXmbx6|5*kN|<`fjZ#a`bm)iRbylA86&W?PUbeIpm(dSHW(t*WcrQ4Rji2NYK4mS>
zQA}a^yH;Wf4Ji5Jr(Z#ZDCLR=;F{hmeoVGnX`f7t&$ryHP*qiz6`I)3-3fc8LOj9R
zxOc0peY8kb{Wtk4jKy(SWi+lDByqIuQ;U;tzLHn@Bqut#&RC7kGecMR9pn`D5H-G%
zm26PGyG#}0hIluNWIRgIq)WPt7gg;!TZYCrYEiv{D8?9NAF2BlY1|aHth4K89+Q;(
z%2J8_F5{Lb4&QP0e)X|#oBha^++ZqYyUxWwzCh^RQCa_;qtV^8N}O+z?zzNT$0s5R
z`kxGsv+<TD3H04_`wFNXN#+t4Dss)G^qy)yiW0SN*XAK`hWK1qvQ-@YzK>9GDmhbc
zX?7_RT`{@u>xhgXGBq5h>dMY0B=Jd1_2{kbPnnsSvehf-!riSf8^oU`o+borF;K^N
zqfay!mvnlU27~L&JwpQnJmG~mGpc{QY=uFNnw}f4kJ0sb;p>c~s;zh{an3*_w+vv2
zGK=*l1dKmAuCK9PGeffg3ba4^wj8&+kt4gFnk@Aj_p7*0IMFcGd!e<?)Y1PRUvI$`
zM;mmDhCm1q90o{m2s%K};1Jv$1_pP6yIb(!?gWP*gAMK$+#Q0uyZf2E=euX!v+i2=
z7j*aYRF~|%tE$H68Sayv9>xJje*EIm_~V~<>OMJ;XExf(86*n=)_zmh3bUg^%iZ?e
zH8|UN1v|aca@PWlszI`hEycGCpmGUsmug~R0fNCBB={DA47W^wLeFs#me>PqASVjS
z_e0XmoISy(^PPkD4p_{MpZxuFvlziAFpaUR<Z!kw2pMpGR)9&<!k5izWT<<nsq(de
z$xsZ1ysm)SFPEbVdUa^zbZcEJ_`UxH0GsiI=y`9x+H%PyM=%lD5~1<o=1^}q=nixx
zGkv4gs|`s>#v8CS0ViH~GqIqcp%whj^avA={Ny|o29{o@WMgEox??`wFB<5DWvK_!
zn{Fhj<Vr~p`(j+umPvwex=XcT3v8?UC-OhiRk>D`ocKW2MarHqhQ4@5H8a6>nxU83
zGA%RBgdd)&u&x5H$O73|ku1dwW(^nda@r4<7dP01QeV+Kd}N|}GXSsZCH)G&*U&jm
z?F9ahYPCe*GR~JO>Qf*_o(J4)s5Gpckx<gvT&4h_&Ud$Nc1ShlNzh(LmNea$EwTaU
z<cWU&F_9_Wwe@jyEHF%cW(~#NL>j3sH~|3jvfN?)WaK1@J90SbG+>?tnRkfqzGA_~
zzO7vVFRx*paw`R+x9Uly(=L$3OzB?~S}Ls`Gg&6#igff%LW`RUlYe5D8RbfcZWA$X
zX3JSk<V?l7SjU)C+RGWMyFTLHD~@i`sSlPg5;$YQhE+G2=&lrcjoi@6K&%EJ8d`{^
zWg4mM=5hU!sb6NafAzC#nu@uv65X8>5dU@YH<Y-_i}H5IU?W1OjPVXGI<tuE{(mcD
z#k7wIC8ul3)J*@Oo6=zis34oB?};KV8Tky9Z0%l8rxKwiF_wqLRYuauI$efT?VD!7
zx@HIIuyraMMI_UFl?N2KHuymE^tQYs{^nv4rwEPhj_+vKJ1?1x&&jZ(V^F>!<+J(Q
zGBEj`G!<~@n*@`KIJ7qSGa0M58@1xn*Ot90tf4)I<%_Q50h#XE)z`rXTe6<&E3ECK
zPo3J}1FC8o=<lwUWD&4*55^pW?wzMY7GR-fv_CQOWE2~?W1{NdbF#fAhS2aD)V`xk
zTX#M5r5)F0AQQ0vyT#^jjX5407DuAROr4XxTq<BE7x#zs<F=<)*|6sMZG+zL?Cg%|
z>d!-)Tb{~)F5EHr&VI<;mfGJ)919NuVoi|IFtEXRqjhUVlzw5XxiTRo#Gel}(IZpu
zc;2xWFD+X9Q}2cY1d83iP+$z%D+Op2Q*vwTet`24=s&z$81V{Q8qlqhXqsQp{as<3
zkT`*#jxqlDWy$^nRegA(k<5#bKtaKD?uWT4pfWw8tZ&t;nXOkYN)?4`j9QY$%+<$u
zUvu#NInhMI&Os)CKgn;V?$i9n?W=V17oAFt2dd2;w43YVy`-9w6<^DgigBuE4!z=1
z9`u<|qRR_Pn3iG=IMi|XcoAb_220+28U$TWGKyct{+hq6X={0H!F#}%H8E18iYqG4
zpc+`W$Yxr_U4d1cdXk^_^^E#IHfAapK^k#5_K_E|j0<f_9Q};HZK3Z#{^ReTFn6nh
z=fP7)Zjx$nt4D2UEvtM>oQ8t~v^ZLPsMHU93EmM%x}^CM`s-B7*~(^wit9JxTd{qu
zVxLBQcaPO31eS2X%UqKQt(^NNe;Dz6GpI^ABUyGqy-xZ2uyS|{IZQM;d4<dXa^UrP
zIHcEixc;*Flx5G6CI2}q&s^a~DNEzt<S(wpVm1DKNbo27?uWs5?~FAXI@@H4VZ1>5
zFdKDkC_sKhyvCdyG_}?Z8{`0{1m$NtxTekj9hSB?|7gwcluFSpQmW6nimBZ8(Q~);
zY9$UZ&Av7Z_)$3)_TcLaUVO~)QLw0kt+^t!Z4nw1c!bci;cG6N^(1-v-x@8P&%jk3
z@^h|jRz`OOok}PU714=a6V7mbGf=8hGc16xM>Em1Nid#1XNehQz<PogzAxnZ(F=6`
zZBvuk<#u#^l&-p1sQ4g9mqd^E5%0NOAk`zar8qFNp*ip2&me}vQ<4qgEv~z}C!upe
zUAmA#mGVpRA}jFbC8N09tY@X_%I8<DVGuWD!6B^W;9hYoit)HtSy5G3iP5|NcP1Ps
zxGFu(^2=8H-rRJ+x~5EqU^>(orlzr(neE&3qA&lILss!~0~YMNo(z@n@TPN%Ez!oG
ztV|MKo+VKZU&PBYVOm+Yn9Gntl~RLMZ1>r=2iX4KXU=FUED8xwruy;<>*&&QW)_A6
zS9O=Oc&=Hq1CC@~%Zlq2>b1>Wf}zLK!|>)TYvof7JI`G`_q6LD$xWwmEe($ot9vt8
z_rWWl@^d0gMC+J*xmVht`f0wJ@g4h3?LvJue#K<*^w8Cnx6;<GipcM_k-US=w<g8$
zjS{m~pY~}{W{%aARqoR=RKPwvw7kqw=SW1Myi)dh#M$$)&qZ1_Rk!+3j)#xUzm+6Q
zV?}k*ELx^Ds~k4PM_=n*iPzLr%^%;z#RSF(3-f#?_xrYoNyh$xJ}lQ#%NU^TI?+>G
z{!Yi~xRgO|uIVuBrQAeKyJs})XAnK62O0S{kBa=;r!j8MT~pR2*81UA$J6H>cek#A
zjEi5l8L1hrZNZZfwLe>}s=+KjAt^!q<$x{YpzSpGt9|wJqfJ*~1RUt@j||A?*5fvL
zx{W8xKl`SK<)}+e1GJw--)F*?stiaE++-<UwA;q;-Fii<dD`zVAdh6MK1c2Jhc)gI
zhL<-YSiZbOEo{X~lUO7j28n$(LMB1eQNCoQdNwbMqB0H|$V}7=h*=}cu%0FSK%b^8
zWkSpf4QC-YM>35LSDp^0$9fz1!;D-}O*{NJ>p0|9U+`pT1Apxh{6>R!F{%372wi+x
zVq9Wxn4Y3~ExZ!`OCN+iiVWCgtU0i%xxab{xLt{8dO&2Zwh}2uLN%$=b2v2e8dbiu
zYAgt5e<fs7;7l_9OXOzw^!^k)i1RH?hMNEM$vlP47fgDOPBf~@(ag_FI?W30VzOt#
z#ku@(A(4J-I6~~Ww&`tCiTpb*G5)kA@+8g>HJz(Uy?P@j>e^p=*E|N2;)y)&y^W+H
z4H6xjiCpeyvgnA(b|mIOi_`_H1-$HaMBqB)tF`f{#$%qzBHY*r_~Upg7>#liOJ*<+
zvk6ri&r;|5h1w*<CC)Zk)p$5lGM{srQYofG`c=?Uuq87mbU%IXBLc_bVAI92h=I2J
ze78h<6IvXgxt~*Ow5xLq+fm|w#V3juoAx+v$j{7j7@WpVxox;kp)uvD3=F=|kct>P
zp$Z50czE?2Vs&wmo?6IP8{VKv18^zz8NmkdUR7-GsS@Ro2)071q?8D@cDwtmEl&}q
z@~5Xc3{L)NAUxhuk^*{w!T@AA;UDCRF=|~SUBOfm2BR~BtR<fG4m!k<MS?f<{uE5C
zD1OS&jUzr_S7+Oe6}*MzAwWyAUn;1I$bvzbws{LV9Zd4oJ~}pvM!hvkeU?9BIKHvv
z<k9veF<ny%8Tn9RI)2v)$NQreCO23KJ4Heoq|vUxcgvHs`~(!c--Wn;oxjhfK7ZxA
zfL)3bRobUR`@=5W<Jd$}A73_V9iMkzPw%f&{8&O@V+OZU1uq}5z*Rfsu8CjkVgO(J
zj=D6BcV_i1q;a3T-shH<622}cA(K|T{6xL(&Nx>hII5szae`Ul8*+W*x5UT4GAdPZ
zRULO9ivn|!*l&xPws}u~D7<zeMd=w|xA1C~t^wHIpMeTl)K#jXW~(fjm=8OI731+p
zDmc|i5F|DREN;~Za%^c3Xyy|Y@F<gcByRBLDzARCD#Vtf5xp)hv2X`Z?O845?8r;;
z*PU-u^ex3ha=+l-&USa|y=25y_tSoNtr$qNq@?n(Q_!Hd0{<F$8HllcXukdQavE#e
zbD-XSL-<!3R3j)77lTQLpiS%tdFIZjk!`a>E!6(wkUc>qkzH`{hW<t%;-^x5x0zx~
z&l?WVk+Ai7{m+&&VpIYyQ6*1~0hB5Be0lj!7z6H46>R!KZV>|zrzfzFu>j?7rm(^r
zU2mlU#5$zddHor{C19mRJuwB4IP*x@?z_I_*vz0Hwh$w$uEu?Q0up&P_)@NzsEpT^
z5c|s=sSOEF`3u5dM$e6xBd4zdv48?wQhbPnanC#aNKtA8K1{!d1M$rGg3{`6-qrU(
z`>fEZnecB$=U-7jB_Oe@X(Grtj$o<cd-)65t5djLIrLc1Py>e(1{E80McxixR`<t?
zun8-xDo5di_}>&JHkdEyG4one%>C#`Mkc&m#%NnF)RXn>@;_>6dNI(=TGo2pXujJ!
zR*QLr^go-*!kL$vnk>tl`g1R{rA{}&Y|8>+3W5ZsK-L+K>|UyW>ZuFRXk-U;!Ua<v
zaYsTj7Os%fqDh3Fri<hLT*ukHZ}ltSKk#|^@rnsnI+V-y^9hA~*T<4X5dMLw7}1eK
zs-VAGFVP5|PuUL*TXa|L3C6C$JMHM`q{NkL&JlqB_533{mJ?X=g`V3Vq9ObyKeiE1
zPcSRI@eJCy6e0VG?r1XHbYn8yEH@`d%C@{m^5;)PYT1s!uM(g9uI|-tjcgxS_!=F!
z=WhD*{ODNVj2yrspg%;x!9n_0MQ%&iA!4Q+@_39z5LRANRca(?*F`C_14Y-DM%%`M
z0<_gr?x^-<fgxHic}if&+zXlz{Cf&7Q3?eQN~TUC{#se%o+JsKM{C$O`9^9hb=B>B
zy}LrtwiCOTGPR~uOi~Xb&N`Nm6vcFHyUl5l+hx$$Zfnmjd!Y4t%EjV4qIbIwzU28u
z9QnPNJFG64C@_Bs88uAtD35|v6b))v@r!1zX1-KU;Xon=u$=Ku4hyNlwlO~!ufPP*
zu<Nm@3H%+KNbI^Cwe`{b3<G^1oS^HGtMz$|Vb{}pO=_%AV$^xqKbp^Bh28v-Qc-W}
zC#9g7L3S2~@@{nX>zipxaxx+Px#aiuJKy1Ubbp04Bsf;fdh%$<Q3>W$eg7aV&ftfC
zDYAbedS1>uJ~l+ULT=PBker+q^+&@I<}?sF=FGeMrNy4KJaoeB@G+YJu8d}xbe-d!
z&vqm3y&U!O<iKBLW%D<S>CA_{R81Uqz8iZW(Z=dL_;#-=a;E#U_VP<SGAU#@PT}mj
zToQ>oGxAH=d~G{j*4{C>-t2FJoN458Vx>r1#<+%kg-)O4qPmBH)aGik^$A0<#$tEb
z1aFmX>Us{iRH`X@lOzampg<0Q<4s{~JV1)xvtGUddb;;9Ly(-PIFB-d$xo$U+8RV1
z)qa6Zt?htp55V8Da0USS`R(7b&9$x_nWgvAAn>919ZXhd<Y(|CgdjV{-wUn^1ruZQ
zqY$J)M6kYFTWpTrI;&l$I6BjJh0ukYZYz>6+c8VT0XPE{E>#ST3;0eL71n7V+<n>)
z32fRuh;q9T&BGzMR`;YO^{;{X)8+{pJ@0Ua5{yl9dR9p{Pg*1{F$9q%ks9FN0>n6$
zmVmFKu~GRM$*8A(D<{kxX#pQ7?Yze5tX31EYKCYGH}3Ov+^EaRd13)`8Z?##)A0a|
z3yuA~qpoB@qCYTW9s6u0KLIg*x>Q4jl!|N>DKX=9CHvTN)l}ixao73^3Y(5~o((b8
z-=yZdz<hZ28$W1^bh#9rfKDg!U|?e&bBE;*|0LBQ*p#TZ9NW%I48xw;_^xdjNT8&(
zahA!(IohNcfO)T*L^c_k#M56w(o6CYDhqb%WJ=k=t@ZfGfi4Pvx&i*Yn#|%_ed7YF
zyL6IktoD*Zk_B$DyUV!Zzmz~v5|20bQc?s&B%>nL$RQp&5O{h^;%Lgnw!S^VmCzU#
zx+u5zlLUc3`p6Z%3Nzvp2D?7BHmZ}RgQG<PsUgk?H@>bBrwfhh3O)UFNi<T^4^K5@
zq_Kd<GXFGVDhBqH-9!W9k+>Fy2uK3D?+2a$!q^Z6JN#RQtkExh9WT}ztb$-qW0S+k
zaOUR&%kkC4X7y@{X<Z61MWVCcA^Xq1lStBae>B_fp{%y-h0_@+eyq3O)(4b*){M}v
zhL<dtj$#o$kgu^K;bt-Q-N-#+eH2Wfi8~U^ZXfDDLGkxM0o(u4q@@DR_ER`?YKVZO
zgIo8N@FXNy9a*?p2zKSdCh)-K3=E<VQ_)5T{zIOrc}UaLDW4OaAE?kaCbacJhWXp|
zPXu2~M%ZMnk>G?o-n@0E3FDSBFR|SDY%+{0-6lcU!-1vmTb}~fm?&l)ZlnfOQASGK
z*^hkWQLwNa2$QsF*jOpxGsvrwNztQ<j_9k`a@|}!bv3#_t=I<dJwG}5@#PN?72HBt
z;NvCEv6Y&)O!X%b;wQJ_=XAL-Zp*ZzJ38U!q1G7ar2NQ9KQ5j*U&F@9g|v0e{iV!t
z*$RxsELPOOYD16V(c%6-`EFK%&90=FQyb^g+E>DTt?o2@efyF)0ha11ra`fZBr{=|
zH4TpLeJ?l-=Nqw-5ff#}RYU6nzye;^?7eU~zCIM4@{n&Px+E4_S}glx(M_3WpIOMW
zSr8ne01kckb+az=%5f?<?9}9;B1jq`Z^AYDB!}j~lq|=S=d;ejWe;TfXkf6@F;$os
z)BHF8&qoWcsHCl}DBVVs+#i32qU=)3O~SXeXH`siN_&F{&bi}N{ygFtebMoHS13y~
z@|ekM$%;U3@M<P16R2wXS!ii!1h|gS6C-=-b61;bCH3qEp#nPYd<h_<g+%j`YK&AF
zCZAbX^`Jsh%t3d32PC7puWqNA+h6L5J4zPKI_LUiw2Zg69#3;Gujo)oIpq!GX{^ro
ze&Z4Cd0JDA=|s2WNv!kQ@L^ZziTaBFyJBesdE&v{G~65fQ0`G0xv**|jfFVUcYMFz
zCR2G0%`{Dx+cZ_wQ1<6*)n>MdVB@5?MB-))`%XR0=C=csBke{A2AErcwHyU3u`5G-
zsYA8s5$qbmpxL%NCcz__?RX22GR^NRa;-^N`%d>32cE_^0Zy2qq)<*RN!BvCPy(xD
zt2buN)vhi}Z7n)Gjeeg`LqD35GKW}#CbK+<L`3{qK2w8)iQfgOzM6GrD~$LH1CZe8
z-X_>*-UPH_a;0VtNrfeky(yRa$l{aI+EnO+1eb@DumjqdUiZSyq8HIoga5n8vv#~0
z)G_`>ltzrqe8Wz(H>5b2Z1J+WjjR7zBc(8i=@7Fr0pfMh^Hmg;*q@t?hAwQ_gcb##
zH%74Wz!~y*m~}RshNitpE<0dF1w?&U3{GX9!u~}374&rWogdi{p%WWQ!9i-|EmJj4
z52g!S9#8Kic^)sj)ZIA>dYA3++d&D8rkQq7`BY+WN{SQ`pGa!k`fhVKGsG_-g2tBx
zSc?WA0DolLB`5UAF3b#kQ%z0<-H-y7k7_F%@sEtOKD~c*h{H}c{F|ysOjo3?Ad+3u
zfY;nE5cv0kN0cUzlED-SgYjtlI4J4{oqhUi4z%b~5BD|_I>y$=eUZEXHNRqLQSh#@
z!6w_J@PI61$bvGoOT1yTP7fF*yZwD6j0mo<mX@Bb&rxA1NFviC2!~RO9q7Oq&Oh8S
zJqy9@v0A&)?dlSn4`?*vzLdoh7r$SJe%z_`L8k(i)pE?cpX#Kvox%Kr^F;YoY&fwp
z6Y9LEanFToeqS9KbfZefHaXPnXmBSjp<}#rX~}ZFNV54#<`?GM9nAi}Spn9hCqjb}
zv62LYmgPJSQTQ8onO4JE8HFXM(_dDJ5aX>!IaH*ozq_bCfGUF_{oZncn~ga+@4zhE
z@D%8WH)r73c;xl&i#2{3#tU$)g=fAu%0>5Egf0A}jbJU%MpNm|uT5Vg6dV!sn=U^+
zG`31%aS-2@w4lc)^<kpmb4uZn(fJ(Xf{SsXjF($20$xj(Xno;Usx8%aZOpTev4HAD
ze|jW@pOA6gN<=tu#rgKiJ<M{cP<hn)LP86eV+eXf3E$k#6G(?2C3ZIct;c&BG`-$|
z@iC>*F0LeyO0XJ%S70%^frTaIxs)z!`|>JmHVz>22}i|P?32z=>_ms?=PyEm2*|N%
zj%5wErqeT=1Ws*cj&X4SbKb8QI}N^TcGRv7W`YHp*hZd1pP*e&wxYPK>k$>kr_f7r
zp<%?(p|H`T(z&3X*1<&=;vNxB`OcVcdevuK36L$XHsr|1TXLHxx8L^|0CZ}op^LiW
zJN~z#pzmz7V%f0d9tYR-1dz&{5Rc38{3c;g?3(WboasaD`Ta<W_qJ;I&#-TySV_P1
z3XLY7Kd7=H8yPv*IO{)}?d$It3^PP*o8}C$zl8;7%StEF9XHFZxVl(zwCd06xn-L?
zx%@Q137(O#hpZFlOy&)TD>p{#<N2yngxMwX1pGoQ7g{iPiw_#2t22d{TgH^t1q!?%
z%}5w!CJ*Pwfc~&_hWxN8{n5dQZ01~6KJKt|Pqawl+>M{p9OU{$eibWsSOFq$V`3)f
zu1X6E-YHc05S`k3sjuGoHIsJn*RQ(Dn{j^(DyopSq-OYkv;fu}U5iYL#0L;>?)jGm
zAKAw5428ooO5S|xBpo;dC^D69a{;C2TZ7wthAHgYm2pUB<uxluEwQAGGmxveBwbF=
zTO>S?u1*L{$+}ekJua8Zffl@Ae@jfjZA0`F;GdC{Q_Z~hfdUv-hp1+VgbB{^)<^Z5
zE&Te6+Qbu2T$Z4hgDywufQx2|9`mg<roK{pU0eHyT^+XPj028Z4!5TT3A<Hd3`0@>
z`}{mX+rQ!AwrSg#$7JD(b(_^rC#u8PQiwr_w5jENGgXNY$&p-CzuV{J*N$Gf)$7nZ
zlMnrqfe{xzTRSF&y|Ln`M%N5dHQ(iZV(WVp`OUGV9G~Ym1$b?@#9DKr9|{yqCUD*j
z{~G*#A%pdC9%D`?CLf6>BsQ`9#>GkpN>E+i3c_FdwxNI8&l(F5d-SKjCi`X_ROe6R
zSNMR}+Bmmoj+~KSDJcyr%SXla`*z=t&&~(uOP%ljbfDg4*LAZd&h)wB4nzn^0bEb#
zXy2h;bP~OPNFaJz=bCIES{uF1`yI&)%=@iYnFw+Fq+9+~PYATcp<2a$bulqa^e=y&
zQb~CC%bozto&GD*=nJI#&*hE-l!6HlZ8&zjYwZh18Q35_k?B_ahcJ2b&coMf_Kp6V
z_>7{6bpE(>&v)oKUpmSg(@yBFd#}@3csM4qEB=j{KHJA9-8>J;3a+Sd4*~5o$2GpP
z<MCH^<mj^;V@^St8MiY^e|LFi?+?$S14ah|u)y{gZ;SZ&cwe{0+dA{M4%p^PvwX(s
zHjkwR{kGL3#fBA4d_{=GK`8Y$Lff;9l4)GUG);a#E!O6<f;#ogGa-s31c|Fi@<*BM
z9P$XOgE?cMSx0{duQBs-F@smcclY20LJmrVX%YQyN>Za0G&Xk<!2R`tde+8D$m#U!
z!_xx(S`SCX#~ElPAH$-+-$<>j$6AlK>3i<G`0r!VmHzxX4T+9&2}9K+Oz01r1^sEe
zK!O^s>ekL_sjG9=SqTQ>zdE%Ut`muaqFxV4&**_-sua}<j+v#32K{rQAY5CFlJB-K
z2RBcsbp23D$2&y4t3Wb56_4Bg!|wo1k{{>oSBkUf_ktaO_V#i8FJGQ7-z6j^?r{Jw
zpgH1t?bq-x4JVvmrA@pqGmL`xVz-Kl&n26^a<7RSrDViGdk(e;4iqm1GT-)kOA`M+
zP;c!3)??FE0AC8b`v<?kRxhw9O(2o*B=Alk{|2lxZxuPLW5RwQ*Y|2Qyf8m?gkHSN
zYn-E+N*&}qV^XLq8^5u6Xnkv6BqH3gf|N1|>F+ZXV1OY}w3!}T-~ja7(OC$RyVfVI
zMzDsr93|(6JW0=+6^`<`)$%;5dFK{vy1Wgi)wX+@GaHhI(80fbdD;2cKJb6-E=}?P
zwgMrsfE{hY>)i15?afWqUJZf=H1q%Kh#s%iGxd6;q}PjCTd8}7JbyeRW@jS(YvtOm
zHiQAV4h^nJV__^mSzWTaqU0V~9M_Fsu>6?D#MZh`6>^)Z1UC%3e|cm&xuX5lyd2_D
z`AH`w)S&OMdUjCgQX|qYZ6w8VBY1;UsI9NTf7~w-)gMMVQCPKwG%pRhD3Pc5eSx6K
zs~MYSht<@?V_)(_D{bkBwM811pF>AL!V~tR{*7N;28zvznyz92CEYI7VcYnG7*Yel
z+g=!wNd%nwUATS_G$))uNtuhf12&j)5oc$1v{O(1)e|MRe|CP^y95K2U5APEZ9IIB
zebLEaGv{*10~!mW1oCa$eN<iG_|Qp)dN*J*)mTC9MZO_1iIdCCig&A#1RUndUz8k`
z_cn4XNAkh;Q}`)B*d83H1N4aYX2&KVOM$ElK7^c|EKH%Xx)di7t%qw-)$dK#n_>AT
zRG*ctH#RncxTeYWawwN_1_&lkRut|#%z2N0#XD3p0q)BE>3EDBA3qMqx`P<RoL7_b
zxa!!_(}N;2h|J6#OHMbC_|67hhUJMrke<Sw9R1BnGVI=eeyMy!dhuA4y?dmOzS_lv
z#yxjFejnosGZ>I{E*-1fz?FFHs(gk0;pg~?z;IheaPfD@H!+dMjbaQmBnek_!mjsy
zv^JY`fJ-(RE-CXO>#eke1a=dtV!n5zX}>KgJJ{ymzb7+*IKY$`5sp##xoy2HACJn!
zn)g&cy0%4=V2xfvuTB;IDq2=K6}W73jNCo;g)loxhrNt1A6_oSqvY+T6e~munVbye
zz2p0ou4&J3iJIBSIFf7q?`>a(<B<sW0%H36SB5hvD1Qg|;-Nh!^@oXR1=26#z{v~@
zu6HdLS<y<U{xo@i&^ue*&#)36T4kPsX}KWNnRz**tOtvLOG~9?jl`R~)B#jZ`Qey$
zoCqahmR0`~-vjPJ!z0P}B}Y%J#Nj7;KgPdrn||7PP}}rTSI6i4U{shPJA@sNo72lY
z{W}<wD@Di8_7;zvihE^$S1NWZ#)n=(NLdpc5S8TdbbfG-cT5j6h%B2&V&y{lo^OJ_
zze}^ix<VluH6le&9jwYg2<~h~Z{6@13xg9Xg@3RXgT(!U*OuC^j;Dk}Ou$xSA@*;K
zT}L@-bu&)RTZ(F|@Oo?xI~D}!&945fdI<A&R}~%>p13OdQ;c8g2O4tj8Rveln@&D?
z&EBz(LDTn}+E%ra+A^4T7G~&B8Le0@zR6>eC!XgHh%nOjlslDV)J@Me+a@E}rAQw1
z_u!!Nd2~C)<-CXAg7z1DLY^>SNQ4q!%!+&@%%5>`X({XxRNl7)j<=tp=rd&ok!22n
zssbTTP8Tw&UqOblS62d;*5>9t2Yu>Bo4kbgr>8!9OiMnm$A~O+{ORFUvGG_~d+t&*
z@+AG+pL>QZ-*Dc3VlhY=Iw8c)z^ufD6W6HoZg@{;P8l0xxbiu|oFw`+F48@GN;|9w
zN&C~-SNrP9x+IrON!HI4{mT7CZ6C<a27gO1j|(EL=hU<@Rci14Oo>el08R!Q7%HcT
zZIsG`N}`CwZ-VDoTn1Hj=p|zhd%@^8Fb{8ySzt^B<i)s!XoM%vmVdjDoO|(j9X>!K
zO7A0SQ^OLURfWRt<`?51*ifBa)XTBm*8$%?Bx!3oMv|sY18wK$L=CrP;Q)$v_lV@w
z{Z9rxY4_i&<aSorGV<@xKlMvVKWSVnPHgbR${tX5$acB-dLz|tJO7kNlF%5&L_m1F
zM7?E*mKL$bp${)n%20_~JNq`=Vi>n0*FK!nE6bk>3cat2_+_4Y4{2=MZ@a{DyV7fB
z@sXu?LVVamPiPHQD>{1Xb|gR65zw9*QAsxB|E5?T<k0>^<jm_z=Hmoq!<jqe;1-Kr
zg(2@zr-T&1B){SWh?BD`MKzy_(ysD_A*6HfY+`S9tkp5Nk`FZ^A0ZfZV@J0;&Us>T
zj{<>@7!Hr>=>NB9)Ve898A<`+f*h+WJ4F!fCpQiS6^AzBtWdDNf4Aw2w|(~Kp6Z`g
zAU94cnVntn^A2IHx*6rh8!F%db6<4v+;L7*@+GC}I~@||B6wm(Nk!4)i`h6^Lc40<
zuhHcG!5))^k=-9kNxrE#ez4KJ!S{N6wrLY`v2w?$o}#{ZWrNyxGXm}J_M{lvd<0&X
zyM}f){sMQeS>P8NcbRvF^?FYghy+poArJ;Roew@erztK$17~;DO%<;Sf*#GfDh85Y
z1qG*kMNzMNj16Fmz((3BoFp-~G|Bce@*R*3dwl9|dR!m+Z(n*xG++#!w+{`m=RfR5
zBQ1Vz38yFlVysRi;V41a@{m57!Nd;qZ8>$3%@kNzJ2OiMDygae2*OE9!5O1EC0(|U
z;~m8aMcGKhb$~h#n0(GbhHIv*+&vWGawm&U52A{=gemcs{iY>D!1o;UcikV$!Rtvp
z@}YDxo0{RCa@PD7CBX9z!)`Nx%A%|@6neSB%R(VQ65y|)inVK7ky~`SoC&GyZYd6E
zVP5=1LTDZn(^9{lDqy?~4L4gaf3Lnd0Gql~jDPsLjM2Uma{JUZDPXF9G~Vt#C*%{Y
zquh?~a+f@4dh%=r`9h6BsW+@09?MkhB7sS3uOMwjUuwb4(tJ|l-cm-!QBm%ja!bhp
zA3qw4h3jG~DjYHL!Ye&6`2JD1Gi7h#?EHcS1!t<LrDX@e(BzIq;`3l|_wb3@=lHm+
zpZ0Gkq1lo(x<hi~>dedtGRjoGXm5~%oV4+iVsdO20u=%hTpwACYc2t=fQ&@fJi&02
zMVJv{fs(3_zLp0ZdPcd3p*Ct06=^%&r{s(8+M|EUvK!ti2|ZVSUy%&I4Jk1$Xs*W5
z!qbbck@+GbhzGxXul-JJ;zR*7&xGlNfAsBTt7PtcuqmVw&tGR_?H3Ps0mej(1#NyB
zKnQ)_PxoYuoC?MNi9yFJNY{~)|Ej`sUq_$~I}4LMJg#k?VA1Dq-(zAts<~i9zvQ!J
zNy*p^Illw6i(N{YF`-8x*$)wR4!$>S{!;e%^q=Bllc19h@qs43qj(Id_R&M>{;*on
z&cExWCn~H9hVo(xFsNe5tA@hpFg_f=n^|<L)f&>70<*>>DvD8W*%dx>vDeddobLx$
zLQZb9u>kzfmJ4Pmb}xZBl7yCxp>?pYJsCD90#~Ep6v}Om;b6R_wtwRw-pFN|zGw-`
z5Bz4)M&(`1atU$YRbaD_r{aXidGBc;O+DO<YR(}_%(7B|KeCmUIk$4B!2*trra28a
zmqI``dWJSKvr=*F#*HSMhi`2S<AM#Wx91lE8enMZ>(Cw2gu%d>zd0K-wb|&tHs9@@
zqubVkL`;mE4Od596dn<9K8niR*I}XEvTVefC+@-#PdtLOccir@6TZu&le!beGl>0o
zw>tj<=28CgF=PNg%6<ymbXt???nxSq7A~a!gVdxv`Lnw!c~>R<9m!~aul0vMeT_f*
z;he>=FaExGOZ&P5{2WEHOqudcy?_7CL1`F+L=1##4nlZv*mW~X1Gw)Q7T+hRY8gmY
zQ!K|Oi7v9{gJW-~PQEl4fBouPk25CVLo-J-zyX~6dU2md37o8pKxlpJ<n*}Y3D2s@
zgx#XFw<SM{#U%jE(e6~}X*0;zaKy3{i^#zSyB=D7Ut~l3$63WjWjZT~o`bVyZ=_XR
zPHt^Smweq%6Fb(J9A?G%!fRG0{IHCHR6h06doAV-e%y+qm`P##ZQC8rs6zVq<;0?6
zm0eG2bpn;(F}FYdDL?6RYC$4Qs%gCaC)hVf@8qLsPtR>2!^uv%>~AH5G`zm#a3kL<
zS}2990RH={g7(IxBAnJGvz{1n;k(MpXKIeJxQA3Ez3ALHhm&r@(2oR%bE<j}+Z-{2
z3lw208nRwk&v5HMTHYv~LMVyPQF<V(_`Ck(o*u=nw5V~zgf?)v)2FijOK;C`rKsxf
zSrc-#pvJidFl8fkkQh^LILu6u;5^Cf)*d&xDv!B1KR6a3q}-%518<ZRLD8ITJbuV@
zQV&D~t?pM&+$=>57X%g<7<hNZl|=;6&mc2%ll=mE@Ivzix#+uh<g`vm(Tik6o`IKP
zY=fENp!r~C)2^NqDN3{d0e#LyV+wQqs$BfZkXWxCw6YGKdGnQO0+9)(JT!8_ScD52
zdcrOu+`9RWaf2|G0L5^d=++nUa#2+_b5#}@QdV>C0^@?RYCyBRt(e<*qp8kCe#{Qh
zkq+G$%7@ZH$-yd}g^cV<UxqITIxq(28`3=Cze1th1UVeJa|u@Q4)qPKh$#BH2<y9w
zBm3|u`{ldEF3p`MaW_>Q849zvQMn}~sT;(&^7^<oI`1Tx#3i04zaYk&=64SDX^}$b
z7nBIYLY}u~(*Rm4A9iFbtoGCY9$+fMWCF{!QEkzqHe@V@aWiMNHJk>rf4J`4wUT}e
z9Ke-XX{hM-jkL-a?(Rtrx(}RvIID$n!a!(DnBv3%!Ntqx%{@&RjHb049Lp!-dOy3=
zz(^=oyZkc}HQpE>AKbhDn_iyU#VL4T04RLWPd1!R-(P5wF2MnvR0W|Ff>Yy?3h7Y8
zLvX-YT7l-;TjZgqUiutkIU5HHdyJl_MCyy!P-W%x5XRIjeWz(B)El%ajsD5%d)nfG
z-ddHU&N0uJo@3&PA13prX$fo+AGm}JL`|}@&h18`VnTcW8OWH(+HmaK6E8sz&9|lu
z<J;tUGQ3ET$2Bs4;Vw*EE=k)Hs^PZ1-=j}5LtGjCFj{CQ^4o>o&={)~eu+3}@a9D5
z#dk&IB84SwG7Zr8ESm-xc$6UFA0ol3NN8EvD%8CA8WkrJ3b}z8A%hJzcT`Qg=4dcE
zMmX?7m1Y#fS_X{>2sz%xhm6%0l~K|s<Ez@oDZ4>cZBN9g38KDb{`ZbXNbH<7hJ9v_
z6K-`M9m_KZN4obW5#M68HNnUCMf=~r`I4EabSDs=K%hEHmr)be_vJn7*))_L;Vw1W
z&f<Gtu{cQH`U#V9|B>1257KX*=^^5W@Xb0L@I-HOA7udyJx7Y6{{*yaqQLR<8Gapl
znweG}(L2B~GE1vC>iAT^4amq(*iqXbX@!KMZhVV1r-iZbXUqsGV@t5AGsSxbHzJF7
zu-mkvbsv;zjW`97O=Z?pN#b#-iE}t~udS;k2lBojd+B_*{Appl-BGPT*^oz^gM}4m
z9D^P5dGrmj9#hn+kg=HODMfT_zb3Tn&4Yj=j`SEF?5N(Hi}W4HHUH&ZR9sdJd)T3u
zjck7-@+88so2Tql5)q$p5LXQYrJsm+-nb1H{tm@{%k=Y`vlJuehf8Ai7~a*#_ZEw%
zWA9+<!i#m4#5)I9IPs{TdB!nJDX7q<LUbML>xRR>$YFEZx=I|-i%ZfZa&C8AujkaV
z76Grf(I`8^F!ZeS7KNh*{_Q`di<j<<R7QD!M@o_T+4+r#x;jl=<{iPxb1Rkr7oy7M
zXm_?>5{)*rdm7b638v;D-aWMV)JSb|H2k?XIM?T&$_KNO_w8dFe^|uw!aqVdjvB4r
z^EJuI&F~T}N%eOV)6b6e&Wc8zH-7#b4iTZ}JzWdPpo*XL#s#f8aDt3_!P5)X?zqfm
z!SqSddU2KU>_Ct$zQuRo+qyV_R-dct<5C1gxs<uN)plCK#FRLf#rIDk|9Qe@3dIzi
z!I3V*I10Bv%%-|05#h0kERG}&z2oeK@R<6$0U`l<@fm4U!BTMw&)9Rg>$$o6S!NCw
z_U@Vt)X_v19APCfi3brz{T|0A`S}qubjp8va2e#8@T19~hSxSZ!CxuYPK<-ZrVTz9
z<mJU%DvQf;b1FoPkSV|a&tq{B_>GP-$!kbo(!;PFC&PvSsy9C&Ttp5b=(PPPqzPHc
zR7sLd+5&O**td*nfoGV9a&&6sKzBXgpuePb6innoj;K|}f0*QaQ`bVk4-OmS_<@w~
z9o3<6-ptYIp4X(~(eVj?LPt50?Y7b;HDJ$N<3`Hhiy4yoFh%fNmvuA;hX%T#*gz~m
zz)MPm>Nc{zS;9^BXy?vF`Qh*s%1B>KZ@j%1KGt2IOC&-`>3lFrBH@Ac{%`7b+@Iw%
zYIsr5w3k)JYJGETA`E}lhT&MdBd=~W5s}UU{h#4rE*TTHnS5MvG4MG3CNHlnK0PQX
z@O=rFrY#JlBYImsg%}$L@TT1%G1souR$u+u^jDhCX%jcyPAv#>^f0yjGaRWe`^TFR
zs$x2+zj^LZ!>KT3qY+AG(@u%B<cW+QeYY7KpQ*^)Fz517Nr_F$k(X&;?n}6%43q0g
zh1zGqD`nSMN=il04Jj5-|5spFHaIpBK0w#m;55Op)m(ZAh=sF+5&or)@omxbfV3-T
z-I5)D;YenX&-0_>`$roR3pp+n?s|rP6d7r^v9MY<^JA0{V@q2bn;viAoY4tnK=N0{
z#(358<2lIH<)jd~3Qz{?G<I;TAjc9S5aj$=MM-IO9QPOJpU7(sid2bEKg_^DYsEYV
zMZLOIvSzY~Pc#GBu0aKF&dN$gI%A1t#&kFtHT9>)QPW`wU-wZ>=+|qb5*A+Dd<+jY
z2OGRyley<qb;ZCB)Tlj>^E&VG8eVYm*hpv2Zf0ko{U*mpjArAlFWS|@#$vU*BV|0)
z&@Kp9Gq;dITEdw@4onn5-}z8PVpA*ho%KKado%w$L;g>p(Kwe+;bRp+pMnXlLIruo
z0%pf>##*CHIA5h_q8BqDcWfhJk9TuszxV>Q@T0`F^Q{ZxTxftjg3muD<+8|>(i(MX
zYl*Vp<KC-a3iYRq=nc@qDpvjz*jAwU0ci<O8XDRoJu77d&Rf_5^n(RLe^Z73;vp8o
zMHIflW1&+-3NvbTd4`p11`M?&Ru&_MMlag7U2<o77;`^8A<|nI$x*qi%&&@oG(2}r
zscOdVJTXky?wfbJEWi0$l1<cC@q!1uEa96JjLGP~)+JN@TxZ8@YWVD4AvA)ba(=wz
zNO0PIuO5hw%!)!^+I^twaW1>me&Mcb3**<XOFByqs{iS^&W>-JAD1ZEnA2~Hr#^X7
zfXyw<=VBAGs_*cH#g)4Zg){09*_r<{>~jA%p1!Qrm1!3|Hh6djeHeUEpMgg|d|(xA
z6-+e1Y$n_@DhA`aH)YuEpJ=_VZs=PPg|8g%_67uQ1D%JQ+tWg}Zw2}m+v?XpzBmq)
zMeh&o^qK++jQ-Waw#_h6R>RGpyT|3@-TK7S5%s8>Ls>WrH(2k~c4_!gl_H$+G2s{I
z&3$Vwx1KE?tqejxbj!?91}H5PcK+wIaPjR2TT53c^mIaya%u5{5IH#?N=iz;e9!um
zgVaTvWB*{ULi?sZZPgSm#`aY7%IIPB#V-uV4#w`;yySC0=hxaQ&#h|1%Qk0?_nD%g
zG(yemv;?L2&4xyG$w2#!lS;8{KiIGK0~3a2$v-)KS`?J&yOQZMntW$;MA4epKbULz
zMd?U=NML;Bdd=dWYz$@rOP41hdYeIN7}>>*LB1^}W>h<e<N`OWU5YRX#K5?-`p8sP
z0l~UKV9>8D0wK5C0NY`oZ%Og!_Tom*k^_S#_+tl@;nM&z2KM=)jHAt3$|tpX#EDqI
zFW4@Ozh7hnv}?4%-gtfj)(y@EVIz;LC&ng=wzge&3Ak<;L`4{224R5Zy4k?qvv)s=
zh~4P0RM=0HQXm!CQ78L9zCT`oT@+-sQjdPvfzvO&xnSB#O=V(AF_+J5rquM`$C4pH
zB>oAk{?VUs@Q8MdLu)ZYv#!19)%0eSW+4~<qy!%m5lOLUKSxCL3*JeGeqhVOHp?vt
zuXsa=G)X4mAZSQe#bR<yVQY4@)Poem{^QM|@1nxvm8cXZLt{psM9=2LZ@r%C=vDK{
zgWkfRWAourLQikKeR8_d*9O~CXih^u>Xi7qjSbbs%kqUp2)nxKS~B3)U{drtmukL=
zJl{B|>fvXO2!jVR8vnN=ID%MAcohqA3SeD%hU4F6HgIvN&03*upNpxZKdZqBEyDa=
z-!ylrXdd=ICzY*(Fj;T9HXcpGe4AEGz`@aJAw(<$61X=c6vPK#V5!@@Ffk~kxQM1W
zNzshdkX%I9!I<Cs)PDu05g$xi&;mU%Xu0X_d)U+6*>VbON9mSO00q{E^{edVZZEZX
zF*Gs58ErW2T4^yg$0c4oKgK+s)-%%!-7+6&t9s}J)+jO&$NNOVCVU3;Rl$Ib@;dfi
zJ~3DVUYCAY>ns6P*3#|cpi6ypXeh>~q<;zU*0HshG=!NUOpc1+7sm$p$AOY4*`Lg)
zuylC-=!xU?hcM@yG#t-)59cyqsoweg(`K&7mQ=;uP}0!AUS5VB=-<!qzpF}>3dUH=
zANdYEgL+~yiF$~vBVjLZ7(+3)J@(b3e)V^4*2_w)ku7$+FD61VUQWf?PnV+R4Z58y
z%iuyh+V(aKCpwfzself8I4T&0(<GA#dMNi0jSG({8y!~)pc+*zOb*AbJf0^d)%(qN
zQIF!U4u4$4f0>9ic_oYu#WhaUhe@>wzS2)ptP_cW0tL&b$(K{I9iU{_2C<L+lA#f;
z!yO3^5TsqV95Jjm7Asw0w$EOcff-|huB0#Z&h-c6;qU5>TB^**94qJY@q@%1YU}DK
zIXUr5ZL&-zNH{?Y<;L4<j$>q%IV2*&A{;WPGAif<5s1`tDFpDcMMRsMxo5CS?ZV<F
z0<rfiQ0FA_M;_a}It(IotayT86H9S_`M4sWdxFL~67}DUM^e~5*a;Are`KS?n);HS
ztsxE5@Cm&&%<UR^xRTEEs~V6D{lPw%bd}l44umM|697+IKRREd@xj$kKk3E*jJR)5
z2Vji@#M>2JJ2{lVFOGn)pG{P456zm5H&(=mPG8qD505wT4Ao(o=yAQFu@!@tw>Jl&
zN14-+kUR*|n!w`?UKD(dvkmZ?jgmPg3iv_E!BNnds2#7Irjo;Xdthq>aqP<$&4ZO+
zuqeEO#6DAR*9BW-8PTZzn}VHZ{wNTp@-=;D=ZB(9<HJ!sQVREum-Ohy9bCO@CL>Ic
zoRDO6WGDD!F^bgu&4d#=IWZkbn)Hk}RVZIePf|@qrh&Z+Ua{S85cwJlM*(zMa3xs`
zrR<kJ-*=E#rVqEg+R-KXz$KUQ-)W&y+Bxk?)qJfZcYfijR>lT%<5P&_#EbDD<5kTh
zGPwxM_w<JmHb8Lk0PA5NSyIx7Y?7%e3BkqO_Cz$gUT}1wlpbuomgA)TL|}ujY0-j@
z3Qc|53vb>KW=n|*sRpbuy*}4!IE_$gT;944_rBD*I7?O=GCGt`$jd>M?Vt(io-=AQ
zj&ZCmvyyXfg7QEAOP79NGKc?Q>knJvlV-}FMqN2VfE1B&vc$WPV=F?*q$Z1uEQXAG
z*l{_qjDys7%s~%1=~+cO6<!C^=1Y%<p+AW>D!!lW&@V(nwq8#ORjpq>Ay={R!9=iE
zv2z|i>qidzcimsjLBntshu$zhL{W5nV-b_svMHt=54(mi<lV?Fm}2=aqF+Ac|9+iH
z0ywi6KzL9-B8akM^gVB@j$ZZT%t8<jnC85Te-|7X)RME@KUkHl7wD>sPSMr<4&!J<
z<BK@p<Iyh-reAh}{b9>>7|zCYZ*M*W&7$z^;wC3%2RP{R3VXHa(P#e45n+J~3q}w(
z^b3RO3dw*ijfi>sgL#LafSg~y<}|jU`0BFGNPix+HsypuAKN@J3D=^3yfNRgJkHVK
zS%(36&DNv`{mKYOLLivlY;y-T)Rv5rPAcAN4Bc{{uSnp(3?cA`5!RU#)Q}-A*+?Bu
z|K#oEXcnR;?^*R_CwfIP``$N$RD3x#HMHQMn{K(}&x_XPN8+G1Eie8;*_0nI@QB}e
zzB%oS!fa}he>%1YX<irvV~y<O!p6SYk}Lxav>`p4D)9gLJ|ws~(I5TNBq!i1yf0-s
za1z{OY=&J-NdZAR41ecgnOwQ_34ji4&_>@XHRId{ELUb?Wb6sT2{9ZE{NBv}-Gv;8
zc7M-xceP27oYLQZ<M100`NHtaDS{pLaDnOA0we+oU_>B{82Q=25=?r8)1I-DhWkn;
zST4l^8dC=UpASAHTiZA8`3R(<0m?RC?(k-97E2^`kJ)DHh#Bq%9K)xW7VKi9py31Y
zw|3WWlcU9jowAqDsy=|}7G7||IDLL%P23nMxuoYnC@Fvz<TB6nLf_;;DU^Rb$9y^m
zo=2jeOBC?`1ur@2v+>T1{6Cs0#~Pu0s{gy56Yk)^R1Amwq%C4-nkBB+jaF#C^ON8k
zf$8|<GUs1KLJ-ck!j(sY`=4H5c^>x<3Y28NQod#y!K-lDizAZonuo5E_rtIOoSW4y
zvUt>&fALq>HwB;fjy=$RvO`N-e2t8%`;97|4k=gWLLu4=jRtU_r|ljA@9MfEY$@vF
zM#uU4wOzO`jb3{jn=~-8B#Qg&oJ60~?Fe>tFVDVvT$Q9sSXiwnfOXQ(xQw6ZlI2Fp
zMqtJo{mg6l#s9b&o!-NK!Pn{9Ga)|F_O%thu`e7G8!J%kR<HNh0fCUgYnP!2msBW;
zfoFz864}N7#qPM_J^tT{K#Vt${|Yde*V6~Qg*92+aNhpwQ3(9AI)?vGnYz@1U2SaQ
zX7#yZh_$CWpgBRZ|8!s=j8E@ZMn3_(ggnTm!Gx;3*@A?Img3Jv=^^RP$m;W%<ukYc
zwIBs~@Q}HM6&5x4(}M<6y5<Xg2HCMjK-NS1-lP<{mZqknj#Aj~q>)OCXhKV4d{`d(
z1&B2}5tZH1nO0v6O!vy@57ViS@#ek!40X8Ml|6b~Rgx#_$_<ER=SG+C5eVJ;larAz
z`e#9&<R7*BcqmfDSRvvh%++NWOhz_Os=K1Q_x<$S|A&6dl^wj%aXyIr&)W)j5WT&j
z1_rZ}O?J1?jiAI|52#gaCOTs{mW7jjj=<IS+-?yN6_*F)Z}}}7iHfWwlQX~|=s=i6
z_X24(j{7ospM!t0O*WD-t3uo6Yj2)Hdzcw%yNaNhqowJ9H!&E?RDYR2U+ik_)ArxL
z)kx>oeWc}|EC;4XW@|ry@7I&4BtxS^>g(}ofE0)+c1V-TjaGxm6hPDZpi6o;6fhl+
zTJS&3*Dz{?&hx{q$VT9Liqkp)Y9w;i&|7A`l>Z|mv|RZpxa&q9bvn@7(qk?uFIO3k
zI*t54KE@k!92;B=DS1bUa1owr$nQ3$oM$Yy<oR5t@W>88CXwSF1yTVSq?7qlKTjpe
zrgEhXnOIqUr72!W&wv!|S9J9n8gKXcl$U{vX}|PEY>^FT*{sqQe2q^`Dxp7WJGGIO
zCYjk(U&UDF%L+TIo&&+=^_#^5iiv-_sYo94MYbw~n;(LyVIse?_s_5nl7nN7o@A`T
zIDW6I&-LW6pGS>PGsLZtpc)9!bJ56xj6S)Wd!ZKGlwPom6leAD)mbeD)R=Ep?xo3`
z^|o`Ko3jzBk=J{_)MPAv@cc-X@ro{>{mhX@sC5l^z}UlR7lOAxj|01~JQ|9c{11bU
zL{hReP*#_V{@$m*V>l@OXJt_>a*^JDt`P!TNNyYyYAZ`<IBF(VzO0B6L}e`Y_xJSl
zaV@97Y<l28Ut;=CnBAwn&?`gVuGi*{<*sa+pT6Cm+z@7HA|o-v5l&<(&GmpCNErM+
z*JbY^!AG3sbOdE=G>D!c%m|Kp7Pg_&vXhW2D>NCyqz`eFR@~smqWp~bFj&jgQq9qq
zB^y<*2~0hj`D7F$mjXz+YCOe5XmmKM3@D#oZ$HJh?SUW@TrFfP0rXv9Zk+!h#fAC_
zs-$+cr2!6wAr>J?**S&CIyyXMVONG@@24!Z-2$#}GKa4$H!ss!9tVr@umI%mDH(X%
zW&3g;@nfV?5)WlZ{)_CDod5m+S%G~xos(*c7aul3%=251<M7jqXpakwfDPM=$yM!9
zZxPgASQ?~98Duo?lv&AT2T=`v!<3dg__ycYCY#8lN$??TkKYyYjnZN5S)a&jh4I20
zp_iQ)Zc1Zn+7nX(yI1CX4~wb@@8>y{(?*Q9hYJ<P&z@Zg@UU{&UMEvTTD3_ifK7eE
zKJ%Qn%86}m8Vv&bG6AjQ`J+}FrGt|_>i;S_{VU9yE^K=6dUl_&q6MPq-UlShimh<;
zQko;p$ZI2X49nB%WF_mqtcg|2H#FzVI?LWZtkyEJhFr>%aS&qv^kg)2<Zr@Z_EQyX
z+`rHNI7V+2OJw%^4E*ERJ2*fq>TL~=x8mYA<De+=KQZ%>JR1>=<?EWf^gw{00M?Wg
z+><I}$<%WeyeTB@jt3??4k5d<GZ!ZY+qs#|;tgYO{!eq%YrXoXSeZ~{f_OPtP|cU5
zum2Ys2zfAmVx+aVnv=I6x*1$gxt4Cga@zmZ*m=J-wRCNmqI4oHG!ZmXgh+25x^$#T
z3j~oG5DC3krATjvNEHx5m2M&sKxxO&%K@cG5d>)hf*`%U8}z&0^Zxeb4_KLN_RN|!
z&%U3vm%by43UH)qmjldBIzR7D{*ssftOEm`tix#pgjF0hMUoMPKD=g9g1z&S&?wNa
zMc*_z2w9NUG;nP`9iDi)dFMmC-o#+g)!e(^zcCdc?0=Q+E3mWuOx3s-oX~Bb@Ci=>
zXTvG6up1=CtDQ_7o(g6A^?Mgg;~cM@^P}V-u2$r#m9!?zZ2pz>I)NbFkGW;zbem~M
z>q3Buq$pK`724i8B+ZSa!~6KC!|J|nG)4d)0c0RYvfPrEkZLb!A_l}q#GVf}v%>jo
z-i4K(fkx3vkv`k(qhfDy&M$u~MnWggyB>~#qw2(&)2GprP$vMZf5oNr!0u`aFX3tk
zd`%I5MYy>xcSgDxZnFoJOp$}vx%v)9n3`Jr0qpJk{zgIEO9!Z?Y?f89m#EZ@rn4W|
z{P^<na?vMv;i|tjEReJh#@czY!=ESOTw2~!8g(X&Hs34KSTK^3pDgH(GZcp&oM$q$
zaNWwae{>HjH0N`G<;o~kv&FjM?Cb^F^%R%l=bzYL@mt#eNbvyvmx0$WQ*ITuHJ6Z>
zqIK!2nS`O&vFafvPEN?0U4jXIx6I0`-8Qa5WG1!mq~y(V*yUX&)FI?giAqB3#|Pb_
zur!Q$krf9gE_cWR3~!f)`3(b&#+#HI$}mjSA2BEynf4zU6RI#LoEYlO6WWfNz8w;y
zMA^z0{hJn8NWCz)NlR<j?5>^}_EuWusIi2|sIWLOnlCP80#EfQ7-s79pvT!Va$aFO
zQPfAv#TG9A_1LWkHagwi6Q!Zh@$Ra_mYhIT)nM~*WPG-WFGlMX7#6)?^Lcm3b?R`c
zdi``RA9SIwU%zx)rIj8*5Q{CXlc%>v*dx<donUd)ULJcsjC9wex^inao1G!h%MVVY
zdj_R%xRwe9<UmDQw%!_XR>I%-lEdv}9M;W#OzFAw_b7566PX^LDo4<Xl^kACJh}3t
z#p`mMc3fWyc(i-W?IcvO>L^iGn6m%(DV(kp+7+jL8$F^7qzu1=3df1e_8Mg1BU2X7
z!R+>#4f&bx2QQr*8R6ajJN7hPGD(}yZ^&SW8EF&FGz#n?(9w0E6de7^>sBNM7cGJZ
zth^Go9!>a5Ge?eg5fdibpoO!2C0SzmJKd3!M0Ld#=w>dUloqs@1anFz9#Lx>N|-^K
z*zwfZ;h@koO>PpiSgXesQ^QjUyTwj&fnH@iA_7%NM)>FL)>m{RTojwz>D*y!w6@o^
zsxg^I3*!1{py8c-VJsW%I)_6Rj}ZNq=}!<2i^>0%ih=StAYq{LK=In{IMG+&#d6OL
z6~Eb%9K~GmPW>-O;f$;YY6{RYH*)shOPl}z)CM%E&6sjjs$h=ra!Bh@K35};jc=`m
zLQoyq&-@dQZTr6H>C<#w#6r`|F*}-pai~Qx;y!uV=+m@8ITZxq^e86KI3{!gp{6Av
z!du4BPo+j`gfBJzJ=^5hXOj?WF5{no^0}*jfZPy^Ik33S5K)^|=Gpg>HENreP)eM*
zqX12ejMRL3OrH=R>p__U(KJ4&;DA8OoO!+*Q<6BL!8`%57b)N#90sBG8gx-<B;9T0
zfYY-rXG$zWoWxcmf1mlYJM{{ZY!VvmvAyQvBCl(oeUedjBIB*yvbGy|mEN&n=LO#z
zZj#$iqS(5b4B}1ZcDUV@{3g|QJJ54vm4b?9);}gxz9U8ZUVp2Z?b=mWIAt0U`XNT}
zs70;@^()tc*;iq|F5)pPu<DDob)%Id-U1GbnGw`fx7B$ra3x|SD|I+W_WtIV78EOU
z+2F$hHJosWJ2sa?b^#Y#QHn*E8mUo~>cTSU<RU`ci5NQA2d&-o#<S-EiawuachMbl
zbRmS_p&~Xy*#8Yp{#uQcwg!}aIfjx3ZI1S$XixfB-0OxS{dR}6Eu}(MYx3<NSOq~F
zX&QQB6+1{JJFbnE$4T8}u*GK^Vj;Sf*AX$v@xy4a(F&t#iW9Ssu^#uccWb%)*mjD}
zxS;g!KgGGFk%N6-39NsPePV4EE8;ZB-RHT0MV;m@Cm}22<5taf+nJ1|yB7J;RJPIn
z<T`G4)$R_%>xL7@AI&3xBPwVk&!uxPhKkxJwr|IFr+4XFiUVP)D(|T5#w-Qa5a?=<
zIOx`~1}$OlueWsy?=!VuN?$SaJ|lUiPF@~$*+=L1#UPJ^*bcEUKn}ZUyG%C~JP&9u
zR9A;AFpu~tQHzr3MLpcJioVR2isX*Fedf<ofnEmZ0O5v8UE#M#fYmUtR@7Zc5Ld72
zLxGJ7)g40s*@rd-%!{^o$-^U*uj0*4&ToLOmg9r2%k)$EmCssD`qaL)aCJkfgy`}E
zRH*KOLtRbr2*UnsJ{j`OSx}jb+`T_8iDtQV#Iqq-j}rx^mZmhR=OO`GFX&7FZu9f^
z6*>*>6>85S=~GD+5!Q?CTIcof%!k)}e@>B?bRz07R(kx`#)Hzz%1*%U51zAjb`l9-
z5>nTE=4*S_Hb36Hns>VC0)^XncJ;q4WWVNnmNfZfTI1zSKJMZ!s`B0#kob&kIurG4
z-Y(#w_J8i^8(_VWE$(H=g>BztW@i#@7V(mGzr*P4@{NVs9C6ExUY5(*)la_vo}G$(
z`|;#vXL;x3+ZJ8Px~z)h{iY&KP8lYJ+XvaX6^@FikOK=~r>*mTAHPkK1c8RvI3KxR
zF&tKh+#tNuGSgGPk@Opyj491{s8x1xg#&~HktN&~;1cx;d!f4SUFe{elw!Pn15u}j
zYu5}jW<*r7Wmw=KeBQ&@H~$dA#|2ON7l4;j?I+e5S{V!^-2>z^Z{=sUhpd8+$4&=v
zk|r6FycFsEBCZaPR?)U#_~XjTwt=RN)(<voMBmI;kUdL_Xa~aRLzVSP^;Q%jlCt~%
zjX*MFK7qe){B+(SfP#33PDBGX-X$$~M9l~7d)oeq00Me9DHWcKf5$<jKc^gqYfADi
z2Ez(fb<ERIU<azbp~-R)IjIyRJmaRq$G~x*reJ71Za4g)`gGc4`_K_)X}L%D<B5AB
zr<aXTN3a=SJDl!(3(#jY2VhDpWMD)_yU5Zd6xLg7!ei!rm!u<^!o+3!ff`KU%C!%#
zpS}w(1m1)gzqwx-^AEvX$TZtDF93^~a5C!5QnCgd-W)>Y@eID--4){WQ}e6Jh}T`N
zZSMY5wss`KpdrsCJnlf||K<>4q1F7ee`tuk5RoD8(;29ZthNbvEmX%Ee_=91bh^Ir
z-cO(q5f=cy%Y#<m5@V)K==NG6h@(<-%Kd7j0a#`u5}<pI0Cgndv9lQ+kuSebP5Kzx
zwpFKz^}zZ=%t5hc?O$7t)`sH3KnZHcYptUPXhW{{SzwnX=!;%cSay7>cCoEyUNtt+
zSxvCK>)yc9%lq{Q$PZ-Xs}y;7i8KQvw_ILS^>MHZ8VntMo>dwXS|E8tKrgb9_je8B
zZgYtS1xA(>_yR7cg_JtG534$QC<sm}C}C+$;S$_~C!%N|31pncY`vc2WgIyufc5n6
z7ua7|u-0s~zDByXQ#}^kFc+?@i-Z|JbooAI3kYgvG;EUR4<6Wz_leJIq+w0?qE4}K
z=-A3b>~@D~<*E;#6N*|jyGGL7^|9+Ss}^-Ryg#;VAFc-ToqEIJK^ii<G{5edqy%PR
zqK6y!Xg8QHsluj^@{gr1GBsX+1fZTI8Zh|{Vn*B^{2m?B(dlx->2I6m0t#L?7dn_$
z<np8Wy~MgVCbiYIJ8KIS_@IKTZOw<`R^W%rbFR8T=~FH$`sK=))pJC*v0xQa6u#o*
z);ao;+0IEho3rl=;`#ghcpp||wS|X`C<+{3AG;(4xc(ZD`r;Sbp^`QQz|onfWFicb
zh-BS@ySu2G@ZBlg_V3kucO>ocVuI`+jUcJ|pW?EZ(W$u4pYJpt!V}oURMQK|PAtCj
zp}<hzSaRtb*txcNeWTwYRe-`^=pWnC>r_C%p?6=3Zl{&?QoHZf&eMrYC|y<!Y<inf
z!Q?s}jy-$w4Br-(eMpJLT&W#Zv3zS@m0_x!1vaUF5#*zXAiN(%I{?uD*r*($gdmuh
z>Sa!aS1f~}DGufdRs@|-anu8|MT$Aq&f!v@uo)E`XG`U+ZKM=eIQmA6+Y9wnh5rd`
zn1eu|Qfn;9$a@IFd|Ec|#d#6R3zUwLfIDe+d(l!{guXRy&@8*2@JsSOkkN_Fk(=X!
zAC0Y;;=6lt$v0F~wHe8d4tJx7(V-<f_dCEW=_w9sJ1z?fq;znPSG9$i7t)jxg(G>`
zLk;bk04sj7%d|fHek7(|Pw#7gDUJ%{2CYXw5aKF0ECz<@{Qf6dLOd%~H8H6L6seos
zQ!+OvHgdO!c#4|%5x0l8@TETs1PH5Sb?J0_T8l&2>F>O@w!?38DF{{wKiSDA$GOxF
zoC)6FlT|2#qx^8RE~Y{vmC0_VCtAd}>p5pSQ!Hm3xnLePjj{jj+xmHLFY1A(^Jm60
zW)kOo*`EQ^k#x}QPX?_xu1K>gke>L1wbq~lO+=iDl010(wp$4a_6VctUI^B(F^FYr
z<_Y6XvIFfx%zDug!*!wcIfIX%5)L!WbOP42eEh&WdjF03ER^!nkEa2$QK~c=XQwBW
zd@QPYm^%O@WW#(M^4>W83*@)k<4faZgRlsmd;Ii`X16v<E2vj0<mKX4SHCJgB~D=$
zgoW4*5nXJRKjURp&U;tPwyGc(lUHLSUoSZ;TIG}MOWQp*G!#{L=qYy;oeBCp%Zy6>
z1vKxu|5!Bq#9KhtW`~En$WtH0^>cYgF37xXNym<H&h>;8Qe5&E!fWXIzyF|%{@g{O
z|70NA%^I&RFBaH89H^*()<~oPkb|kvu29gF&$@rKvuk`;Pjbtdp!(raTPKppMTo_l
zToz^&zk(e7TTyvhrvUW1L4xAH6OHF4vHH>1Hqa+?i3ar5Dxj&UDL_p1Cpf!jqNCtV
z6}y*Fxcfn$fApFn0pJ9yK$B<wS9w9SAKe7rWG<Ju8a-x<9{AykFdm!5>?wG6bztsZ
z<fT99N#t3p_L+P_Tt^t-5gOxTF@=5*+JR1qukGO)s%YYcVmdz*ibOlR1F^q%*<=SF
zY*^shK?{(pg?9>#;CpIH<^G@QYxBi!v3@k&<L2<}+Wp`7%kix}Pk*$xwo?4!nyu6q
z5;CaxMV6k*%~f(V(amaT3J;BT%L=c#p7S7PBHb37a<s5idJ@cNdvX$#vgbG$X7NZ{
z19Te2aol_L>X4#~RL4}E#k#!O$puaFf5I+ZSk$7gT(iv;Wystee)=bu!xQeqQ{Grc
z>;p~#Of!~lbt7xF=2{i7&EfTA3YlyaJ9}dWvK}jbrh~$z6<Wbt=H~Q1^9&y>{84{P
zvCyjidpR<NRUES)A5A*%lc_sR1Y52yo(!Z^zpuO;W|`=}+`$i;9FObn8EA6Va1N3^
z4tW<8S+Hp}0XpM>zv}DY)j95Eq~Jg;*YvBAUbH#-Gv@1R=Nx#mtQqA@TmHlwWC~vT
z`9pKJJW`ci|Ncau433TXt3vE6HHnom72bZnbLooHiMS#j5Mu%vR+!{2${^$CUiy$*
zE76g!&ij7{&Z7&HZjnhcT6oC1%r(wvYVyo9m3w4yQQvr!@7fq0r%R#<UO<rQv0VXE
z6@Gn$2?d^v&gcC1k^ms?Yhipd6Y;*)*8WHPhNW|yiAm5%C)d}|wj9%BLQPB?XtD=D
zm&hdlcczvg|BQ?zKKi1iVXqsp6h1pAeubK{)lOPp?d()%dm&@>j95KX<nh6^cWp$#
NPfJZtwMyAK{6A8{{KWtO

literal 0
HcmV?d00001

diff --git a/doc/source/images/develop/kernel/poll_list.png b/doc/source/images/develop/kernel/poll_list.png
new file mode 100644
index 0000000000000000000000000000000000000000..2e6a2a7211eb1322fd7354c96e4d2bff134d78bc
GIT binary patch
literal 24755
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

literal 0
HcmV?d00001

-- 
Gitee


From 5c7dff7b667d12d323585a8aa060fe6d96270a5a Mon Sep 17 00:00:00 2001
From: Frank Li <lgl88911@163.com>
Date: Thu, 10 Nov 2022 14:04:01 +0800
Subject: [PATCH 5/6] doc: add data passing docs

Add data passing docs, include: fifo,lifo,msgq,stack,mailbox,pipe.

Signed-off-by: Frank Li <lgl88911@163.com>
---
 doc/source/develop/kernel/data_passing.rst    | 109 +++
 doc/source/develop/kernel/fifo_lifo.rst       | 510 ++++++++++++
 doc/source/develop/kernel/index.rst           |   6 +
 doc/source/develop/kernel/mailbox.rst         | 727 ++++++++++++++++++
 doc/source/develop/kernel/msgq.rst            | 483 ++++++++++++
 doc/source/develop/kernel/pipe.rst            | 704 +++++++++++++++++
 doc/source/develop/kernel/stack.rst           | 285 +++++++
 .../images/develop/kernel/datapassing.png     | Bin 0 -> 43199 bytes
 doc/source/images/develop/kernel/limit.png    | Bin 0 -> 22954 bytes
 doc/source/images/develop/kernel/msgq.png     | Bin 0 -> 13542 bytes
 doc/source/images/develop/kernel/pipe-b.png   | Bin 0 -> 24269 bytes
 doc/source/images/develop/kernel/queue.png    | Bin 0 -> 32394 bytes
 doc/source/images/develop/kernel/stack.png    | Bin 0 -> 17296 bytes
 13 files changed, 2824 insertions(+)
 create mode 100644 doc/source/develop/kernel/data_passing.rst
 create mode 100644 doc/source/develop/kernel/fifo_lifo.rst
 create mode 100644 doc/source/develop/kernel/mailbox.rst
 create mode 100644 doc/source/develop/kernel/msgq.rst
 create mode 100644 doc/source/develop/kernel/pipe.rst
 create mode 100644 doc/source/develop/kernel/stack.rst
 create mode 100644 doc/source/images/develop/kernel/datapassing.png
 create mode 100644 doc/source/images/develop/kernel/limit.png
 create mode 100644 doc/source/images/develop/kernel/msgq.png
 create mode 100644 doc/source/images/develop/kernel/pipe-b.png
 create mode 100644 doc/source/images/develop/kernel/queue.png
 create mode 100644 doc/source/images/develop/kernel/stack.png

diff --git a/doc/source/develop/kernel/data_passing.rst b/doc/source/develop/kernel/data_passing.rst
new file mode 100644
index 0000000..9bc02a7
--- /dev/null
+++ b/doc/source/develop/kernel/data_passing.rst
@@ -0,0 +1,109 @@
+.. _kernel_data_passing:
+
+数据传递
+#########
+
+Zephyr OS内核提供6种内核对象用于在Thread/ISR之间传递数据，分别是:
+
+* FIFO: 先进先出
+
+* LIFO: 后进先出
+
+* Stack: 堆栈
+
+* Message Queue： 消息队列
+
+* MailBox：邮箱
+
+* Pipe：管道
+
+
+官方文档中列出了一个表，和清晰的说明这6种内核对象的特性 |datapassing|
+
+内核对象特性
+============
+
+FIFO/LIFO
+---------
+
+FIFO使用queue实现，因此FIFO内保存的数据是离散的，不需要占用连续的物理内存。
+发送数据插入在queue list的尾部，从queue
+list头部接收数据而达到先进先出的目的。
+LIFO也使用queue实现，但是是在queue
+list的尾部插入数据和读取数据，因此是后进先出。LIFO的其它特性和FIFO一样
+FIFO/LIFO传递的数据，并不是将所有数据放入FIFO/LIFO，而是传递指向数据的指针。因此传递的数据可以是任意大小。
+可以在ISR中put FIFO/LIFO. 也可在ISR内get FIFO/LIFO，但不能等待。
+FIFO/LIFO不限制数据项的多少. 线程get
+FIFO/LIFO后，数据项从FIFO/LIFO中删除，如果FIFO/LIFO为空，线程可进行等待。
+允许多个线程等待同一个FIFO/LIFO，当FIFO/LIFO有数据时会分配给等待时间最长的最高优先级线程。
+
+Stack
+-----
+
+既然有了LIFO为什么还要Stack呢,
+lifo是将离散的内容通过lifo串接起来已后进先出的方式管理，没有数量的限制。Stack是将一片连续的内存空间已后进先出的方式管理，在初始化的时候就进行了数量限制。
+可以在ISR中push stack。 也可在ISR内pop stack，但不能等待。
+stack有大小限制，满了后无法push入数据，之后的行为有stack使用者控制，内核自己不可预期。
+允许多个线程等待同一个STACK，当STACK有数据时会分配给等待时间最长的最高优先级线程。
+
+Message Queue
+-------------
+
+Message Queue初始化时已经定义了每个Q
+message大小，和message的总数量，一个message queue对应一个ring buffer
+收发的message都放在ring buffer中。ring
+buffer必须按N对齐，N是2的幂，message的大小必须是N的倍数。
+message可以通过线程或ISR发送到消息队列。发送message就是将message放入ring
+buffer, 如果ring buffer满了，线程内可以等待发送，但ISR中发送不能等待。
+多个thread可以向同一个message queue发送message，当ring
+buffer满时，所有thread都发生等待，当有ring
+buffer有空间时，会让等待时间最长的最高优先级线程发送message。
+接收message类似于发送，允许多个thread从同一个message
+queue接收message，当ring buffer空时，所有的thread都会等待，当ring
+buffer有数据时，会让等待时间最长的最高优先级线程先获得message.
+ISR也可以接收message，但不能等待。
+线程也可以peek消息队列顶部的消息，peek不会删除ring buffer中的消息。
+
+MailBox
+-------
+
+邮箱只允许线程间交换邮件，ISR不能使用邮箱
+每个邮件只能由一个线程接收，不支持点对多点或者广播。
+邮件收发线程相互知道对方，不是匿名传递。
+邮箱消息包含零个或多个字节的消息数据。消息数据的大小和格式是由应用程序定义的，每条消息的格式都可以不同。
+邮件数据的有两种形式存放： 1.
+消息缓冲区由发送或接收消息的线程提供的内存区域。例如数组或结构变量。 2.
+是消息块是从内存池分配的内存区域。
+
+如果一条消息没有消息缓冲区和消息块，称为空消息。消息缓冲区或内存块存在但包含零字节实际数据的消息不是空消息。
+发送线程创建一条消息将其发送给邮箱时，该邮件归邮箱所有，直到将其提供给接收线程为止。
+发送线程可以将邮件发给指定线程，也可以用K_ANY将其发送给任意线程。接收线程也从指定线程接收邮件指定线程，也可以用K_ANY接收任意线程的邮件。
+邮箱可以同步发送：发送阻塞，直到接收线程接收到消息，这是有一个隐性的流控制机制：在接收线程未处理完全，发送线程是阻塞的。
+异步发送：发送不阻塞，需要邮箱的用户显示的进行流控制。
+
+管道
+----
+
+管道用于两个线程之间流式传递数据，可以同步也可以异步。ISR不能使用PIPE。
+如果指定了pipe的size，说明pipe是有ring
+buffer的，如果未指定pipe不使用ring buffer。如果有ring
+buffer，pipe发送数据没发送完的部分会放入到ring buffer中。
+同步发送时，线程可以通过管道发送全部或者部分数据，管道会尝试尝试尽可能多的发送数据，但如果不能立即满足要发送的最小长度，该发送会失败。接收的数据被复制到ring
+buffer中或者直接被pipe的读取者读走。
+
+使用限制
+========
+
+下图说明了数据传递内核对象的使用限制，绿色的线的常规做法，红色的线的做法虽然允许，但不建议使用。
+|limit| 这里提前说一下为什么会有这些限制：
+ISR里面不能等待，是因为ISR本身有时间处理的要来，另外这些对象的等待都是依赖thread
+wait_q实现，ISR不会支持
+ISR不能使用mailbox/pipe，因为mailbox和pipe都是依赖thread的swap_data来交换数据，ISR不会支持。不过异步传输是否可用于ISR值得研究。
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/reference/kernel/index.html
+
+.. |datapassing| image:: ../../images/develop/kernel/datapassing.png
+.. |limit| image:: ../../images/develop/kernel/limit.png
diff --git a/doc/source/develop/kernel/fifo_lifo.rst b/doc/source/develop/kernel/fifo_lifo.rst
new file mode 100644
index 0000000..c977482
--- /dev/null
+++ b/doc/source/develop/kernel/fifo_lifo.rst
@@ -0,0 +1,510 @@
+.. _kernel_fifo_lifo:
+
+数据传递-FIFO/LIFO
+####################
+
+API
+---
+
+相似API
+~~~~~~~
+
+FIFO和LIFO API都是用宏包装queue的API实现，它们有一组类似的发送接收API，这里放在一起介绍
+
+**#define k_fifo_init(fifo)** **#define k_lifo_init(lifo)**
+
+作用：初始化一个struct k_fifo/strut k_lifo fifo/lifo: struct
+
+k_fifo/strut k_lifo
+
+**#define k_fifo_put(fifo, data)** **#define k_lifo_put(lifo, data)**
+
+作用：将数据放入fifo/lifo fifo/lifo：数据要放入的fifo/lifo data:
+
+要放入fifo/lifo的数据
+
+**#define k_fifo_alloc_put(fifo, data)** **#define k_lifo_alloc_put(lifo, data)**
+
+作用：fifo/lifo分配一个空间，将数据放入
+
+fifo/lifo：数据要放入的fifo/lifo data: 要放入fifo/lifo的数据
+
+**#define k_fifo_get(fifo, timeout)** **#define k_lifo_get(lifo,timeout)**
+
+作用：从fifo/lifo读出数据 fifo/lifo：要读的fifo/lifo data:
+读出的数据
+
+FIFO特殊API
+~~~~~~~~~~~
+
+FIFO比LIFO多一些API
+**#define k_fifo_cancel_wait(fifo)**
+
+作用：放弃等待，让第一个等待的fifo的thread退出pending，k_fifo_get的数据将是NULL
+
+fifo: 操作的fifo
+
+**#define k_fifo_put_list(fifo, head, tail)**
+
+作用：将一个单链表加入到fifo中 fifo: 操作的fifo head: 单链表的第一个节点
+
+tail: 单链表的最后一个节点
+
+**#define k_fifo_put_slist(fifo, list)**
+
+作用：将一个单链表加入到fifo中，这里单链表对象为sys_slist_t fifo:
+
+操作的fifo list: sys_slist_t 单链表
+
+**#define k_fifo_is_empty(fifo)**
+
+作用：检查fifo是否为空
+
+fifo: 要检查的fifo
+
+**#define k_fifo_peek_head(fifo)**
+
+作用：peek fifo头部上的节点(下个将会被read的数据)，但不会将数据从fifo删除
+
+fifo: 被peek的fifo 返回：返回peek的数据
+
+**#define k_fifo_peek_tail(fifo)**
+
+作用: peek fifo尾部上的节点(FIFO中最后进入的数据)，但不会将数据从fifo删除
+fifo: 被peek的fifo 返回：返回peek的数据
+
+使用说明
+--------
+
+可以在ISR中put fifo/lifo.也可在ISR内get fifo/fifo，但不能等待。
+fifo/lifo不限制数据项的多少。
+
+初始化
+~~~~~~
+
+经过初始化的fifo/lifo才能被使用，下面两种方法是一样的，显示定义
+
+::
+
+   struct k_fifo my_fifo;
+   struct k_lifo my_lifo;
+
+   k_fifo_init(&my_fifo);
+   k_lifo_init(&my_lifo);
+
+隐式定义：
+
+::
+
+   K_FIFO_DEFINE(my_fifo);
+   K_LIFO_DEFINE(my_lifo);
+
+写数据
+~~~~~~
+
+这里用fifo演示put，用Lifo演示alloc_put
+
+::
+
+   //使用put发送数据，最开始的word必须保留，用于存放queue，这也就是为什么要求4对其的原因
+   //使用alloc_put没有这个限制
+   struct data_item_t {
+       void *fifo_reserved;   /* 1st word reserved for use by fifo */
+       ...
+   };
+
+   struct data_item_t fifo_tx_data;
+   char lifo_tx_data[32];
+
+   void producer_thread(int unused1, int unused2, int unused3)
+   {
+       while (1) {
+           /* create data item to send */
+           //fifo_tx_data使用的是put，因此最开始的4个字节不能使用
+           fifo_tx_data = ...
+           lifo_tx_data = ...
+
+           /* send data to consumers */
+           k_fifo_put(&my_fifo, &fifo_tx_data);
+           //alloc_put时，queue会从线程池中分配出内存存放lifo，所以不需要保留开始4个字节
+           //在get时，queue会自动将其释放掉
+           k_lifo_alloc_put(&my_lifo, &lifo_tx_data);
+
+           ...
+       }
+   }
+
+读数据
+~~~~~~
+
+::
+
+   void consumer_fifo_thread(int unused1, int unused2, int unused3)
+   {
+       struct data_item_t  *rx_data;
+
+       while (1) {
+           rx_data = k_fifo_get(&my_fifo, K_FOREVER);
+
+           /* process fifo data item */
+           ...
+       }
+   }
+
+   void consumer_lifo_thread(int unused1, int unused2, int unused3)
+   {
+       struct data_item_t  *rx_data;
+
+       while (1) {
+           rx_data = k_lifo_get(&my_lifo, K_FOREVER);
+
+           /* process lifo data item */
+           ...
+       }
+   }
+
+实现
+====
+
+前面已经提到过fifo/lifo都是使用queue实现，fifo/lifo是直接包queue的API,每一个fifo/lifo API都对应一个queue的API，可以说fifo/lifo就是queue的使用方法不一样，先看结构体就可以看出使用的就是queue
+
+FIFO/LIFO
+-----------
+
+::
+
+   struct k_fifo {
+       struct k_queue _queue;
+   };
+
+   struct k_lifo {
+       struct k_queue _queue;
+   };
+
+每个fifo/lifo都有一个对应的queue API，这里列出来,更详细的可以看include/kernel.h，下面斜体加粗的就是fifo/lifo区别所在
+k_fifo_init->k_queue_init k_fifo_cancel_wait->k_queue_cancel_wait
+**k_fifo_put->k_queue_append**
+**k_fifo_alloc_put->k_queue_alloc_append**
+k_fifo_put_list->k_queue_append_list
+k_fifo_put_slist->k_queue_merge_slist k_fifo_get->k_queue_get
+k_fifo_is_empty->k_queue_is_empty k_fifo_peek_head->k_queue_peek_head
+k_fifo_peek_tail->k_queue_peek_tail k_lifo_init->k_queue_init
+**k_lifo_put->k_queue_prepend**
+**k_lifo_alloc_put->k_queue_alloc_prepend** k_lifo_get->k_queue_get
+
+Queue
+-----
+
+从上一节可以看出FIFO就是用queue实现的，因此我们继续分析queue
+
+Queue初始化
+~~~~~~~~~~~
+
+初始化：建立一个wait_q，建立一个单项标志链表
+
+添加数据到queue
+~~~~~~~~~~~~~~~
+
+添加数据到queue基本都是通过queue_insert完成
+k_queue_append->queue_insert： 在链表尾部插入
+k_queue_insert->queue_insert: 在指定节点后插入
+k_queue_prepend->queue_insert：在链表头部插入
+z_impl_k_queue_alloc_append->queue_insert：从thread
+pool中分配节点，并插入到尾部
+z_impl_k_queue_alloc_prepend->queue_insert：从thread
+pool中分配节点，并插入到头部 z_impl_k_queue_peek_head ->
+z_queue_node_peek: 从链表中读取头，但不删除该节点
+z_impl_k_queue_peek_tail -> z_queue_node_peek:
+从链表中读取尾，但不删除该节点
+
+::
+
+   static s32_t queue_insert(struct k_queue *queue, void *prev, void *data,
+                 bool alloc)
+   {
+       k_spinlock_key_t key = k_spin_lock(&queue->lock);
+   #if !defined(CONFIG_POLL)
+       struct k_thread *first_pending_thread;
+
+       //获取等待queue的thread，如果有的话，将数据提供给该thread，引发调度，直接返回
+       first_pending_thread = z_unpend_first_thread(&queue->wait_q);
+
+       if (first_pending_thread != NULL) {
+           prepare_thread_to_run(first_pending_thread, data);
+           z_reschedule(&queue->lock, key);
+           return 0;
+       }
+   #endif /* !CONFIG_POLL */
+
+       /* Only need to actually allocate if no threads are pending */
+       if (alloc) {
+           //要alloc节点空间
+           struct alloc_node *anode;
+           //从线程池中alloc节点空间
+           //并初始化数据
+           anode = z_thread_malloc(sizeof(*anode));
+           if (anode == NULL) {
+               k_spin_unlock(&queue->lock, key);
+               return -ENOMEM;
+           }
+           anode->data = data;
+           //初始化节点的时候，设置标志为1，表示是alloc的，在get的时候就需要释放
+           sys_sfnode_init(&anode->node, 0x1);
+           data = anode;
+       } else {
+           //如果data中自带节点，则无需alloc
+           sys_sfnode_init(data, 0x0);
+       }
+       //将节点插入到指定节点之后
+       //prev如果为NULL，data节点会被插入到单链表的最开始
+       sys_sflist_insert(&queue->data_q, prev, data);
+
+       //如果配置了poll，会通知queue条件已经满足
+   #if defined(CONFIG_POLL)
+       handle_poll_events(queue, K_POLL_STATE_DATA_AVAILABLE);
+   #endif /* CONFIG_POLL */
+
+       //引发调度
+       z_reschedule(&queue->lock, key);
+       return 0;
+   }
+
+当传入参数data是净数据时(没有在data的最开始预留node位置)，那么在insert的使用需要用alloc指定要分配节点
+
+从Queue中读取数据
+~~~~~~~~~~~~~~~~~
+
+使用k_queue_get->z_impl_k_queue_get从queue中读取数据，读取数据时数据从queue中删除，实际的删除动作就是从链表中将节点移除
+
+::
+
+   void *z_impl_k_queue_get(struct k_queue *queue, s32_t timeout)
+   {
+       k_spinlock_key_t key = k_spin_lock(&queue->lock);
+       void *data;
+
+       if (likely(!sys_sflist_is_empty(&queue->data_q))) {
+           sys_sfnode_t *node;
+           //如果链表不为空，从链表中取出头节点
+           node = sys_sflist_get_not_empty(&queue->data_q);
+           //从节点中取出数据，如果node是从线程池中分配的，将其释放
+           data = z_queue_node_peek(node, true);
+           k_spin_unlock(&queue->lock, key);
+           //取到数据后立即返回
+           return data;
+       }
+
+       if (timeout == K_NO_WAIT) {
+           k_spin_unlock(&queue->lock, key);
+           return NULL;
+       }
+
+   #if defined(CONFIG_POLL)
+       k_spin_unlock(&queue->lock, key);
+
+       return k_queue_poll(queue, timeout);
+
+   #else
+       //没有取到数据，进入等待
+       //可以结合发送看，如果有线程在等待queue数据，那么新进入queue的数据是不会进入链表的
+       int ret = z_pend_curr(&queue->lock, key, &queue->wait_q, timeout);
+
+       return (ret != 0) ? NULL : _current->base.swap_data;
+   #endif /* CONFIG_POLL */
+   }
+
+从node中提取数据
+~~~~~~~~~~~~~~~~
+
+从链表中peek或者移出的node，需要使用下面API从node中提取数据
+
+::
+
+   void *z_queue_node_peek(sys_sfnode_t *node, bool needs_free)
+   {
+       void *ret;
+
+       if ((node != NULL) && (sys_sfnode_flags_get(node) != (u8_t)0)) {
+           //检查到flag 不为0，说明加入链表的node是从线程池中分配
+           struct alloc_node *anode;
+
+           //这里取出数据后释放node
+           anode = CONTAINER_OF(node, struct alloc_node, node);
+           ret = anode->data;
+           if (needs_free) {
+               k_free(anode);
+           }
+       } else {
+           //不是从线程池分配的node，直接返回
+           ret = (void *)node;
+       }
+
+       return ret;
+   }
+
+如果是移出的node在Insert的时候是从线程池alloc出来的，那么在这里需要needs_free=true指定要free空间。如果是Peek的node数据时，则只用提取数据，例如：
+
+::
+
+   static inline void *z_impl_k_queue_peek_head(struct k_queue *queue)
+   {
+       return z_queue_node_peek(sys_sflist_peek_head(&queue->data_q), false);
+   }
+
+   static inline void *z_impl_k_queue_peek_tail(struct k_queue *queue)
+   {
+       return z_queue_node_peek(sys_sflist_peek_tail(&queue->data_q), false);
+   }
+
+放弃等待数据
+~~~~~~~~~~~~
+
+k_queue_get的时候如果queue内没有数据，允许进行等待。等待期间可以使用k_queue_cancel_wait放弃等待
+
+::
+
+   void z_impl_k_queue_cancel_wait(struct k_queue *queue)
+   {
+       k_spinlock_key_t key = k_spin_lock(&queue->lock);
+   #if !defined(CONFIG_POLL)
+       struct k_thread *first_pending_thread;
+       //获取正在等待的第一个线程
+       first_pending_thread = z_unpend_first_thread(&queue->wait_q);
+
+       //让该线程退出等待
+       if (first_pending_thread != NULL) {
+           prepare_thread_to_run(first_pending_thread, NULL);
+       }
+   #else
+       handle_poll_events(queue, K_POLL_STATE_CANCELLED);
+   #endif /* !CONFIG_POLL */
+       //重调度
+       z_reschedule(&queue->lock, key);
+   }
+
+关于poll
+~~~~~~~~
+
+一般情况下queue等待数据是通过让其thread
+等待queue的wait_q实现，一旦配置poll后将不再使用该机制，而是通过poll，queue
+get使用k_queue_poll等待queue有数据，因此可能和其它thread等待poll条件发生冲突
+
+::
+
+   static void *k_queue_poll(struct k_queue *queue, s32_t timeout)
+   {
+       struct k_poll_event event;
+       int err, elapsed = 0, done = 0;
+       k_spinlock_key_t key;
+       void *val;
+       u32_t start;
+       //初始化要等待的条件
+       k_poll_event_init(&event, K_POLL_TYPE_FIFO_DATA_AVAILABLE,
+                 K_POLL_MODE_NOTIFY_ONLY, queue);
+
+       if (timeout != K_FOREVER) {
+           start = k_uptime_get_32();
+       }
+
+       do {
+           event.state = K_POLL_STATE_NOT_READY;
+               //开始poll
+           err = k_poll(&event, 1, timeout - elapsed);
+
+           if (err && err != -EAGAIN) {
+               return NULL;
+           }
+           //通知后去链表拿数据
+           key = k_spin_lock(&queue->lock);
+           val = z_queue_node_peek(sys_sflist_get(&queue->data_q), true);
+           k_spin_unlock(&queue->lock, key);
+
+           //如果没拿到数据，说明可能被其它thread将数据拿走，需要重新等待
+           if ((val == NULL) && (timeout != K_FOREVER)) {
+               elapsed = k_uptime_get_32() - start;
+               done = elapsed > timeout;
+           }
+       } while (!val && !done);
+
+       return val;
+   }
+
+插入链表数据
+~~~~~~~~~~~~
+
+queue也提供2个API将数据以链表的形式插入到queue中,区别是k_queue_append_list插入后不会影响被插入链表，而k_queue_merge_slist插入链表后会把链表清空
+
+::
+
+   int k_queue_append_list(struct k_queue *queue, void *head, void *tail)
+   {
+       /* invalid head or tail of list */
+       CHECKIF(head == NULL || tail == NULL) {
+           return -EINVAL;
+       }
+
+       k_spinlock_key_t key = k_spin_lock(&queue->lock);
+   #if !defined(CONFIG_POLL)
+       struct k_thread *thread = NULL;
+       //有等待的thread全部取出来消化这个链表
+       //注意，消化完后原来的链表还在
+       if (head != NULL) {
+           thread = z_unpend_first_thread(&queue->wait_q);
+       }
+
+       while ((head != NULL) && (thread != NULL)) {
+           prepare_thread_to_run(thread, head);
+           head = *(void **)head;
+           thread = z_unpend_first_thread(&queue->wait_q);
+       }
+
+       //没有消化完的加入到queue中
+       if (head != NULL) {
+           sys_sflist_append_list(&queue->data_q, head, tail);
+       }
+
+   #else
+       sys_sflist_append_list(&queue->data_q, head, tail);
+       handle_poll_events(queue, K_POLL_STATE_DATA_AVAILABLE);
+   #endif /* !CONFIG_POLL */
+
+       z_reschedule(&queue->lock, key);
+
+       return 0;
+   }
+
+::
+
+   int k_queue_merge_slist(struct k_queue *queue, sys_slist_t *list)
+   {
+       int ret;
+
+       /* list must not be empty */
+       CHECKIF(sys_slist_is_empty(list)) {
+           return -EINVAL;
+       }
+
+        //和k_queue_append_list功能一样
+       ret = k_queue_append_list(queue, list->head, list->tail);
+       CHECKIF(ret != 0) {
+           return ret;
+       }
+       //但消化完链表后，原有链表被清空
+       sys_slist_init(list);
+
+       return 0;
+   }
+
+图例
+----
+
+下面用一张图简单说明FIFO/LIFO和queue操作之间的关系 |QUEUE|
+可以看到FIFO是通过k_queue_appen将数据加入到queue的链表尾，LIFO通过k_queue_prepend将数据加入到queue的链表头，而FIFO/LIFO读数据都是用k_queue_get从链表头读数据，所以达到了FIFO先进先出，LIFO后进先出的目的。
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/reference/kernel/data_passing/fifos.html
+https://docs.zephyrproject.org/latest/reference/kernel/data_passing/lifos.html
+
+.. |QUEUE| image:: ../../images/develop/kernel/queue.png
diff --git a/doc/source/develop/kernel/index.rst b/doc/source/develop/kernel/index.rst
index 6fcd7c3..560b821 100644
--- a/doc/source/develop/kernel/index.rst
+++ b/doc/source/develop/kernel/index.rst
@@ -16,3 +16,9 @@ Zephyr内核分析和使用方法。
    poll.rst
    event.rst
    condition_variables.rst
+   data_passing.rst
+   stack.rst
+   fifo_lifo.rst
+   msgq.rst
+   mailbox.rst
+   pipe.rst
diff --git a/doc/source/develop/kernel/mailbox.rst b/doc/source/develop/kernel/mailbox.rst
new file mode 100644
index 0000000..ba06862
--- /dev/null
+++ b/doc/source/develop/kernel/mailbox.rst
@@ -0,0 +1,727 @@
+.. _kernel_mailbox:
+
+数据传递-邮箱
+###############
+
+Zephyr的邮箱(mailbox)可以看作是升级版的消息队列(msgq)，与msgq不一样的是：邮箱的消息可以指定发送者和接收者，邮箱消息的大小可以不固定，长度也没有对齐的要求。此外邮箱只能用于线程间交换消息，不能用于ISR内。
+
+邮箱构成和特性
+===============
+
+Zephyr允许定义任意数量的邮箱，最大数量只由可用内存的量决定。
+一个邮箱主要是由发送队列和消息队列两个wait_q组才，如下定义：
+
+::
+
+   struct k_mbox {
+       _wait_q_t tx_msg_queue;
+       _wait_q_t rx_msg_queue;
+       struct k_spinlock lock;
+   };
+
+-  发送队列：用于保存已发送但还未被接收的消息
+-  接收队列：用于保存正在等待消息的线程
+
+当发送线程发送消息到邮箱后会阻塞等待(同步发送)接收线程完成消息接收才退出等待，或是不阻塞而是等待接收线程完成消息接收后通过信号量通知(异步发送)。
+邮箱支持：
+
+* 一对一： A发到邮箱的消息只能B收, B只收A的消息
+* 一对多： A发到邮箱的消息任意线程都可以收，注意不是广播。
+* 多对一： B线程可以收任意线程发到邮箱中消息。
+
+邮箱不支持广播，邮箱中的消息只能被一个线程使用。
+
+消息
+----
+
+消息描述符
+~~~~~~~~~~
+
+消息是由消息描述符描述，指定消息的内存地址，并描述消息如何被邮箱处理。发送线程和接收线程在访问邮箱时都需要提供消息描述符，消息描述符相互匹配才能传递消息。
+消息描述符的结构如下：
+
+::
+
+   struct k_mbox_msg {
+       uint32_t _mailbox;
+       size_t size;
+       uint32_t info;
+       void *tx_data;
+       void *_rx_data;
+       struct k_mem_block tx_block;
+       k_tid_t rx_source_thread;
+       k_tid_t tx_target_thread;
+       k_tid_t _syncing_thread;
+   #if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
+       struct k_sem *_async_sem;
+   #endif
+   };
+
+``_mailbox``\ 和\ ``_rx_data``\ 这两个字段已经不再使用
+``_syncing_thread``
+用于通知发送者发送的消息已经被接收，\ ``_async_sem``\ 用于异步发送后通知消息已经完成，这两个字段都是内部使用。
+
+消息描述符中容纳消息的方式有两种：
+
+* 缓冲：给定一段buffer，消息数据放于其中
+* 内存块：申请的一片内存块，消息数据放于其中
+
+实际的消息发送二选一，如果二者都为NULL，则表示发送空消息。
+
+``tx_data`` 发送缓冲消息的内存指针，如果是内存块消息或者空消息该字段为NULL，接收者不初始化该字段
+``tx_block`` 内存块id，发送内存块消息时使用该字段。如果是缓冲消息或是空消息该字段为NULL，接收者不初始化该字段。
+``size`` 消息大小，允许为0，为0时表示空消息. 接收时表示允许接收消息的最大size,如果收到的消息不是想要的发送方的size将为设为0，如果消息被接收，发送方的size将被更新为实际接收的大小。
+``info`` 发送者和接收者在消息接收时双向交换字段，32bit大小
+``tx_target_thread`` 接收消息的线程id，接收者消息不初始化该字段，接收者接收该消息后邮箱会将该字段更新为为实际接收者的id。当指定为K_ANY时该消息可以被任意线程接收。
+``rx_source_thread`` 发送消息的线程id，发送者消息不初始化该字段，接收者接收该消息后邮箱会将该字段更新为为实际发送者的id。当指定为K_ANY时该线程可接收任意消息。
+
+消息的生命周期
+~~~~~~~~~~~~~~
+
+创建消息：发送线程将消息发送到邮箱 消息保存在邮箱
+删除消息：接收线程从邮箱接收消息，并将其消耗
+
+使用
+====
+
+API
+---
+
+``#define K_MBOX_DEFINE(name)``
+
+作用:定义一个k_mbox，并初始化
+
+name: k_mbox name
+
+``void k_mbox_init(struct k_mbox *mbox)``
+
+作用: 初始化k_mbox
+
+mbox: 要初始化的mbox
+
+返回值: 0标示初始化成功
+
+``int k_mbox_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg, k_timeout_t timeout)``
+作用：同步发送消息到邮箱，会等到有线程从邮箱接收，或是超时才退出。如果发送超时消息将不会被保存在邮箱中
+
+mbox: 邮箱 tx_msg: 发送消息的描述符，包含了接收者，消息信息，见前文说明
+
+timeout： 等待时间，单位ms。K_NO_WAIT不等待, K_FOREVER一直等
+
+返回值：0发送成果，-ENOMSG不等待发送失败，-EAGAIN 等待超时
+
+``void k_mbox_async_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg, struct k_sem *sem)``
+
+作用：异步发送消息到邮箱，发送后立即返回，有线程从邮箱接收该消息时使用sem通知。
+
+mbox: 邮箱 tx_msg: 发送消息的描述符，包含了接收者，消息信息，见前文说明
+
+sem：接收消息通知信号量
+
+``int k_mbox_get(struct k_mbox *mbox, struct k_mbox_msg *rx_msg, void *buffer, k_timeout_t timeout)``
+
+作用：从邮箱接收消息。
+
+mbox: 邮箱
+
+rx_msg: 接收消息的描述符，指定发送者，接收消息的信息，见前文说明
+
+buffer: 接收消息数据存放buffer，如果为NULL，邮箱将保存该消息，消息的信息保存在rx_msg中，直到使用k_mbox_data_get消耗该消息才会从邮箱中删除
+
+timeout： 等待时间，单位ms。K_NO_WAIT不等待, K_FOREVER一直等
+
+返回值：0发送成果，-ENOMSG不等待发送失败，-EAGAIN 等待超时
+
+``void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer)``
+
+作用：将消息数据搬运到buffer中，并从邮箱中删除该消息。
+
+rx_msg: 接收消息的描述符，包含了要接收消息的信息
+
+buffer: 接收消息数据存放buffer，如果为NULL将直接丢弃该消息
+
+使用说明
+--------
+
+初始化
+~~~~~~
+
+先定义初始化一个邮箱，下面两种方式的效果是一样的 使用宏
+
+::
+
+   K_MBOX_DEFINE(my_mailbox);
+
+使用函数
+
+::
+
+   struct k_mbox my_mailbox;
+   k_mbox_init(&my_mailbox);
+
+发送消息
+~~~~~~~~
+
+同步
+
+::
+
+   void producer_thread(void)
+   {
+       char buffer[100];
+       int buffer_bytes_used;
+
+       struct k_mbox_msg send_msg;
+
+       while (1) {
+
+           //准备要发送的消息数据
+           ...
+           buffer_bytes_used = ... ;
+           memcpy(buffer, source, buffer_bytes_used);
+
+           //准备消息描述符
+           send_msg.info = 123;
+           send_msg.size = buffer_bytes_used;
+           send_msg.tx_data = buffer;
+           send_msg.tx_block.data = NULL;
+           send_msg.tx_target_thread = consumer_thread_id;
+
+           //发送消息到mailbox，并等待被接收
+           k_mbox_put(&my_mailbox, &send_msg, K_FOREVER);
+
+           //接收完毕退出等待，检查info, size, tx_target_thread 的更新
+           //info和接收者交换会变为456
+           //size变为实际接收的30
+
+           /* verify that message data was fully received */
+           if (send_msg.size < buffer_bytes_used) {
+               printf("some message data dropped during transfer!");
+               printf("receiver only had room for %d bytes", send_msg.info);
+           }
+       }
+   }
+
+异步，异步发送函数\ ``k_mbox_async_put``\ 在配置了\ ``CONFIG_NUM_MBOX_ASYNC_MSGS=y``\ 后才会有效
+
+::
+
+   void producer_thread(void)
+   {
+       char buffer[100];
+       int buffer_bytes_used = 100;
+
+       struct k_mbox_msg send_msg;
+
+       struct k_sem rev_sem;
+       k_sem_init(&rev_sem, 0, 10);
+
+       while (1) {
+
+           //准备消息描述符
+           ...
+           buffer_bytes_used = ... ;
+           memcpy(buffer, source, buffer_bytes_used);
+
+           /* prepare to send message */
+           send_msg.info = 123;
+           send_msg.size = buffer_bytes_used;
+           send_msg.tx_data = buffer;
+           send_msg.tx_block.data = NULL;
+           send_msg.tx_target_thread = consumer_thread_id;
+
+           //发送消息到mailbox
+           k_mbox_async_put(&my_mailbox, &send_msg, &rev_sem);
+
+           //等待消息被接收通知信号量
+           k_sem_take(&rev_sem, K_FOREVER);
+
+           //接收完毕退出等待，检查info, size, tx_target_thread 的更新
+           //info和接收者交换会变为456
+           //size变为实际接收的30
+
+           /* verify that message data was fully received */
+           if (send_msg.size < buffer_bytes_used) {
+               printf("some message data dropped during transfer!");
+               printf("receiver only had room for %d bytes", send_msg.info);
+           }
+       }
+   }
+
+接收消息
+~~~~~~~~
+
+::
+
+   void consumer_thread(void)
+   {
+       struct k_mbox_msg recv_msg;
+       char buffer[100];
+
+       int i;
+       int total;
+
+       while (1) {
+           //准备消息描述符
+           recv_msg.info = 456;
+           recv_msg.size = 30;
+           recv_msg.rx_source_thread = producer_thread_id;
+
+           //等待接收消息
+           k_mbox_get(&my_mailbox, &recv_msg, buffer, K_FOREVER);
+
+           //接收完毕退出等待，检查info, size, rx_target_thread 的更新
+           //info和发收者交换会变为123
+           //size为实际接收的数据长度30
+
+           /* verify that message data was fully received */
+           if (recv_msg.info != recv_msg.size) {
+               printf("some message data dropped during transfer!");
+               printf("sender tried to send %d bytes", recv_msg.info);
+           }
+
+           /* compute sum of all message bytes (from 0 to 100 of them) */
+           total = 0;
+           for (i = 0; i < recv_msg.size; i++) {
+               total += buffer[i];
+           }
+       }
+   }
+
+实现
+====
+
+该小节通过对邮箱内核代码的分析，理解Zephyr是如何实现以上描述的功能特性.
+mailbox的实现代码在kernel:raw-latex:`\mailbox`.c中 ## 初始化
+前文提到过mailbox的核心就是两个wait_q，初始化则是对发送和接收的wait_q进行初始话，并初始化一个lock用于操作wait_q时锁调度
+
+::
+
+   void k_mbox_init(struct k_mbox *mbox)
+   {
+       z_waitq_init(&mbox->tx_msg_queue);
+       z_waitq_init(&mbox->rx_msg_queue);
+       mbox->lock = (struct k_spinlock) {};
+   }
+
+
+发送消息
+--------
+
+这里主要分析同步发送，\ ``k_mbox_put->mbox_message_put``
+
+::
+
+   int k_mbox_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
+              k_timeout_t timeout)
+   {
+       //发送消息的线程在消息被接收前会被放入tx_msg_queue中挂起，这里将当前thread保存在消息中的_syncing_thread，方便消息被接收后对_syncing_thread进行恢复
+       tx_msg->_syncing_thread = _current;
+
+       int ret = mbox_message_put(mbox, tx_msg, timeout);
+
+       return ret;
+   }
+
+消息发送的主要流程位于\ ``mbox_message_put``\ 中，有下面两种情况：
+
+1. 遍历邮箱\ ``rx_msg_queue``\ 中等待消息的线程，如果找到匹配的接收线程，让接收线程变为就绪，挂起当前线程。
+2. 如果没找到匹配的接收线程，将消息放入\ ``tx_msg_queue``\ ，挂起当前线程并等待超时。
+
+代码详细分析如下：
+
+::
+
+   static int mbox_message_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
+                    k_timeout_t timeout)
+   {
+       struct k_thread *sending_thread;
+       struct k_thread *receiving_thread;
+       struct k_mbox_msg *rx_msg;
+       k_spinlock_key_t key;
+
+       //设置描述符中发送线程id为当前线程
+       tx_msg->rx_source_thread = _current;
+
+       //发送线程要交换的数据被设置为消息描述符
+       sending_thread = tx_msg->_syncing_thread;
+       sending_thread->base.swap_data = tx_msg;
+
+       //锁调度，开始处理消息发送
+       key = k_spin_lock(&mbox->lock);
+
+       //检查rx_msg_queue中是否有线程在等待接收邮箱消息
+       _WAIT_Q_FOR_EACH(&mbox->rx_msg_queue, receiving_thread) {
+           //获取接收消息描述符
+           rx_msg = (struct k_mbox_msg *)receiving_thread->base.swap_data;
+
+           //将收发消息描述进行匹配
+           if (mbox_message_match(tx_msg, rx_msg) == 0) {
+               //该消息有线程可匹配，让接收线程从挂起恢复
+               z_unpend_thread(receiving_thread);
+
+               //pend返回设置为0，表示有正常拿到消息
+               arch_thread_return_value_set(receiving_thread, 0);
+               //让接收线程处于就绪态，下一次调度的时候接收线程就会取得消息进行处理
+               z_ready_thread(receiving_thread);
+
+   #if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
+               //异步发送流程，接收线程处理消失时不做阻塞
+               if ((sending_thread->base.thread_state & _THREAD_DUMMY)
+                   != 0U) {
+                   z_reschedule(&mbox->lock, key);
+                   return 0;
+               }
+   #endif
+
+               //同步发送流程，异步线程处理消息时，发送消息线程被直接挂起，异步线程处理完后会通过线程交换数据中保存的tx_msg->_syncing_thread让发送线程进入就绪继续运行
+               int ret = z_pend_curr(&mbox->lock, key, NULL, K_FOREVER);
+
+               return ret;
+           }
+       }
+
+       //没有匹配的接收线程，同时也不等待消息发送，就立即退出
+       if (K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
+           k_spin_unlock(&mbox->lock, key);
+           return -ENOMSG;
+       }
+
+   #if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
+       //异步发送时会用一个dummy thread来进行等待消息接收完成，真正的发送线程会立即退出
+       if ((sending_thread->base.thread_state & _THREAD_DUMMY) != 0U) {
+           //这里是在发送线程中执行，而挂起的dummy thread，因此不会卡在这里
+           z_pend_thread(sending_thread, &mbox->tx_msg_queue, K_FOREVER);
+           k_spin_unlock(&mbox->lock, key);
+           return 0;
+       }
+   #endif
+       //同步发送，如果没有匹配的线程接收，当前线程被加入tx_msg_queue中，等待超时。因为tx_msg是放到当前线程的交换数据内，这个操作就相当于将消息放入了邮箱
+       int ret = z_pend_curr(&mbox->lock, key, &mbox->tx_msg_queue, timeout);
+
+       return ret;
+   }
+
+接收
+----
+
+消息接收的流程和发送的流程是对称的，有下面两种情况： 1.
+遍历邮箱\ ``tx_msg_queue``\ 中查看是否有消息，如果找到匹配的消息，接收线程接收处理该消息后通知发送线程恢复执行。
+2.
+如果没找到匹配的消息，将接收线程放入\ ``rx_msg_queue``\ ，挂起当前线程并等待接收消息超时。
+
+代码详细分析如下：
+
+::
+
+   int k_mbox_get(struct k_mbox *mbox, struct k_mbox_msg *rx_msg, void *buffer,
+              k_timeout_t timeout)
+   {
+       struct k_thread *sending_thread;
+       struct k_mbox_msg *tx_msg;
+       k_spinlock_key_t key;
+       int result;
+
+       //设置描述符中接收线程id为当前线程
+       rx_msg->tx_target_thread = _current;
+
+       //锁调度，开始处理消息接收
+       key = k_spin_lock(&mbox->lock);
+
+       //检查邮箱的tx_msg_queue中是否有可用消息
+       _WAIT_Q_FOR_EACH(&mbox->tx_msg_queue, sending_thread) {
+           //从线程交换数据中获取发送消息描述符
+           tx_msg = (struct k_mbox_msg *)sending_thread->base.swap_data;
+
+           //将收发消息描述进行匹配
+           if (mbox_message_match(tx_msg, rx_msg) == 0) {
+               //该消息和接收线程匹配，将发送消息的线程从邮箱tx_msg_queue中取出
+               z_unpend_thread(sending_thread);
+
+               k_spin_unlock(&mbox->lock, key);
+
+               //处理数据，数据处理完后会让发送线程就绪并重新调度。如果这里buffer为空，会将数据保留，同时发送线程仍然处理挂起状态。
+               result = mbox_message_data_check(rx_msg, buffer);
+
+               return result;
+           }
+       }
+
+       //没有匹配的消息，同时也不等待，退出本次接收
+       if (K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
+           k_spin_unlock(&mbox->lock, key);
+           return -ENOMSG;
+       }
+
+       //如果没有匹配的消息，当前线程被加入rx_msg_queue中，等待超时
+       _current->base.swap_data = rx_msg;
+       result = z_pend_curr(&mbox->lock, key, &mbox->rx_msg_queue, timeout);
+
+       //接收到消息进行消息处理，数据处理完后会让发送线程就绪并重新调度。如果这里buffer为空，会将数据保留，同时发送线程仍然处理挂起状态。
+       if (result == 0) {
+           result = mbox_message_data_check(rx_msg, buffer);
+       }
+
+       return result;
+   }
+
+消息匹配
+--------
+
+从前面的分析看到消息匹配是使用\ ``mbox_message_match``\ 对收发消息描述符进行比较，比较过程中主要有如下事项：
+
+1. 比较收发的thread id是否匹配
+
+2. 进行thread id交换
+
+3. 进行info交换
+
+4. 更新实际可以接收的size
+
+5. 将消息的数据地址更新到接收消息描述符内
+
+6. 将发送线程id更新到接收消息描述符中
+
+::
+
+   static int mbox_message_match(struct k_mbox_msg *tx_msg,
+                      struct k_mbox_msg *rx_msg)
+   {
+       uint32_t temp_info;
+
+       //匹配thread id
+       if (((tx_msg->tx_target_thread == (k_tid_t)K_ANY) ||
+            (tx_msg->tx_target_thread == rx_msg->tx_target_thread)) &&
+           ((rx_msg->rx_source_thread == (k_tid_t)K_ANY) ||
+            (rx_msg->rx_source_thread == tx_msg->rx_source_thread))) {
+
+           //更新收发者的id，主要是給一方是K_ANY用，否则不会有变化
+           rx_msg->rx_source_thread = tx_msg->rx_source_thread;
+           tx_msg->tx_target_thread = rx_msg->tx_target_thread;
+
+           //交换info
+           temp_info = rx_msg->info;
+           rx_msg->info = tx_msg->info;
+           tx_msg->info = temp_info;
+
+           //计算实际可以接收的数据
+           if (rx_msg->size > tx_msg->size) {
+               rx_msg->size = tx_msg->size;
+           }
+
+           //将消息的数据地址更新到接收消息描述符内
+           rx_msg->tx_data = tx_msg->tx_data;
+           rx_msg->tx_block = tx_msg->tx_block;
+           if (rx_msg->tx_data != NULL) {
+               rx_msg->tx_block.data = NULL;
+           } else if (rx_msg->tx_block.data != NULL) {
+               rx_msg->tx_data = rx_msg->tx_block.data;
+           } else {
+               /* no data */
+           }
+
+           //将发送线程id更新到接收消息描述符中
+           rx_msg->_syncing_thread = tx_msg->_syncing_thread;
+
+           return 0;
+       }
+
+       return -1;
+   }
+
+消息处理
+--------
+
+邮箱消息数据的处理有内部函数\ ``mbox_message_data_check``\ 和外部函数\ ``k_mbox_data_ge``\ t两个。在\ ``k_mbox_get``\ 传入的参数\ ``buffer=NULL``\ 时，\ ``mbox_message_data_check``\ 检查到时消息会被保留在邮箱。之后可以再通过\ ``k_mbox_data_get``\ 来读取该消息，如果此时\ ``buffer=NULL``\ 该消息就会从邮箱中取出丢弃。
+代码分析如下：
+
+::
+
+   static int mbox_message_data_check(struct k_mbox_msg *rx_msg, void *buffer)
+   {
+       if (buffer != NULL) {
+           //buffer不为NULL将数据读到buffer中
+           k_mbox_data_get(rx_msg, buffer);
+       } else if (rx_msg->size == 0U) {
+           //buffer为空，且size为0，表示为空消息无需接收数据，直接将消息从邮箱中取出丢弃
+           mbox_message_dispose(rx_msg);
+       } else {
+           //buffer为NULL且不是空消息，表示应用后续会用k_mbox_data_get取数据
+       }
+
+       return 0;
+   }
+
+   void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer)
+   {
+       //buffer为空，不需要消息数据，直接丢弃该消息
+       if (buffer == NULL) {
+           rx_msg->size = 0;
+           mbox_message_dispose(rx_msg);
+           return;
+       }
+
+       //不是空消息，将消息数据copy到buffer中
+       if ((rx_msg->tx_data != NULL) && (rx_msg->size > 0U)) {
+           (void)memcpy(buffer, rx_msg->tx_data, rx_msg->size);
+       }
+
+       //空消息，无需接收数据，直接将消息从邮箱中取出丢弃
+       mbox_message_dispose(rx_msg);
+   }
+
+mbox_message_dispose再来看取出消息丢弃的流程
+
+::
+
+   static void mbox_message_dispose(struct k_mbox_msg *rx_msg)
+   {
+       struct k_thread *sending_thread;
+       struct k_mbox_msg *tx_msg;
+
+       // 消息被接收被通知的thread会变为NULL，因此不用再丢弃，这季节返回
+       if (rx_msg->_syncing_thread == NULL) {
+           return;
+       }
+
+       if (rx_msg->tx_block.data != NULL) {
+           rx_msg->tx_block.data = NULL;
+       }
+
+       //通过将被通知thread设置为NULL，表示该消息已经被接收，并从邮箱丢弃
+       sending_thread = rx_msg->_syncing_thread;
+       rx_msg->_syncing_thread = NULL;
+
+
+       //更新实际接收数据的大小
+       tx_msg = (struct k_mbox_msg *)sending_thread->base.swap_data;
+       tx_msg->size = rx_msg->size;
+
+   #if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
+       //异步发送，消息接收完毕，邮箱中已删除该消息，使用信号量进行通知
+       if ((sending_thread->base.thread_state & _THREAD_DUMMY) != 0U) {
+           struct k_sem *async_sem = tx_msg->_async_sem;
+
+           mbox_async_free((struct k_mbox_async *)sending_thread);
+           if (async_sem != NULL) {
+               k_sem_give(async_sem);
+           }
+           return;
+       }
+   #endif
+
+       //同步发送，消息接收完毕，邮箱中已删除该消息，通知发送者退出等待状态，发送线程变为ready，并重新调度
+       arch_thread_return_value_set(sending_thread, 0);
+       z_mark_thread_as_not_pending(sending_thread);
+       z_ready_thread(sending_thread);
+       z_reschedule_unlocked();
+   }
+
+异步支持
+--------
+
+邮箱支持异步，在发送者发送消息后可以立即退出不用等到被接收后才退出。通过下面手段实现异步支持：
+1. 初始化时创建指定数量的异步消息，里面包含一个发送消息描述符和一个用于等待消息被接收的dummy
+thread
+
+2. 发送异步消息时，将发送描述符存放在异步消息内，并将等待的同步_syncing_thread设置为dummy
+thread，并指定通知接收完成的信号量
+
+3. 接收消息完成后通过信号量通知接收已经完成
+
+异步消息支持的数量受\ ``CONFIG_NUM_MBOX_ASYNC_MSGS``\ 配置限制。
+这里我们主要分析异步消息初始化和发送的流程，其它都已经在前文分析的代码中进行了注释
+
+异步消息
+~~~~~~~~
+
+异步消息的结构如下
+
+::
+
+   struct k_mbox_async {
+       struct _thread_base thread;     //dummy thread
+       struct k_mbox_msg tx_msg;   //发送消息描述符
+   };
+
+
+初始化
+~~~~~~
+
+初始化建立异步消息的stack，并将声明好的异步消息放入stack
+
+::
+
+   static int init_mbox_module(const struct device *dev)
+   {
+       ARG_UNUSED(dev);
+
+       //声明CONFIG_NUM_MBOX_ASYNC_MSGS个异步消息
+       static struct k_mbox_async __noinit async_msg[CONFIG_NUM_MBOX_ASYNC_MSGS];
+
+
+       int i;
+
+       for (i = 0; i < CONFIG_NUM_MBOX_ASYNC_MSGS; i++) {
+           //将异步消息内的thread设置为dummy状态
+           z_init_thread_base(&async_msg[i].thread, 0, _THREAD_DUMMY, 0);
+           //将异步消息压入堆栈内
+           k_stack_push(&async_msg_free, (stack_data_t)&async_msg[i]);
+       }
+
+       return 0;
+   }
+
+   //在Zephyr初始化的PRE_KERNEL_1阶段会调用init_mbox_module
+   SYS_INIT(init_mbox_module, PRE_KERNEL_1, CONFIG_KERNEL_INIT_PRIORITY_OBJECTS);
+
+异步发送
+~~~~~~~~
+
+异步发送和同步发送的主要流程一致，差别就是使用异步消息和dummy
+thread进行等待，的代码如下：
+
+::
+
+   void k_mbox_async_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
+                 struct k_sem *sem)
+   {
+       struct k_mbox_async *async;
+
+       //分配异步消息
+       mbox_async_alloc(&async);
+
+       //初始化dummy thread的优先级
+       async->thread.prio = _current->base.prio;
+
+       //将发送消息存放在异步消息内
+       async->tx_msg = *tx_msg;
+       //将dummy_thread做为被通知thread进行等待，当前thread调用k_mbox_async_put可立即返回
+       async->tx_msg._syncing_thread = (struct k_thread *)&async->thread;
+       //将通知信号量保存在异步信息中
+       async->tx_msg._async_sem = sem;
+
+       //发送消息
+       (void)mbox_message_put(mbox, &async->tx_msg, K_FOREVER);
+   }
+
+上面出现了对异步消息的堆栈的处理函数，其实就是对初始化时异步消息堆栈的处理，发送时pop出一个空的异步消息，接收完后将异步消息又加入到堆栈中
+
+::
+
+   static inline void mbox_async_alloc(struct k_mbox_async **async)
+   {
+       (void)k_stack_pop(&async_msg_free, (stack_data_t *)async, K_FOREVER);
+   }
+
+   static inline void mbox_async_free(struct k_mbox_async *async)
+   {
+       k_stack_push(&async_msg_free, (stack_data_t)async);
+   }
+
+从前面的分析我们知道初始化时空闲的异步消息只有\ ``CONFIG_NUM_MBOX_ASYNC_MSGS``\ 个。当空闲的异步消息用完后stack就为空了，此时再发送异步消息就会因为stack pop的特性发生阻塞，\ ``k_mbox_async_put``\ 被挂起，直到有异步消息被接收后push回stack。
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/reference/kernel/data_passing/mailboxes.html
diff --git a/doc/source/develop/kernel/msgq.rst b/doc/source/develop/kernel/msgq.rst
new file mode 100644
index 0000000..7ff53d2
--- /dev/null
+++ b/doc/source/develop/kernel/msgq.rst
@@ -0,0 +1,483 @@
+.. _kernel_msgq:
+
+数据传递-消息队列
+####################
+
+使用
+====
+
+API
+---
+
+Message queue的API有下面10个全部声明在kernel.h中，每个函数都有参数\ ``struct k_msgq *msgq``\.都是指该函数操作或者使用的msgq后面就不在单独列出说明
+
+**void k_msgq_init(struct k_msgq q, char buffer, size_t msg_size, u32_tmax_msgs);**
+
+作用：初始化一个msgq, 内存由使用者分配
+
+buffer: msgq的buffer，需要由使用者分配，大小为msg_size*max_msgs
+
+msg_size: msgq中每个message的大小 max_mags: msgq中最多容纳的message数量
+
+**__syscall int k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,u32_t max_msgs);**
+
+作用：初始化一个msgq, 内存由msgq从线程池中分配
+
+msg_size: msgq中每个message的大小
+
+max_mags: msgq中最多容纳的message数量
+
+**int k_msgq_cleanup(struct k_msgq* msgq);**
+
+作用：释放k_msgq_alloc_init分配msgq内存
+
+**__syscall int k_msgq_put(struct k_msgq *msgq, void*\ data, s32_t timeout);**
+
+作用：将message放入到msgq
+
+data：message数据
+
+timeout:等待时间，单位ms。K_NO_WAIT不等待, K_FOREVER一直等
+
+返回值：放入成功返回0
+
+**__syscall int k_msgq_get(struct k_msgq *msgq, void* data, s32_t timeout);**
+
+作用：从msgq读出message
+
+data：message数据
+
+timeout: 等待时间，单位ms。K_NO_WAIT不等待,K_FOREVER一直等 返回值：读出成功返回0
+
+**__syscall int k_msgq_peek(struct k_msgq *msgq, void* data);**
+
+作用：peek msgq
+
+data: peek到的message
+
+返回： peek到数据返回0
+
+**__syscall void k_msgq_purge(struct k_msgq *msgq);**
+
+作用：清空msgq中的message
+
+**__syscall u32_t k_msgq_num_free_get(struct k_msgq *msgq);**
+
+作用：获取msgq还可以放多少个message
+
+返回值：空闲数目
+
+**__syscall void k_msgq_get_attrs(struct k_msgq *msgq, struct k_msgq_attrs* attrs);**
+
+作用：获取msgq的信息，也就是message的大小，总数量和已使用数量，都放在struct k_msgq_attrs 内
+
+**__syscall u32_t k_msgq_num_used_get(struct k_msgq *msgq);**
+
+作用：获取msgq中有多少个message
+返回值：message数目
+
+使用说明
+--------
+
+可以在ISR中put msgq.也可在ISR内get msgq，但不能等待。
+msgq必须事先指定message的大小和个数。大小需要是2的幂对齐。
+msgq用于异步传输小数据。msgq在读写时需要锁中断，因此不建议用来传输大数据。
+
+初始化
+~~~~~~
+
+初始化一个queue, 由用户分配内存
+
+::
+
+   struct data_item_type {     //message的数据结构
+       u32_t field1;
+       u32_t field2;
+       u32_t field3;
+   };
+
+   char __aligned(4) my_msgq_buffer[10 * sizeof(data_item_type)];
+   struct k_msgq my_msgq;
+
+   k_msgq_init(&my_msgq, my_msgq_buffer, sizeof(data_item_type), 10);
+
+由message queue自己在线程池中分配
+
+::
+
+   k_msgq_alloc_init(&my_msgq, sizeof(data_item_type), 10);
+
+写入message
+~~~~~~~~~~~
+
+运行在线程或者ISR中写入message，ISR中写入时不能发生等待。示例如下
+
+::
+
+   void producer_thread(void)
+   {
+       struct data_item_t data;
+
+       while (1) {
+           /* create data item to send (e.g. measurement, timestamp, ...) */
+           data = ...
+
+           /* send data to consumers */
+           while (k_msgq_put(&my_msgq, &data, K_NO_WAIT) != 0) {
+               /* message queue is full: purge old data & try again */
+               //这里purge并不是必要步骤，是否需要进行purge根据实际应用由用户自己选择
+               k_msgq_purge(&my_msgq);
+           }
+
+           /* data item was successfully added to message queue */
+       }
+   }
+
+读message
+~~~~~~~~~
+
+可以将message从msgq读出, 之后msgq中不再有该message
+
+::
+
+   void consumer_thread(void)
+   {
+       struct data_item_t data;
+
+       while (1) {
+           /* get a data item */
+           k_msgq_get(&my_msgq, &data, K_FOREVER);
+
+           /* process data item */
+           ...
+       }
+   }
+
+也可以只是peek，该message任然保留在msgq中
+
+::
+
+   void consumer_thread(void)
+   {
+       struct data_item_t data;
+
+       while (1) {
+           /* read a data item by peeking into the queue */
+           if(0 == k_msgq_peek(&my_msgq, &data)){
+               /* process data item */
+           }
+           ...
+       }
+   }
+
+实现
+====
+
+msgq的实现代码在zephyr/kernel/msg_q.c中，msgq是以ringbuffer的模式进行管理，在初始化的时候建立ringbuffer，读写数据时都是以固定的单位大小从ringbuffer内读写数据。
+msgq的数据结构如下
+
+::
+
+   struct k_msgq {
+       _wait_q_t wait_q;       //wait_q用于控制msgq的等待
+       struct k_spinlock lock;  //msgq多线程保护锁
+       size_t msg_size;        // message的大小
+       u32_t max_msgs;     // msgq最大容纳message的个数
+       char *buffer_start;     //msgq ringbuffer的开始地址
+       char *buffer_end;       //msgq ringbuffer的结束地址
+       char *read_ptr;             //msgq ringbuffer的读指针
+       char *write_ptr;        //msgq ringbuffer的写指针
+       u32_t used_msgs;    //msgq中有效message的个数
+       u8_t flags;                     //msgq的ringbuffer从线程池分配标志
+   };
+
+示意图 如下，每读或者写一个message，读写指针就向前移动msg_size |msgq|
+
+初始化/释放
+-----------
+
+初始化msgq就是对struct_msgq中的各成员进行初始化
+
+::
+
+   void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size,
+            u32_t max_msgs)
+   {
+       //初始化各成员
+       msgq->msg_size = msg_size;
+       msgq->max_msgs = max_msgs;
+       msgq->buffer_start = buffer;
+       msgq->buffer_end = buffer + (max_msgs * msg_size);
+       msgq->read_ptr = buffer;
+       msgq->write_ptr = buffer;
+       msgq->used_msgs = 0;
+       msgq->flags = 0;        // msgq ringbuffer是由使用者分配，这里设为0
+       z_waitq_init(&msgq->wait_q);    //初始化msgq的wait_q
+       msgq->lock = (struct k_spinlock) {};
+
+       z_object_init(msgq);
+   }
+
+k_msgq_alloc_init->z_impl_k_msgq_alloc_init,
+msgq内存从线程池中分配，再使用k_msgq_init初始化
+
+::
+
+   int z_impl_k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,
+                   u32_t max_msgs)
+   {
+       void *buffer;
+       int ret;
+       size_t total_size;
+
+       //计算msg_size乘max_msgs，并检查是否溢出，实际调用的是__builtin_mul_overflow
+       if (size_mul_overflow(msg_size, max_msgs, &total_size)) {
+           ret = -EINVAL;
+       } else {
+           //从线程池中分配msgq的ringbuffer 内存
+           buffer = z_thread_malloc(total_size);
+           if (buffer != NULL) {
+               //初始化各变量
+               k_msgq_init(msgq, buffer, msg_size, max_msgs);
+               //使用K_MSGQ_FLAG_ALLOC在flags中标识ringbuffer是从线程池中分配
+               msgq->flags = K_MSGQ_FLAG_ALLOC;
+               ret = 0;
+           } else {
+               ret = -ENOMEM;
+           }
+       }
+
+       return ret;
+   }
+
+如果msgq是从线程池中分配的内存，可以使用k_msgq_cleanup将其释放
+
+::
+
+   int k_msgq_cleanup(struct k_msgq *msgq)
+   {
+       //如果还有thread在等待msgq，说明不能释放，退出
+       CHECKIF(z_waitq_head(&msgq->wait_q) != NULL) {
+           return -EBUSY;
+       }
+
+       //判断alloc标志，并释放内存
+       if ((msgq->flags & K_MSGQ_FLAG_ALLOC) != 0) {
+           k_free(msgq->buffer_start);
+           msgq->flags &= ~K_MSGQ_FLAG_ALLOC;
+       }
+       return 0;
+   }
+
+mssage操作
+----------
+
+写msgq
+~~~~~~
+
+k_msgq_put->z_impl_k_msgq_put
+
+::
+
+   int z_impl_k_msgq_put(struct k_msgq *msgq, void *data, s32_t timeout)
+   {
+       //isr内写msgq不能等
+       __ASSERT(!arch_is_in_isr() || timeout == K_NO_WAIT, "");
+
+       struct k_thread *pending_thread;
+       k_spinlock_key_t key;
+       int result;
+
+       key = k_spin_lock(&msgq->lock);
+
+
+       if (msgq->used_msgs < msgq->max_msgs) {
+           //msgq中ringbuffer有空间
+
+           //检查是否有thread在等待读取msgq的message
+           pending_thread = z_unpend_first_thread(&msgq->wait_q);
+           if (pending_thread != NULL) {
+               //有线程在等message，直接将该数据提供给等待线程
+               (void)memcpy(pending_thread->base.swap_data, data,
+                      msgq->msg_size);
+               //等待线程拿到数据后，让等待线程ready，并重新调度
+               arch_thread_return_value_set(pending_thread, 0);
+               z_ready_thread(pending_thread);
+               z_reschedule(&msgq->lock, key);
+               return 0;
+           } else {
+               //没有线程需要数据，则将数据放入ringbuffer
+               (void)memcpy(msgq->write_ptr, data, msgq->msg_size);
+               msgq->write_ptr += msgq->msg_size;
+               if (msgq->write_ptr == msgq->buffer_end) {
+                   msgq->write_ptr = msgq->buffer_start;
+               }
+               //更新msgq剩余的message数
+               msgq->used_msgs++;
+           }
+           result = 0;
+       } else if (timeout == K_NO_WAIT) {
+           //msgq ringbuffer满，且不等待就立即退出
+           result = -ENOMSG;
+       } else {
+           //msgq 满，将message放入swap_data，等待其它thread来读
+           _current->base.swap_data = data;
+           return z_pend_curr(&msgq->lock, key, &msgq->wait_q, timeout);
+       }
+
+       k_spin_unlock(&msgq->lock, key);
+
+       return result;
+   }
+
+读msgq
+~~~~~~
+
+k_msgq_get->z_impl_k_msgq_get
+
+::
+
+   int z_impl_k_msgq_get(struct k_msgq *msgq, void *data, s32_t timeout)
+   {
+           //isr内读msgq不能等
+       __ASSERT(!arch_is_in_isr() || timeout == K_NO_WAIT, "");
+
+       k_spinlock_key_t key;
+       struct k_thread *pending_thread;
+       int result;
+
+       key = k_spin_lock(&msgq->lock);
+
+       if (msgq->used_msgs > 0) {
+           //ringbuffer中有数据，直接从ringbuffer中读出message
+           (void)memcpy(data, msgq->read_ptr, msgq->msg_size);
+           msgq->read_ptr += msgq->msg_size;
+           if (msgq->read_ptr == msgq->buffer_end) {
+               msgq->read_ptr = msgq->buffer_start;
+           }
+
+           //更新msgq剩余的message数
+           msgq->used_msgs--;
+
+           //此时ringbuffer有空闲空间，如果有thead在等待写msgq，则在这里写入
+           pending_thread = z_unpend_first_thread(&msgq->wait_q);
+           if (pending_thread != NULL) {
+               /* add thread's message to queue */
+               (void)memcpy(msgq->write_ptr, pending_thread->base.swap_data,
+                      msgq->msg_size);
+               msgq->write_ptr += msgq->msg_size;
+               if (msgq->write_ptr == msgq->buffer_end) {
+                   msgq->write_ptr = msgq->buffer_start;
+               }
+               //更新msgq剩余的message数
+               msgq->used_msgs++;
+
+               //等待写入msgq的thread在写入msgq后变为ready，并重新调度
+               arch_thread_return_value_set(pending_thread, 0);
+               z_ready_thread(pending_thread);
+               z_reschedule(&msgq->lock, key);
+               return 0;
+           }
+           result = 0;
+       } else if (timeout == K_NO_WAIT) {
+           /msgq ringbuffer空，且不等待就立即退出
+           result = -ENOMSG;
+       } else {
+           //msgq 空，将message放入swap_data，等待其它thread来写
+           _current->base.swap_data = data;
+           return z_pend_curr(&msgq->lock, key, &msgq->wait_q, timeout);
+       }
+
+       k_spin_unlock(&msgq->lock, key);
+
+       return result;
+   }
+
+peek msgq
+~~~~~~~~~
+
+也可以通过peek读message，该方式不会将message从msgq的ringbuffer中删除
+k_msgq_peek->z_impl_k_msgq_peek
+
+::
+
+   int z_impl_k_msgq_peek(struct k_msgq *msgq, void *data)
+   {
+       k_spinlock_key_t key;
+       int result;
+
+       key = k_spin_lock(&msgq->lock);
+
+       if (msgq->used_msgs > 0) {
+           //ringbuffer中有数据直接copy出去
+           (void)memcpy(data, msgq->read_ptr, msgq->msg_size);
+           result = 0;
+       } else {
+           //ringbuffer中有无数据返回错误
+           result = -ENOMSG;
+       }
+
+       k_spin_unlock(&msgq->lock, key);
+
+       return result;
+   }
+
+清空msgq
+~~~~~~~~
+
+当不需要msgq中的数据时可以使用k_msgq_purge清空
+k_msgq_purge->z_impl_k_msgq_purge
+
+::
+
+   void z_impl_k_msgq_purge(struct k_msgq *msgq)
+   {
+       k_spinlock_key_t key;
+       struct k_thread *pending_thread;
+
+       key = k_spin_lock(&msgq->lock);
+
+       //清空ringbuffer前，会先让等待读msgq的thead将message读走
+       while ((pending_thread = z_unpend_first_thread(&msgq->wait_q)) != NULL) {
+           arch_thread_return_value_set(pending_thread, -ENOMSG);
+           z_ready_thread(pending_thread);
+       }
+
+       //复位 ringbuffer
+       msgq->used_msgs = 0;
+       msgq->read_ptr = msgq->write_ptr;
+
+       z_reschedule(&msgq->lock, key);
+   }
+
+获取msgq信息
+------------
+
+获取msgq的信息函数实现很简单结合前面k_msgq的结构体很容易理解，这里就不再注释分析了
+
+::
+
+   void z_impl_k_msgq_get_attrs(struct k_msgq *msgq, struct k_msgq_attrs *attrs)
+   {
+       attrs->msg_size = msgq->msg_size;
+       attrs->max_msgs = msgq->max_msgs;
+       attrs->used_msgs = msgq->used_msgs;
+   }
+
+   static inline u32_t z_impl_k_msgq_num_free_get(struct k_msgq *msgq)
+   {
+       return msgq->max_msgs - msgq->used_msgs;
+   }
+
+   static inline u32_t z_impl_k_msgq_num_used_get(struct k_msgq *msgq)
+   {
+       return msgq->used_msgs;
+   }
+
+参考
+====
+
+https://gcc.gnu.org/onlinedocs/gcc/Integer-Overflow-Builtins.html
+https://docs.zephyrproject.org/latest/reference/kernel/data_passing/message_queues.html
+
+.. |msgq| image:: ../../images/develop/kernel/msgq.png
diff --git a/doc/source/develop/kernel/pipe.rst b/doc/source/develop/kernel/pipe.rst
new file mode 100644
index 0000000..35f4bad
--- /dev/null
+++ b/doc/source/develop/kernel/pipe.rst
@@ -0,0 +1,704 @@
+.. _kernel_pipe:
+
+
+数据同步-管道
+###############
+
+原理简介
+========
+
+Zephyr的Pipe用于线程向线程发送字节流，不能用于ISR。一个pipe只能做到单工或是半双工。Zephyr在设计上虽然支持对同一pipe进行同时多线程发和多线程收，但一般情况下都只建议做一发一收。
+
+Ring buffer工作原理
+====================
+Zephyr允许定义任意数量的管道，最大数量只由可用内存的量决定。管道的尺寸由管道的ring-buffer大小决定，管道内也可以不带ring-buffer。
+线程发送数据到管道时，如果数据没有被其它线程接收完，剩余的数据会被放入到管道内的ring-buffer。线程接收数据时会先从ring
+buffer内读取，再从pipe内等待发送的线程接收数据。
+如下图示，第一次发送数据1\ :sub:`6,接收线程只收1`\ 4，剩余5，6会被放入ring
+buffer。下一次接收时会先从ring buffer中读出
+5，6.再接收发送线程发送的7,8。 |image0|
+``
+
+收发行为
+--------
+
+发送时会指定发送到pipe数据的尺寸，和允许最小传送尺寸。如果实际传送尺寸小于最小传送尺寸，且不等待传送，将立即返回失败。
+接收时会指定从pipe接收数据的尺寸，和允许最小接收尺寸。如果实际接收的尺寸小于最小接收尺寸，且不等待接收，将立即返回失败。
+从pipe收发数据，只要实际收发数据的尺寸大于指定最小收发尺寸，本次收发都是成功的。
+接收和发送都允许等待，收发数据没有达到指定的尺寸前会保持阻塞，如果超时后实际收发数据的尺寸小于指定的最小尺寸，将返回失败。
+如果实际接收和发送数据的尺寸已经满足指定的最小尺寸，将记录退出，不会保持阻塞等待收发所有指定数据。
+
+使用
+====
+
+API
+---
+
+``#define K_PIPE_DEFINE(name, pipe_buffer_size, pipe_align)``
+
+作用:定义一个k_pipe，为其分配ring buffer
+
+name: k_pipe name
+
+pipe_buffer_size: pipe内ring buffer的大小
+
+pipe_align: 定义静态数组座位ring buffer，该参数指定该数组的对齐大小，只能是2的幂
+
+``void k_pipe_init(struct k_pipe *pipe, unsigned char *buffer, size_t size)``
+
+作用:初始化k_pipe, 并为其指定ring buffer
+
+pipe: 要初始化的pipe
+
+buffer: ringbuffer地址
+
+size: ring buffer大小
+
+``int k_pipe_alloc_init(struct k_pipe *pipe, size_t size)``
+
+作用:初始化k_pipe, 并为其分配ring buffer
+
+pipe: 要初始化的pipe
+
+size: 分配ring buffer大小
+
+返回值：0表示成功，-ENOMEM表示memory不足
+
+``int k_pipe_cleanup(struct k_pipe *pipe)``
+作用:释放k_pipe_alloc_init分配的ring buffer pipe: 要释放buffer的pipe
+返回值：0表示成功，-EAGAIN表示目前正在使用无法释放
+
+``int k_pipe_put(struct k_pipe *pipe, void *data, size_t bytes_to_write, size_t *bytes_written, size_t min_xfer, k_timeout_t timeout)``
+
+作用:发送数据到pipe
+
+pipe: 管道
+
+data: 发送数据的地址
+
+bytes_to_write：发送数据的尺寸
+
+bytes_written： 实际发送的尺寸
+
+min_xfer： 最小发送尺寸
+
+timeout：等待时间，单位ms。K_NO_WAIT不等待, K_FOREVER一直等
+
+返回值：0表示成功，-EINVAL表示参数错误，-EIO表示未等待且未传送任何数据，-EAGAIN表示传送的数据单数据量小于min_xfer
+
+``int k_pipe_get(struct k_pipe *pipe, void *data, size_t bytes_to_read, size_t *bytes_read, size_t min_xfer, k_timeout_t timeout)``
+
+作用:从pipe接收数据
+
+pipe: 管道
+
+data: 发送数据的地址
+
+bytes_to_read: 接收数据的尺寸 bytes_read 实际接收的尺寸 min_xfer 最小接收尺寸
+
+timeout：等待时间，单位ms。K_NO_WAIT不等待, K_FOREVER一直等
+
+返回值：0表示成功，-EINVAL表示参数错误，-EIO表示未等待且未收到任何数据，-EAGAIN表示接收的数据单数据量小于min_xfer
+
+``size_t k_pipe_read_avail(struct k_pipe *pipe)``
+
+作用:获取pipe内有多少有效数据，也就是ring buffer的有效数据大小
+
+pipe: 管道 返回值：可读数据大小
+
+``size_t k_pipe_write_avail(struct k_pipe *pipe)``
+
+作用:获取可以向管道写多少数据，也就是ring buffer内的空闲空间大小
+
+pipe: 管道 返回值：可写数据大小
+
+使用说明
+--------
+
+初始化
+~~~~~~
+
+先定义初始化一个pipe，一共有三种方式
+使用宏，宏会定义一个数组作为pipe的ring buffer
+
+::
+
+   K_PIPE_DEFINE(my_pipe, 100, 4);
+
+使用函数初始化，需要自己定义一个数组作为ring buffer
+
+::
+
+   unsigned char __aligned(4) my_ring_buffer[100];
+   struct k_pipe my_pipe;
+
+   k_pipe_init(&my_pipe, my_ring_buffer, sizeof(my_ring_buffer));
+
+使用函数初始化，由pipe自己分配内存作为ring buffer
+
+::
+
+   struct k_pipe my_pipe;
+   k_pipe_alloc_init(&my_pipe, 100)
+
+用k_pipe_alloc_init初始化的pipe，不再使用时需要用k_pipe_cleanup释放其分配的ring buffer
+
+::
+
+   k_pipe_cleanup(&my_pipe)
+
+写pipe
+~~~~~~
+
+发送数据需要分三种情况处理，如下分析
+
+::
+
+   struct message_header {
+       ...
+   };
+
+   void producer_thread(void)
+   {
+       unsigned char *data;
+       size_t total_size;
+       size_t bytes_written;
+       int    rc;
+       ...
+
+       while (1) {
+           /* 准备要发送到pipe的数据，尺寸大于struct message_header */
+           data = ...;
+           total_size = ...;
+
+           /* 通过pipe发送数据 */
+           rc = k_pipe_put(&my_pipe, data, total_size, &bytes_written,
+                           sizeof(struct message_header), K_NO_WAIT);
+
+           if (rc < 0) {
+               //数据头没有发送完，发送失败处理
+               ...
+           } else if (bytes_written < total_size) {
+               //数据头发送完，但数据没全发送，进行处理（例如继续发送）
+               ...
+           } else {
+               //所有数据都发送完毕
+               ...
+           }
+       }
+   }
+
+读pipe
+~~~~~~
+
+接收数据也分三种情况处理，如下分析
+
+::
+
+   void consumer_thread(void)
+   {
+       unsigned char buffer[120];
+       size_t   bytes_read;
+       struct message_header  *header = (struct message_header *)buffer;
+
+       while (1) {
+           rc = k_pipe_get(&my_pipe, buffer, sizeof(buffer), &bytes_read,
+                           sizeof(header), K_MSEC(100));
+
+           if ((rc < 0) || (bytes_read < sizeof (header))) {
+               //数据头未收全，接收失败处理
+               ...
+           } else if (header->num_data_bytes + sizeof(header) > bytes_read) {
+               //数据头收完，但数据没收全，进行处理（例如跳到下一次接收）
+               ...
+           } else {
+               //所有数据接收完毕
+               ...
+           }
+       }
+   }
+
+实现
+====
+
+该小节通过对管道内核代码的分析，理解Zephyr是如何实现以上描述的功能特性.
+pipe的实现代码在kernel:raw-latex:`\pipes`.c中
+
+pipe结构体
+----------
+
+一个管道主要是由ring buffer和两个wait_q组成，ring buffer最为pipe
+buffer， 两个wait_q用于管理发送和接收线程，如下定义：
+
+::
+
+   struct k_pipe {
+
+       //下面5个字段是ring buffer管理用，使用的是常规管理方法，本文不做分析
+       unsigned char *buffer;
+       size_t         size;
+       size_t         bytes_used;
+       size_t         read_index;
+       size_t         write_index;
+
+       //同步锁
+       struct k_spinlock lock;
+
+       //两个wait_q，readers用于管理读pipe的线程，writers用于管理写pipe的线程
+       struct {
+           _wait_q_t      readers; /**< Reader wait queue */
+           _wait_q_t      writers; /**< Writer wait queue */
+       } wait_q;           /** Wait queue */
+
+       //pipe flag，如果pipe的ring buffer是pipe分配的，该flag之为K_PIPE_FLAG_ALLOC
+       uint8_t        flags;       /**< Flags */
+   };
+
+
+初始化
+------
+
+k_pipe_init和K_PIPE_DEFINE主要就是初始化ring buffer和两个wait_q,流程简单，查看代码即可。
+这里看一下k_pipe_alloc_init和k_pipe_cleanup的流程
+k_pipe_alloc_init->z_vrfy_k_pipe_alloc_init->z_impl_k_pipe_alloc_init
+
+::
+
+   int z_impl_k_pipe_alloc_init(struct k_pipe *pipe, size_t size)
+   {
+       void *buffer;
+       int ret;
+
+       if (size != 0U) {
+           /从线程resource_pool内分配内存作为ring buffer
+           buffer = z_thread_malloc(size);
+           if (buffer != NULL) {
+               //初始化pipe
+               k_pipe_init(pipe, buffer, size);
+               //标记该pipe用的ring buffer是自己分配的内存
+               pipe->flags = K_PIPE_FLAG_ALLOC;
+               ret = 0;
+           } else {
+               ret = -ENOMEM;
+           }
+       } else {
+           //不需要ring buffer，直接进行初始化
+           k_pipe_init(pipe, NULL, 0);
+           ret = 0;
+       }
+
+       return ret;
+   }
+
+
+   int k_pipe_cleanup(struct k_pipe *pipe)
+   {
+       SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_pipe, cleanup, pipe);
+
+       //pipe使用中，不允许释放ring buffer
+       CHECKIF(z_waitq_head(&pipe->wait_q.readers) != NULL ||
+               z_waitq_head(&pipe->wait_q.writers) != NULL) {
+           return -EAGAIN;
+       }
+
+       //检查ring buffer是从线程resource_pool分配，释放内存
+       if ((pipe->flags & K_PIPE_FLAG_ALLOC) != 0U) {
+           k_free(pipe->buffer);
+           pipe->buffer = NULL;
+           pipe->flags &= ~K_PIPE_FLAG_ALLOC;
+       }
+
+       return 0;
+   }
+
+
+写pipe
+------
+
+写pipe的函数调用关系如下：
+k_pipe_put->z_vrfy_k_pipe_put->z_impl_k_pipe_put->z_pipe_put_internal
+z_pipe_put_internal内主要做下面几件事
+
+* 根据写pipe的数据长度，从readers wait_q中将读pipe的线程放入读pipe链表
+* 将数据依次拷贝给读pipe链表中的线程
+* 如果写数据还有剩余，将剩余数据放入pipe buffer中
+* 发送数据达到最小尺寸，立即退出发送
+* 发送数据未达到最小尺寸，等待发送超时
+
+::
+
+   int z_pipe_put_internal(struct k_pipe *pipe, struct k_pipe_async *async_desc,
+                unsigned char *data, size_t bytes_to_write,
+                size_t *bytes_written, size_t min_xfer,
+                k_timeout_t timeout)
+   {
+       struct k_thread    *reader;
+       struct k_pipe_desc *desc;
+       sys_dlist_t    xfer_list;
+       size_t         num_bytes_written = 0;
+       size_t         bytes_copied;
+
+
+       //参数判断
+       CHECKIF((min_xfer > bytes_to_write) || bytes_written == NULL) {
+           return -EINVAL;
+       }
+
+       k_spinlock_key_t key = k_spin_lock(&pipe->lock);
+
+       //将等待读pipe的thread从readers wait_q中移除并加入到链表xfer_list中
+       //最后一个读pipe的thread不加入到xfer_list中，而是直接放入到reader
+       if (!pipe_xfer_prepare(&xfer_list, &reader, &pipe->wait_q.readers,
+                   pipe->size - pipe->bytes_used, bytes_to_write,
+                   min_xfer, timeout)) {
+           k_spin_unlock(&pipe->lock, key);
+
+           //读pipe的总量小于写pipe的min_xfer，且写pipe不等待，立即返回失败
+           //该部分原理在pipe_xfer_prepare中分析
+           *bytes_written = 0;
+
+           return -EIO;
+       }
+
+
+       z_sched_lock();
+       k_spin_unlock(&pipe->lock, key);
+
+       //遍历读pipe thread 链表xfer_list
+       struct k_thread *thread = (struct k_thread *)
+                     sys_dlist_get(&xfer_list);
+       while (thread != NULL) {
+           //用pipe_xfer依次将写pipe的数据拷贝到读pipe thread中
+           desc = (struct k_pipe_desc *)thread->base.swap_data;
+           bytes_copied = pipe_xfer(desc->buffer, desc->bytes_to_xfer,
+                         data + num_bytes_written,
+                         bytes_to_write - num_bytes_written);
+
+           num_bytes_written   += bytes_copied;
+           desc->buffer        += bytes_copied;
+           desc->bytes_to_xfer -= bytes_copied;
+
+           //读pipe的thread已经拿到全部数据，被转为就绪
+           z_ready_thread(thread);
+
+           thread = (struct k_thread *)sys_dlist_get(&xfer_list);
+       }
+
+
+       //最后一个等待读pipe的线程从pipe中读取数据，因为可能数据可能读不够，因此不将其转为就绪态
+       if (reader != NULL) {
+           desc = (struct k_pipe_desc *)reader->base.swap_data;
+           bytes_copied = pipe_xfer(desc->buffer, desc->bytes_to_xfer,
+                         data + num_bytes_written,
+                         bytes_to_write - num_bytes_written);
+
+           num_bytes_written   += bytes_copied;
+           desc->buffer        += bytes_copied;
+           desc->bytes_to_xfer -= bytes_copied;
+       }
+
+       //写pipe数据如果还有剩余，放入pipe ring buffer
+       num_bytes_written +=
+           pipe_buffer_put(pipe, data + num_bytes_written,
+                    bytes_to_write - num_bytes_written);
+
+       //写pipe的数据如果已经消耗完，返回成功
+       if (num_bytes_written == bytes_to_write) {
+           *bytes_written = num_bytes_written;
+           k_sched_unlock();
+
+           return 0;
+       }
+
+       //如果写pipe已经达到最小传送尺寸min_xfer，立即返回成功不再等待
+       if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT)
+           && num_bytes_written >= min_xfer
+           && min_xfer > 0U) {
+           *bytes_written = num_bytes_written;
+           k_sched_unlock();
+
+           return 0;
+       }
+
+
+       struct k_pipe_desc  pipe_desc;
+
+       pipe_desc.buffer         = data + num_bytes_written;
+       pipe_desc.bytes_to_xfer  = bytes_to_write - num_bytes_written;
+       //如果写pipe数据未被读完且需要等待超时的，将线程加入到wirters wait_q，等待读pipe线程
+       if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
+           _current->base.swap_data = &pipe_desc;
+
+           k_spinlock_key_t key2 = k_spin_lock(&pipe->lock);
+           z_sched_unlock_no_reschedule();
+           (void)z_pend_curr(&pipe->lock, key2,
+                    &pipe->wait_q.writers, timeout);
+       } else {
+           k_sched_unlock();
+       }
+
+       //计算实际写pipe数据，并和min_xfer比较，检查是否达到最小传送量
+       *bytes_written = bytes_to_write - pipe_desc.bytes_to_xfer;
+       int ret = pipe_return_code(min_xfer, pipe_desc.bytes_to_xfer,
+                    bytes_to_write);
+
+       return ret;
+   }
+
+
+读pipe
+------
+
+读pipe的函数调用关系如下：
+k_pipe_get->z_vrfy_k_pipe_get->z_impl_k_pipe_get
+z_impl_k_pipe_get的流程和写pipe是对称的，主要做下面几件事
+
+* 根据读pipe的数据长度，从writers wait_q中将写pipe的线程放入
+* 将pipe内ring buffer的数据拷贝给读pipe线程
+* 写pipe链表中写pipe线程的数据依次拷贝给读pipe线程
+* 如果写pipe线程链表的数据还有剩余，将其写到pipe buffer内
+* 接收数据达到最小尺寸，立即退出接收
+* 接收数据未达到最小尺寸，等待接收超时
+
+::
+
+   int z_impl_k_pipe_get(struct k_pipe *pipe, void *data, size_t bytes_to_read,
+                size_t *bytes_read, size_t min_xfer, k_timeout_t timeout)
+   {
+       struct k_thread    *writer;
+       struct k_pipe_desc *desc;
+       sys_dlist_t    xfer_list;
+       size_t         num_bytes_read = 0;
+       size_t         bytes_copied;
+
+       //检查参数
+       CHECKIF((min_xfer > bytes_to_read) || bytes_read == NULL) {
+           return -EINVAL;
+       }
+
+       k_spinlock_key_t key = k_spin_lock(&pipe->lock);
+
+       //将等待写pipe的thread从writers wait_q中移除并加入到链表xfer_list中
+       //最后一个读pipe的thread不加入到xfer_list中，而是直接放入到writer
+       //这里计算长度没有考虑pipe buffer内的数据，因此链表内待接收数据和buffer数据的总和可能会大于读pipe需要的长度
+       if (!pipe_xfer_prepare(&xfer_list, &writer, &pipe->wait_q.writers,
+                   pipe->bytes_used, bytes_to_read,
+                   min_xfer, timeout)) {
+           k_spin_unlock(&pipe->lock, key);
+           *bytes_read = 0;
+
+           //写pipe的总量小于读pipe的min_xfer，且写pipe不等待，立即返回失败
+           //该部分原理在pipe_xfer_prepare中分析
+
+           return -EIO;
+       }
+
+
+       z_sched_lock();
+       k_spin_unlock(&pipe->lock, key);
+
+       //先从pipe buffer中读数据
+       num_bytes_read = pipe_buffer_get(pipe, data, bytes_to_read);
+
+       //遍历读pipe thread 链表xfer_list
+       struct k_thread *thread = (struct k_thread *)
+                     sys_dlist_get(&xfer_list);
+       while ((thread != NULL) && (num_bytes_read < bytes_to_read)) {
+           //用pipe_xfer依次将写pipe的thread的数据拷贝到读pipe thread中
+           desc = (struct k_pipe_desc *)thread->base.swap_data;
+           bytes_copied = pipe_xfer((uint8_t *)data + num_bytes_read,
+                         bytes_to_read - num_bytes_read,
+                         desc->buffer, desc->bytes_to_xfer);
+
+           num_bytes_read       += bytes_copied;
+           desc->buffer         += bytes_copied;
+           desc->bytes_to_xfer  -= bytes_copied;
+
+           //由于前面从pipe buffer中还接收了数据，因此链表未遍历完就可能将需要读的数据量读够
+           if (num_bytes_read == bytes_to_read) {
+               break;
+           }
+
+           //数据被读完的thread转为就绪太
+           pipe_thread_ready(thread);
+
+           thread = (struct k_thread *)sys_dlist_get(&xfer_list);
+       }
+
+       //buffer和链表内的数据都被读完了，还没读够长度，则从writer中读
+       if ((writer != NULL) && (num_bytes_read < bytes_to_read)) {
+           desc = (struct k_pipe_desc *)writer->base.swap_data;
+           bytes_copied = pipe_xfer((uint8_t *)data + num_bytes_read,
+                         bytes_to_read - num_bytes_read,
+                         desc->buffer, desc->bytes_to_xfer);
+
+           num_bytes_read       += bytes_copied;
+           desc->buffer         += bytes_copied;
+           desc->bytes_to_xfer  -= bytes_copied;
+       }
+
+       //由于前面从pipe buffer中还接收了数据，因此链表未遍历完就可能将需要读的数据量读够，链表中剩余的数据将放入pipe buffer
+       while (thread != NULL) {
+           desc = (struct k_pipe_desc *)thread->base.swap_data;
+           bytes_copied = pipe_buffer_put(pipe, desc->buffer,
+                           desc->bytes_to_xfer);
+
+           desc->buffer         += bytes_copied;
+           desc->bytes_to_xfer  -= bytes_copied;
+
+           //链表中写pipe线程数据被放入pipe buffer后，该线程转为就绪态
+           pipe_thread_ready(thread);
+
+           thread = (struct k_thread *)sys_dlist_get(&xfer_list);
+       }
+
+       //由于前面从pipe buffer中和链表中还接收了数据，因此writer中的数据可能会有剩，需要将writer中的剩余数据放入到pipe buffer中
+       //由于pipe buffer可能无法放下wirter中所有写pipe的数据，因此wirter线程不能转为就绪
+       if (writer != NULL) {
+           desc = (struct k_pipe_desc *)writer->base.swap_data;
+           bytes_copied = pipe_buffer_put(pipe, desc->buffer,
+                           desc->bytes_to_xfer);
+
+           desc->buffer         += bytes_copied;
+           desc->bytes_to_xfer  -= bytes_copied;
+       }
+
+       //数据读全，立即返回
+       if (num_bytes_read == bytes_to_read) {
+           k_sched_unlock();
+
+           *bytes_read = num_bytes_read;
+
+           SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_pipe, get, pipe, timeout, 0);
+
+           return 0;
+       }
+
+       //如果读pipe已经达到最小传送尺寸min_xfer，立即返回成功不再等待
+       if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT)
+           && num_bytes_read >= min_xfer
+           && min_xfer > 0U) {
+           k_sched_unlock();
+
+           *bytes_read = num_bytes_read;
+
+           SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_pipe, get, pipe, timeout, 0);
+
+           return 0;
+       }
+
+       struct k_pipe_desc  pipe_desc;
+
+       pipe_desc.buffer        = (uint8_t *)data + num_bytes_read;
+       pipe_desc.bytes_to_xfer = bytes_to_read - num_bytes_read;
+       //如果读pipe未达到最小尺寸且需要等待超时的，将线程加入到readers wait_q，等待写pipe线程
+       if (!K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
+           _current->base.swap_data = &pipe_desc;
+           k_spinlock_key_t key2 = k_spin_lock(&pipe->lock);
+
+           z_sched_unlock_no_reschedule();
+           (void)z_pend_curr(&pipe->lock, key2,
+                    &pipe->wait_q.readers, timeout);
+       } else {
+           k_sched_unlock();
+       }
+
+       //计算实际读pipe数据，并和min_xfer比较，检查是否达到最小传送量
+       *bytes_read = bytes_to_read - pipe_desc.bytes_to_xfer;
+       int ret = pipe_return_code(min_xfer, pipe_desc.bytes_to_xfer,
+                    bytes_to_read);
+
+       return ret;
+   }
+
+内部API
+-------
+
+从前面分析可以看出读写pipe的操作在流程上基本是对称的，都依赖于pipe_xfer_prepare，pipe_xfer。
+另外就是操作pipe buffer： pipe_buffer_put/pipe_buffer_get，前面提到过pipe buffer的操作就是ring buffer操作，本文不做分析。 pipe_xfer_prepare传输列表准备，读写都是用的这个函数，至少传入的参数不一样
+
+::
+
+   static bool pipe_xfer_prepare(sys_dlist_t      *xfer_list,
+                      struct k_thread **waiter,
+                      _wait_q_t        *wait_q,
+                      size_t            pipe_space,
+                      size_t            bytes_to_xfer,
+                      size_t            min_xfer,
+                      k_timeout_t           timeout)
+   {
+       struct k_thread  *thread;
+       struct k_pipe_desc *desc;
+       size_t num_bytes = 0;
+
+       //不等待的传送，检查需求是否大于最小尺寸，如果需求不满足最小尺寸就立即退出
+       //对于写pipe来说：检查readers wait_q中等待读pipe线程需求的数据量是否大于要写的最小尺寸
+       //对于读pipe来说：检查writers wait_q中等待写pipe线程拥有的数据量是否大于要读的最小尺寸
+       if (K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
+           _WAIT_Q_FOR_EACH(wait_q, thread) {
+               desc = (struct k_pipe_desc *)thread->base.swap_data;
+
+               num_bytes += desc->bytes_to_xfer;
+
+               if (num_bytes >= bytes_to_xfer) {
+                   break;
+               }
+           }
+
+           if (num_bytes + pipe_space < min_xfer) {
+               return false;
+           }
+       }
+
+
+       sys_dlist_init(xfer_list);
+       num_bytes = 0;
+
+       //遍历writer或reader wait_q，按照需求数量的长度将线程加入链表xfer_list内，加入的同时从wait_q中移除
+       while ((thread = z_waitq_head(wait_q)) != NULL) {
+           desc = (struct k_pipe_desc *)thread->base.swap_data;
+           num_bytes += desc->bytes_to_xfer;
+
+           if (num_bytes > bytes_to_xfer) {
+               //最后一个thread不会被加入到链表中，因为该thread的数据需求不会被全部满足
+               break;
+           }
+
+           //其它thread会被从wait_q中移除并加入到链表中，这些thread的数据需求(读或写)将会被全部满足
+           z_unpend_thread(thread);
+           sys_dlist_append(xfer_list, &thread->base.qnode_dlist);
+       }
+
+       //将最后一个thread送出，外部会对没满足完的需求另做处理
+       *waiter = (num_bytes > bytes_to_xfer) ? thread : NULL;
+
+       return true;
+   }
+
+pipe_xfer非常简单就是copy数据：
+
+::
+
+   static size_t pipe_xfer(unsigned char *dest, size_t dest_size,
+                const unsigned char *src, size_t src_size)
+   {
+       size_t num_bytes = MIN(dest_size, src_size);
+       const unsigned char *end = src + num_bytes;
+
+       while (src != end) {
+           *dest = *src;
+           dest++;
+           src++;
+       }
+
+       return num_bytes;
+   }
+
+但也由此可知道，虽然pipe可以用来传送大量数据，但如果为了提高效率，减少数据copy还是使用消息列队等方式直接传送内存的指针比较好。
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/reference/kernel/data_passing/pipes.html
+
+.. |image0| image:: ../../images/develop/kernel/pipe-b.png
diff --git a/doc/source/develop/kernel/stack.rst b/doc/source/develop/kernel/stack.rst
new file mode 100644
index 0000000..c68fcfe
--- /dev/null
+++ b/doc/source/develop/kernel/stack.rst
@@ -0,0 +1,285 @@
+.. _kernel_stack:
+
+数据传递-堆栈
+###############
+
+使用
+====
+
+API
+---
+
+**void k_stack_init(struct k_stack stack, stack_data_t buffer, u32_t num_entries);**
+
+作用：初始化一个stack，stack的内存由使用者分配
+
+stack: 被初始化的stack
+
+buffer: stack使用的内存
+
+num_entries：stack的成员数量
+
+**__syscall s32_t k_stack_alloc_init(struct k_stack *stack, u32_tnum_entries);**
+
+作用：初始化一个stack，stack使用的内存从thread pool分配
+
+stack: 被初始化的stack
+
+num_entries：stack的成员数量
+
+返回值: 0表示初始化成功
+
+**int k_stack_cleanup(struct k_stack* stack);**
+
+作用：释放k_stack_alloc_init中为stack分配的内存
+
+stack: 操作的stack
+
+返回值: 0表示free成功，如果有pop在等待数据时会返回非0
+
+**__syscall int k_stack_push(struct k_stack *stack, stack_data_t data);**
+
+作用：压栈
+
+stack：被压栈的stack
+
+data: 要push的数据
+
+返回值：push成功返回0
+
+**__syscall int k_stack_pop(struct k_stack *stack, stack_data_t* data, s32_t timeout);**
+
+作用：出栈 stack：被出栈的stack
+
+data: pop的数据
+
+timeout: stack没数据时可等待超时，单位ms。K_NO_WAIT不等待, K_FOREVER一直等
+
+返回值：pop成功返回0
+
+使用说明
+--------
+
+可以在ISR中push stack.也可在ISR内pop stack，但不能等待。 stack满后,push将会失败。 stack的数据成员是指针类型stack_data_t的大小和CPU位数对应
+
+初始化
+~~~~~~~
+
+下面两种方式都可以对stack进行初始化 使用函数
+
+::
+
+   #define MAX_ITEMS 10
+
+   stack_data_t my_stack_array[MAX_ITEMS];
+   struct k_stack my_stack;
+
+   k_stack_init(&my_stack, my_stack_array, MAX_ITEMS);
+
+使用宏
+
+::
+
+   K_STACK_DEFINE(my_stack, MAX_ITEMS);
+
+栈操作
+~~~~~~
+
+堆栈当中存储的只是数据的指针
+
+::
+
+   struct my_buffer_type {
+       int field1;
+       ...
+       };
+   struct my_buffer_type my_buffers[MAX_ITEMS];
+
+   void producer_thread(int unused1, int unused2, int unused3)
+   {
+       //将数据指针入栈
+       for (int i = 0; i < MAX_ITEMS; i++) {
+           k_stack_push(&my_stack, (stack_data_t)&my_buffers[i]);
+       }
+   }
+
+   void consumer_fifo_thread(int unused1, int unused2, int unused3)
+   {
+       struct my_buffer_type *new_buffer;
+       //将数据指针出栈，并进行操作
+       k_stack_pop(&buffer_stack, (stack_data_t *)&new_buffer, K_FOREVER);
+       new_buffer->field1 = ...
+   }
+
+实现
+====
+
+数据结构
+--------
+
+stack的数据结构如下，wait_q用于pop时无数据等待数据，lock用于多线程访问stack时进行线程保护
+
+::
+
+   struct k_stack {
+       _wait_q_t wait_q;
+       struct k_spinlock lock;
+       stack_data_t *base, *next, *top;
+       u8_t flags;
+   };
+
+base是栈底,
+next是栈顶，top是堆栈最大的位置，也就是说next不能超过top.如下图 |stack|
+
+flag只指示该堆栈的内存是否是从线程池中分配的，如果是用k_stack_alloc_init初始化的堆栈，flag就会被设置为下面的值
+
+::
+
+   #define K_STACK_FLAG_ALLOC  ((u8_t)1)
+
+初始化
+------
+
+初始化起始就是将stack的各个指针设置正确
+
+::
+
+   void    (struct k_stack *stack, stack_data_t *buffer,
+             u32_t num_entries)
+   {
+       z_waitq_init(&stack->wait_q);   //初始化wait_q
+       stack->lock = (struct k_spinlock) {};
+       stack->next = stack->base = buffer; //base指向buffer开始
+       stack->top = stack->base + num_entries; //top执行buffer尾部
+
+       z_object_init(stack);
+   }
+
+push
+----
+
+k_stack_push->z_impl_k_stack_push,分析见注释
+
+::
+
+   int z_impl_k_stack_push(struct k_stack *stack, stack_data_t data)
+   {
+       struct k_thread *first_pending_thread;
+       k_spinlock_key_t key;
+
+       // stack满了，返回
+       CHECKIF(stack->next == stack->top) {
+           return -ENOMEM;
+       }
+
+       key = k_spin_lock(&stack->lock);
+
+       //查看是否有thread已经在等待stack数据
+       first_pending_thread = z_unpend_first_thread(&stack->wait_q);
+
+       if (first_pending_thread != NULL) {
+           //如果有thread在等stack数据，将push的数据直接给该thread
+           //stack指针不做修改
+           z_ready_thread(first_pending_thread);
+
+           z_thread_return_value_set_with_data(first_pending_thread,
+                              0, (void *)data);
+           z_reschedule(&stack->lock, key);
+       } else {
+           //没有thread等stack，将数据放入stack，然后修改next指针
+           *(stack->next) = data;
+           stack->next++;
+           k_spin_unlock(&stack->lock, key);
+       }
+
+       return 0;
+   }
+
+pop
+---
+
+k_stack_pop->z_impl_k_stack_pop，分析见注释
+
+::
+
+   int z_impl_k_stack_pop(struct k_stack *stack, stack_data_t *data, s32_t timeout)
+   {
+       k_spinlock_key_t key;
+       int result;
+
+       key = k_spin_lock(&stack->lock);
+
+       //检查stack中是否有数据，有就修改next，然后将数据传出
+       if (likely(stack->next > stack->base)) {
+           stack->next--;
+           *data = *(stack->next);
+           k_spin_unlock(&stack->lock, key);
+           return 0;
+       }
+
+       //如果pop不等待，又没有数据就直接退出
+       if (timeout == K_NO_WAIT) {
+           k_spin_unlock(&stack->lock, key);
+           return -EBUSY;
+       }
+
+       //将thread加入wait_q等待stack数据
+       result = z_pend_curr(&stack->lock, key, &stack->wait_q, timeout);
+       if (result == -EAGAIN) {
+           //等待超时，则退出
+           return -EAGAIN;
+       }
+
+       //等待到数据就传出数据
+       *data = (stack_data_t)_current->base.swap_data;
+       return 0;
+   }
+
+Stack从thread pool分配内存
+--------------------------
+
+除了传入stack内存外，stack也可以自己从内存池中分配stack内存
+k_stack_alloc_init->z_impl_k_stack_alloc_init 分配内存并初始化stack。
+k_stack_cleanup和z_impl_k_stack_alloc_init配对使用，当不使用时使用该api来做k_free。
+分析见代码注释
+
+::
+
+   s32_t z_impl_k_stack_alloc_init(struct k_stack *stack, u32_t num_entries)
+   {
+       void *buffer;
+       s32_t ret;
+
+       //从线程池中分配内存
+       buffer = z_thread_malloc(num_entries * sizeof(stack_data_t));
+       if (buffer != NULL) {
+           k_stack_init(stack, buffer, num_entries);
+           //设置flags，指示该stack的buffer是从内存池中分配
+           stack->flags = K_STACK_FLAG_ALLOC;
+           ret = (s32_t)0;
+       } else {
+           ret = -ENOMEM;
+       }
+
+
+   int k_stack_cleanup(struct k_stack *stack)
+   {
+       //检查wait_q，如果有线程在等待数据不能clean up stack
+       CHECKIF(z_waitq_head(&stack->wait_q) != NULL) {
+           return -EAGAIN;
+       }
+       //检查有alloc flag，对stack buffer进行释放
+       if ((stack->flags & K_STACK_FLAG_ALLOC) != (u8_t)0) {
+           k_free(stack->base);
+           stack->base = NULL;
+           stack->flags &= ~K_STACK_FLAG_ALLOC;
+       }
+       return 0;
+   }
+
+参考
+====
+
+https://docs.zephyrproject.org/latest/reference/kernel/data_passing/stacks.html
+
+.. |stack| image:: ../../images/develop/kernel/stack.png
diff --git a/doc/source/images/develop/kernel/datapassing.png b/doc/source/images/develop/kernel/datapassing.png
new file mode 100644
index 0000000000000000000000000000000000000000..18398d5bf6080f5232db34d1a1f7e98687e98df6
GIT binary patch
literal 43199
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
P|MaUUrv@sMH4FGZCfDP7

literal 0
HcmV?d00001

diff --git a/doc/source/images/develop/kernel/limit.png b/doc/source/images/develop/kernel/limit.png
new file mode 100644
index 0000000000000000000000000000000000000000..fa5d833b128c41a86e87890a6d1985cc6cea1483
GIT binary patch
literal 22954
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
QgPFlt-%PJW*XjPh0LG40g#Z8m

literal 0
HcmV?d00001

diff --git a/doc/source/images/develop/kernel/msgq.png b/doc/source/images/develop/kernel/msgq.png
new file mode 100644
index 0000000000000000000000000000000000000000..c9299a003d59a8ef9977d116255f63d68ca13cf3
GIT binary patch
literal 13542
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
C^Sbo_

literal 0
HcmV?d00001

diff --git a/doc/source/images/develop/kernel/pipe-b.png b/doc/source/images/develop/kernel/pipe-b.png
new file mode 100644
index 0000000000000000000000000000000000000000..0e44baaef56b3d8ac1299c62ea0221d430e717a1
GIT binary patch
literal 24269
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
Yf4wvrkv9jfsi!m0G0`s4JbV8C0ZhOct^fc4

literal 0
HcmV?d00001

diff --git a/doc/source/images/develop/kernel/queue.png b/doc/source/images/develop/kernel/queue.png
new file mode 100644
index 0000000000000000000000000000000000000000..ce3f1fe8e4fc519c555532b406f326d2524a0e36
GIT binary patch
literal 32394
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
X_u9)hZ@@d|w<(`fJDYy`hVTCYf;DNX

literal 0
HcmV?d00001

diff --git a/doc/source/images/develop/kernel/stack.png b/doc/source/images/develop/kernel/stack.png
new file mode 100644
index 0000000000000000000000000000000000000000..1af5a82bdd6161298a53270a2a3d0a6023811ebb
GIT binary patch
literal 17296
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

literal 0
HcmV?d00001

-- 
Gitee


From a12fef83dbb3b9c8d35f6e75bfa9fb41576a42de Mon Sep 17 00:00:00 2001
From: Frank Li <lgl88911@163.com>
Date: Sat, 12 Nov 2022 09:34:44 +0800
Subject: [PATCH 6/6] doc: fixed build warning

Signed-off-by: Frank Li <lgl88911@163.com>
---
 doc/source/develop/windows.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/source/develop/windows.rst b/doc/source/develop/windows.rst
index e906d3e..58fa63e 100644
--- a/doc/source/develop/windows.rst
+++ b/doc/source/develop/windows.rst
@@ -20,7 +20,7 @@ Zephyr的代码可以分为Zephyr OS和Zephyr modules两大部分，都托管在
 
     * 只包含Zephyr OS最新发行版和lts发行版，可以访问 `镜像 <https://gitee.com/src-openeuler/zephyr>`_
     * 包含了Zephyr OS和Zephyr modules，可以访问 `网盘 <https://pan.baidu.com/s/1v6wk386WMKZ8X8cXSdfUOQ>`_ 提取码: **zeph**
-    * 如果需要同步Zephyr OS的git仓库，可以先通过 `gitee镜像 <https://gitee.com/zephyr-rtos/zephyr>`_ 同步，然后再同步到github上
+    * 如果需要同步Zephyr OS的git仓库，可以先通过 `gitee zephyr镜像 <https://gitee.com/zephyr-rtos/zephyr>`_ 同步，然后再同步到github上
       的仓库
     * Zephyr modules数量较多，但只有部分git仓库在 `gitee镜像 <https://gitee.com/zephyr-rtos>`_ 上存在，缺失的部分需要通过其方式
       获得。在实际开发过程中，很少会使用到所有Zephyr modules, 因此可以根据需要，只准备相应的modules。
-- 
Gitee