# 流水线(Pipeline)
流水线是用来定义流程并执行相关操作的抽象。下图给出了流水线的一个简单抽象。
![image][pipeline-image]
我们定义的流水线包含以下几种概念：
1. 节点：封装某一种或者某一类操作，这个操作由使用流水线包的项目按照自己的需求自行实现， 我们也会逐渐添加一些预定义的节点供大家使用；
2. 流程：节点的容器，规定了其内节点的执行顺序，预定义的流程包括顺序(seq)流程， 条件(if)流程，循环(loop)流程，遍历(range)流程，交换参数(bi)流程，也可按照需要自定义流程；
3. 流水线：由流程和节点组成，其根流程本质上就是一个顺序流程， 其下可以包含各种其他流程或者节点。
结构如下图所示，整体采用了组合模式
![image][class-image]
## 定义流水线
定义流水线需要不断交错进行两个步骤，节点或流程开发和流水线编排。
### 节点或流程开发
代码定义了Component接口，从上面的类图中可以看到，无论是流程还是节点，本质上就是一个Component，需要定义自己的流程或者节点，仅需要实现Component接口
```go
// "git.sxidc.com/go-tools/utils/pipeline/component"
type Component interface {
GetType() string // 返回组件类型，如内部预定义的顺序流程的，返回seq
GetName() string // 返回组件实例的名称，这个名称是在流水线编排中传递进来的
Run(globalRunParams *GlobalRunParams, dynamicParams map[string]any) (any, error) // 执行逻辑，由于流水线使用了Go的协程，这里返回一个RunToken，需要Wait在RunToken上，以获取结果
}
```
为了简化开发，我们提供了一个Component的基类，定义一个自己的Component可以用下面更简单的方法
```go
type FooComponent struct {
component.BaseComponent
}
func (f *FooComponent) Run(globalRunParams *component.GlobalRunParams, dynamicParams map[string]any) (any, error) {
return f.OnRun(globalRunParams, dynamicParams,
func(globalRunParams *component.GlobalRunParams, dynamicParams map[string]any) (any, error) {
// 完成运行逻辑
// globalRunParams全局运行参数，运行流水线章节详细说明
// dynamicParams动态运行参数，运行流水线章节详细说明
// 返回值是本组件运行后的结果及出错信息
})
}
```
组件的创建使用了Builder模式，需要定义一个实现了Builder接口的组件构建器，Builder接口如下所示：
```go
// "git.sxidc.com/go-tools/utils/pipeline/component"
type Builder interface {
ProductType() string // 返回制品类型，应当与上面实现的Component的GetType方法返回值一致
Build(name string, buildParams map[string]any, runParams map[string]any) (Component, error) // 构建过程
}
```
但是我们定义的流程和节点还需要进行注册才能使用，注册需要调用如下函数：
```go
// "git.sxidc.com/go-tools/utils/pipeline/component"
func RegisterComponentBuilders(builders ...Builder) error
```
如果要动态注销，需要调用下面的接口：
```go
// "git.sxidc.com/go-tools/utils/pipeline/component"
func UnRegisterComponents(typeNames []string)
```
如果此时想单独测试自己编写的组件，可以使用下面的函数创建组件
```go
// "git.sxidc.com/go-tools/utils/pipeline/component"
func BuildComponent(typeName string, name string, buildParams map[string]any, runParams map[string]any) (Component, error)
```
### 流水线编排
有两种编排流水线的方式：代码通过构造Definition结构编排流水线和通过YAML编排
#### 通过Definition编排
Definition结构定义如下：
```go
// "git.sxidc.com/go-tools/pipeline/utils"
type Definition struct {
Name string `yaml:"name"` // 流水线名称
Components []ComponentDefinition `yaml:"components"` // 组件定义
}
type ComponentDefinition struct {
Type string `yaml:"type"` // 组件类型，确保是注册过的组件
Name string `yaml:"name"` // 组件名称
BuildParams map[string]any `yaml:"build_params"` // 组件构建参数，不同的组件需要的构建参数不同
RunParams map[string]any `yaml:"run_params"` // 构建时指定的静态运行参数
}
```
使用Definition需要填充对应的属性，然后运行Definition的方法即可创建流水线：
```go
// "git.sxidc.com/go-tools/pipeline/utils"
func (def *Definition) NewPipeline() (*Pipeline, error)
```
#### 通过YAML编排
通过yaml文件编排本质上还是通过Definition生成，编写的YAML文件格式从上面的Definition的tag中就能看到，下面给出一个测试中用到的YAML定义：
```yaml
name: test
components:
- type: seq
name: seq-flow
build_params:
components:
- type: println
name: seq-flow-node
run_params:
content: seq-flow-node
- type: println
name: pipeline-node
run_params:
content: pipeline-node
- type: if
name: if-flow
build_params:
condition:
type: seq
name: condition_flow
build_params:
components:
- type: bool
name: bool
run_params:
op: pass
value: true
condition_true:
type: seq
name: true-flow
build_params:
components:
- type: println
name: if-node-true
run_params:
content: if-node-true
condition_false:
type: println
name: if-node-false
run_params:
content: if-node-false
- type: loop
name: loop-flow
build_params:
condition:
type: bool
name: condition-node
run_params:
op: rand
sub:
type: seq
name: sub-flow
build_params:
components:
- type: println
name: loop-sub-node
run_params:
content: loop-sub-node
- type: range
name: range-flow
build_params:
values:
- range first
- range second
sub:
type: println
name: range-sub-node
run_params:
content: range-sub-node
- type: bi
name: bi-flow
build_params:
components:
- type: println
name: bi-flow-node
run_params:
content: bi-flow-node
run_params:
is_bi: true
left_params: left
right_params: right
```
后面章节会给出几种内置流程的构建参数和运行参数，可以对照查看上面的编排。YAML编排可以将内容写入文件，也可以是内存中保存的，有两个函数可以使用YAML编排创建流水线：
```go
// "git.sxidc.com/go-tools/pipeline/utils"
// 通过YAML定义文件创建流水线
func NewPipelineFromYaml(yamlPath string) (*Pipeline, error)
// 通过YAML字符串创建流水线
func NewPipelineFromYamlStr(yamlStr string) (*Pipeline, error)
```
## 运行流水线
运行流水线，这里只需要调用Pipeline的方法即可
```go
// "git.sxidc.com/go-tools/pipeline/utils"
func (p *Pipeline) Run(globalRunParams map[string]any, dynamicParams map[string]any) *component.RunToken
```
下面是一段样例代码
```go
token := p.Run(globalRunParams, dynamicParams)
if token.Wait(); token.Err != nil {
t.Fatal(token.Err)
}
fmt.Println(token.Result)
```
这里可以看到有两个参数，分别是全局运行参数和动态运行参数，这里对运行流水线的运行参数进行说明，运行流水线的参数有三种：
1. 全局运行参数：该运行参数会在流水线中的所有流程和节点之间传递，也可以在运行时利用该参数传递组件之间共享的参数；
2. 构建时静态运行参数：构建一个组件(流程或者节点)的时候，我们可以传递静态运行参数，该参数会在组件运行过程中被使用；
3. 动态运行参数：用来在运行时指定的运行参数，如果同时指定了静态运行参数，则会覆盖静态运行参数
动态运行时参数有两种构造方式：一种是使用map直接构造，另一种是利用YAML构造，但不管使用哪种方法，动态运行时参数都是通过组件的名称进行查找的，如下是对应上面YAML编排示例的动态运行参数构造：
```yaml
seq-flow:
seq-flow-node:
content: "!!!!seq-flow-node!!!!"
pipeline-node:
content: "!!!!pipeline-node!!!!"
if-flow:
condition_flow:
bool:
op: pass
value: true
true-flow:
if-node-true:
content: "!!!!if-node-true!!!!"
if-node-false:
content: "!!!!if-node-false!!!!"
loop-flow:
sub-flow:
loop-sub-node:
content: "!!!!loop-sub-node!!!!"
range-flow:
range-sub-node:
content: "!!!!range-sub-node!!!!"
bi-flow:
is_bi: true
left_params: "!!!!left!!!!"
right_params: "!!!!right!!!!"
bi-flow-node:
content: "!!!!bi-flow-node!!!!"
```
## 附：自定义的几种流程的构建参数和运行参数
### 顺序流程
流程类型：seq
构建参数：
```yaml
components: # 包含的子组件定义数组
- type: 任何的流程或者节点类型
name: 该组件在流水线中的名称
build_params: # 该类型组件的构建参数
...
run_params: # 该类型组件的静态运行时参数
...
```
运行参数：无
### 条件流程
流程类型：if
构建参数：
```yaml
condition: # 条件判断组件，返回结果必须为bool
type: 任何的流程或者节点类型
name: 该组件在流水线中的名称
build_params: # 该类型组件的构建参数
...
run_params: # 该类型组件的静态运行时参数
...
condition_true: # 条件为真时运行的组件
type: 任何的流程或者节点类型
name: 该组件在流水线中的名称
build_params: # 该类型组件的构建参数
...
run_params: # 该类型组件的静态运行时参数
...
condition_false: # 条件为假时运行的组件
type: 任何的流程或者节点类型
name: 该组件在流水线中的名称
build_params: # 该类型组件的构建参数
...
run_params: # 该类型组件的静态运行时参数
...
```
运行参数：无
### 循环流程
流程类型：loop
构建参数：
```yaml
condition: # 条件判断组件，返回结果必须为bool
type: 任何的流程或者节点类型
name: 该组件在流水线中的名称
build_params: # 该类型组件的构建参数
...
run_params: # 该类型组件的静态运行时参数
...
sub: # 循环体组件
type: 任何的流程或者节点类型
name: 该组件在流水线中的名称
build_params: # 该类型组件的构建参数
...
run_params: # 该类型组件的静态运行时参数
...
```
运行参数：无
### 遍历流程
流程类型：range
构建参数：
```yaml
values: # 需要遍历的值的数组
- 遍历值
sub:
type: 任何的流程或者节点类型
name: 该组件在流水线中的名称
build_params: # 该类型组件的构建参数
...
run_params: # 该类型组件的静态运行时参数
...
```
运行参数：无
** 该流程会在子组件的动态运行参数中植入一个键为range_once_value的参数值，该值给出了当前range到的值，另外，还会植入一个键为range_index的参数值(int类型)，给出遍历到的Index。
### 交换流程
流程类型：bi
构建参数：
```yaml
components:
- type: 任何的流程或者节点类型
name: 该组件在流水线中的名称
build_params: # 该类型组件的构建参数
...
run_params: # 该类型组件的静态运行时参数
...
```
运行参数：
```yaml
is_bi: 是否双向运行(交换参数)
left_params: 左参数，对应Go的any类型
right_params: 右参数，对应Go的any类型
```
** 该流程会在每轮运行时在动态运行参数中植入两个参数bi_left和bi_right，分别代表本轮执行的左参数和右参数
[pipeline-image]:data:image/png;base64,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
[class-image]:data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA6IAAAGgCAYAAACwr9qlAAAABHNCSVQICAgIfAhkiAAAABl0RVh0U29mdHdhcmUAZ25vbWUtc2NyZWVuc2hvdO8Dvz4AAAA9aVRYdENyZWF0aW9uIFRpbWUAAAAAADIwMjPlubQxMeaciDA25pelIOaYn+acn+S4gCAxMeaXtjE45YiGMDjnp5J+ur89AAAgAElEQVR4nOzdeXyNd/7//2dWCQkSSxBZ7G21U5VGKkkxxKBTS1GlpgtjqbWjti5aNehY2glt0SYlauzbNAS1FPkNQxFfiraqtcQWSy1JCMfJOb8/jPNpmqhQua6TnMf9dsutOe9rOa8r59L3eV7X+7ouN7vdbhcAAAAAAAZxN7sAAAAAAIBrIYgCAAAAAAxFEAUAAAAAGIogCgAAAAAwFEEUAAAAAGAogigAAAAAwFAEUQAAAACAoQiiAAAAAABDEUQBAAAAAIYiiAIAAAAADEUQBQAAAAAYytPsAgAAcDXf7DugpV+sUEbGGWVlXzG7HJfi7++nqlWC1CquuaKfaGR2OQDgstzsdrvd7CIAAHAV/5q/SKPHTZCnp6fCQkNUsUKg2SW5lIuXLuvosXRZLBb1691Tw4cMMrskAHBJBFEAAAyyM223nnvhr4qKfFxTJ7+nypUrmV2SSzr/8896b9I/9cXK1VoyN0kRDRuYXRIAuByuEQUAwCApa9bJ09NTE8eNJoSaqGKFChoz6g15e3spedUas8sBAJdEEAUAwCCnM86oRnioQkOqm12Ky/P391NoSIgyMs6YXQoAuCSCKAAABsnKylZgQIDZZeB/KgQGcLMoADAJQRQAAAAAYCiCKAAAAADAUARRAAAAAIChCKIAAAAAAEMRRAEAAAAAhiKIAgAAAAAMRRAFAAAAABiKIAoAAAAAMBRBFAAAAABgKIIoAAAAAMBQBFEAAAAAgKEIogAAAAAAQxFEAQBwcUlJSVq3bl2+9u+//15z5841oSIAQEnnaXYBAADAXCdOnJCPj0++9qpVqyohIUFPPvmkwsLC8k232Ww6f/58od+nYsWKcnfnGDgAgCAKAAB+YceOHerXr1+eto4dOzp+r1atmlauXClJOn/+vNq0aVPodaekpKhq1ar3p1AAQLFGEAUAwEXl5ubKYrHIarXKYrEoJydHjRo10s6dO/Xvf/9bnTp1csy7YcMG1a9fv8AgmZqaKj8/v9u+T3Z2tpo2bVok2wAAKJ4YHwMAgItauXKlYmNjlZKSog8//NBxdjM3N1cLFizQli1bJElWq1WTJk1Senq6meUCAEoQgigAAC6qQ4cOSktLU4cOHTRs2DBt3rxZkuTl5aVBgwZpz549kqQFCxaoYcOGioqKMrFaAEBJwtBcAADg0LNnT+3fv9/xes6cOY7fGzVqJEmaNm2aIiMjDa8NAFByEEQBAHBhNptNV69e1e7du3X16lXNmjXL0T5kyBC1a9dOLVq0MLlKAEBJQxAFAMBFLVu2TFOmTJHValWTJk0UFxen2NhY5ebmym6368aNG9qxY4dGjRqVZ7m//e1veu6550yqGgBQEhBEAQBwUREREZo1a5YWLlyo2rVrKywsTFu2bFFmZqY6dOigGTNmqF69epKkwYMHKzo6Wl27djW5agBAScDNigAAcFHh4eGqU6dOvvbExETVqFFDdevWlSSdOXNG27dv5xEsAID7hjOiAAAgDx8fH/3444/q2LGjnn/+eaWmpqp169YFPkNUkk6ePKkyZcrcdn1XrlwpqlIBAMUUQRQAAOQxYMAA9ejRQ59//rkmTJgg6ebQXLvdLjc3t3zzP//880aXCAAo5giiAAC4qFs3JLpy5YojYF68eFHfffedtm7dquTkZMXFxalevXpKSkrSxo0bNWbMGIWHh+dZT2pqqvz8/G77PtnZ2QzrBQDkQRAFAMBF3bhxQy1atFDp0qXVo0cP5eTkqHv37goJCdEjjzyimTNnOm5W1LlzZ02bNk3x8fGaOnWqJMnf318jR45UqVKlfvN9fHx8NG7cOJUvX77ItwkAUDy42e12u9lFAADgCrq91FuSXQs+/8zsUu7Z7YbnFkfdXuolyU0LPk80uxQAcDncNRcAABRaSQmhAABzEUQBAAAAAIYiiAIAAAAADEUQBQAAAAAYiiAKAAAAADAUQRQAAAAAYCieIwoAgJO7ceOG5s2bp7Vr1yo9PV3u7u4KDg5W69at1b17d3l5eZldoqnsdrs+//xzvfzyy2aXAgAoJIIoAABO7MaNG+rfv79++ukn9erVSxEREZKkb775RgkJCdq6das+/fRTubu77iCnQ4cO6dNPPyWIAkAxQhAFAMCJzZ8/X3v27NHnn3+uhx56yNFer149RURE6P3339fx48cVFhamS5cuKT4+Xjt37tSVK1dUo0YNDRgwQJGRkZKkpKQkbdmyRS1atNAXX3yhM2fOqEmTJnrllVf03nvv6ejRo/Ly8tKoUaP0+OOPy2azKTIyUm+88YY2btyoEydOSJKef/55de3aVZKUm5urpKQkrV69WmfPnlXVqlXVuXNndenSRW5ubo73bNu2rRYuXKiLFy8qODhY7777rkJDQyVJly9f1vvvv68tW7bIZrOpVq1aGjhwoBo2bChJGjBggB544AFdu3ZNX3/9tS5fvqzIyEiNHj1a+/fv18CBA2WxWBQbG6vXXntNHTt2NPIjAgDcA9c9fAoAQDGwdu1aNWnSJE8IvaVmzZqaPn26wsLCJEkjRozQ6dOnlZSUpHXr1qlVq1bq37+/Dh48KEny9PTUDz/8IHd3dy1evFizZs3SmjVrNHToUL3zzjtatWqVnnjiCX3wwQeSJHd3d7m7u+tf//qXRo8erRUrVuitt97S5MmTtX37dklSYmKili5dqrFjx2rz5s0aMWKEPv74Yy1atCjPe548eVILFizQqlWrJEnTpk1zbMfbb7+tzMxMLV26VBs2bNCf//xnDRgwQKdPn3asY9myZYqOjtbSpUs1b948/fe//1VycrIiIiL09ttvy9vbW1u2bCGEAkAxQRAFAMCJHT9+XHXq1LnjfD/99JPS0tI0aNAgBQUFqVSpUurWrZuqVaum1atX55m3S5cukqRatWopICBAMTExCgoKkiQ9/vjjOnr0aJ7527Rp45geFRWl2rVra/PmzZKkxYsXq2vXrqpfv748PT0VGRmpli1bauXKlY7lrVar+vTpIzc3N3l6eiomJkY//fSTJCk9PV1bt27V8OHDVaFCBXl5ealTp06qUaOGI7RK0gMPPKCYmBhJUuXKlfXQQw851gEAKH4YmgsAgBPz9PRUbm7uHec7fvy4JCk8PDxPe2hoqGNIrSRVqlQpz/WkpUqVUqVKlfK8tlgsedZx64zrLVWqVNGZM2eUnZ2ty5cvF/ieX331VZ73/OUNlby9vXXt2jVJ0rFjxyRJ7du3z7dNdevWdfxerVq1PNO8vLwc6wAAFD8EUQAAnFhoaKi+++672063Wq3y9Py/7tzNzS3PdJvNdsf3+PUyv/brIJybmytfX9/bzm+32/Os87fWfysUb9q0SWXLlr3nGgEAxQtDcwEAcGJt2rTRtm3btHPnznzTjh8/rjZt2mj37t2Os5aHDx92TLfb7UpPT893RvNu/Xqo7qlTp1SlShX5+fkpMDBQR44cyTf/rRsR3UlISIgkOa5jveXkyZOy2+33XjQAwKkRRAEAcGJdunRR48aN9dprrykpKUnfffedDh48qMWLF6tHjx76wx/+oAYNGqhGjRqKiorStGnTdOHCBVksFs2ZM0fnzp1T27Ztf1cN69ev14EDB2Sz2ZSSkqJjx46pVatWkqSuXbtq8eLFOnjwoGw2m77++mtt2LBBnTp1KtS6Q0NDFRMTo/j4eB0/flw2m02bNm1S586dtW/fvkKtw8fHRzdu3NDJkyd15cqVe95OAIBxGJoLAIATc3d314cffqjFixdr1apVSkpKkt1uV3h4uPr27atOnTo5hreOHTtWkydP1jPPPCN3d3fVrl1biYmJqlGjxu+qoWvXrpo2bZq++eYbBQYGatSoUXrwwQclSS+//LKuXr2qwYMH68qVKwoODtbrr79+V+F3zJgx+uCDD/Tiiy/q+vXrCgsL09ixY/WHP/yhUMtHRkaqTp066tKli3r06KFevXrd03YCAIzjZmfcCwAAhuj2Um9Jdi34/DOzSym0yMhI/eMf/1BcXJzZpdx33V7qJclNCz5PNLsUAHA5DM0FAAAAABiKIAoAAAAAMBTXiAIAgNsq6G69AAD8XpwRBQAAAAAYiiAKAAAAADAUQRQAAAAAYCiCKAAAAADAUARRAAAAAIChCKIAAAAAAEMRRAEAAAAAhiKIAgAAAAAMRRAFAAAAABiKIAoAAAAAMBRBFAAAAABgKIIoAAAAAMBQBFEAAAAAgKEIogAAGMTf308XLl40uwz8z/mfL8jfr4zZZQCASyKIAgBgkKpVgnTkaLpOnc4wuxSXd/bsOR1LP64qVYLMLgUAXBJBFAAAg7SKay6r1aqx/5iss2fPmV2Oyzp1OkOjx02Q1WrVU61aml0OALgkN7vdbje7CAAAXMXk+I80I3GWPD09FRYaoooVAs0uyaVcuHhRR46my2q16tmO7TVx3LtmlwQALokgCgCAwdJ271HyqjXKyDijrOwrZpdz12xWqyTJ3dPT5Erunr+/n6pWCVLT2Gg1b9bE7HIAwGURRAEAwF35+OOPJUkDBw40uRIAQHHFNaIAAOCurFmzRmvWrDG7DABAMVb8xtQAAADTZGdn68yZM47f/fz8TK4IAFAccUYUAAAU2vz582W322W32zV//nyzywEAFFMEUQAAUGirVq1SuXLlVK5cOaWkpJhdDgCgmCKIAgCAQrFarTp58qSefPJJPfnkkzp16pSs/7uDLgAAd4MgCgAACmXOnDmy2+2Ki4tTXFyc7Ha75syZY3ZZAIBiiCAKAAAKJSUlRX5+foqKilJUVJT8/PwYngsAuCcEUQAAUCjp6emKjY2Vt7e3vL29FRsbq/T0dLPLAgAUQwRRAABwR3PnzpXdblfLli0dbS1btpTdbtfcuXNNrAwAUBwRRAEAwB0lJyerdOnSaty4saOtcePGKl26tJKTk02sDABQHBFEAQDAHR05ckTR0dEqVaqUo61UqVKKjo7WkSNHTKwMAFAcEUQBAMBvWrx4cb5hubfcGp67ePFiEyoDABRXbna73W52EQAAwHl169ZNP/zwg6pWrVrg9NOnT6tu3bpasGCBwZUBAIorT7MLAAAAzs3NzU2hoaGO18ePH5ckhYSESJJCQ0Pl5uZmSm0AgOKJM6IAAOCuNG3aVJKUmppqciUAgOKKa0QBAAAAAIYiiAIAAAAADEUQBQAAAAAYiiAKAAAAADAUQRQAAAAAYCiCKAAAAADAUARRAAAAAIChCKIAAAAAAEMRRAEAAAAAhiKIAgAAAAAMRRAFAAAAABiKIAoAAAAAMBRBFAAAAABgKIIoAAAAAMBQBFEAAAAAgKEIogAAAAAAQxFEAQAAAACGcrPb7XaziwAA5JeSkqIxY8aYXQaQj81mkyS5u3M8GwDup5EjR6pz585ml2EIT7MLAAAUbMWKFY4v/IAzYv8EgPtr3bp1BFEAgPkiIiKUkJBgdhkAAKCI9enTx+wSDMWYGgAAAACAoQiiAAAAAABDEUQBAAAAAIYiiAIAAAAADEUQBQAAAAAYiiAKAAAAADAUQRQAAAAAYCiCKAAAAADAUARRAAAAAIChCKIAAAAAAEMRRAEAAAAAhiKIAgAAAAAMRRAFAAAAABiKIAoAAAAAMBRBFAAAAABgKIIoAAAAAMBQBFEAAAAAgKEIogAAAAAAQxFEAQAAAACG8jS7APy2b/Yd0NIvVigj44yysq+YXY5L8ff3U9UqQWoV11zRTzQyuxwAAACgxOCMqBP71/xF6vDcX7RwyXIdOZYuyc6PgT/px09o0dJ/6y89+2py/EeF+9AAAAAA3BFnRJ3UzrTdGj1ugqIiH9fUye+pcuVKZpfkks7//LPem/RPzUicpeZNn1REwwZmlwQAAAAUe5wRdVIpa9bJ09NTE8eNJoSaqGKFChoz6g15e3spedUas8sBAAAASgSCqJM6nXFGNcJDFRpS3exSXJ6/v59CQ0KUkXHG7FIAAACAEoEg6qSysrIVGBBgdhn4nwqBAdwsCgAAALhPCKIAAAAAAEMRRAEAAAAAhiKIAgAAAAAMRRAFAAAAABiKIAoAAAAAMBRBFAAAAABgKE+zCwCA++WbfQe09IsVysg4U6Iet9Ptpd5ml/C7+fv7qWqVILWKa67oJxqZXQ4AoAQqKd8DimO/fy/9PGdEAZQI/5q/SB2e+4sWLlmuI8fSJdn5caKfY+npWrB4mf7Ss68mx3/02x8mAAB3ie8B5v6kHz+hRUv/fVf9PGdEARR7O9N2a/S4CYqKfFxTJ7+nypUrmV0SCnDqdIbG/mOyZiTOUvOmTyqiYQOzSwIAlAB8D3AO53/+We9N+meh+3nOiAIo9lLWrJOnp6cmjhtN5+PEqlWtojGjXpenp6eSV60xuxwAQAnB9wDnULFCBY0Z9Ya8vb0K1c8TRAEUe6czzqhGeKhCQ6qbXQruoHLlSgoLDVFGxhmzSwEAlBB8D3Ae/v5+Cg0pXD9PEAVQ7GVlZSswIMDsMlBIFSsEFuubSAAAnAvfA5xLhcCAQvXzBFEAAAAAgKEIogAAAAAAQxFEAQAAAACGIogCAAAAAAxFEAUAAAAAGIogCgAAAAAwFEEUAAAAAGAogigAAAAAwFAEUQAAAACAoQiiAAAAAABDEUQBAAAAAIYiiAKAiXJzc80uAQAAGIR+//8QRHFHffr00cSJE+/b+vr16+dYX1pamiIiInTp0qX7tn6gKMXHx2vjxo33ZV1r167Vn/70J124cOGO8yYlJWndunX52r///nvNnTv3vtQDAADyot8vOp5mFwDzTJ8+XTNnzszTFhgYqIceekj9+/dXvXr1JElDhw6Vr69vkdRQt25dJSQkyM/Pr0jWD9xvFy5c0NWrVyVJ7dq1U2ZmpiQpNjZWdrtd69evzzP/li1b5O3tnW89aWlpeu+991S/fn29+uqrmjp1qgIDA2/7vidOnJCPj0++9qpVqyohIUFPPvmkwsLC8k232Ww6f/58obevYsWKcnfnGCUAABL9flEiiLq4oKAgJSUlOV6fOXNGs2bN0iuvvKIlS5aoYsWKjkBaFPz9/RUREVFk6weK0rVr17R582b99NNPmj59uj744AONHz9ea9as0bfffquhQ4cWuFxycrKmTp2qSZMmKSoqSrNnz1b37t319ttvKzo6+o7vu2PHDvXr1y9PW8eOHR2/V6tWTStXrpQknT9/Xm3atCn0NqWkpKhq1aqFnh8AAFdBv39/EURdnLu7u4KCghyvg4KCNH78eDVt2lTbt2/X008/rT59+qhWrVoaOXKkdu3apb59+yo+Pl6JiYk6f/68ypcvr2HDhjkC5eXLl/X+++9ry5YtstlsqlWrlgYOHKiGDRvme/+0tDT16dNHX331lcqXL6/GjRvrnXfe0bp163T06FHl5OSoS5cu6tmzp6SbR3kSExOVnJysy5cvKzg4WF27ds3zjxEoCjabTdevX5fVatX169dlsVjyzXP06FFNnTpVzZo1K/Bo6OnTpzVx4kQdOHBA06dP15YtW5Sdna2XX35Z4eHhGjlypKKjozVo0CBVr15d0s1rSSwWi6xWqywWi3JyctSoUSPt3LlT//73v9WpUyfH+jds2KD69esX2KGkpqb+5siD7OxsNW3a9F7+NAAAlDj0+0WPIIp8vLy85ObmJpvNlm+ap+fNXSY5OVkzZ86Ut7e3ZsyYob/97W9atWqVypYtq7fffltubm5aunSpypYtqxUrVmjAgAFavnz5HY+4eHh4aNasWYqPj1f16tW1detWDR48WE2bNlWtWrU0d+5crV69WlOmTFHt2rW1b98+DR48WH5+fvrTn/5UJH8PQJK+/fZbvfTSS5KkdevWaceOHcrNzVWnTp1048YN1alTRydOnFDFihWVk5OTZzj7qVOnNHPmTK1Zs0atW7fWggULVLFiRUnSiBEj9OOPP6pv375auHCh3n//fXXs2FF//OMfNXjwYO3cuVNjx451rCspKUmbN29Wbm6uFixYoKCgIMXGxspqtWrSpEkaO3YsZzQBAPid6PeLHhcCIY/s7GxNmTJFPj4+atSo0W3n69atm+PIT/fu3XX16lXt2LFD6enp2rp1q4YPH64KFSrIy8tLnTp1Uo0aNbRq1apC1dCqVSvHUaHo6Gh5enrq8OHDkqT58+erR48eqlu3rtzd3fXoo4+qffv2Wr58+e/ccuC3Pfzww0pLS1P9+vX1+uuva+LEifLw8NCyZcsUHx8v6eb1HGFhYTp//nye6z7sdrvOnTun2bNn65133nF0Rg888IBmzpypBg0aSJKCg4P1wQcfKCEhQWXLllXFihXVoUMHpaWlqUOHDho2bJg2b94s6eYBo0GDBmnPnj2SpAULFqhhw4aKiooy8K8CAEDJRL9f9Dgj6uIyMjIUGxsr6eY/mmvXrqlGjRr65z//qSpVqtx2udDQUMfvZcuWla+vrzIyMlSqVClJUvv27fMtU7du3ULV9MujOm5ubvLy8tK1a9d09epVnTt3TmPHjs1zpEi6OTYeKGrXr1/XwYMHlZmZqQ4dOuSbfvjwYcXExOjHH3/Uww8/7GgPDg7Whx9+qOTkZP3lL3+57fptNpsiIyM1Y8YMRydVkJ49e2r//v2O13PmzHH8fusA0rRp0xQZGXlX2wcAAP4P/X7RIoi6uEqVKikhIUHSzdAXEBCgMmXK3HG5Xz8DKTc3Vz4+Po67bm3atElly5a9p5rc3Nx+s/3999/XH//4x3taN/B77N+/33GtyOLFi5Wbm6tmzZpJkmJiYrRlyxatWLFCVqtVa9eulXTz7tSPPfaYpJsHaAo6SCNJBw4c0ODBgzVw4MB802w2m65evardu3fr6tWrmjVrlqN9yJAhateunVq0aFEEWwwAgOui3y9aBFEX5+HhoZCQkLte7tixY44zl+fOnZPFYlGVKlUc6zp48GCeozInT55UtWrVbhsyC8PX11eVKlXS999/nyeInj17VuXLly/wInHgftq1a5dKlSqlLl266Ntvv5WHh4e++uorXb9+XaVKlVJOTo6sVqvatGmjlStXKiAg4Lbr2r17t1asWKE333xTR48e1auvvqrhw4erfv36eeZbtmyZpkyZIqvVqiZNmiguLk6xsbHKzc2V3W7XjRs3tGPHDo0aNSrPcn/729/03HPPFcnfAQAAV0C/X7S4RhT3ZO7cuY4AmpiYqPLly6tRo0YKDQ1VTEyM4uPjdfz4cdlsNm3atEmdO3fWvn37fvf7duvWTYsXL9bOnTtls9l06NAh9erVS/Pnz78PWwX8tq+++kqPP/64KlWqpNGjRzvahw8friNHjsjX11ebNm1STk6Otm/fnm/5W/ttQkKCgoODlZWVpcGDB+vs2bMaNWqUWrdurdTU1DzDbyIiIjRr1iw99dRTatCggcLCwrRlyxatXbtWpUuX1vz587Vt2zZt27ZNkZGRevXVV7Vt27Zi1xkBAOBs6PeLFkEU96Rjx44aMGCAmjdvrv3792vKlCmOM5JjxoxRzZo19eKLLyo2NlYJCQkaO3as/vCHP/zu933hhRfUpUsXjR49WjExMRoyZIjatm2rF1988XevG/gtu3btUoUKFVSuXDlJynMGPioqynEwZP369QoODs63/E8//aQ333xT0s074F27dk2TJk1yHKy5NdTHbrfrzTffdDw8Ozw8XHXq1Mm3vsTERNWoUcNx7fWZM2e0fft202/FDgBASUC/X/QYmuvC+vfvr/79+99xvlvXkP5Sw4YNtXjx4gLnDwgI0Lhx4267vhkzZjh+j4iIUFpamuP1li1b8s3/yzZ3d3f169cv30N9gaJ2/vx5Pfvss9q0aZOjzWKxKD4+XqmpqbJYLEpPT9eRI0ccjxK6du2afHx8JElr1qxRkyZNHNdRSzeHxk+cOFEXL16UJG3dulVly5bVgw8+qE8++USvvfbabevx8fHRjz/+qI4dO+r5559XamqqWrdufdtbuJ88efI3r/++cuVK4f8YAACUcPT7RY8gCgCF0KpVK9ntdkeH9P/+3/9TVlaWsrKyNH/+fO3atUtTp05V586dlZOTI0navHmz/P399fDDD2vx4sVKTEyUdPN5vBcvXlRYWJgCAgIUEBAgi8WiFStWqE6dOnrllVfUvXt3de/eXUFBQQXWM2DAAPXo0UOff/65JkyYIEkaPHiw7HZ7gddiP//880XxZwEAoESi3y96BFEAKAQ3N7c8/6P39/fXuHHj1KZNG0k3j5KeO3dO3bt312effabr168rJydHFSpU0PXr19W7d2/Vq1dP0s3OrU+fPvnuPh0UFKRBgwapevXqio+PV2BgoOPGBFeuXHG8/8WLF/Xdd99p69atSk5OVlxcnOrVq6ekpCRt3LhRY8aMUXh4eJ51p6amys/P77bbl52dXayH9wAAcD/R7xc9gijuSoMGDfIMpQVcVe3atVW7dm1JN58zlpCQoPj4eHl5eal+/foaP368ypUrp5kzZ8rf318vvPCCY9lRo0Zp1KhRslgsjrZbz8y95dYDqi0Wi1q0aKHSpUurR48eysnJUffu3RUSEqJHHnlEM2fOdHR0nTt31rRp0xQfH6+pU6dKutlxjhw50vGM39vx8fHRuHHjVL58+fvzBwIAoASh37//3Ox2u920d8dtdXuptyS7Fnz+mdmlQFK3l3pJctOCzxPNLgUFMPLfi8VikYeHhzw8PPK022y2PNeBmOl2w3ScBf+eAAD3U1F+D6Dfv3uF7ec5IwoAd+F2z6t1ls5IklN1RgAAFGf0+0XHef6CAAAAAACXQBAFAAAAABiKIAoAAAAAMBRBFAAAAABgKIIoADiBfv36aeLEiWaXAQAAnFRJ+67AXXMBoIhNnz5dM2fOLHBa3bp1tWDBAoMrAgAA91vPnj21f/9+zZkzRw888ECeaW+88YZKly6tt99+26TqnA9BFAAMULly5QLD6C8fZg0AAC+ShI8AACAASURBVIo3f39/jRkzRnPnzs337FHkxdBcADCAh4eHqlWrlu+nUqVKBc5/6NAh9e/fX82bN1fLli312muv6eTJk5Kkp59+WsuWLXPMu2TJEkVERCgtLc3RFh8fr/79+xftRgEAgDyee+45Xb58WbNnz/7N+S5duqTRo0frqaeeUtOmTfXyyy9r586djunZ2dl644031KxZM/3pT3/SZ599lu95oevXr1eXLl3UuHFjtWvXTvHx8bp27VpRbFaRIIgCgJPJzMxU7969Vbt2ba1cuVLLli2Tr6+vevXqJYvFoieeeEK7d+92zL9jxw7VqlVLu3btcrTt3LlTMTExZpQPAIDL8vb21ltvvaXPPvtMR44cue18I0aM0OnTp5WUlKR169apVatW6t+/vw4ePCjp5gHlgwcPat68eUpOTpbFYtG+ffscyx84cEDvvPOO+vfvry1btmjGjBlKS0tTfHx8kW/j/UIQBQAns2bNGtlsNg0cOFBlypRR2bJlNXjwYJ09e1bbt29X48aNHWc/bTabdu3ape7duzuCaGZmpg4dOkQQBQDABDExMWrRooX+/ve/y2az5Zv+008/KS0tTYMGDVJQUJBKlSqlbt26qVq1alq9erUkae3atXr22WcVHBwsX19f9e3bV6VKlXKsY/78+YqLi1OzZs3k4eGh4OBg9e7dW8nJyQW+pzPiGlEAMMDp06fVuHHjfO2tW7fW6NGj87QdP35cwcHB8vb2drQFBQXJ29tbJ06cULt27fTzzz8rPT1dV65ckb+/v1q2bKnJkyfr+vXr2rVrl6pUqaLw8PCi3iwAAFCAYcOGqXPnzlq0aJG6deuWZ9rx48clKV8/HRoaqhMnTujy5cvKyclRcHCwY5qHh4dCQkIcr48dO6bvvvvOEVx/6cyZM6patep93JqiQRAFAANUqlRJn3zySb52Pz+/Auf/9XUgv2z38/PTI488orS0NGVmZioyMlKlS5dWzZo1tXfvXu3atUvR0dH3tX4AAFB45cuX17BhwzRu3Dg1adKkwH791223zmRaLBZJkt1uzzM9NzfX8bu7u7u6du2q4cOH3+/SDcPQXAAwgKenp8LDw/P9VKxYMd+84eHhOnHihKMjkqSTJ0/KYrEoNDRUktS4cWPt3r1bO3bsUGRkpCTpscce065du7Rr1y6G5QIAYLLWrVsrMjJS48ePz3OX/LCwMEnS4cOHHW12u13p6ekKCwtTYGCgvLy8dOrUKcd0i8Wi9PR0x+uQkBDH9aS3ZGVlKTMzs6g2574jiAKAk2ndurU8PT01ffp0Xbt2TZmZmZo6daqqV6+uqKgoSTeD6N69e7V3715FRERIkho2bKjU1FQdP37cEU4BAIB53njjDe3fv1/bt293tNWoUUNRUVGaNm2aLly4IIvFojlz5ujcuXNq27atPDw8FBMToyVLlujYsWO6fPmyPvroozzr7datm/bs2aMlS5bIYrHo559/1ltvvaW33nrL6E28ZwRRAHAyfn5++uijj7Rv3z61aNFCnTt3loeHhxITE+XpefOKioceekhZWVmqXLmy4xEwjz32mA4fPqwGDRrI19fXzE0AAAC6+RzxV199VefPn8/TPnbsWAUEBOiZZ55Rq1attGXLFiUmJqpGjRqSpLfffls1a9bUiy++qE6dOqlcuXKKjIyU1WqVJD388MMaP368lixZoqZNm6pLly4KCAjQ+PHjDd/Ge+Vm//XgYziFbi/1lmTXgs8/M7sUSOr2Ui9JblrweaLZpaAA/HspXvj3BAC4n/ge4FwK289zRhQAAAAAYCiCKAAAAADAUARRAAAAAIChCKIAAAAAAEMRRJ2Uv7+fLly8aHYZ+J/zP1+Qv18Zs8sAAAAASgSCqJOqWiVIR46m69TpDLNLcXlnz57TsfTjqlIlyOxSAAAAgBKBIOqkWsU1l9Vq1dh/TNbZs+fMLsdlnTqdodHjJshqteqpVi3NLgcAAAAoETzNLgAFi36ikfr17qkZibP01eb/T2GhIapYIdDsslzKhYsXdeRouqxWq57t2F5PNHrc7JIAAACAEoEg6sSGDxmk5k2fVPKqNcrIOKOs7Ctml3TXrDduSJI8vbxMruTuhYWG6olGkWoaG63mzZqYXQ4AAABQYhBEnVxEwwaKaNjA7DLu2ejRoyVJY8aMMbkSAAAAAM6Ca0RRZC5cuKAvv/xSX375pS5cuGB2OQAAAACcBEEURWb+/PmyWq2yWq2aP3++2eUAAAAAcBIEURSJzMxMLVmyxPF6yZIlyszMNLEiAAAAAM6CIIoisWjRImVnZzteZ2dna9GiRSZWBAAAAMBZEERx3125ckULFy7M175w4UJduVL87vwLAAAA4P4iiOK+W7ZsmS5dupSv/dKlS1q2bJkJFQEAAABwJgRR3FfXrl37zRsTzZ8/X9euXTOwIrgCf38/Xbh40ewyUEjnf74gf78yZpcBACgh+B7gXArbzxNEcV+tWLFC586du+30c+fOacWKFQZWBFdQtUqQjhxN16nTGWaXgjs4e/acjqUfV5UqQWaXAgAoIfge4Dzupp8niOK++uUNin7PPMDdaBXXXFarVWP/MVlnz97+QAjMdep0hkaPmyCr1aqnWrU0uxwAQAnB9wDncLf9vJvdbrcbUBdcRFZWltq2bausrKwCp/v7+2vlypXy9/c3uDKUdJPjP9KMxFny9PRUWGiIKlYINLsk/MKFixd15Gi6rFarnu3YXhPHvWt2SQCAEoTvAea6l36eIIr7bsaMGfrss88KnNarVy/169fP4IrgKtJ271HyqjXKyDijrOzif4dmS87N0QPevn4mV/L7+fv7qWqVIDWNjVbzZk3MLgcAUAIV9+8BdptNkuTmXvwGrd5LP08QxX138eJFtW/fPt+jWsqUKaPk5GQFBASYVBlQvPz5z3+WJK1atcrkSgAAQFFLTU2VJDVt2tTkSoxR/OI2nF5AQICeeeaZfO3PPPMMIRS4CxkZGcrI4MYLAAC4gvXr12v9+vVml2EYgiiKRPfu3VWqVCnH61KlSql79+4mVgQUL8ePHy/wdwAAUPLcuHFDGzdu1MaNG3Xjxg2zyzEEQRRFonLlymrbtq3jddu2bVW5cmUTKwKKl19eS8111QAAlGxff/21rl+/ruvXr+vrr782uxxDEERRZF566SW5u7vL3d1dL730ktnlAMXK6dOnVbZsWZUtW1anT582uxwAAFCENmzY4Oj3N2zYYHY5hvA0uwCUXNWqVVPNmjUdvwMonFvP2o2NjZUkrV69WtnZ2fLzK/53zwUAAHnZbDalpqY6+v3U1FTZbDa5F8O7596Nkr11MF25cuVUrlw5s8sAipW//OUvkqSWLVuqZcuWedoAAEDJsmPHDmVmZjr6/czMTO3YscPssoocZ0QBwMmcOHFCZcqUUVRUlKSbjz46ceKEyVUBAICisHHjxnz9/saNG/XEE0+YXFnR4owoADgZu92umJgYlSpVSqVKlVJMTIx45DMAACXTpk2b8vX7mzZtMrusIkcQBQAn0qVLF0lyDMn95e+3pgEAgJJh165dunDhQr5+/8KFC9q1a5eJlRU9gigAOJHDhw/L19dX0dHRjrbo6Gj5+vrq8OHDJlYGAADut40bN96239+4caOJlRU9gigAOBG73a7GjRvLx8fH0ebj46PGjRszPBcAgBJm06ZNt+33S/rwXIIoADiJW8/bjYuLyzft1pCd7t27G1oTAAAoGnv37tXZs2dv2++fPXtWe/bsMaEyY3DXXABwEt9++60kKSEhQQkJCQXO88MPPxhZEgAAKCJfffWVpN/u9zdu3KgGDRoYWZZhCKIA4CTsdrvc3Nx07NgxSTcfcC3J8UBrNzc3hucCAFBCWCwWtWrVyvF6586dkqTIyEhJUr169WSxWEypzQgEUQBwEr++O15ERESB7QAAoPh7/fXX87zu06ePJOm9994zoxzD3XUQ/fTTT2976hgoyK0v0wAAAAAg3UMQTUtLU9myZfXggw8WRT0ogV588UWzSwAAAADgRO5paG6dOnU0ffr0+10LAAAAAMAF8PgWAAAAAIChCKIAAAAAAEMRRAEAAAAAhiKIAgAAAAAMRRAFAAAAABiKIAoAAAAAMBRBFAAAAABgKIIoAAAAAMBQBFEAAAAAgKEIogAAAAAAQxFEAQAAAACGIogCAAAAAAxFEAUAAAAAGIogCgAAAAAwFEEUAAAAAGAogigAAAAAwFAEUQAAAACAoQiiAAAAAABDEUQBAAAAAIYiiAIAAAAADEUQBQAAAAAYiiAKAAAAADAUQRQAAAAAYCiCKAAAAADAUARRAAAAAIChCKIAAAAAAEMRRAEAAAAAhiKIAgAAAAAMRRAFAAAAABjK0+wCXE1KSorGjBljdhlwMna7XXa73ewy4KQiIiLMLgFAEXBzc5Obm5vZZcAgI0eOVOfOnc0uA3AaBFGDrVixQjabzewyAACAyTgI6VrWrVtHEAV+gSBqgoiICCUkJJhdBpxInz59JIn9AnmwX7gWPm/XwuftWm593gD+D9eIAgAAAAAMRRAFAAAAABiKIAoAAAAAMBRBFAAAAABgKIIoAAAAAMBQBFEAAAAAgKEIogAAAAAAQxFEAQAAAACGIogCAAAAAAxFEAUAAAAAGIogCgAAAAAwFEEUAAAAAGAogigAAAAAwFAEUQAAAACAoQiiAAAAAABDEUQBAAAAAIYiiAIAAAAADEUQBQAAAAAYiiAKAAAAADAUQRQAAAAAYCiCKAAAAADAUARRAAAAAIChCKIAAAAAAEMRRAEAAAAAhiKIAgAAAAAMRRAFAAAAABiKIAoAAAAAMBRBFAAAAABgKIIoAAAAAMBQBFEAAAAAgKEIogAAAAAAQxFEAQAAAACGIogCAAAAAAxFEAUAAAAAGIogCgAAAAAwFEEUAAAAAGAogigAAAAAwFAEUQAAAACAoQiiAAAAAABDEUQBAAAAAIYiiAIAAAAADEUQBQAAAAAYiiAKAAAAADAUQRQAAAAAYCiCKAAAAADAUARRAAAAAIChCKIAAAAAAEO52e12+90s0KdPH0lSQkJCkRR0J9/sO6ClX6xQRsYZZWVfMaUGV+Xv76eqVYLUKq65op9oZHY5ebBfmIf9oujYcnMlSe4eHiZXcvfM2C+K++ddnPF5uxY+b9fizP18SWN2zjJasQqi/5q/SKPHTZCnp6fCQkNUsUKg4TW4souXLuvosXRZLBb1691Tw4cMMrskSewXZmO/QEGM3i/4vM3F5+1a+Lxdi7P28wUp7gcsXO0AdLEJojvTduu5F/6qqMjHNXXye6pcuZKh74+bzv/8s96b9E99sXK1lsxNUkTDBqbWw37hHNgvUBCj9gs+b+fA5+1a+Lxdi7P18wXhgIW57uWAhacBdd0XKWvWydPTUxPHjeZ/QiaqWKGCxox6Q6vXrlfyqjWm/4+I/cI5sF+gIEbtF3zezoHP27XwebsWZ+vnf21n2m6NHjeBAxYmu3XAYkbiLDVv+uQd95Nic7Oi0xlnVCM8VKEh1c0uxeX5+/spNCREGRlnzC6F/cKJsF+gIEbsF3zezoPP27XwebsWZ+rnf40DFs7h1gELb28vJa9ac8f5i00QzcrKVmBAgNll4H8qBAY4xdh79gvnwn6BghT1fsHn7Vz4vF0Ln7drcZZ+/tc4YOE87uaARbEJogAAAADwaxywcC6FPWBBEAUAAAAAGIogCgAAAAAwFEEUAAAAAGAogigAAAAAwFAEUQAAAACAoQiiAAAAAABDEUQBAAAAAIYiiAIAAAAADEUQBQAAAAAYiiAKAAAAADAUQRQAAAAAYCiCKAAAAADAUARRAAAAAIChCKIAAAAAAEMRRAEAAAAAhiKIAgAAAAAMRRAFAAAAABiKIAoAAAAAMBRBFAAAAABgKIIoAAAAAMBQBFEAAAAAgKEIogAAAHAJvXr1UnJy8l0vZ7Va9fLLL+vgwYN3veyZM2f0zjvvFOo9ZsyYoXPnzhU4rWfPnrp48eId15Obm6tNmzYpOzv7rmsFjEQQBQAAQImXkZGhffv2KTo6+q6X9fT0VEhIiObNm1eo+e12u+P3SpUqac+ePfrvf/+bZ57Zs2fnCbY2m03Xrl1Tly5dlJqamu/9K1WqpC+++KLA99u7d69mz56t4cOHq0WLFpoyZYrS0tI0adIkRUZGqlGjRnl+IiIidOHChcJuvstx5gMWv3Ty5En16dMnX/tf//pXnTx5stDrmT9/vrZt23ZX730/eBr+jgBu6+DBg3r99deVkZGhuXPnqlatWmaXBMBEffr0Ua1atTRy5EizSwGKnezsbDVt2jRfe+vWrfO1ffzxx2rcuLEkadu2bRo4cOBt17tq1ap8bTNmzFCjRo0kSadOnVLfvn21aNEilS5dWu7u7uratasWLlzoCMHp6emaNm1anvq8vb01ZMgQRUZGasOGDVq0aJG+/vrrPO+zYcMGffzxx47XcXFxmjhxovbu3atLly4pMDBQ1atX19y5cyVJX3/9tQYMGKCXX345z3oiIiJuu32u7tYBi3/84x93vewvD1j8/e9/v+P8drtdbm5ukvIesPjlwZLZs2ercePGqlevXr7lr127pj179uRr37Nnj65du1boutPS0mSxWPTII4/km3ZrHy4KBNH74PLly0pMTNR//vMfnTt3Tp6enqpevbratWunrl27ml0enFj79u0VFxenQYMGSZKWLl0qX19frV+/XqVLlza5OtwP06dP1+rVq5WSkmJ2KXAi06dP18yZMx2vvb29VaFCBcXExGjQoEHy8/OTJA0dOlS+vr5mlYlf6Nmzp/bu3ZunrUyZMgoPD9eLL76ouLg4kyrDnSxZskTly5e/7fRu3brlawsPD9esWbMKtf4uXbrkeV2tWjWFhIRoyZIleumllyTdDL+ffPKJrl69qtKlSztCaY0aNfKtLzY2VrGxsbJarbLZbDp27Jh69eqlTz75RLVq1dLGjRsVGBioBg0aOALCiy++KEn66quv7ulsnCsrbgcshg4dqs2bN+dZb0EHFn65XzZr1kwffPDBbWuVpI8++kgfffRRvvbk5GRVr179N5e9VwTR+2D48OG6evWqxowZo/DwcF2/fl3/+c9/9MEHH8hms+n55583u0QUE5mZmapZs6bjSyiAkisoKEhJSUmSbg7nOnTokMaPH6+cnBzHkfSCjoDDPHFxcXrttdccr7OysrRq1SqNHDlSU6dOVWxsrInV4XYqVKigcuXK3Xa6h4dHgW2/tcydlu/Tp4+GDRumLl26yNfXV4GBgfryyy9VunRpZWdna+XKlZoyZUqeZQ4ePKigoCBHaPb09JTVatXYsWP117/+VQ8++KAkycvLS6NHj9a8efMUGBgoSbp+/bpsNpvjvzk5OQXWhdsrLgcs3n33Xd24cUOSdOTIEb3yyitau3ZtnnW3bNlSCQkJjuW8vLzuWN+wYcMK3MaiRBD9nSwWi3bv3q1x48apQYMGjvbOnTurYsWKec5qHTx4UPHx8dq/f798fX3VoEEDDR06VFWqVJEkHT58WOPGjdMPP/ygypUra8iQIXrnnXc0YsQItWnTxvBtg7H69u2r3bt3y83NTZs3b9bs2bNVu3Zts8uCAQ4dOqT4+Hh9//338vDw0COPPKKhQ4cqODhYknTp0iXFx8dr586dunLlimrUqKEBAwYoMjJSktS7d2898MADys7O1jfffKPs7Gw1a9ZMQ4cOlbe3t5mbht/g7u6uoKAgx+vg4GBt3bpVBw4ccLQxNNe5+Pj45PnMgoKC9Oqrr2r37t1au3atI4hu3bpVn376qQ4fPixvb29FRkZqxIgRqlChgiSpcePGeuedd7Ru3TodPXpUOTk56tKli3r27Cnp5nC9xMREJScnKysrSy1btlRYWJi++OILLV++XNKdv1Pg/2RnZ/9mKLPZbHle16lTR4MGDdK6dev0xhtv/Oa6R44cqeHDh+e7lKZBgwaqVauWFi5cqB49ekiS4zvh3LlzFRoamu8s1pIlS7Ru3ToNGjRIzz77rM6fP6/4+HhlZGSoYsWKWrp0qbKyspSVlaUbN27o3Xff1YcffihJ6t+/f54hmrGxsWrVqpUCAgI0ffp0TZ8+Pc97EVLzKy4HLPz9/R2/X716VfXq1XMckLilXr16CgoKytfubAiiv5O3t7dCQ0O1fPlyPfroo6patapjWrNmzRy/X716VQMHDlTHjh01ZcoUWa1WffDBBxo8eLAWLlwoNzc3DR06VLVq1dKXX34pi8Wi8ePHKzs7u1BHMVD8ffrppxoxYoS8vb01btw4s8uBQTIzM9W7d2+1a9dOkydPVm5uriZOnOi4UYK3t7dGjBghSUpKSlL58uW1fPly9e/fX3PnzlW9evXk6emp5cuXa8qUKRo9erTOnDmjF154Qf7+/r85bAjO5ciRI9q2bZs6dOhgdim4S7fOXEnShQsXNHToUPXp00cJCQnKzMzU66+/rkmTJmnixImSbn4hnTVrluLj41W9enVt3bpVgwcPVtOmTVWrVi0tW7ZMSUlJmjJliiIiIpSSkqKPPvrIEWTv9J2iqK7nKq7atWt3V/NXrFhRTz75pK5fv641a9Y42qdOnSofHx/17dvX0ebv73/b4fNDhgxR79691bBhQz366KOSbl6LN2fOHCUmJuabf9SoUYqKitLYsWNVs2ZNHTp0SOvWrVOFChU0b948BQQEKCAgQOXLl1e3bt20fPlypaSk6Omnn3YM9e/fv7/Onz+fZz8YPnz4XW2/qyouByykm5cFSjf3v2nTpjle3zJjxgzHfH5+fnm2y2azOQ5k/9LmzZv1/vvv52nbuXNnkf7/5J6C6IkTJ+44zvh+u2G5Li8nPbL/z3/+UxMmTFDbtm0VHh6uRx99VBEREWratKnKlCkjSVq7dq28vLzUr18/x3Kvvfaamjdvrr1798rb21vp6emaMGGCY1hm3759840BB1CyrFmzRjabTQMHDnScvRw8eLCeeuopbd++XcHBwUpLS9Ps2bMdZ2K6deumhQsXavXq1Y6hmw899JCjYwkKClLLli2VmppKEHViGRkZjut+LBaLLBaLnn766Xw3FYHzslgsSklJ0d69ezVhwgRJUvny5bVq1SqVL19eHh4e8vHxUcuWLfWvf/0rz7KtWrVyXHcVHR0tT09PHT582HENYExMjKKioiRJHTp00Jdffum4y+mdvlM89thjRmx+sbFx48bfPGv11FNPFdh+5coV/fe//3UcHPLx8VHp0qVVuXLlQr3vAw88oFdffVUjRozQvHnz5O7urjfffFODBw9W/fr1C1ymZcuWeuSRR1SlShXVr19fTZo0kZeXlypVqqT09HRVrVpVNptNJ06c0MMPP6yAgADHsgcOHNCBAwdktVr15ptvql+/fnr22WdvW1/79u311ltvFWpbXEFxOWBhsVjUvHnzQtc5a9Ysx3p/KSUl5bb3Izl37pz+//buPaiq8t/j+IctICo6GiCgoE6TjhdEs5IzTVMOuuUyUZScysZriSc0NdP0zJgp8lMkm5IhFYMJTNLtpcZDo8X4o9s4P4+meZ/+0MQbyqWkBFPkdv7gsH5s7qSuvZH3a4YZ1t6LvR9YD3uvz7Oe/X1efvnlNj/H39XuIDpixAgdPXpU27Ztux/taVbAoMFOG0QHDRqk1NRUFRcX6/jx4zp+/Lg2b96stWvXatWqVRo3bpwuXLigwsLCJkc18vPzjc4ZGBho97gAHmyXL19W//797abQ+vr6yt3dXVeuXDFGYBu+HgwYMEBXrlyx267Pz89PBQUF96/huGs+Pj7GVYzq6moVFBQoIyNDr732mtLT05lW7YS+/vpr5ebmGtvl5eXy8fHRO++8YxQrslgs+u6777Rnzx4VFRWppqZG5eXlcnW1P+WqP4PKxcVFbm5uRpXL+oMUdYKCgvTjjz9KUqvnFATRe+PQoUPaunWr3SyFiooK3bp1y26/lgqKxcTE6NixY1qyZIm6du2qUaNGtVrI0s/PT7dv35aHh4exhEhcXJzmz5+v5ORklZeXa8mSJY2WcklNTVV0dLROnDihrl27aufOnTp8+LBx/6RJk7R06VKjWA7sdZQBC3d3dx09etTYLioqUkRERJPtHz9+fLPP27t372b7bnl5eZvafrfaHUQXLFigBQsW3I+2tGjy9FhJNa3u50g+Pj6yWq2yWq1avHix4uPjjSBqsVg0ePBg2Wy2Jn+27o2t/rpTDacAAHgw1ZVub+n2hvs0fH2oqqpqtO3h4XGPWoj7oUuXLurXr5+xHRAQoKFDh2rcuHHKzc2lNoATeuaZZzR//nxJtf9jCxYs0JNPPml35SA3N1dJSUlKTExUaGioLBaLdu3aZUyVq9Pc/71kv6RDU/u3dk4Be+25elTfyZMnGw0C7tq1S7t27bK77eDBgy0OHC1atEhRUVGqrKw0PuPbkj///FMzZ86UzWZTdXV1m6ZGfv/99yotLdXIkSN14sQJLVq0SGfPnm3153D3HDVg8SDgM6J36ciRI9qzZ49WrlxpN9rp4uKi4OBg7d27VxUVFRowYIB27txpVMGSat9orl69qv79+xtT7vLz8zVkyBBJ4gUE6AQGDRqk7Oxs3blzxziRyc/P1507dzRgwAAjqJw/f17BwcGSal87Ll26JKvVajzOxYsX7R73ypUrFC3pwEpLSx3dBDShe/fudjOX6qqZhoSEGHUhjh07pkceecRuOZfTp0+363l8fHx07do1u9vqF7Fq7ZwC9rKzs1u80hUTE9Pk7SdPntT169dVVVVlfMbu1Vdf1aJFi9r83GfOnNHy5csVFBSkmpoaxcbGKiEhocV1PLOyshQQECB3d3fdunVL3t7eLT5HdXW11q5dq3Xr1qmoqEiS1KtXLz322GOKjY01+l9FRYXmzZtnBNv169cb07/RCwQYbwAACipJREFU8QYs7pYzVPkmiN6luiqHCxcu1PTp0xUYGKjKykqdOnVKqampGj9+vNzc3BQWFqaNGzcqKSnJqGSZkZGh3bt366uvvtLw4cPl7++vtLQ0LVu2TDdv3lRaWhpVzYAHQFVVla5evdrodj8/P4WHhxsVDd944w3duXNHycnJCggIUEhIiFxdXRUSEqINGzYoMTFRnp6e2r59u4qLixUVFWU81q+//qp9+/Zp4sSJOnfunHJzc/X666+b+Wuinaqrq1VYWCipNkQUFxcrIyNDHh4eevrppx3cOrRFcHCwZs6cqfj4eA0bNky+vr7y9/dXQUGBCgsL9dBDD8lmsykvL09//fWXbt68adSOaMlTTz2ltLQ0HT9+XCNHjtTevXt1/vx59erVS5JaPadgHWp7np6eLS6L1tQVx7KyMp09e1YBAQHavXt3uz8vd+PGDX3++efKyspSbGyssc7n5s2bFRcXp6lTp2ratGmNAvKNGze0Y8cOJScnS6otYlY3CNmUusGINWvWaOTIkXZTxyXZfcaQqbkt62gDFn+XxWLRDz/80Op+NTU1973wGWXV7pK/v78yMzPl5eWlFStWKDo6WlOmTNHWrVs1bdo0Yy247t27KyUlRQUFBYqIiJDVatXJkyeVmppqLGL7wQcfqLCwUJGRkZo7d65eeumlFqfuAOgYioqKFBUV1eirpKREnp6eSklJ0alTpzR+/HjFxMSoS5cuSktLM2ZZJCQkqE+fPnrhhRcUFhamAwcOKC0tzW5dsbCwMB07dkxWq1Xz5s1TZGRkp5jW05HVvd5HRkbq2Wef1eLFi2WxWPTpp59yNbsDmT17tvr3769ly5apurpaL774op544gnFxMQoKipKpaWl+vDDD+Xr66vo6OhG1S2bMnnyZEVFRWnx4sWyWq06d+6coqOjjXOC1s4pYK+srKzFr6Y+CmWz2TRq1Ch99NFH2rhxo7744os2PVdeXp4SExMVGRmpM2fOKD09XTNmzJDFYpHFYlFcXJxSUlJ08OBBRUREKCEhwW4GXEZGhoYMGaJHH31Uv/32m06cONFkoZk6b731liRpzJgx7fyroKG6AYvmvloasOjWrZt2797d7ue8ceOGNm3apNmzZ+u5557Tpk2blJqaqqioKKOvtOU1o77i4mLl5+fr3LlzKi8vb3RRq6ioSLNmzZKLi4suX76sb775Rp6enrp586Y2btxoDNpMmTJFeXl57f6d2oMrovfAwIEDtXLlylb3Gzp0qDZv3tzi/Z999pndbXxO9MFWV4Sgzvvvv++gluB+mTNnjubMmdPiPiNGjDCK1jTFy8vLqMjZHFdXVy1dupQKiB1EW/qFJH3yyScmtAZt0dyi9a6ursrKyjK2u3Xr1uRref3X+wMHDjS6v/5tbm5umjdvnrF0kyStWbPGbg3T1s4p8G/trYZ6+fJlZWVlKT4+XgMHDtTy5cu1atUq1dTU6PHHH9fPP/8sLy8vdevWza62h6+vr9LT09W1a1dt2bKl0VIddUJCQrRt2zYdPnxYWVlZysnJ0eDBg5Wfny+bzaa0tDRVV1crKSlJoaGhdsddqu1zt2/fVmVlpcrKypr9PaZPn65ffvnF2K6qqtLcuXONAQ1PT099++237frbPMjau3yL9O8Bi3fffVfTpk1rVJSsOXl5ebLZbNq7d69Gjx6t9PR0DRs2zLg/Li5OY8aMUXJysrZv366IiAi98sorGjx4cKuPvWPHDm3ZskXu7u4aNmyYHn74Ybv7t2zZooEDB6pHjx7GFfiYmBh5e3tr//79Cg8PV3BwsCZOnKiVK1cqMzPzvl0YI4gCAAA4kf379+u9997Txx9/rNGjR+v06dPKycnRwoULHd20DsXFxUW+vr6y2WzGtOamzJ071+5K8vr16zVp0iSjcvGECRM0fPhwffnllzp06JCWLFmisrIyVVRUGD8THh6u1atXa/Xq1W1u39ixY+2myZaUlOj5559XUFCQDh06pD/++EPx8fHG/ZMmTVKvXr3k4eEhPz8/RURENJouGhgYqIkTJ0qqDRxou44yYNGaN998s9ml244cOaLs7GxjOSkfHx/l5+dLqi2gFxoaqpycHAUHBys2NlbZ2dnKyclReHh4u/42bUUQBQAAcCITJkzQxYsXtWLFCv3+++/q27evZsyY0e4T5c6uR48e2rdvX6v7bdiwwW47MTFRbm5udrf169evxRP8eyEoKEhBQUGSakPI2LFj7a5ETZ061fg+MzOzyccYMmSIUfQSbdPRBiwaslgs6t27d5uuWp49e1ZLly41iiv16dNHVqvVqM4cGRmp8+fPS6pdJubtt9++r9P9CaJO7qeffnJ0EwA4uYbLQgDo2FxcXDRr1izNmjXL0U3plJxlDV/qhJijow1YNOTt7d2oSFVzJk+ebLfdp08fu6vuo0aNsvtMclhY2L1pZDMIogAAAADQDs4yYNGRUTUXAAAAAGAqgigAAAAAwFQEUQAAAACAqQiiAAAAAABTEUQBAAAAAKYiiAIAAAAATEUQBQAAAACYiiAKAAAAADAVQRQAAAAAYCqCKAAAAADAVARRAAAAAICpCKIAAAAAAFMRRAEAAAAApiKIAgAAAABMRRAFAAAAAJiKIAoAAAAAMBVBFAAAAABgKoIoAAAAAMBUBFEAAAAAgKkIogAAAAAAUxFEAQAAAACm6jBBtGdPT10vKXF0M/D/fvv9unp69nB0M+gXToZ+gabc737B8XYuHO/OhePduTjL+zweDB0miPr7+SrvwiVdvVbg6KZ0ekVFxbp46bL8/Hwd3RT6hROhX6ApZvQLjrfz4Hh3LhzvzsWZ3ucbYsDCubR1wKLDBNGwCaGqrKxUQuI6FRUVO7o5ndbVawVa8Y+1qqysVGSY1dHNoV84CfoFmmJWv+B4OweOd+fC8e5cnO19viEGLJxHewYsXGpqampMaNM9se6jFG1K+1Surq4aOCBQ3l4PObpJncr1khLlXbikyspK/eeLzyvpHysd3SRJ9AtHo1+gKWb3C463Y3G8OxeOd+firO/z9f3rfw9rymv/pbAJoYp/97/Vt6+Po5vUKV29VqCExHXK+ee32paZpv8Y+3iL+3eoICpJR38+rv/Z+7UKCgpVWnbT0c3pVHr29JS/n6+eeepJhY572tHNsUO/cBz6BZriiH7B8XYcjnfnwvHuXJz5fb4+Biwc6+8MWHS4IAoAAAAADTFg4Th/Z8CCIAoAAAAAMFWHKVYEAAAAAHgwEEQBAAAAAKYiiAIAAAAATEUQBQAAAACYiiAKAAAAADAVQRQAAAAAYCqCKAAAAADAVARRAAAAAICpCKIAAAAAAFMRRAEAAAAApiKIAgAAAABMRRAFAAAAAJiKIAoAAAAAMBVBFAAAAABgKoIoAAAAAMBUBFEAAAAAgKkIogAAAAAAUxFEAQAAAACmIogCAAAAAExFEAUAAAAAmIogCgAAAAAw1f8BNh1CwK82macAAAAASUVORK5CYII=