- Features • - QuickStart • - Make • - Wiki -
- -## Features - -* 超强的性能, 在本地测试极限性能的场景下, 能超过ffuf与feroxbruster的性能50%以上. 实际情况受到网络的影响, 感受没有这么明确. 但在多目标下可以感受到明显的区别. -* 基于掩码的字典生成 -* 基于规则的字典生成 -* 动态智能过滤, 自定义过滤策略 -* 全量[gogo](https://github.com/chainreactors/gogo)的指纹识别, 全量的[fingerprinthub](https://github.com/0x727/FingerprintHub),[wappalyzer](https://github.com/projectdiscovery/wappalyzergo)指纹 -* 自定义信息提取, 内置敏感信息提取规则 -* 自定义输出格式与内容 -* *nix的命令行设计, 轻松与其他工具联动 -* 多角度的自动被ban,被waf判断 -* 断点续传 - -## QuickStart - -[**Document**](https://chainreactors.github.io/wiki/spray/start) - -### 基本使用 - -**从字典中读取目录进行爆破** - -`spray -u http://example.com -d wordlist1.txt -d wordlist2.txt` - -**通过掩码生成字典进行爆破** - -`spray -u http://example.com -w "/aaa/bbb{?l#4}/ccc"` - -**通过规则生成字典爆破** - -规则文件格式参考hashcat的字典生成规则 - -`spray -u http://example.com -r rule.txt -d 1.txt` - -**批量爆破多个目标** - -`spray -l url.txt -r rule.txt -d 1.txt` - -**断点续传** - -`spray --resume stat.json` - -### 高级用法 - -**check-only 模式** - -类似ehole/httpx这类对单页面信息收集的模式. 会有针对性的性能优化. 默认使用[templates](https://github.com/chainreactors/templates/tree/master/fingers)指纹库. 可以使用`--finger`打开第三方指纹库的匹配 - -`spray -l url.txt --check-only` - -**启用拓展指纹识别** - -会进行主动探测常见的指纹目录, 并额外启用fingerprinthub与wappalyzer拓展指纹库 - -`spray -u http://example.com --finger ` - -**启用爬虫** - -`spray -u http://example.com --crawl` - -**扫描备份文件与常见通用文件** - -`spray -u http://example.com --bak --common` - -**启用所有插件** - -`spray -u http://example.com -a` - -**被动url收集** - -参见: https://github.com/chainreactors/urlfounder - -## Wiki - -详细用法请见[wiki](https://chainreactors.github.io/wiki/spray/) - -https://chainreactors.github.io/wiki/spray/ - -## Make - -``` -git clone --recurse-submodules https://github.com/chainreactors/spray - -cd spray - -go mod tidy - -go generate - -go build . -``` - -## Similar or related works - -* [ffuf](https://github.com/ffuf/ffuf) 一款优秀的http fuzz工具, 与spray的功能有一定重合但并不完全相同 -* [feroxbuster](https://github.com/epi052/feroxbuster) 在编写spray之前我最常使用的目录爆破工具, 但因为批量扫描与过滤配置不便的原因选择自行编写 -* [dirsearch](https://github.com/maurosoria/dirsearch) 较早的目录爆破工具, 参考了部分字典生成与配色 -* [httpx](https://github.com/projectdiscovery/httpx) http信息收集功能, 参考了通过脚本语言编写任意过滤条件的功能 -* [gobuster](https://github.com/OJ/gobuster) 一款统一是go编写的爆破工具, 但不仅限于目录爆破 - -## TODO - -1. [x] 模糊对比 -2. [x] 断点续传 -3. [x] 简易爬虫 -4. [x] 支持http2 -5. [ ] auto-tune, 自动调整并发数量 -6. [x] 可自定义的递归配置 -7. [x] 参考[feroxbuster](https://github.com/epi052/feroxbuster)的`--collect-backups`, 自动爆破有效目录的备份 -8. [x] 支持socks/http代理, 不建议使用, 优先级较低. 代理的keep-alive会带来严重的性能下降 -9. [ ] 云函数化, chainreactors工具链的通用分布式解决方案. - -## Thanks - -* [fuzzuli](https://github.com/musana/fuzzuli) 提供了一个备份文件字典生成思路 -* [fingerprinthub](https://github.com/0x727/FingerprintHub) 作为指纹库的补充 -* [wappalyzer](https://github.com/projectdiscovery/wappalyzergo) 作为指纹库补充 +# SPRAY + + + ++ Features • + QuickStart • + Make • + Wiki +
+ +## Features + +* 超强的性能, 在本地测试极限性能的场景下, 能超过ffuf与feroxbruster的性能50%以上. 实际情况受到网络的影响, 感受没有这么明确. 但在多目标下可以感受到明显的区别. +* 基于掩码的字典生成 +* 基于规则的字典生成 +* 动态智能过滤, 自定义过滤策略 +* 全量[gogo](https://github.com/chainreactors/gogo)的指纹识别, 全量的[fingerprinthub](https://github.com/0x727/FingerprintHub),[wappalyzer](https://github.com/projectdiscovery/wappalyzergo)指纹 +* 自定义信息提取, 内置敏感信息提取规则 +* 自定义输出格式与内容 +* *nix的命令行设计, 轻松与其他工具联动 +* 多角度的自动被ban,被waf判断 +* 断点续传 + +## QuickStart + +[**Document**](https://chainreactors.github.io/wiki/spray/start) + +### 基本使用 + +**从字典中读取目录进行爆破** + +`spray -u http://example.com -d wordlist1.txt -d wordlist2.txt` + +**通过掩码生成字典进行爆破** + +`spray -u http://example.com -w "/aaa/bbb{?l#4}/ccc"` + +**通过规则生成字典爆破** + +规则文件格式参考hashcat的字典生成规则 + +`spray -u http://example.com -r rule.txt -d 1.txt` + +**批量爆破多个目标** + +`spray -l url.txt -r rule.txt -d 1.txt` + +**断点续传** + +`spray --resume stat.json` + +### 高级用法 + +**check-only 模式** + +类似ehole/httpx这类对单页面信息收集的模式. 会有针对性的性能优化. 默认使用[templates](https://github.com/chainreactors/templates/tree/master/fingers)指纹库. 可以使用`--finger`打开第三方指纹库的匹配 + +`spray -l url.txt --check-only` + +**启用拓展指纹识别** + +会进行主动探测常见的指纹目录, 并额外启用fingerprinthub与wappalyzer拓展指纹库 + +`spray -u http://example.com --finger ` + +**启用爬虫** + +`spray -u http://example.com --crawl` + +**扫描备份文件与常见通用文件** + +`spray -u http://example.com --bak --common` + +**启用所有插件** + +`spray -u http://example.com -a` + +**被动url收集** + +参见: https://github.com/chainreactors/urlfounder + +## Wiki + +详细用法请见[wiki](https://chainreactors.github.io/wiki/spray/) + +https://chainreactors.github.io/wiki/spray/ + +## Make + +``` +git clone --recurse-submodules https://github.com/chainreactors/spray + +cd spray + +go mod tidy + +go generate + +go build . +``` + +## Similar or related works + +* [ffuf](https://github.com/ffuf/ffuf) 一款优秀的http fuzz工具, 与spray的功能有一定重合但并不完全相同 +* [feroxbuster](https://github.com/epi052/feroxbuster) 在编写spray之前我最常使用的目录爆破工具, 但因为批量扫描与过滤配置不便的原因选择自行编写 +* [dirsearch](https://github.com/maurosoria/dirsearch) 较早的目录爆破工具, 参考了部分字典生成与配色 +* [httpx](https://github.com/projectdiscovery/httpx) http信息收集功能, 参考了通过脚本语言编写任意过滤条件的功能 +* [gobuster](https://github.com/OJ/gobuster) 一款统一是go编写的爆破工具, 但不仅限于目录爆破 + +## TODO + +1. [x] 模糊对比 +2. [x] 断点续传 +3. [x] 简易爬虫 +4. [x] 支持http2 +5. [ ] auto-tune, 自动调整并发数量 +6. [x] 可自定义的递归配置 +7. [x] 参考[feroxbuster](https://github.com/epi052/feroxbuster)的`--collect-backups`, 自动爆破有效目录的备份 +8. [x] 支持socks/http代理, 不建议使用, 优先级较低. 代理的keep-alive会带来严重的性能下降 +9. [ ] 云函数化, chainreactors工具链的通用分布式解决方案. + +## Thanks + +* [fuzzuli](https://github.com/musana/fuzzuli) 提供了一个备份文件字典生成思路 +* [fingerprinthub](https://github.com/0x727/FingerprintHub) 作为指纹库的补充 +* [wappalyzer](https://github.com/projectdiscovery/wappalyzergo) 作为指纹库补充 * [dirsearch](https://github.com/maurosoria/dirsearch) 提供了默认字典 \ No newline at end of file diff --git a/config.yaml b/config.yaml index 492769f..78ab7ad 100644 --- a/config.yaml +++ b/config.yaml @@ -1,156 +1,156 @@ -input: - # Files, Multi,dict files, e.g.: -d 1.txt -d 2.txt - dictionaries: [] - # Bool, no dictionary - no-dict: false - # String, word generate dsl, e.g.: -w test{?ld#4} - word: "" - # Files, rule files, e.g.: -r rule1.txt -r rule2.txt - rules: [] - # Files, when found valid path , use append rule generator new word with current path - append-rules: [] - # String, filter rule, e.g.: --rule-filter '>8 <4' - filter-rule: "" - # Files, when found valid path , use append file new word with current path - append-files: [] -functions: - # String, add extensions (separated by commas), e.g.: -e jsp,jspx - extension: "" - # Bool, force add extensions - force-extension: false - # String, exclude extensions (separated by commas), e.g.: --exclude-extension jsp,jspx - exclude-extension: "" - # String, remove extensions (separated by commas), e.g.: --remove-extension jsp,jspx - remove-extension: "" - # Bool, upper wordlist, e.g.: --uppercase - upper: false - # Bool, lower wordlist, e.g.: --lowercase - lower: false - # Strings, add prefix, e.g.: --prefix aaa --prefix bbb - prefix: [] - # Strings, add suffix, e.g.: --suffix aaa --suffix bbb - suffix: [] - # Strings, replace string, e.g.: --replace aaa:bbb --replace ccc:ddd - replace: {} - # String, skip word when generate. rule, e.g.: --skip aaa - skip: [] -output: - # String, custom match function, e.g.: --match 'current.Status != 200'' - match: "" - # String, custom filter function, e.g.: --filter 'current.Body contains "hello"' - filter: "" - # String, open fuzzy output - fuzzy: false - # String, output filename - output-file: "" - # String, fuzzy output filename - fuzzy-file: "" - # String, dump all request, and write to filename - dump-file: "" - # Bool, dump all request - dump: false - # Bool, auto generator output and fuzzy filename - auto-file: false - # String, output format, e.g.: --format 1.json - format: "" - # String, output format - output_probe: "" - # Bool, Quiet - quiet: false - # Bool, no color - no-color: false +input: + # Files, Multi,dict files, e.g.: -d 1.txt -d 2.txt + dictionaries: [] + # Bool, no dictionary + no-dict: false + # String, word generate dsl, e.g.: -w test{?ld#4} + word: "" + # Files, rule files, e.g.: -r rule1.txt -r rule2.txt + rules: [] + # Files, when found valid path , use append rule generator new word with current path + append-rules: [] + # String, filter rule, e.g.: --rule-filter '>8 <4' + filter-rule: "" + # Files, when found valid path , use append file new word with current path + append-files: [] +functions: + # String, add extensions (separated by commas), e.g.: -e jsp,jspx + extension: "" + # Bool, force add extensions + force-extension: false + # String, exclude extensions (separated by commas), e.g.: --exclude-extension jsp,jspx + exclude-extension: "" + # String, remove extensions (separated by commas), e.g.: --remove-extension jsp,jspx + remove-extension: "" + # Bool, upper wordlist, e.g.: --uppercase + upper: false + # Bool, lower wordlist, e.g.: --lowercase + lower: false + # Strings, add prefix, e.g.: --prefix aaa --prefix bbb + prefix: [] + # Strings, add suffix, e.g.: --suffix aaa --suffix bbb + suffix: [] + # Strings, replace string, e.g.: --replace aaa:bbb --replace ccc:ddd + replace: {} + # String, skip word when generate. rule, e.g.: --skip aaa + skip: [] +output: + # String, custom match function, e.g.: --match 'current.Status != 200'' + match: "" + # String, custom filter function, e.g.: --filter 'current.Body contains "hello"' + filter: "" + # String, open fuzzy output + fuzzy: false + # String, output filename + output-file: "" + # String, fuzzy output filename + fuzzy-file: "" + # String, dump all request, and write to filename + dump-file: "" + # Bool, dump all request + dump: false + # Bool, auto generator output and fuzzy filename + auto-file: false + # String, output format, e.g.: --format 1.json + format: "" + # String, output format + output_probe: "" + # Bool, Quiet + quiet: false + # Bool, no color + no-color: false # Bool, No progress bar no-bar: false - # Bool, No stat - no-stat: false -plugins: - # Bool, enable all plugin - all: false - # Strings, extract response, e.g.: --extract js --extract ip --extract version:(.*?) - extract: [] - # String, extract config filename - extract-config: "" - # Bool, enable recon - recon: false - # Bool, enable active finger detect - finger: false - # Bool, enable bak found - bak: false - # Bool, enable valid result bak found, equal --append-rule rule/filebak.txt - file-bak: false - # Bool, enable common file found - common: false - # Bool, enable crawl - crawl: false - # Int, crawl depth - crawl-depth: 3 -request: - # Strings, custom headers, e.g.: --headers 'Auth: example_auth' - headers: [] - # String, custom user-agent, e.g.: --user-agent Custom - useragent: "" - # Bool, use random with default user-agent - random-useragent: false - # Strings, custom cookie - cookies: [] - # Bool, read all response body - read-all: false - # Int, max response body length (kb), -1 read-all, 0 not read body, default 100k, e.g. --max-length 1000 - max-length: 100 -mode: - # Int, request rate limit (rate/s), e.g.: --rate-limit 100 - rate-limit: 0 - # Bool, skip error break - force: false - # Bool, check only - default: false - # Bool, no scope - no-scope: false - # String, custom scope, e.g.: --scope *.example.com - scope: [] - # String,custom recursive rule, e.g.: --recursive current.IsDir() - recursive: current.IsDir() - # Int, recursive depth - depth: 0 - # String, custom index path - index: / - # String, custom random path - random: "" - # Int, check period when request - check-period: 200 - # Int, check period when error - error-period: 10 - # Int, break when the error exceeds the threshold - error-threshold: 20 - # Strings (comma split),custom black status - black-status: 400,410 - # Strings (comma split), custom white status - white-status: 200 - # Strings (comma split), custom fuzzy status - fuzzy-status: 500,501,502,503 - # Strings (comma split), custom unique status - unique-status: 403,200,404 - # Bool, unique response - unique: false - # Int, retry count - retry: 0 - sim-distance: 5 -misc: - # String, path/host spray - mod: path - # String, Client type - client: auto - # Int, deadline (seconds) - deadline: 999999 - # Int, timeout with request (seconds) - timeout: 5 - # Int, Pool size - pool: 5 - # Int, number of threads per pool - thread: 20 - # Bool, output debug info - debug: false - # Bool, log verbose level ,default 0, level1: -v level2 -vv - verbose: [] - # String, proxy address, e.g.: --proxy socks5://127.0.0.1:1080 - proxy: "" + # Bool, No stat + no-stat: false +plugins: + # Bool, enable all plugin + all: false + # Strings, extract response, e.g.: --extract js --extract ip --extract version:(.*?) + extract: [] + # String, extract config filename + extract-config: "" + # Bool, enable recon + recon: false + # Bool, enable active finger detect + finger: false + # Bool, enable bak found + bak: false + # Bool, enable valid result bak found, equal --append-rule rule/filebak.txt + file-bak: false + # Bool, enable common file found + common: false + # Bool, enable crawl + crawl: false + # Int, crawl depth + crawl-depth: 3 +request: + # Strings, custom headers, e.g.: --headers 'Auth: example_auth' + headers: [] + # String, custom user-agent, e.g.: --user-agent Custom + useragent: "" + # Bool, use random with default user-agent + random-useragent: false + # Strings, custom cookie + cookies: [] + # Bool, read all response body + read-all: false + # Int, max response body length (kb), -1 read-all, 0 not read body, default 100k, e.g. --max-length 1000 + max-length: 100 +mode: + # Int, request rate limit (rate/s), e.g.: --rate-limit 100 + rate-limit: 0 + # Bool, skip error break + force: false + # Bool, check only + default: false + # Bool, no scope + no-scope: false + # String, custom scope, e.g.: --scope *.example.com + scope: [] + # String,custom recursive rule, e.g.: --recursive current.IsDir() + recursive: current.IsDir() + # Int, recursive depth + depth: 0 + # String, custom index path + index: / + # String, custom random path + random: "" + # Int, check period when request + check-period: 200 + # Int, check period when error + error-period: 10 + # Int, break when the error exceeds the threshold + error-threshold: 20 + # Strings (comma split),custom black status + black-status: 400,410 + # Strings (comma split), custom white status + white-status: 200 + # Strings (comma split), custom fuzzy status + fuzzy-status: 500,501,502,503 + # Strings (comma split), custom unique status + unique-status: 403,200,404 + # Bool, unique response + unique: false + # Int, retry count + retry: 0 + sim-distance: 5 +misc: + # String, path/host spray + mod: path + # String, Client type + client: auto + # Int, deadline (seconds) + deadline: 999999 + # Int, timeout with request (seconds) + timeout: 5 + # Int, Pool size + pool: 5 + # Int, number of threads per pool + thread: 20 + # Bool, output debug info + debug: false + # Bool, log verbose level ,default 0, level1: -v level2 -vv + verbose: [] + # String, proxy address, e.g.: --proxy socks5://127.0.0.1:1080 + proxy: "" diff --git a/core/format.go b/core/format.go index 6d06fff..0a04b4c 100644 --- a/core/format.go +++ b/core/format.go @@ -1,278 +1,278 @@ -package core - -import ( - "bytes" - "encoding/json" - "fmt" - "github.com/chainreactors/logs" - "github.com/chainreactors/spray/core/baseline" - "github.com/chainreactors/spray/pkg" - "github.com/chainreactors/words/mask" - "io" - "net/url" - "os" - "sort" - "strings" -) - -// TreeNode represents a node in the path tree -type TreeNode struct { - Name string - Children map[string]*TreeNode - Result *baseline.Baseline // nil for directory nodes - IsLeaf bool -} - -// NewTreeNode creates a new tree node -func NewTreeNode(name string) *TreeNode { - return &TreeNode{ - Name: name, - Children: make(map[string]*TreeNode), - IsLeaf: false, - } -} - -// AddPath adds a path to the tree -func (tn *TreeNode) AddPath(parts []string, result *baseline.Baseline) { - if len(parts) == 0 { - tn.Result = result - tn.IsLeaf = true - return - } - - part := parts[0] - if part == "" { - if len(parts) > 1 { - tn.AddPath(parts[1:], result) - } else { - tn.Result = result - tn.IsLeaf = true - } - return - } - - if _, exists := tn.Children[part]; !exists { - tn.Children[part] = NewTreeNode(part) - } - - tn.Children[part].AddPath(parts[1:], result) -} - -// RenderTree renders the tree structure -func (tn *TreeNode) RenderTree(prefix string, isLast bool, color bool) string { - var sb strings.Builder - - if tn.Name != "" { - connector := "├── " - if isLast { - connector = "└── " - } - - sb.WriteString(prefix) - sb.WriteString(connector) - - if tn.IsLeaf && tn.Result != nil { - // Leaf node with result - if color { - sb.WriteString(tn.Result.ColorString()) - } else { - sb.WriteString(tn.Result.String()) - } - } else { - // Directory node - sb.WriteString(tn.Name) - if !strings.HasSuffix(tn.Name, "/") { - sb.WriteString("/") - } - } - sb.WriteString("\n") - } - - // Sort children for consistent output - var keys []string - for k := range tn.Children { - keys = append(keys, k) - } - sort.Strings(keys) - - for i, key := range keys { - child := tn.Children[key] - isLastChild := i == len(keys)-1 - - newPrefix := prefix - if tn.Name != "" { - if isLast { - newPrefix += " " - } else { - newPrefix += "│ " - } - } - - sb.WriteString(child.RenderTree(newPrefix, isLastChild, color)) - } - - return sb.String() -} - -func Format(opts Option) { - var content []byte - var err error - if opts.Format == "stdin" { - content, err = io.ReadAll(os.Stdin) - } else { - content, err = os.ReadFile(opts.Format) - } - - if err != nil { - return - } - - // Group by host+path for deduplication. - // Prefer the HTTP Host header when present so that - // different virtual hosts on the same IP:port do not - // get merged together. - group := make(map[string]map[string]*baseline.Baseline) - for _, line := range bytes.Split(bytes.TrimSpace(content), []byte("\n")) { - var result baseline.Baseline - err := json.Unmarshal(line, &result) - if err != nil { - logs.Log.Error(err.Error()) - return - } - result.Url, err = url.Parse(result.UrlString) - if err != nil { - continue - } - - // Determine host key: prefer Host header when available. - hostKey := result.Host - if hostKey == "" { - hostKey = result.Url.Host - // Normalize default ports when URL host does not include one. - if result.Url.Port() == "" { - if result.Url.Scheme == "https" { - hostKey += ":443" - } else if result.Url.Scheme == "http" { - hostKey += ":80" - } - } - } - if hostKey == "" { - continue - } - - if _, exists := group[hostKey]; !exists { - group[hostKey] = make(map[string]*baseline.Baseline) - } - group[hostKey][result.Path] = &result - } - - // Default to tree mode if not specified - outputProbe := opts.OutputProbe - if outputProbe == "" { - outputProbe = "full" - } - - if outputProbe == "tree" { - formatTree(group, opts) - } else if outputProbe == "full" { - formatFull(group, opts) - } else { - // Custom probe output - formatProbe(group, opts, outputProbe) - } -} - -// formatTree renders results in tree structure -func formatTree(group map[string]map[string]*baseline.Baseline, opts Option) { - // Sort host:port for consistent output - var hosts []string - for host := range group { - hosts = append(hosts, host) - } - sort.Strings(hosts) - - for _, host := range hosts { - results := group[host] - - // Build tree for this host - root := NewTreeNode("") - for path, result := range results { - if !opts.Fuzzy && result.IsFuzzy { - continue - } - - // Split path into parts - parts := strings.Split(strings.Trim(path, "/"), "/") - if path == "/" { - parts = []string{"/"} - } - - root.AddPath(parts, result) - } - - // Print host header - logs.Log.Console(fmt.Sprintf("\n%s\n", host)) - - // Render tree - logs.Log.Console(root.RenderTree("", true, !opts.NoColor)) - } -} - -// formatFull renders results in full/original format -func formatFull(group map[string]map[string]*baseline.Baseline, opts Option) { - for _, results := range group { - for _, result := range results { - if !opts.Fuzzy && result.IsFuzzy { - continue - } - if !opts.NoColor { - logs.Log.Console(result.ColorString() + "\n") - } else { - logs.Log.Console(result.String() + "\n") - } - } - } -} - -// formatProbe renders results with custom probe fields -func formatProbe(group map[string]map[string]*baseline.Baseline, opts Option, probeFields string) { - probes := strings.Split(probeFields, ",") - for _, results := range group { - for _, result := range results { - if !opts.Fuzzy && result.IsFuzzy { - continue - } - logs.Log.Console(result.ProbeOutput(probes) + "\n") - } - } -} - -func PrintPreset() { - logs.Log.Console("internal rules:\n") - for name, rule := range pkg.Rules { - logs.Log.Consolef("\t%s\t%d rules\n", name, len(strings.Split(rule, "\n"))) - } - - logs.Log.Console("\ninternal dicts:\n") - for name, dict := range pkg.Dicts { - logs.Log.Consolef("\t%s\t%d items\n", name, len(dict)) - } - - logs.Log.Console("\ninternal words keyword:\n") - for name, words := range mask.SpecialWords { - logs.Log.Consolef("\t%s\t%d words\n", name, len(words)) - } - - logs.Log.Console("\ninternal extractor:\n") - for name, _ := range pkg.ExtractRegexps { - logs.Log.Consolef("\t%s\n", name) - } - - logs.Log.Console("\ninternal fingers:\n") - for name, engine := range pkg.FingerEngine.EnginesImpl { - logs.Log.Consolef("\t%s\t%d fingerprints \n", name, engine.Len()) - } - - logs.Log.Consolef("\nload %d active path\n", len(pkg.ActivePath)) -} +package core + +import ( + "bytes" + "encoding/json" + "fmt" + "github.com/chainreactors/logs" + "github.com/chainreactors/spray/core/baseline" + "github.com/chainreactors/spray/pkg" + "github.com/chainreactors/words/mask" + "io" + "net/url" + "os" + "sort" + "strings" +) + +// TreeNode represents a node in the path tree +type TreeNode struct { + Name string + Children map[string]*TreeNode + Result *baseline.Baseline // nil for directory nodes + IsLeaf bool +} + +// NewTreeNode creates a new tree node +func NewTreeNode(name string) *TreeNode { + return &TreeNode{ + Name: name, + Children: make(map[string]*TreeNode), + IsLeaf: false, + } +} + +// AddPath adds a path to the tree +func (tn *TreeNode) AddPath(parts []string, result *baseline.Baseline) { + if len(parts) == 0 { + tn.Result = result + tn.IsLeaf = true + return + } + + part := parts[0] + if part == "" { + if len(parts) > 1 { + tn.AddPath(parts[1:], result) + } else { + tn.Result = result + tn.IsLeaf = true + } + return + } + + if _, exists := tn.Children[part]; !exists { + tn.Children[part] = NewTreeNode(part) + } + + tn.Children[part].AddPath(parts[1:], result) +} + +// RenderTree renders the tree structure +func (tn *TreeNode) RenderTree(prefix string, isLast bool, color bool) string { + var sb strings.Builder + + if tn.Name != "" { + connector := "├── " + if isLast { + connector = "└── " + } + + sb.WriteString(prefix) + sb.WriteString(connector) + + if tn.IsLeaf && tn.Result != nil { + // Leaf node with result + if color { + sb.WriteString(tn.Result.ColorString()) + } else { + sb.WriteString(tn.Result.String()) + } + } else { + // Directory node + sb.WriteString(tn.Name) + if !strings.HasSuffix(tn.Name, "/") { + sb.WriteString("/") + } + } + sb.WriteString("\n") + } + + // Sort children for consistent output + var keys []string + for k := range tn.Children { + keys = append(keys, k) + } + sort.Strings(keys) + + for i, key := range keys { + child := tn.Children[key] + isLastChild := i == len(keys)-1 + + newPrefix := prefix + if tn.Name != "" { + if isLast { + newPrefix += " " + } else { + newPrefix += "│ " + } + } + + sb.WriteString(child.RenderTree(newPrefix, isLastChild, color)) + } + + return sb.String() +} + +func Format(opts Option) { + var content []byte + var err error + if opts.Format == "stdin" { + content, err = io.ReadAll(os.Stdin) + } else { + content, err = os.ReadFile(opts.Format) + } + + if err != nil { + return + } + + // Group by host+path for deduplication. + // Prefer the HTTP Host header when present so that + // different virtual hosts on the same IP:port do not + // get merged together. + group := make(map[string]map[string]*baseline.Baseline) + for _, line := range bytes.Split(bytes.TrimSpace(content), []byte("\n")) { + var result baseline.Baseline + err := json.Unmarshal(line, &result) + if err != nil { + logs.Log.Error(err.Error()) + return + } + result.Url, err = url.Parse(result.UrlString) + if err != nil { + continue + } + + // Determine host key: prefer Host header when available. + hostKey := result.Host + if hostKey == "" { + hostKey = result.Url.Host + // Normalize default ports when URL host does not include one. + if result.Url.Port() == "" { + if result.Url.Scheme == "https" { + hostKey += ":443" + } else if result.Url.Scheme == "http" { + hostKey += ":80" + } + } + } + if hostKey == "" { + continue + } + + if _, exists := group[hostKey]; !exists { + group[hostKey] = make(map[string]*baseline.Baseline) + } + group[hostKey][result.Path] = &result + } + + // Default to tree mode if not specified + outputProbe := opts.OutputProbe + if outputProbe == "" { + outputProbe = "full" + } + + if outputProbe == "tree" { + formatTree(group, opts) + } else if outputProbe == "full" { + formatFull(group, opts) + } else { + // Custom probe output + formatProbe(group, opts, outputProbe) + } +} + +// formatTree renders results in tree structure +func formatTree(group map[string]map[string]*baseline.Baseline, opts Option) { + // Sort host:port for consistent output + var hosts []string + for host := range group { + hosts = append(hosts, host) + } + sort.Strings(hosts) + + for _, host := range hosts { + results := group[host] + + // Build tree for this host + root := NewTreeNode("") + for path, result := range results { + if !opts.Fuzzy && result.IsFuzzy { + continue + } + + // Split path into parts + parts := strings.Split(strings.Trim(path, "/"), "/") + if path == "/" { + parts = []string{"/"} + } + + root.AddPath(parts, result) + } + + // Print host header + logs.Log.Console(fmt.Sprintf("\n%s\n", host)) + + // Render tree + logs.Log.Console(root.RenderTree("", true, !opts.NoColor)) + } +} + +// formatFull renders results in full/original format +func formatFull(group map[string]map[string]*baseline.Baseline, opts Option) { + for _, results := range group { + for _, result := range results { + if !opts.Fuzzy && result.IsFuzzy { + continue + } + if !opts.NoColor { + logs.Log.Console(result.ColorString() + "\n") + } else { + logs.Log.Console(result.String() + "\n") + } + } + } +} + +// formatProbe renders results with custom probe fields +func formatProbe(group map[string]map[string]*baseline.Baseline, opts Option, probeFields string) { + probes := strings.Split(probeFields, ",") + for _, results := range group { + for _, result := range results { + if !opts.Fuzzy && result.IsFuzzy { + continue + } + logs.Log.Console(result.ProbeOutput(probes) + "\n") + } + } +} + +func PrintPreset() { + logs.Log.Console("internal rules:\n") + for name, rule := range pkg.Rules { + logs.Log.Consolef("\t%s\t%d rules\n", name, len(strings.Split(rule, "\n"))) + } + + logs.Log.Console("\ninternal dicts:\n") + for name, dict := range pkg.Dicts { + logs.Log.Consolef("\t%s\t%d items\n", name, len(dict)) + } + + logs.Log.Console("\ninternal words keyword:\n") + for name, words := range mask.SpecialWords { + logs.Log.Consolef("\t%s\t%d words\n", name, len(words)) + } + + logs.Log.Console("\ninternal extractor:\n") + for name, _ := range pkg.ExtractRegexps { + logs.Log.Consolef("\t%s\n", name) + } + + logs.Log.Console("\ninternal fingers:\n") + for name, engine := range pkg.FingerEngine.EnginesImpl { + logs.Log.Consolef("\t%s\t%d fingerprints \n", name, engine.Len()) + } + + logs.Log.Consolef("\nload %d active path\n", len(pkg.ActivePath)) +} diff --git a/core/ihttp/client.go b/core/ihttp/client.go index 0b9debf..310396a 100644 --- a/core/ihttp/client.go +++ b/core/ihttp/client.go @@ -1,136 +1,136 @@ -package ihttp - -import ( - "context" - "crypto/tls" - "fmt" - "github.com/chainreactors/proxyclient" - "github.com/valyala/fasthttp" - "net" - "net/http" - "time" -) - -var ( - DefaultMaxBodySize int64 = 1024 * 100 // 100k -) - -func CheckBodySize(size int64) bool { - if DefaultMaxBodySize == -1 { - return true - } - if DefaultMaxBodySize == 0 { - return false - } - return size < DefaultMaxBodySize -} - -const ( - Auto = iota - FAST - STANDARD -) - -func NewClient(config *ClientConfig) *Client { - var client *Client - - if config.Type == FAST { - client = &Client{ - fastClient: &fasthttp.Client{ - TLSConfig: &tls.Config{ - Renegotiation: tls.RenegotiateOnceAsClient, - InsecureSkipVerify: true, - }, - Dial: customDialFunc(config.ProxyClient, config.Timeout), - MaxConnsPerHost: config.Thread * 3 / 2, - MaxIdleConnDuration: config.Timeout, - //MaxConnWaitTimeout: time.Duration(timeout) * time.Second, - ReadTimeout: config.Timeout, - WriteTimeout: config.Timeout, - ReadBufferSize: 16384, // 16k - MaxResponseBodySize: int(DefaultMaxBodySize), - NoDefaultUserAgentHeader: true, - DisablePathNormalizing: true, - DisableHeaderNamesNormalizing: true, - }, - ClientConfig: config, - } - } else { - client = &Client{ - standardClient: &http.Client{ - Transport: &http.Transport{ - DialContext: config.ProxyClient, - TLSClientConfig: &tls.Config{ - Renegotiation: tls.RenegotiateNever, - InsecureSkipVerify: true, - }, - TLSHandshakeTimeout: config.Timeout, - MaxConnsPerHost: config.Thread * 3 / 2, - IdleConnTimeout: config.Timeout, - ReadBufferSize: 16384, // 16k - }, - Timeout: config.Timeout, - CheckRedirect: func(req *http.Request, via []*http.Request) error { - return http.ErrUseLastResponse - }, - }, - ClientConfig: config, - } - } - return client -} - -type ClientConfig struct { - Type int - Timeout time.Duration - Thread int - ProxyClient proxyclient.Dial -} - -type Client struct { - fastClient *fasthttp.Client - standardClient *http.Client - *ClientConfig -} - -func (c *Client) TransToCheck() { - if c.fastClient != nil { - c.fastClient.MaxConnsPerHost = -1 // disable keepalive - } else if c.standardClient != nil { - c.standardClient.Transport.(*http.Transport).DisableKeepAlives = true // disable keepalive - } -} - -func (c *Client) FastDo(req *fasthttp.Request) (*fasthttp.Response, error) { - resp := fasthttp.AcquireResponse() - err := c.fastClient.DoTimeout(req, resp, c.Timeout) - return resp, err -} - -func (c *Client) StandardDo(req *http.Request) (*http.Response, error) { - return c.standardClient.Do(req) -} - -func (c *Client) Do(req *Request) (*Response, error) { - if c.fastClient != nil { - resp, err := c.FastDo(req.FastRequest) - return &Response{FastResponse: resp, ClientType: FAST}, err - } else if c.standardClient != nil { - resp, err := c.StandardDo(req.StandardRequest) - return &Response{StandardResponse: resp, ClientType: STANDARD}, err - } else { - return nil, fmt.Errorf("not found client") - } -} - -func customDialFunc(dialer proxyclient.Dial, timeout time.Duration) fasthttp.DialFunc { - if dialer == nil { - return func(addr string) (net.Conn, error) { - return fasthttp.DialTimeout(addr, timeout) - } - } - return func(addr string) (net.Conn, error) { - ctx, _ := context.WithTimeout(context.Background(), timeout) - return dialer.DialContext(ctx, "tcp", addr) - } -} +package ihttp + +import ( + "context" + "crypto/tls" + "fmt" + "github.com/chainreactors/proxyclient" + "github.com/valyala/fasthttp" + "net" + "net/http" + "time" +) + +var ( + DefaultMaxBodySize int64 = 1024 * 100 // 100k +) + +func CheckBodySize(size int64) bool { + if DefaultMaxBodySize == -1 { + return true + } + if DefaultMaxBodySize == 0 { + return false + } + return size < DefaultMaxBodySize +} + +const ( + Auto = iota + FAST + STANDARD +) + +func NewClient(config *ClientConfig) *Client { + var client *Client + + if config.Type == FAST { + client = &Client{ + fastClient: &fasthttp.Client{ + TLSConfig: &tls.Config{ + Renegotiation: tls.RenegotiateOnceAsClient, + InsecureSkipVerify: true, + }, + Dial: customDialFunc(config.ProxyClient, config.Timeout), + MaxConnsPerHost: config.Thread * 3 / 2, + MaxIdleConnDuration: config.Timeout, + //MaxConnWaitTimeout: time.Duration(timeout) * time.Second, + ReadTimeout: config.Timeout, + WriteTimeout: config.Timeout, + ReadBufferSize: 16384, // 16k + MaxResponseBodySize: int(DefaultMaxBodySize), + NoDefaultUserAgentHeader: true, + DisablePathNormalizing: true, + DisableHeaderNamesNormalizing: true, + }, + ClientConfig: config, + } + } else { + client = &Client{ + standardClient: &http.Client{ + Transport: &http.Transport{ + DialContext: config.ProxyClient, + TLSClientConfig: &tls.Config{ + Renegotiation: tls.RenegotiateNever, + InsecureSkipVerify: true, + }, + TLSHandshakeTimeout: config.Timeout, + MaxConnsPerHost: config.Thread * 3 / 2, + IdleConnTimeout: config.Timeout, + ReadBufferSize: 16384, // 16k + }, + Timeout: config.Timeout, + CheckRedirect: func(req *http.Request, via []*http.Request) error { + return http.ErrUseLastResponse + }, + }, + ClientConfig: config, + } + } + return client +} + +type ClientConfig struct { + Type int + Timeout time.Duration + Thread int + ProxyClient proxyclient.Dial +} + +type Client struct { + fastClient *fasthttp.Client + standardClient *http.Client + *ClientConfig +} + +func (c *Client) TransToCheck() { + if c.fastClient != nil { + c.fastClient.MaxConnsPerHost = -1 // disable keepalive + } else if c.standardClient != nil { + c.standardClient.Transport.(*http.Transport).DisableKeepAlives = true // disable keepalive + } +} + +func (c *Client) FastDo(req *fasthttp.Request) (*fasthttp.Response, error) { + resp := fasthttp.AcquireResponse() + err := c.fastClient.DoTimeout(req, resp, c.Timeout) + return resp, err +} + +func (c *Client) StandardDo(req *http.Request) (*http.Response, error) { + return c.standardClient.Do(req) +} + +func (c *Client) Do(req *Request) (*Response, error) { + if c.fastClient != nil { + resp, err := c.FastDo(req.FastRequest) + return &Response{FastResponse: resp, ClientType: FAST}, err + } else if c.standardClient != nil { + resp, err := c.StandardDo(req.StandardRequest) + return &Response{StandardResponse: resp, ClientType: STANDARD}, err + } else { + return nil, fmt.Errorf("not found client") + } +} + +func customDialFunc(dialer proxyclient.Dial, timeout time.Duration) fasthttp.DialFunc { + if dialer == nil { + return func(addr string) (net.Conn, error) { + return fasthttp.DialTimeout(addr, timeout) + } + } + return func(addr string) (net.Conn, error) { + ctx, _ := context.WithTimeout(context.Background(), timeout) + return dialer.DialContext(ctx, "tcp", addr) + } +} diff --git a/core/ihttp/response.go b/core/ihttp/response.go index 1ee7f58..5878d35 100644 --- a/core/ihttp/response.go +++ b/core/ihttp/response.go @@ -1,110 +1,110 @@ -package ihttp - -import ( - "github.com/chainreactors/logs" - "github.com/chainreactors/utils/httputils" - "github.com/valyala/fasthttp" - "io" - "net/http" - "strings" -) - -type Response struct { - StandardResponse *http.Response - FastResponse *fasthttp.Response - ClientType int -} - -func (r *Response) StatusCode() int { - if r.FastResponse != nil { - return r.FastResponse.StatusCode() - } else if r.StandardResponse != nil { - return r.StandardResponse.StatusCode - } else { - return 0 - } -} - -func (r *Response) Body() []byte { - if r.FastResponse != nil { - return r.FastResponse.Body() - } else if r.StandardResponse != nil { - if r.StandardResponse.ContentLength == -1 { - body, err := io.ReadAll(r.StandardResponse.Body) - if err != nil { - return nil - } - return body - } else { - var body []byte - if r.StandardResponse.ContentLength > 0 && CheckBodySize(r.StandardResponse.ContentLength) { - body = make([]byte, r.StandardResponse.ContentLength) - } else { - return nil - } - - n, err := io.ReadFull(r.StandardResponse.Body, body) - _ = r.StandardResponse.Body.Close() - if err == nil { - return body - } else if err == io.ErrUnexpectedEOF { - return body[:n] - } else if err == io.EOF { - return nil - } else { - logs.Log.Error("readfull failed, " + err.Error()) - return nil - } - } - return nil - } else { - return nil - } -} - -func (r *Response) ContentLength() int64 { - if r.FastResponse != nil { - return int64(r.FastResponse.Header.ContentLength()) - } else if r.StandardResponse != nil { - return r.StandardResponse.ContentLength - } else { - return 0 - } -} - -func (r *Response) ContentType() string { - var t string - if r.FastResponse != nil { - t = string(r.FastResponse.Header.ContentType()) - } else if r.StandardResponse != nil { - t = r.StandardResponse.Header.Get("Content-Type") - } else { - return "" - } - - if i := strings.Index(t, ";"); i > 0 { - return t[:i] - } else { - return t - } -} - -func (r *Response) Header() []byte { - if r.FastResponse != nil { - return r.FastResponse.Header.Header() - } else if r.StandardResponse != nil { - return append(httputils.ReadRawHeader(r.StandardResponse), []byte("\r\n")...) - } else { - return nil - } -} - -func (r *Response) GetHeader(key string) string { - if r.FastResponse != nil { - return string(r.FastResponse.Header.Peek(key)) - } else if r.StandardResponse != nil { - return r.StandardResponse.Header.Get(key) - } else { - return "" - } -} +package ihttp + +import ( + "github.com/chainreactors/logs" + "github.com/chainreactors/utils/httputils" + "github.com/valyala/fasthttp" + "io" + "net/http" + "strings" +) + +type Response struct { + StandardResponse *http.Response + FastResponse *fasthttp.Response + ClientType int +} + +func (r *Response) StatusCode() int { + if r.FastResponse != nil { + return r.FastResponse.StatusCode() + } else if r.StandardResponse != nil { + return r.StandardResponse.StatusCode + } else { + return 0 + } +} + +func (r *Response) Body() []byte { + if r.FastResponse != nil { + return r.FastResponse.Body() + } else if r.StandardResponse != nil { + if r.StandardResponse.ContentLength == -1 { + body, err := io.ReadAll(r.StandardResponse.Body) + if err != nil { + return nil + } + return body + } else { + var body []byte + if r.StandardResponse.ContentLength > 0 && CheckBodySize(r.StandardResponse.ContentLength) { + body = make([]byte, r.StandardResponse.ContentLength) + } else { + return nil + } + + n, err := io.ReadFull(r.StandardResponse.Body, body) + _ = r.StandardResponse.Body.Close() + if err == nil { + return body + } else if err == io.ErrUnexpectedEOF { + return body[:n] + } else if err == io.EOF { + return nil + } else { + logs.Log.Error("readfull failed, " + err.Error()) + return nil + } + } + return nil + } else { + return nil + } +} + +func (r *Response) ContentLength() int64 { + if r.FastResponse != nil { + return int64(r.FastResponse.Header.ContentLength()) + } else if r.StandardResponse != nil { + return r.StandardResponse.ContentLength + } else { + return 0 + } +} + +func (r *Response) ContentType() string { + var t string + if r.FastResponse != nil { + t = string(r.FastResponse.Header.ContentType()) + } else if r.StandardResponse != nil { + t = r.StandardResponse.Header.Get("Content-Type") + } else { + return "" + } + + if i := strings.Index(t, ";"); i > 0 { + return t[:i] + } else { + return t + } +} + +func (r *Response) Header() []byte { + if r.FastResponse != nil { + return r.FastResponse.Header.Header() + } else if r.StandardResponse != nil { + return append(httputils.ReadRawHeader(r.StandardResponse), []byte("\r\n")...) + } else { + return nil + } +} + +func (r *Response) GetHeader(key string) string { + if r.FastResponse != nil { + return string(r.FastResponse.Header.Peek(key)) + } else if r.StandardResponse != nil { + return r.StandardResponse.Header.Get(key) + } else { + return "" + } +} diff --git a/core/pool/config.go b/core/pool/config.go index 8b74500..1dafe9e 100644 --- a/core/pool/config.go +++ b/core/pool/config.go @@ -1,70 +1,70 @@ -package pool - -import ( - "github.com/chainreactors/logs" - "github.com/chainreactors/proxyclient" - "github.com/chainreactors/spray/core/baseline" - "github.com/chainreactors/spray/core/ihttp" - "github.com/chainreactors/words" - "github.com/chainreactors/words/rule" - "github.com/expr-lang/expr/vm" - "sync" - "time" -) - -type Config struct { - BaseURL string - ProxyClient proxyclient.Dial - Thread int - Wordlist []string - Timeout time.Duration - ProcessCh chan *baseline.Baseline - OutputCh chan *baseline.Baseline - FuzzyCh chan *baseline.Baseline - Outwg *sync.WaitGroup - RateLimit int - CheckPeriod int - ErrPeriod int32 - BreakThreshold int32 - Mod SprayMod - Request *ihttp.RequestConfig - ClientType int - MatchExpr *vm.Program - FilterExpr *vm.Program - RecuExpr *vm.Program - AppendRule *rule.Program - Fns []words.WordFunc - AppendWords []string - Fuzzy bool - IgnoreWaf bool - Crawl bool - Scope []string - Active bool - Bak bool - Fuzzuli bool - Common bool - RetryLimit int - Random string - Index string - MaxRedirect int - MaxCrawlDepth int - MaxRecursionDepth int - MaxAppendDepth int -} - -func NewBruteWords(config *Config, list []string) *words.Worder { - word := words.NewWorderWithList(list) - word.Fns = config.Fns - word.Run() - return word -} - -func NewBruteDSL(config *Config, dsl string, params [][]string) *words.Worder { - word, err := words.NewWorderWithDsl(dsl, params, nil) - if err != nil { - logs.Log.Error(err.Error()) - } - word.Fns = config.Fns - word.Run() - return word -} +package pool + +import ( + "github.com/chainreactors/logs" + "github.com/chainreactors/proxyclient" + "github.com/chainreactors/spray/core/baseline" + "github.com/chainreactors/spray/core/ihttp" + "github.com/chainreactors/words" + "github.com/chainreactors/words/rule" + "github.com/expr-lang/expr/vm" + "sync" + "time" +) + +type Config struct { + BaseURL string + ProxyClient proxyclient.Dial + Thread int + Wordlist []string + Timeout time.Duration + ProcessCh chan *baseline.Baseline + OutputCh chan *baseline.Baseline + FuzzyCh chan *baseline.Baseline + Outwg *sync.WaitGroup + RateLimit int + CheckPeriod int + ErrPeriod int32 + BreakThreshold int32 + Mod SprayMod + Request *ihttp.RequestConfig + ClientType int + MatchExpr *vm.Program + FilterExpr *vm.Program + RecuExpr *vm.Program + AppendRule *rule.Program + Fns []words.WordFunc + AppendWords []string + Fuzzy bool + IgnoreWaf bool + Crawl bool + Scope []string + Active bool + Bak bool + Fuzzuli bool + Common bool + RetryLimit int + Random string + Index string + MaxRedirect int + MaxCrawlDepth int + MaxRecursionDepth int + MaxAppendDepth int +} + +func NewBruteWords(config *Config, list []string) *words.Worder { + word := words.NewWorderWithList(list) + word.Fns = config.Fns + word.Run() + return word +} + +func NewBruteDSL(config *Config, dsl string, params [][]string) *words.Worder { + word, err := words.NewWorderWithDsl(dsl, params, nil) + if err != nil { + logs.Log.Error(err.Error()) + } + word.Fns = config.Fns + word.Run() + return word +} diff --git a/core/pool/pool_test.go b/core/pool/pool_test.go index fa69142..401bdb6 100644 --- a/core/pool/pool_test.go +++ b/core/pool/pool_test.go @@ -1,526 +1,526 @@ -package pool - -import ( - "context" - "github.com/chainreactors/parsers" - "github.com/chainreactors/spray/core/baseline" - "runtime" - "sync" - "sync/atomic" - "testing" - "time" -) - -// --------------------------------------------------------------------------- -// helpers -// --------------------------------------------------------------------------- - -func newTestBasePool(ctx context.Context, cancel context.CancelFunc) *BasePool { - return &BasePool{ - Config: &Config{ - Thread: 4, - OutputCh: make(chan *baseline.Baseline, 100), - FuzzyCh: make(chan *baseline.Baseline, 100), - Outwg: &sync.WaitGroup{}, - }, - ctx: ctx, - Cancel: cancel, - additionCh: make(chan *Unit, 40), // Thread*10 - closeCh: make(chan struct{}), - processCh: make(chan *baseline.Baseline, 8), // Thread*2 - wg: &sync.WaitGroup{}, - handlerDone: make(chan struct{}), - } -} - -func newTestBaseline() *baseline.Baseline { - return &baseline.Baseline{ - SprayResult: &parsers.SprayResult{ - UrlString: "http://example.com/test", - IsValid: true, - }, - } -} - -// mustFinish fails the test if fn does not return within d. -func mustFinish(t *testing.T, d time.Duration, msg string, fn func()) { - t.Helper() - done := make(chan struct{}) - go func() { fn(); close(done) }() - select { - case <-done: - case <-time.After(d): - t.Fatalf("timeout: %s", msg) - } -} - -// --------------------------------------------------------------------------- -// addAddition -// --------------------------------------------------------------------------- - -func TestAddAddition_Normal(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - pool := newTestBasePool(ctx, cancel) - - pool.addAddition(&Unit{path: "/a", source: parsers.WordSource}) - - select { - case u := <-pool.additionCh: - if u.path != "/a" { - t.Fatalf("path = %q, want /a", u.path) - } - case <-time.After(time.Second): - t.Fatal("addAddition: channel receive timed out") - } - pool.wg.Done() // balance the Add(1) - pool.wg.Wait() // must not hang -} - -func TestAddAddition_AfterCancel(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - cancel() - - pool.addAddition(&Unit{path: "/a", source: parsers.WordSource}) - - select { - case <-pool.additionCh: - t.Fatal("should not send after cancel") - default: - } - // wg must be zero — the cancelled path must not leak a counter - pool.wg.Wait() -} - -// Regression: old code had a `default` branch that spawned an async goroutine. -// If the goroutine sent successfully, wg.Done() was never called — wg leak. -// This test verifies wg stays balanced after many addAddition calls. -func TestAddAddition_WgBalance(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - pool := newTestBasePool(ctx, cancel) - - const N = 100 - // drain concurrently so addAddition never blocks on a full buffer - var received int32 - go func() { - for range pool.additionCh { - atomic.AddInt32(&received, 1) - pool.wg.Done() - } - }() - - for i := 0; i < N; i++ { - pool.addAddition(&Unit{path: "/x", source: parsers.WordSource}) - } - - mustFinish(t, 2*time.Second, "wg.Wait hung — wg counter leaked", func() { - pool.wg.Wait() - }) - close(pool.additionCh) // stop drain goroutine - if r := atomic.LoadInt32(&received); r != N { - t.Fatalf("received %d items, want %d", r, N) - } -} - -func TestAddAddition_FullBufferUnblocksOnCancel(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - - // fill buffer - for i := 0; i < cap(pool.additionCh); i++ { - pool.additionCh <- &Unit{path: "/fill"} - } - - mustFinish(t, 2*time.Second, "addAddition on full buffer not unblocked by cancel", func() { - go func() { - time.Sleep(50 * time.Millisecond) - cancel() - }() - pool.addAddition(&Unit{path: "/blocked", source: parsers.WordSource}) - }) -} - -func TestAddAddition_ConcurrentShutdown(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - - var ext sync.WaitGroup - for i := 0; i < 200; i++ { - ext.Add(1) - go func() { - defer ext.Done() - pool.addAddition(&Unit{path: "/c", source: parsers.WordSource}) - }() - } - - time.Sleep(2 * time.Millisecond) - cancel() - - // drain so senders can unblock - go func() { - for range pool.additionCh { - pool.wg.Done() - } - }() - - mustFinish(t, 5*time.Second, "concurrent addAddition+cancel hung", func() { - ext.Wait() - }) - close(pool.additionCh) -} - -// --------------------------------------------------------------------------- -// sendProcess -// --------------------------------------------------------------------------- - -func TestSendProcess_Normal(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - pool := newTestBasePool(ctx, cancel) - - bl := newTestBaseline() - pool.sendProcess(bl) - - select { - case got := <-pool.processCh: - if got.UrlString != bl.UrlString { - t.Fatalf("got %q, want %q", got.UrlString, bl.UrlString) - } - case <-time.After(time.Second): - t.Fatal("sendProcess: channel receive timed out") - } -} - -func TestSendProcess_AfterCancel(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - cancel() - - mustFinish(t, 2*time.Second, "sendProcess blocked after cancel", func() { - pool.sendProcess(newTestBaseline()) - }) -} - -func TestSendProcess_FullBufferUnblocksOnCancel(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - - for i := 0; i < cap(pool.processCh); i++ { - pool.processCh <- newTestBaseline() - } - - mustFinish(t, 2*time.Second, "sendProcess on full buffer not unblocked by cancel", func() { - go func() { - time.Sleep(50 * time.Millisecond) - cancel() - }() - pool.sendProcess(newTestBaseline()) - }) -} - -func TestSendProcess_ConcurrentShutdown(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - - var ext sync.WaitGroup - for i := 0; i < 200; i++ { - ext.Add(1) - go func() { - defer ext.Done() - pool.sendProcess(newTestBaseline()) - }() - } - - time.Sleep(2 * time.Millisecond) - cancel() - - go func() { - for range pool.processCh { - } - }() - - mustFinish(t, 5*time.Second, "concurrent sendProcess+cancel hung", func() { - ext.Wait() - }) - close(pool.processCh) -} - -// --------------------------------------------------------------------------- -// putToOutput -// --------------------------------------------------------------------------- - -func TestPutToOutput_Normal(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - pool := newTestBasePool(ctx, cancel) - - pool.putToOutput(newTestBaseline()) - - select { - case <-pool.OutputCh: - case <-time.After(time.Second): - t.Fatal("putToOutput: receive timed out") - } - pool.Outwg.Done() - pool.Outwg.Wait() -} - -func TestPutToOutput_AfterCancel(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - cancel() - - mustFinish(t, 2*time.Second, "putToOutput blocked after cancel", func() { - pool.putToOutput(newTestBaseline()) - }) - // select may have picked OutputCh (buffer available) or ctx.Done(); - // drain if sent so Outwg stays balanced. - select { - case <-pool.OutputCh: - pool.Outwg.Done() - default: - } - pool.Outwg.Wait() -} - -func TestPutToOutput_OutwgBalance(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - - // fill OutputCh so next send will block - for i := 0; i < cap(pool.OutputCh); i++ { - pool.OutputCh <- newTestBaseline() - pool.Outwg.Add(1) // manual balance for the fills - } - - mustFinish(t, 2*time.Second, "putToOutput on full ch not unblocked by cancel", func() { - go func() { - time.Sleep(50 * time.Millisecond) - cancel() - }() - pool.putToOutput(newTestBaseline()) - }) - - // drain and done for fills - for i := 0; i < cap(pool.OutputCh); i++ { - <-pool.OutputCh - pool.Outwg.Done() - } - pool.Outwg.Wait() -} - -// --------------------------------------------------------------------------- -// putToFuzzy -// --------------------------------------------------------------------------- - -func TestPutToFuzzy_Normal(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - pool := newTestBasePool(ctx, cancel) - - pool.putToFuzzy(newTestBaseline()) - - select { - case bl := <-pool.FuzzyCh: - if !bl.IsFuzzy { - t.Fatal("IsFuzzy should be true") - } - case <-time.After(time.Second): - t.Fatal("putToFuzzy: receive timed out") - } - pool.Outwg.Done() - pool.Outwg.Wait() -} - -func TestPutToFuzzy_AfterCancel(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - cancel() - - mustFinish(t, 2*time.Second, "putToFuzzy blocked after cancel", func() { - pool.putToFuzzy(newTestBaseline()) - }) - select { - case <-pool.FuzzyCh: - pool.Outwg.Done() - default: - } - pool.Outwg.Wait() -} - -// --------------------------------------------------------------------------- -// Handler lifecycle — close(processCh) must exit for-range -// --------------------------------------------------------------------------- - -// Regression: processCh was never closed → Handler goroutine leaked forever. -func TestHandlerDone_SignaledOnProcessChClose(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - pool := newTestBasePool(ctx, cancel) - - go func() { - defer close(pool.handlerDone) - for range pool.processCh { - } - }() - - close(pool.processCh) - - select { - case <-pool.handlerDone: - case <-time.After(2 * time.Second): - t.Fatal("handlerDone not signaled after processCh closed") - } -} - -func TestHandlerDone_ProcessesAllBeforeExit(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() - pool := newTestBasePool(ctx, cancel) - - var count int - go func() { - defer close(pool.handlerDone) - for range pool.processCh { - count++ - } - }() - - const N = 20 - for i := 0; i < N; i++ { - pool.processCh <- newTestBaseline() - } - close(pool.processCh) - <-pool.handlerDone - - if count != N { - t.Fatalf("handler processed %d items, want %d", count, N) - } -} - -// --------------------------------------------------------------------------- -// Full shutdown sequence (integration-level) -// --------------------------------------------------------------------------- - -func TestShutdownSequence_NoDeadlock(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - - // simulate Handler - go func() { - defer close(pool.handlerDone) - for range pool.processCh { - } - }() - - // simulate some work - for i := 0; i < 10; i++ { - pool.addAddition(&Unit{path: "/w", source: parsers.WordSource}) - } - // simulate consumer - for i := 0; i < 10; i++ { - <-pool.additionCh - pool.sendProcess(newTestBaseline()) - pool.wg.Done() - } - - // shutdown: Cancel → wg.Wait → close(processCh) → <-handlerDone - mustFinish(t, 5*time.Second, "shutdown sequence deadlocked", func() { - cancel() - pool.wg.Wait() - close(pool.processCh) - <-pool.handlerDone - }) -} - -func TestShutdownSequence_CancelMidFlight(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - - go func() { - defer close(pool.handlerDone) - for range pool.processCh { - } - }() - - // producers still running when cancel fires - var ext sync.WaitGroup - for i := 0; i < 50; i++ { - ext.Add(1) - go func() { - defer ext.Done() - pool.addAddition(&Unit{path: "/m", source: parsers.WordSource}) - }() - } - for i := 0; i < 50; i++ { - ext.Add(1) - go func() { - defer ext.Done() - pool.sendProcess(newTestBaseline()) - }() - } - - time.Sleep(5 * time.Millisecond) - cancel() - - // drain additionCh - go func() { - for range pool.additionCh { - pool.wg.Done() - } - }() - - mustFinish(t, 5*time.Second, "mid-flight cancel deadlocked", func() { - ext.Wait() - pool.wg.Wait() - close(pool.processCh) - <-pool.handlerDone - close(pool.additionCh) - }) -} - -// --------------------------------------------------------------------------- -// Goroutine leak detection -// --------------------------------------------------------------------------- - -func TestNoGoroutineLeak(t *testing.T) { - // let background goroutines from prior tests settle - runtime.GC() - time.Sleep(100 * time.Millisecond) - before := runtime.NumGoroutine() - - ctx, cancel := context.WithCancel(context.Background()) - pool := newTestBasePool(ctx, cancel) - - go func() { - defer close(pool.handlerDone) - for range pool.processCh { - } - }() - - for i := 0; i < 10; i++ { - pool.addAddition(&Unit{path: "/l", source: parsers.WordSource}) - } - go func() { - for range pool.additionCh { - pool.wg.Done() - } - }() - - cancel() - pool.wg.Wait() - close(pool.processCh) - <-pool.handlerDone - close(pool.additionCh) - - time.Sleep(200 * time.Millisecond) - runtime.GC() - time.Sleep(100 * time.Millisecond) - - after := runtime.NumGoroutine() - if after > before+2 { - t.Errorf("goroutine leak: before=%d after=%d", before, after) - } -} +package pool + +import ( + "context" + "github.com/chainreactors/parsers" + "github.com/chainreactors/spray/core/baseline" + "runtime" + "sync" + "sync/atomic" + "testing" + "time" +) + +// --------------------------------------------------------------------------- +// helpers +// --------------------------------------------------------------------------- + +func newTestBasePool(ctx context.Context, cancel context.CancelFunc) *BasePool { + return &BasePool{ + Config: &Config{ + Thread: 4, + OutputCh: make(chan *baseline.Baseline, 100), + FuzzyCh: make(chan *baseline.Baseline, 100), + Outwg: &sync.WaitGroup{}, + }, + ctx: ctx, + Cancel: cancel, + additionCh: make(chan *Unit, 40), // Thread*10 + closeCh: make(chan struct{}), + processCh: make(chan *baseline.Baseline, 8), // Thread*2 + wg: &sync.WaitGroup{}, + handlerDone: make(chan struct{}), + } +} + +func newTestBaseline() *baseline.Baseline { + return &baseline.Baseline{ + SprayResult: &parsers.SprayResult{ + UrlString: "http://example.com/test", + IsValid: true, + }, + } +} + +// mustFinish fails the test if fn does not return within d. +func mustFinish(t *testing.T, d time.Duration, msg string, fn func()) { + t.Helper() + done := make(chan struct{}) + go func() { fn(); close(done) }() + select { + case <-done: + case <-time.After(d): + t.Fatalf("timeout: %s", msg) + } +} + +// --------------------------------------------------------------------------- +// addAddition +// --------------------------------------------------------------------------- + +func TestAddAddition_Normal(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + pool := newTestBasePool(ctx, cancel) + + pool.addAddition(&Unit{path: "/a", source: parsers.WordSource}) + + select { + case u := <-pool.additionCh: + if u.path != "/a" { + t.Fatalf("path = %q, want /a", u.path) + } + case <-time.After(time.Second): + t.Fatal("addAddition: channel receive timed out") + } + pool.wg.Done() // balance the Add(1) + pool.wg.Wait() // must not hang +} + +func TestAddAddition_AfterCancel(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + cancel() + + pool.addAddition(&Unit{path: "/a", source: parsers.WordSource}) + + select { + case <-pool.additionCh: + t.Fatal("should not send after cancel") + default: + } + // wg must be zero — the cancelled path must not leak a counter + pool.wg.Wait() +} + +// Regression: old code had a `default` branch that spawned an async goroutine. +// If the goroutine sent successfully, wg.Done() was never called — wg leak. +// This test verifies wg stays balanced after many addAddition calls. +func TestAddAddition_WgBalance(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + pool := newTestBasePool(ctx, cancel) + + const N = 100 + // drain concurrently so addAddition never blocks on a full buffer + var received int32 + go func() { + for range pool.additionCh { + atomic.AddInt32(&received, 1) + pool.wg.Done() + } + }() + + for i := 0; i < N; i++ { + pool.addAddition(&Unit{path: "/x", source: parsers.WordSource}) + } + + mustFinish(t, 2*time.Second, "wg.Wait hung — wg counter leaked", func() { + pool.wg.Wait() + }) + close(pool.additionCh) // stop drain goroutine + if r := atomic.LoadInt32(&received); r != N { + t.Fatalf("received %d items, want %d", r, N) + } +} + +func TestAddAddition_FullBufferUnblocksOnCancel(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + + // fill buffer + for i := 0; i < cap(pool.additionCh); i++ { + pool.additionCh <- &Unit{path: "/fill"} + } + + mustFinish(t, 2*time.Second, "addAddition on full buffer not unblocked by cancel", func() { + go func() { + time.Sleep(50 * time.Millisecond) + cancel() + }() + pool.addAddition(&Unit{path: "/blocked", source: parsers.WordSource}) + }) +} + +func TestAddAddition_ConcurrentShutdown(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + + var ext sync.WaitGroup + for i := 0; i < 200; i++ { + ext.Add(1) + go func() { + defer ext.Done() + pool.addAddition(&Unit{path: "/c", source: parsers.WordSource}) + }() + } + + time.Sleep(2 * time.Millisecond) + cancel() + + // drain so senders can unblock + go func() { + for range pool.additionCh { + pool.wg.Done() + } + }() + + mustFinish(t, 5*time.Second, "concurrent addAddition+cancel hung", func() { + ext.Wait() + }) + close(pool.additionCh) +} + +// --------------------------------------------------------------------------- +// sendProcess +// --------------------------------------------------------------------------- + +func TestSendProcess_Normal(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + pool := newTestBasePool(ctx, cancel) + + bl := newTestBaseline() + pool.sendProcess(bl) + + select { + case got := <-pool.processCh: + if got.UrlString != bl.UrlString { + t.Fatalf("got %q, want %q", got.UrlString, bl.UrlString) + } + case <-time.After(time.Second): + t.Fatal("sendProcess: channel receive timed out") + } +} + +func TestSendProcess_AfterCancel(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + cancel() + + mustFinish(t, 2*time.Second, "sendProcess blocked after cancel", func() { + pool.sendProcess(newTestBaseline()) + }) +} + +func TestSendProcess_FullBufferUnblocksOnCancel(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + + for i := 0; i < cap(pool.processCh); i++ { + pool.processCh <- newTestBaseline() + } + + mustFinish(t, 2*time.Second, "sendProcess on full buffer not unblocked by cancel", func() { + go func() { + time.Sleep(50 * time.Millisecond) + cancel() + }() + pool.sendProcess(newTestBaseline()) + }) +} + +func TestSendProcess_ConcurrentShutdown(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + + var ext sync.WaitGroup + for i := 0; i < 200; i++ { + ext.Add(1) + go func() { + defer ext.Done() + pool.sendProcess(newTestBaseline()) + }() + } + + time.Sleep(2 * time.Millisecond) + cancel() + + go func() { + for range pool.processCh { + } + }() + + mustFinish(t, 5*time.Second, "concurrent sendProcess+cancel hung", func() { + ext.Wait() + }) + close(pool.processCh) +} + +// --------------------------------------------------------------------------- +// putToOutput +// --------------------------------------------------------------------------- + +func TestPutToOutput_Normal(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + pool := newTestBasePool(ctx, cancel) + + pool.putToOutput(newTestBaseline()) + + select { + case <-pool.OutputCh: + case <-time.After(time.Second): + t.Fatal("putToOutput: receive timed out") + } + pool.Outwg.Done() + pool.Outwg.Wait() +} + +func TestPutToOutput_AfterCancel(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + cancel() + + mustFinish(t, 2*time.Second, "putToOutput blocked after cancel", func() { + pool.putToOutput(newTestBaseline()) + }) + // select may have picked OutputCh (buffer available) or ctx.Done(); + // drain if sent so Outwg stays balanced. + select { + case <-pool.OutputCh: + pool.Outwg.Done() + default: + } + pool.Outwg.Wait() +} + +func TestPutToOutput_OutwgBalance(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + + // fill OutputCh so next send will block + for i := 0; i < cap(pool.OutputCh); i++ { + pool.OutputCh <- newTestBaseline() + pool.Outwg.Add(1) // manual balance for the fills + } + + mustFinish(t, 2*time.Second, "putToOutput on full ch not unblocked by cancel", func() { + go func() { + time.Sleep(50 * time.Millisecond) + cancel() + }() + pool.putToOutput(newTestBaseline()) + }) + + // drain and done for fills + for i := 0; i < cap(pool.OutputCh); i++ { + <-pool.OutputCh + pool.Outwg.Done() + } + pool.Outwg.Wait() +} + +// --------------------------------------------------------------------------- +// putToFuzzy +// --------------------------------------------------------------------------- + +func TestPutToFuzzy_Normal(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + pool := newTestBasePool(ctx, cancel) + + pool.putToFuzzy(newTestBaseline()) + + select { + case bl := <-pool.FuzzyCh: + if !bl.IsFuzzy { + t.Fatal("IsFuzzy should be true") + } + case <-time.After(time.Second): + t.Fatal("putToFuzzy: receive timed out") + } + pool.Outwg.Done() + pool.Outwg.Wait() +} + +func TestPutToFuzzy_AfterCancel(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + cancel() + + mustFinish(t, 2*time.Second, "putToFuzzy blocked after cancel", func() { + pool.putToFuzzy(newTestBaseline()) + }) + select { + case <-pool.FuzzyCh: + pool.Outwg.Done() + default: + } + pool.Outwg.Wait() +} + +// --------------------------------------------------------------------------- +// Handler lifecycle — close(processCh) must exit for-range +// --------------------------------------------------------------------------- + +// Regression: processCh was never closed → Handler goroutine leaked forever. +func TestHandlerDone_SignaledOnProcessChClose(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + pool := newTestBasePool(ctx, cancel) + + go func() { + defer close(pool.handlerDone) + for range pool.processCh { + } + }() + + close(pool.processCh) + + select { + case <-pool.handlerDone: + case <-time.After(2 * time.Second): + t.Fatal("handlerDone not signaled after processCh closed") + } +} + +func TestHandlerDone_ProcessesAllBeforeExit(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + pool := newTestBasePool(ctx, cancel) + + var count int + go func() { + defer close(pool.handlerDone) + for range pool.processCh { + count++ + } + }() + + const N = 20 + for i := 0; i < N; i++ { + pool.processCh <- newTestBaseline() + } + close(pool.processCh) + <-pool.handlerDone + + if count != N { + t.Fatalf("handler processed %d items, want %d", count, N) + } +} + +// --------------------------------------------------------------------------- +// Full shutdown sequence (integration-level) +// --------------------------------------------------------------------------- + +func TestShutdownSequence_NoDeadlock(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + + // simulate Handler + go func() { + defer close(pool.handlerDone) + for range pool.processCh { + } + }() + + // simulate some work + for i := 0; i < 10; i++ { + pool.addAddition(&Unit{path: "/w", source: parsers.WordSource}) + } + // simulate consumer + for i := 0; i < 10; i++ { + <-pool.additionCh + pool.sendProcess(newTestBaseline()) + pool.wg.Done() + } + + // shutdown: Cancel → wg.Wait → close(processCh) → <-handlerDone + mustFinish(t, 5*time.Second, "shutdown sequence deadlocked", func() { + cancel() + pool.wg.Wait() + close(pool.processCh) + <-pool.handlerDone + }) +} + +func TestShutdownSequence_CancelMidFlight(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + + go func() { + defer close(pool.handlerDone) + for range pool.processCh { + } + }() + + // producers still running when cancel fires + var ext sync.WaitGroup + for i := 0; i < 50; i++ { + ext.Add(1) + go func() { + defer ext.Done() + pool.addAddition(&Unit{path: "/m", source: parsers.WordSource}) + }() + } + for i := 0; i < 50; i++ { + ext.Add(1) + go func() { + defer ext.Done() + pool.sendProcess(newTestBaseline()) + }() + } + + time.Sleep(5 * time.Millisecond) + cancel() + + // drain additionCh + go func() { + for range pool.additionCh { + pool.wg.Done() + } + }() + + mustFinish(t, 5*time.Second, "mid-flight cancel deadlocked", func() { + ext.Wait() + pool.wg.Wait() + close(pool.processCh) + <-pool.handlerDone + close(pool.additionCh) + }) +} + +// --------------------------------------------------------------------------- +// Goroutine leak detection +// --------------------------------------------------------------------------- + +func TestNoGoroutineLeak(t *testing.T) { + // let background goroutines from prior tests settle + runtime.GC() + time.Sleep(100 * time.Millisecond) + before := runtime.NumGoroutine() + + ctx, cancel := context.WithCancel(context.Background()) + pool := newTestBasePool(ctx, cancel) + + go func() { + defer close(pool.handlerDone) + for range pool.processCh { + } + }() + + for i := 0; i < 10; i++ { + pool.addAddition(&Unit{path: "/l", source: parsers.WordSource}) + } + go func() { + for range pool.additionCh { + pool.wg.Done() + } + }() + + cancel() + pool.wg.Wait() + close(pool.processCh) + <-pool.handlerDone + close(pool.additionCh) + + time.Sleep(200 * time.Millisecond) + runtime.GC() + time.Sleep(100 * time.Millisecond) + + after := runtime.NumGoroutine() + if after > before+2 { + t.Errorf("goroutine leak: before=%d after=%d", before, after) + } +} diff --git a/core/task.go b/core/task.go index 75003ed..cdb0282 100644 --- a/core/task.go +++ b/core/task.go @@ -1,73 +1,73 @@ -package core - -import ( - "fmt" - "github.com/chainreactors/logs" - "github.com/chainreactors/utils" - "github.com/chainreactors/words/rule" - "net/url" -) - -type Task struct { - baseUrl string - depth int - rule []rule.Expression - origin *Origin -} - -func NewTaskGenerator(port string) *TaskGenerator { - gen := &TaskGenerator{ - ports: utils.ParsePortsString(port), - tasks: make(chan *Task), - In: make(chan *Task), - } - - go func() { - for task := range gen.In { - gen.tasks <- task - } - close(gen.tasks) - }() - return gen - -} - -type TaskGenerator struct { - Name string - ports []string - tasks chan *Task - In chan *Task -} - -func (gen *TaskGenerator) Run(baseurl string) { - parsed, err := url.Parse(baseurl) - if err != nil { - logs.Log.Warnf("parse %s, %s ", baseurl, err.Error()) - return - } - - if parsed.Scheme == "" { - if parsed.Port() == "443" { - parsed.Scheme = "https" - } else { - parsed.Scheme = "http" - } - } - - if len(gen.ports) == 0 { - gen.In <- &Task{baseUrl: parsed.String()} - return - } - - for _, p := range gen.ports { - if parsed.Host == "" { - gen.In <- &Task{baseUrl: fmt.Sprintf("%s://%s:%s", parsed.Scheme, parsed.Path, p)} - } else { - gen.In <- &Task{baseUrl: fmt.Sprintf("%s://%s:%s/%s", parsed.Scheme, parsed.Host, p, parsed.Path)} - } - } -} - -func (gen *TaskGenerator) Close() { - close(gen.tasks) -} +package core + +import ( + "fmt" + "github.com/chainreactors/logs" + "github.com/chainreactors/utils" + "github.com/chainreactors/words/rule" + "net/url" +) + +type Task struct { + baseUrl string + depth int + rule []rule.Expression + origin *Origin +} + +func NewTaskGenerator(port string) *TaskGenerator { + gen := &TaskGenerator{ + ports: utils.ParsePortsString(port), + tasks: make(chan *Task), + In: make(chan *Task), + } + + go func() { + for task := range gen.In { + gen.tasks <- task + } + close(gen.tasks) + }() + return gen + +} + +type TaskGenerator struct { + Name string + ports []string + tasks chan *Task + In chan *Task +} + +func (gen *TaskGenerator) Run(baseurl string) { + parsed, err := url.Parse(baseurl) + if err != nil { + logs.Log.Warnf("parse %s, %s ", baseurl, err.Error()) + return + } + + if parsed.Scheme == "" { + if parsed.Port() == "443" { + parsed.Scheme = "https" + } else { + parsed.Scheme = "http" + } + } + + if len(gen.ports) == 0 { + gen.In <- &Task{baseUrl: parsed.String()} + return + } + + for _, p := range gen.ports { + if parsed.Host == "" { + gen.In <- &Task{baseUrl: fmt.Sprintf("%s://%s:%s", parsed.Scheme, parsed.Path, p)} + } else { + gen.In <- &Task{baseUrl: fmt.Sprintf("%s://%s:%s/%s", parsed.Scheme, parsed.Host, p, parsed.Path)} + } + } +} + +func (gen *TaskGenerator) Close() { + close(gen.tasks) +} diff --git a/core/types.go b/core/types.go index ab9dd53..23255aa 100644 --- a/core/types.go +++ b/core/types.go @@ -1,37 +1,37 @@ -package core - -import ( - "github.com/chainreactors/spray/pkg" - "github.com/chainreactors/words" -) - -func NewOrigin(stat *pkg.Statistor) *Origin { - return &Origin{Statistor: stat} -} - -type Origin struct { - *pkg.Statistor - sum int -} - -func (o *Origin) InitWorder(fns []words.WordFunc) (*words.Worder, error) { - var worder *words.Worder - wl, err := pkg.LoadWordlist(o.Word, o.Dictionaries) - if err != nil { - return nil, err - } - worder = words.NewWorderWithList(wl) - worder.Fns = fns - rules, err := pkg.LoadRuleWithFiles(o.RuleFiles, o.RuleFilter) - if err != nil { - return nil, err - } - worder.Rules = rules - if len(rules) > 0 { - o.sum = len(rules) * len(wl) - } else { - o.sum = len(wl) - } - - return worder, nil -} +package core + +import ( + "github.com/chainreactors/spray/pkg" + "github.com/chainreactors/words" +) + +func NewOrigin(stat *pkg.Statistor) *Origin { + return &Origin{Statistor: stat} +} + +type Origin struct { + *pkg.Statistor + sum int +} + +func (o *Origin) InitWorder(fns []words.WordFunc) (*words.Worder, error) { + var worder *words.Worder + wl, err := pkg.LoadWordlist(o.Word, o.Dictionaries) + if err != nil { + return nil, err + } + worder = words.NewWorderWithList(wl) + worder.Fns = fns + rules, err := pkg.LoadRuleWithFiles(o.RuleFiles, o.RuleFilter) + if err != nil { + return nil, err + } + worder.Rules = rules + if len(rules) > 0 { + o.sum = len(rules) * len(wl) + } else { + o.sum = len(wl) + } + + return worder, nil +} diff --git a/pkg/bar.go b/pkg/bar.go index 49e3f4d..795c2c9 100644 --- a/pkg/bar.go +++ b/pkg/bar.go @@ -1,61 +1,61 @@ -package pkg - -import ( - "fmt" - "github.com/vbauerster/mpb/v8" - "github.com/vbauerster/mpb/v8/decor" - "time" -) - -func NewBar(u string, total int, stat *Statistor, p *mpb.Progress) *Bar { - if p == nil { - return &Bar{ - url: u, - } - } - bar := p.AddBar(int64(total), - mpb.BarFillerClearOnComplete(), - mpb.BarRemoveOnComplete(), - mpb.PrependDecorators( - decor.Name(u, decor.WC{W: len(u) + 1, C: decor.DindentRight}), // 这里调整了装饰器的参数 - decor.NewAverageSpeed(0, "% .0f/s ", time.Now()), - decor.Counters(0, "%d/%d"), - decor.Any(func(s decor.Statistics) string { - return fmt.Sprintf(" found: %d", stat.FoundNumber) - }), - ), - mpb.AppendDecorators( - decor.Percentage(), - decor.Elapsed(decor.ET_STYLE_GO, decor.WC{W: 4}), - ), - ) - - return &Bar{ - url: u, - bar: bar, - //m: m, - } -} - -type Bar struct { - url string - bar *mpb.Bar - //m metrics.Meter -} - -func (bar *Bar) Done() { - //bar.m.Mark(1) - if bar.bar == nil { - return - } - bar.bar.Increment() -} - -func (bar *Bar) Close() { - //metrics.Unregister(bar.url) - // 标记进度条为完成状态 - if bar.bar == nil { - return - } - bar.bar.Abort(true) -} +package pkg + +import ( + "fmt" + "github.com/vbauerster/mpb/v8" + "github.com/vbauerster/mpb/v8/decor" + "time" +) + +func NewBar(u string, total int, stat *Statistor, p *mpb.Progress) *Bar { + if p == nil { + return &Bar{ + url: u, + } + } + bar := p.AddBar(int64(total), + mpb.BarFillerClearOnComplete(), + mpb.BarRemoveOnComplete(), + mpb.PrependDecorators( + decor.Name(u, decor.WC{W: len(u) + 1, C: decor.DindentRight}), // 这里调整了装饰器的参数 + decor.NewAverageSpeed(0, "% .0f/s ", time.Now()), + decor.Counters(0, "%d/%d"), + decor.Any(func(s decor.Statistics) string { + return fmt.Sprintf(" found: %d", stat.FoundNumber) + }), + ), + mpb.AppendDecorators( + decor.Percentage(), + decor.Elapsed(decor.ET_STYLE_GO, decor.WC{W: 4}), + ), + ) + + return &Bar{ + url: u, + bar: bar, + //m: m, + } +} + +type Bar struct { + url string + bar *mpb.Bar + //m metrics.Meter +} + +func (bar *Bar) Done() { + //bar.m.Mark(1) + if bar.bar == nil { + return + } + bar.bar.Increment() +} + +func (bar *Bar) Close() { + //metrics.Unregister(bar.url) + // 标记进度条为完成状态 + if bar.bar == nil { + return + } + bar.bar.Abort(true) +} diff --git a/pkg/errors.go b/pkg/errors.go index e441543..3c13c92 100644 --- a/pkg/errors.go +++ b/pkg/errors.go @@ -1,41 +1,41 @@ -package pkg - -type ErrorType uint - -const ( - NoErr ErrorType = iota - ErrBadStatus - ErrSameStatus - ErrRequestFailed - ErrWaf - ErrRedirect - ErrCompareFailed - ErrCustomCompareFailed - ErrCustomFilter - ErrFuzzyCompareFailed - ErrFuzzyRedirect - ErrFuzzyNotUnique - ErrUrlError - ErrResponseError -) - -var ErrMap = map[ErrorType]string{ - NoErr: "", - ErrBadStatus: "blacklist status", - ErrSameStatus: "same status with random baseline", - ErrRequestFailed: "request failed", - ErrWaf: "maybe banned by waf", - ErrRedirect: "duplicate redirect url", - ErrCompareFailed: "compare failed", - ErrCustomCompareFailed: "custom compare failed", - ErrCustomFilter: "custom filtered", - ErrFuzzyCompareFailed: "fuzzy compare failed", - ErrFuzzyRedirect: "fuzzy redirect", - ErrFuzzyNotUnique: "not unique", - ErrUrlError: "url parse error", - ErrResponseError: "response parse error", -} - -func (e ErrorType) Error() string { - return ErrMap[e] -} +package pkg + +type ErrorType uint + +const ( + NoErr ErrorType = iota + ErrBadStatus + ErrSameStatus + ErrRequestFailed + ErrWaf + ErrRedirect + ErrCompareFailed + ErrCustomCompareFailed + ErrCustomFilter + ErrFuzzyCompareFailed + ErrFuzzyRedirect + ErrFuzzyNotUnique + ErrUrlError + ErrResponseError +) + +var ErrMap = map[ErrorType]string{ + NoErr: "", + ErrBadStatus: "blacklist status", + ErrSameStatus: "same status with random baseline", + ErrRequestFailed: "request failed", + ErrWaf: "maybe banned by waf", + ErrRedirect: "duplicate redirect url", + ErrCompareFailed: "compare failed", + ErrCustomCompareFailed: "custom compare failed", + ErrCustomFilter: "custom filtered", + ErrFuzzyCompareFailed: "fuzzy compare failed", + ErrFuzzyRedirect: "fuzzy redirect", + ErrFuzzyNotUnique: "not unique", + ErrUrlError: "url parse error", + ErrResponseError: "response parse error", +} + +func (e ErrorType) Error() string { + return ErrMap[e] +} diff --git a/pkg/parse.go b/pkg/parse.go index 5e700bd..43487d0 100644 --- a/pkg/parse.go +++ b/pkg/parse.go @@ -1,26 +1,26 @@ -package pkg - -import "strings" - -var ( - SkipChar = "%SKIP%" - EXTChar = "%EXT%" -) - -func ParseEXTPlaceholderFunc(exts []string) func(string) []string { - return func(s string) []string { - ss := make([]string, len(exts)) - var n int - for i, e := range exts { - if strings.Contains(s, EXTChar) { - n++ - ss[i] = strings.Replace(s, EXTChar, e, -1) - } - } - if n == 0 { - return []string{s} - } else { - return ss - } - } -} +package pkg + +import "strings" + +var ( + SkipChar = "%SKIP%" + EXTChar = "%EXT%" +) + +func ParseEXTPlaceholderFunc(exts []string) func(string) []string { + return func(s string) []string { + ss := make([]string, len(exts)) + var n int + for i, e := range exts { + if strings.Contains(s, EXTChar) { + n++ + ss[i] = strings.Replace(s, EXTChar, e, -1) + } + } + if n == 0 { + return []string{s} + } else { + return ss + } + } +} diff --git a/pkg/templates.go b/pkg/templates.go index f2abd32..2cb9d09 100644 --- a/pkg/templates.go +++ b/pkg/templates.go @@ -2,24 +2,24 @@ // +build !emptytemplates package pkg - -import ( - "github.com/chainreactors/utils/encode" -) - -var RandomDir = "/g8kZMwp4oeKsL2in" - + +import ( + "github.com/chainreactors/utils/encode" +) + +var RandomDir = "/g8kZMwp4oeKsL2in" + func loadEmbeddedConfig(typ string) []byte { - if typ == "spray_rule" { - return encode.MustDeflateDeCompress(encode.Base64Decode("hFPNbqs8EN3zFEfJsMQYU5rwsfpa9RXuKrLktKQlTUsUkvvTxX32K48xcQJRJQRzxsdnPMOxOR3f1n/2puv+w2yOtenq1WH1Sal971wI/p56wN/nHvD3sQdkXBABlNlwju6tObRwBWxGp9ACOsX88cdTomQmk3x5nwdLvKo76C0G0l0i5eLOkSJAV7eYSiZZWSy83IhH6RSzcm+rnEKnfrdhAYYUgxRo0/d1hgK0BXV+ADEoB609jScx5ELuFfEWR4Je0AfBcA36ExReXnFwb5+gwaxclqOjmZCRlzkPP0gtikyeS4lgvwLVVxDOKBeZW0wbWMnxJomL+oqP1GQGTQaJJouHdZXkqsiVXXcG25qfJgKe24+PllN2hMYH4b/5y8Gc31VwBBE0KXy+4t4vBVKvKjAIeNP6eEimZ/PYeANte9dxkKsuYxHAGlqdybOo/n0cLmlvB8nn2IM+Qa+BX/4f5VcrBqOsbfHktSS7amLnwBgMOsEo2Hu5VfyGM1knBj15M5egJQdL14vV/Jb7wM+VajVVJwc99P82WJlFm2ZXr827na8zCt8Uevf/fBqClM+0oB3oxcOdLdL6wsJfdBHs+AI1oL2HR5Y8ePgK+mI7OG+JfhQd6BdoP4v+AQAA//8=")) - } else if typ == "spray_common" { - return encode.MustDeflateDeCompress(encode.Base64Decode("nJOxbtRAFEV7S/4HKxUUIM84m93hZ9DYHuI49tp4hjhJR5UWmkh0FOloqJDIKn+Tzf4G2sy7FxSlAKp3ZFv3zN55e+Hs9CZNsuxVpswqJymSJhWkQ9KCdERaklYkAzJ0GDoMHYYOQ4ehw9Bh6DB0GHHoPM9JiqRJBWlBOiItSSsSkxWTFZMVkxWT1SGJDkWHokPRoejQdGg6NB2aDk2HpkPToenQdGiTJv2wDo3cONpBN2gml2T0g3bQDZpBL2gFnewbqe3F31r+I/1xYlewKdgTbAl2hBuCHmSiXXSLZtErWkWnaBR9Sl4heYVKk9KevnXnQX75ZKcIlydjhGCn18eX5Ah4sJTp33cRSnsaYd5/us9e295J+DzPAq5UJL6bhiFI3ElwYnQ+PEkubSVU22BL6+XTWpJCj5M7EK4zDhvHQXbwr/v7+z7++Bcsn/m3yD18GLvB1pG74fhJVw/X37eb24frq/vNj+3Nz2cfZi/Uy/hie3N1v7mTj24/7b5+jLy7+7z79iVN1g53aP0IsIRzviM1pJ5UCdWdHLJycuWVx2xC36VJa8+sCFsIW6a3fga84ztQDHhEeyZHrDrrfZqMzSihYzMSCtICxIixCWnSeh4lTgcIODYe9K3/BQAA//8=")) - } else if typ == "spray_dict" { - return encode.MustDeflateDeCompress(encode.Base64Decode("3L17d9w4di/6fz7FnLOW1Elmqqgq+Rmnosiy3O2M7HZs93hyoiwukESxoCIBGgCrVL5957PfhY3XBsnyo2fm/HHdreLePwAbIJ4bwAZIqpbxub7X//K7X//hd787Az4QmaFawklNpaHzgFpqCWQn2Y5oCvROs7zbaUOTebfp4Kk2um0MBXCQQcqSKuF8XWIGXFTCZN6PCkGVTUTiLcfSRc/1nKgOcS4llynrXUNSEOfc1IB1Uei8EbWPkColDFHlHeG08eJSllSsZZwpLUklIFcvRwip2ll8MWAcHF4gkgb1MbUxzLxD7irSNsbWyctI1cIb9IrKCShKnoLBd6832FdkjWvZqgyRE64gE2GMV/QevWYKRB8xSswHdx9rLJ6qXbrnefR87qA8fY08TWiuNNHOJ40w4zOb+pjaIYR9BekDBPnJUg+Zd/W1GOiNbjEdYk7ixLHheHC1YBxXDBR7iDdLW6KHcMNKMJycIZj6RMn7EhaTdBkBJ+lIAUw5jEMkcU0XSUYmSiIb53sKYV+jSMbiB4JtdzKFTUSZH3vH/Mg75kfe8WYc6Y0XfQQeJOXmSEpuphNyM06HaXBp+KRFpkDiYxhISPaZjkJi1PqNfZNhBNeU60wxTbWkNHWRooE+fBJMWkLigLNv6BAzcMplIgx+oQkHFwKTacK6QazdIK4ujaFL5NKKDRoyIDgEApwPrvEAMkCsn3W5hYBCZmvWUK9rlIJzWmohVdZ3jSCVpmoQ/0a0NGGStwUgeV+MID84eQiwPmAkSbkkluFYNYSwLxzRYMRiPEubvW2mOKZm1BwnOoWJ7mDcEYy7AI+Mw6khJsbixUi8SMW3xMuLbaojSu2FrBKPitWDKBc4Dxb49Rfz1B+SswhjxiJEuMSClknYJU7+EgtaBkHLKCitE8tx4S7HpbtMi3c5LpXluFjOQ+znIfYHAXsQsdwNlSMAeSlFI/iADc4Pg9SHAcuJpAQnB4DgMXDIzU8dhlBSRyfwkX+UL2MY+U5KAkETEY5bJcZHEY5K0MJJKSJoIsJxU8T4KMJR6ecVkzF/04gn4pyIbhzTOJL2EEvU0oCbJGE6eEpKfVzoR8r8SJFPl/h0gY/L+0hxHynt6cKeLutxUR8p6SMFPV3O08XsxvEBizsrD+GIB1jiD0WZQthXNuST103AqYgnXjp1GSdi4tURFSqYJT2aFLjn0wR1E4VddoP36caxM6X9fNcxGeLkk4TB5WEBHJ1FUtnySSKOlESkgGZ0CMQOOgCjeCw6iAvAgTQhh4kGDOfdEEx9oiIcYEN/U6HVFJoNBY7SnA2GsiE+9U6Tc89jjtMhJ9514DYIN5iIBIeRhjhwmUziuAIPnKaSN+q1UpdxziYtIkUnEzxu/NNOU6GmEjzVApHLOMFTKqJ39Itwx/CRtMm3P5rYo2lN12hGaOJ3lDg1JTFNKtuxOL4yTdskiKZt4qiGrlHYNtHdtgQ5jGrvdmJcShYEkswbLwCMp/6jSf9ouj8dYZb4D2keTbLHc+jx3Hk0Zx7NlQGIkcjYQyscmUrEJnke81sxHfvz9465xC6XI5cPQjQqYYLTL8kS62BleGJtdmJdNkAuFH5bSw+ULATme/aZoJYXwl5WSEzMCkXlDsVt2QzT+/0+G0+GyXrNGkY0xbR/qwFPWt9qPjPBbS6OIZKUckxsF1Yzus4BDSuT0TQi4KHXG/fwCULNptebzEHeM+rGer1J8tbz3pFybWKiyN1DAy8oeQnovQnJPgfgcggYH7hSONY5iaQNet44FqTc+mdIuGHEes1K6rne5+lzzFiXLMDWN+dURlHFzE8bPAn+ER3wkcdkHvF8Eh34dYmcAoNPr2mmwCiaBB34HUSDweDT96QpMIomQQd+B9FgsChi/rEa0Vqy+7jaXDSizvbdbASE1GHeewhqRUkKxiksLlxFsrTdYKQAdCus8MQZUg43fsqyWzzwZR0ZCFyzWeHf1PbLCeQEbGi59c85wnBxRyDzXJKIAARntysWaO+zYdSur7g3vHIv2qqYz5FJXr1V2ZZK1zEhLkloqzJ96MS5E+3pslUhkxwZQ8SIeUl03AgtBV+z2vsDBpIcKIv1yeQiwbAn6hgzqZuFDjadal5NccgbIrE4qhCDB/2pBfKrCWxiVfxqDGFfwwjTUhDubYHxq+lx3fwqUGGx/MoTdiJ71dnwIaq3gQIsX7OGphw4amk99UqLlsqw/pMCxktF1KYQRFaGeZEymhRE0fxyNE+svNN4ClkVWdW3XajpVexTKlr09bwRNdA7gJiMvUTFJC119C72vBGksgOOEepF9m3noRAPXZw9jlWWPsjG3RutGDQ5u10Q657lkSerKdGqz/xAHeiQWFq3hPHNpwzv7lJeM6tHXAeKSimke2ugoZLSz+pTwzQNKX559UcXtXuwltRUZYSXG2G6EFO2eCs38q4ORcC+SeAzx7QEO7UkOtBgoLEWslXhJddC9m1SpRESPcBvjncYLI4zv25EQZF1Bd5N+QnRaAvlp0gaFEJ1e1rc0VhJXvHqEIUyrrATYsCl8S3Yccgh1F8my1lLyhgw6SVZ7CTvhGgbt9LoJ2P/8LvfbeOQtqUH8xvqWUN1S4MoxxmHG7ajRmO3LW0EQFhRR4MOyzg4x3AeYMZnktoWFZFeBdrVIlxoidaQTMpwQd4MaSfyVYw5EItIdZsuMLHALFsVkTYVMHKi1wlDVJfwiVQzviYeDIB9YEdoioFbNyRGJLaBxKEV2dHI9B0M7JFxTqHKNqIWuToo/K62it14wiDhBe3bBToKwW+pwhN3pgDgfuZG6F7lL0TLuIiVagQaYbiumx5NU0641dHtXqp7HctEuKVhbSsC0VkmbhI54OUDD+FtXY/hOpdgTlZPmsjStogCgIlwNvCG2/PrEYL8ZKmHKEElfpV3sAsAlvIgiluTMAxHBpxERRtFiSw3YboywnxTfH3MYRzCveIRHPv3s5cRNhVr4jAOMY4V49h/yI0h5vqmMT6RmsRhHGKcmqReiYrite7Io5gSIPqIkjEf3DPsmCUueBQfosN4x2WM4UEaRuWL0DQJw2yeWJd9PQ0PfQ+TMJm9WVLXk8XMBBhEoUKIsBzpOOfQG5UfNZnIg4dDnKK+RnR78MIOls29iNeRbA8oLApaioqi1zmoTw2WrD41gUhh1BNysnvPNPUdM2bBmerSDkec7uP4wYVmJSOQKVzts3RFYIC4N3wzidplmIQxQkVH+a7jIcIuazPI6bfZR8NafTS4IhbZuR138TXo7Zedj4W2qX37RdeOMKdrgdI1Q/tnTr17ewSf9O/rwnHH+E5f8/EFGf7NvuJhUoLvuY87fjGJiY8vyPhCErGHSQmxWhxz/GISB5XjqI8vJDGtInEiHzTzMKu2yJ3K7j71VB4AUYpmjkDbSW8v37//+PO7Fza4dcLeAH8e2vRbKpXgxEYSl9a6jdCCNEXfOjM1C3Yz3HdZHrPuwfjaG7x3m66pSBdqLGKdZ9T/GC6V78Rb5vXBWhAv5w/nDzJVStZplSmqwxot9pRKyBJXePOEQ25HBDtBy9S3Z13eJYxzev+fN6hTTQHw0hD9OahgiINUvr50j+XZGVgxdS0JpJDaFZ2lwKjZJ1nsqczdOl9kwLc91+A9SlFSpUICEBt93NFSz8JSaApAAt//4oX3RcPK3DSMtIIbXG1oNUAlDTnnaSPG6rbVbIEYS7LP5lHekS2Rg8FmAnXxvDvqIsswW3x3ffni9fVc32uD0xrbL0gaIqF4coq4BrFOtiiEVl6gEP6RuSdknSLrtX02NDn4oUgXKfBBS2mn8JZSjnSLl0AxDcrDe8o3xIKYcCHkzvqJT+pVTce413mPN8Deh+0vNaBssnPVkqaZBGM0l4N1iQnUyo2N7z2iAc88CD5d7m1oWEZRG2GdzDMx9LdIOE3i2ZjlAYjh47QQeLTUCzyyDrY8mjMCgCsEAOqg3I632oh9aOqK1TyupTjOO+SJQx4dEtzDbdeQQNGbGIOJ2LnoZFFO4TW/yPhhfID4gplEo1/fYgZIqFzT8ND3MK4kP9si5N970cuSqgyfDHnfkZIOd54T1TjVgNWnZk9h1UepfNeqUIfHiPW08Z2XJwHWRAbc085B+ydTmpXKc5boi6CsBhpere+onPkhBHE2VFxtBnqRMMHLwjZwSyMfeVJ4EUHeLYB9JIUQERwGbWIB4Fa5gI5Lvp7FTmidxkNOuQAW02jvKvDBccesihSZm2GyI4qSHsHUp5DzIeDEm/E3j0WHePBw6Oh9uv2gDgrVQViNiy7uMJtfpHM9c2B9OzkkS8B4Se/9QV0O6SUWqRyjaTsb75VYB9+EMBO7rvexE7PUIC0ABeuECAysE7yD2894n7LO1e1FOi5kM2ITaRO7P5re645oTaVlvVFKsE6BjUhDWHXXyYu6b99Jsmsot9aNvZzhkgmsK5nAOykyFjXUV+ftF0Sjeox6Kl+b4ZnISBicBSZ06PB/eX/97s3l62vnTyGxKguE76p65SLriWSwZvhLJB2qEKwSPE3EBNhr1jB9iM2i34WJzi4qeDvKnUnQriWs8YmLDDgJKXwhAe3A3oP7QuFxYF/ExuGdDP0R47TAhRpYV0IfB3xwtzF8TFnvmlmnS0SPIswm48kmY8um4swmYx7Hk8yqP06ixm/DPttqNwg4iBSDqc8kbDK2f5xEB34H8WAw9eniKYnt5j9Gck8Lu3mzp0VLVNTIAu8c3bqYoXZWHvucLpJhgxJvO+KFIVOS/X7vR/f7AB4Ep5qVzFWpwLr3DrwVZ9k28dymfm0/XNbMnmz/3ydLerKkGSkOSs1Lwde3fD7PvvD/x1dv3nxwGuj5MmOdM6Kg9/SWz62ufMvnpShIowORkYZKnRm9npV0XtbswtGrf2VtfbI8U7Jc3ZEdsZPnfwH///jDn9+//+Gf/u2bxNiA/4YD/qubihsB6013a+pLSKEn56KpMKvIjiL+L0DD4ofxxpV931s+D9h+v89J2VgKiAxO+xeMZ+vOGkvTe3rxltR0VdE16Rswu/71VWuQ819fsJpptVo89CG7nc4qUWpR0W5eaHnLFw9I08wW8wW8dLmuV0cK6P/545ufP755+erm+v91ob4rxOUHN/KUNQOuppxKM9e3QFP07UUrKrqCxZ1T+F3N5yfLl9/wQ3V5WjHVKfaZrh49ODs1yq1end3yS354LoisXDT88FLINhDLW+5s5khVzWzGW59Xt/yqZnAGEmrgFeQ2OL24Mn8vf373+pa/ZA295UbUT4RXDZWQKZKShpOWrgghp9SMD0BJ2jWHvKVKkZrmmprJkKYrm/6T5Usb/8DbWop2pT6dPDij98RMmualaE/9TvVqo3V3cn55snx5sny53+/nqa+SdYxyPRJg0/yaMFuKaSW/vUXOXXPLf/z4MPvx48fr5/PrP18P2Isfrz/Mrn5+8+H6zx9Of/rw+uZP1+9Wl5eXQ28/Xd+8XRWkmkn6qadKG/fjblCDX4qGCbx0bfP/5uOPRFP/tNhr1b4mamvLCjEXLVHbVXbX8+35+YP/u05vfrn5zR3e23dvfnvYwnTDQP7idMbmlv9J3fKPt/zjqzcvXl++uoF8P1mezfjJ8qz8l9vbQgg9Z5ydfIuf5dlPpNxS+e8bcn8mTYU6WZ79erI8q5h0fk0l+kgLTvfKpuW/yPPn8665AHOplcFPSWnU4JVpuQ05nHJo8V94b9SjnJydWZEZyDWV2Ap+/vPluxdTkr/SkZOF8XwOkr41ESaUnSP/fUN/IdCDbwxUVflad7axkKqy9sGBBSXfMaGdBfKiYUqvvuO1vNKHyPNAN47aCI3iMV2X5dYQZV5IsVdU5qLXq/mv0NP/1b+4m73lpG5Y2ykaKZeChhWkIPOu+dVW5/nc1OZv+f0DhKZ8LWT7f+01WpSxnJSCV6RsWGfaWhhjvqPwuDIhu2EQMwczigerfj0tGrIBn9n3+D4UcSAmHb2npQlK9aGjK1F1p9+W2Izq0p5Uqk7OzkAJPTVsL5tVVhJNayEP2S0nstww6p5mlp3DBpWLfgBC3imTSqWlKEnrvOmN60ovStG2hFcrtRH7jtT01HYcqx/+5w//ffaHs//5n2euX/lT3xjFpmjoD//0jKz++79/MHK2WdRBs7IhSs2J3lZEU6K1ZEWv6fwOZsEXtivPid5KIfTq39+9fPXLu5tbTnro0zL3hOrlurngWNGmv6fBC7xWvw3eW8r776oLvd7kFdH2BBPs0oDFrNHxbznZNz6mPSWwGm/ig9mGwnSWYPdYEST3/qksUSBH3ElZ2hmeOsQUWFHMNkzpi59eGTpXLWuY3Wm6MMldvf4g7n++u340fN6wB7vh3//587u7m/Pnm/L8zfn/ubz8o5FYiormkq7/dhJVDrae7iWoVoxmHZGKSqNsZV8cpp7d8oLVpoZY5dtVyh2j+9xUZ1M4p+ZnhcrRAJpKtTKBP1fFYmYNe1wKGlFn7tHqmbXmjy6tnoEKgZF5ua5vecGLNejSjnBehNjiqummJadlL6VRRH8tiT5ZnqHk/XpqQueaVaunTx89Ontw9uDhaSfpbtUSNxM/NQNQ0IhhJr9anEFkn3Vi8W9nbjbqh6eMd71eLW55oWqjV4Kz1cfvnzXK4EbyGO5Z41+5b7aZ+bFseb7c08L0CNnVhvDaLuH77ezE/UeqQYu9gN83Zjpw5YzJr01cphGZHqyr1v/wu9/d8jL39tsuKlJuaJWvKcVAW0vPNXlLthS637Pv05tK0lBeERkp2/OQpmBSbypyUKuF16FqqityOK3IYbU8O1vMnswWD0+h5q1OlstntNyIk+XZDz88O1meOebk0Rmr7PNZxeg//pPztcQRNpHJPOF3GRvXC05VFxQslHnEvkcCjb4N1HZEXZycERPgjCR5Roy71M4jEBdVsfrBcudLq+Ea2m8S2EQVbWltvV3vVpYFa5pZI0rips9ttXp9/eaXgZNJfnRZ13v22UVRo86jrNmsYYVNVc1KJS5gOPuaqpv4halaWTMr1+gMG+pb0PdVqppBtXbpRHPnsmZ7SbpAZCfnV2vBTbGUohFyJWl1cn4d3f/y778g5j9+efPHf3z4TwgxA+MtL6EBzg6il7Noa2LywoyvbM1Cwwm8SpiRa/ZFR1zbGlZu3Wn15sJ0vysN81ZwkFR1Zix2lbytQIPIyt9XTAK/SAFRUaste+rckO3D+f9v/xXi3r2iUYscCZllRzTmpgaGpdKtyBm163uqZFw+toLs1s7FenV2+tJU9hvC6+9QhqyIzAwYElTXCeji8u3b1ad2M4Pp7Yfr129vLj9cr5416mR5ZjTXXyFQRzQrGurfMawsAUnlzA4llrGKz4BNfKxZ3VA9AWW8zG55aSq9utoQ/e65uE/0BkV2FOwWTuF39cyuKPzjD6M+8wfT/NSPZhB97kf43yrlhu1Mp6De0L1vZUC/leKvkutHYS8zGJmNnTbmRxPXofealkTpzFun3/Jyp4qGtLbegT71tS51pxpRR+//fGoUmFPQ4L8z6Ne9h4nMRSEJLzdfDnI6IbUSZQ/nESphlCzk2UxJvtXzIDHWnPgriXEpPq2YXNmUne434puTp4TUxWH1gmh6uhG9VKulTfKe0m1MT5h/lzsFZZA54vR7EvnT9eWLW14RruqeyIoR0CteXL95df3il3c3q3/NyL9NCXqGcqgiqsvWbW6tgIjqDKRJtqa6BOsd260BSs3v4aFxL0XHvBbhMS60GYk8Wiz3+33WsEISechili33mZmkGh8P9rTIy6wqKiY5aWmWdGhVkSfaSlW0hGdVARlXFSsuZlUBcGPnJ3Y0r8qgglyQzyvT+Z0C8n3qQlUGI6bjU0znScjKtEv7cC5rJl0HWjFSc6ECV3tCwn2Gh871K3vCNczfS6JPzfM7E2zXEj9cQadRmR5+T03+CC70hvHakAr08Yqw5nCqREv9q5z+2qhfjQes4YPdBd+BPKMgzwuiI3Vh2sjv/VKqNeYyHlswmbx48Xy13xBNd1T6p3HsM7BvpG3f+sV9WGDJvryo8tW3/3sJ/DukFMzcIIMp3zEpeMpAJgb6oiOStItjHVApxJZR3OWZITiD7SWjxlr45Pw6af8n51dZcLnl1FRiM7dXlGm6embHL4/+esvp/awRde0URnpfMtMX2OezVy9vOf2MlkXoZ7SQRj+3JOBGYgfnt0hluhXIVGhSrFotbHc7OR+KQePSQAjIqlN/fHlVmV+jvrZfXq7Dyw8VU5rxEibiIaJlkkjkcD5wWJNPqJe60KJcDUt8Te5VL3f0cDF6t1tuT+6yJlKQyWvGa9Ni7NNCDb23KxqecikQ7TePzmvRZt6/mcF9w8i8ON3Sg1FO1GoX1g5vYQnZpdtRPjWRu4gbfGZw+3eYPG6E0idnl6OscBuRd4Kago1+T1Vf3NFSuxlMkN81CfP3jOvvJFv3HDLyfk+LedU0gYZxbN0puSNV6zjd2TfWndEO659sbtdxPdKvaNlpZ+4uNFLqi556LWwhTvkxc9/p4KDwGhchtlkd1tTy15evbj78vLq3y1R1YeKHZOPd9At3sfJX1tH3zAxHyjxhT+/szG6gwW+++K0yuf5bSkyb+khcWHqpqa5E6cqMai0JVwXTLTG56Ld56nZmr/Bx0466nZWd070N555mkuOzfMDaFWB7d0TsAH+FrY6pfjUGhkLyXOb3bjbRaOCWGw1xYuTfML1j1O2ObYwOlMHSCqwYpLw1oHDnXG75puN2CeaiXHW/Z6tbvlFuifSr2s/EwLrRtaSd7Qbj3Pp0U8lV0uNuNNzEYAsGMVlH9AbunDa66MXyD0vj3DbL0vy69zP8HnO2r/yOTdWNRmOY7VdPlsuT8+vRcH0C/fHJ8unJ+fOT86uT5Us0aHsxF7My44LTe6Y04Ro5uAXGtRBrVm80laeSKi1ZqVen9L5s+oquTluqN6JaEV7BMjfRq6JnjYZjeLyG+cxKlULSU5tUJN/LOHmEa9XJo7NbzgrWNPOuveWsNDojW7tVcN5tZmj1mm0Ft9eTbGgDu78Xt5wF2wrnyfDraVsLcINW5ClbrIxD2jJO97MdU7Arw3hpK6WtHHfq7P7xmedM/Te10kxaIvUPv/vdD/84WaiFvca6gdMov/tXlAH/ZoOrsIMBq/zQbr57vxb/OkHLIGkE/DWiBZ9B1tnpnmnb0Ffe3kraESZvbxVpnbepha6kht8R1sB88pbf3d3yO9FL7taT16KpqFwhCJru1oxpDVG6YZwqu5pmT1Pdcryg9SXF8dtb4JelfF/WuVwCwgwqRno9k5RUvtu0+1fml1O9oXA9Diygb2i5ZfrW3Xzo/brlfk9dlKKXipoUmnIysA5+lfeqMvdwn7xpRO0AuETC82K737hGZcbnZl/DpN4+Ld6SmpWlU98vOrI6f9FJajr4U07v9er8hb1x6BQqwfmLb891q2f8feZUINX0La3Vwiuxggw0vcqp7QdvCK/7Yyu0U/JAwYbOxHBudmtIvyWHOO/Ew5Ih7A1Gq5+X766vc2v645cPzVw7N1Xx1A85q+/JzDshK9EKFzVf2nVka6JrihPPlCy5Oju1RC74ipjW2VJNrIBafrLJZpzlbq4XgJa4XZN2y0zldXQX6VbpSrg+vRXuza2e24o7kZkf5yp1PS/X9TcbZtoA32HJmQSwth2tyjsp7g/wDR9rUpHd8lbP4DhRmdDpHnOCx5URDNvd5laDlFHwYbgYoG80A8Wiay6AGcwbXYH2ipWfetr79nlIFT6nkJsGess5acnn3nrkhbtDxU/1YI+aNA2sYalbzqmGE3re3ehcp9+1hwEyOv9upu5XVNlkfY85lh26lR2boftUbeFkes5UUi74DNQcuKgGADfKmJb/N+9TQChcwdP5KO67RjCtSjN3cl0AdDq4GzCAO7GbMNG7O7sIhkmm6SuXV84OYjX/ZzNVbJle/ShOzYBYcr16eHZ2KulaUrVZucSZ9jWzUjXTbstadJRXzO6XJ7k8sUZpCjtMLzrSqJnt8xt1aWuV0ReJ1Kd+uQmMBBKpsPA6W4OVsZ1s+qmDM1Z2EXn7gw5sP0000OH9h6AnV6SljZs0n5xf3fKOysb+2t7FUxeznWUCAStUNvXriqmONHal/4eTs8sjc54fhn6/vZ7acA35pjg2a/gBr/95efPqEtiL/4TXNjrj1NLByfLMeBNaZP7prmyyLwlIJ4WmpabVwK2beQIiTZPe9MqOv51oGqazt6Jp8lc6t4BSzEkRSs+gf7T04pErAqHcVPbX1ILWOOQogNEclJe1p7LvMtsDmYR8R5/QdZUKVsKdhFusdpGa67YznCiov2cS78xRToqGnpqODvK7JLyk8tRXw9WWNQ2VIMCoS25s76SA5XCb+v7cgu7wfbLyWDGjwhYqTrGfTZgNiV53vc55b7phsAdyGQWPi1aZiR+cQvFHKz71rNwqLeRv21CG6W5JpAZt0UjzwtZW+OfWvd1vKhNJdOgtwL4fGuUv725GRv4ny+taiLqhJ8trsL1+eXL24uTs0v2aRu4PCBiqhq8teMH2oKOQ2Z4WXkvPjIM3WnD+tGR0R/PEskJaMyqoNdJMetfkPlv3+/1+XjVNdnHLJUw1ZNv5WisFNumTojANwjFdG3xBKN3OQZOW+7JmZp7rCNjQggoq9/u9O1Df3HJF9i1rmocXcl2uf3+yXCZtffl71RX894s/LP6wND/wXwgUwtxyZTpN+AwZTJ19FqhSQMolrT1g79/455Mzq9aFCzkav8SY1RSM8OwQeWM35+zM578Z35GGVe4KSdNw/ueWY1M81AJ+2zzTLekl06W/hdDBDMyJNEOgJZWWjNffvofiBTSIvHhHSdOuLpvm9DXRoE1/oLJVsJx7ykXZdavFaUvuN3Ck6ez02TvCt19bj4/izXTj+zb83PVnKAO39KBW/3zayXJF+OG0JJrVQh5W36IAUV0akbyKGwuGgxZoNFRr3GgXr2+fwcgXrEa8kd3trfNmw5reMVh5f0dHoyhX1IwmiRmSMj21v0EJZncG2yt6AV9py0wnVNndRYCzO1IU8OG41hTzcn6n6O/TeDbmz6oQxzvbQRC7Uwa+Xacf98m+Ycf42H6x212yqhHdf6ceDqGb3q6cVHxl7RI4WIiIFsYEVq1Ori7ffXj14sS292dTC8KmI7P1fiP2doWCu/UYuO/oq/V5I/bxsAZ888XubNgLNTKwBDYvd9HuciKPmD9az0oHo9gIxY0m1RKp08pvlyiPL3ejINlvCS5g3cqqGkR/6zkAISvbXjvGc3tPuJ26uX+33OjNSpVVrnpeil4yt+OnFMsypyN88yOtGEZ/hxH0WzeDg9kRHMq1DzUrGJ91maSdkFpl2HItWs47Sq4d6QNn8GsPmsyJsiv0HdEbWGY8/bnTq3PnNRdN5YN5pcgwvfJXlrt4YMfBMl5bcnRGaiGJKyOrCn2tzg6CQdvzNgvn5+E9ja9oxf2lFjooAgEnOC5g/ez7engTNPtrBMC2s3+6drNX6IS85cPVIc0t10Z3tmv0lm22BSndaoPUrGy+5b1Pzs5O0drEaWvGTDBEXdxyDRZumpYbLjTNftNaWfbtvaOfKFv7lcCZweWbVYIQSpdN5C6yf3YMaH+wz/U3WI3XodszVJayYVp0jPmel7pncPoRDoU6PqG7DeMg/V47001bKVi1ZlEZ16zeCb+CrJn2kyjd1VyK0kiTZL1m5Xct5GkpROcmk9pm7G/M1z/ccq3JnhbaDvZZ2MeG5Y3ue8xs+0ZLggxcEG9ypudNvZgvPLG85X1XEU3nVVcrw8TFwL7TrKW3vJdNsLG9ODm/evX6R1gI6KHL2VIKl980YXZbCy2+d8uj1+6eGUv22l5xf8tNk5wpuAAqYS5GDjnTtL346cPrm/y7Jo7QERkB5Q4KM3N0Fowfv9I/T4UNMpzBpaQ703AMHPZFDONeJsmLHZOkIeGc1o7J2usUO385PLQpv3FomVDBd/gc/u5TVtFWqMzNT01BfeV99uezVn1qgLBPwmyK9+QwC1XroipGlkTBQ/Z1r6XgSjTUql97WhCm4FkUrk05Gt7O0pl95GGwtat0d4K69TnTy/w7PsFfiOqwMkrMer1en65F04h9360WZ88mTJ3gxhGpM/eElF/9/Oblqx9XrWkAhPHTq58u3/x4vfqva/Be+dNPhmhEuToitpIM7Av3tDD9EvSCQaE7WyzPHzx89PjJ00iB19pnCVuHHIGdpL+PiSJI70JMsFfU2bIB3d0kmhSi1wEasu5M57c3+z0tzETMLv0ZpmPWuORCdXOjTnzXrBNE9NrZXjk6vMN+Yzej9mgNZr+hEqaPqlqF2aKBBVN4+wKGdkBXJ+fPWYW9NEJs+2717NRoP9O6ufOe/ZZAuSR7uzX9qeKrqVXZW75nIQ8d5V4PTg2ZX1eqCg6xwyLEfr93rXu/j6e49vt9aLUujEecc9Sn9/u93khKKpWd6x2RCgwqELpP4T1U589tE60Bv6t+fjZK2f/+B3cUxV6T4y72bKtbecvhklHqmHjlJ3JynG3ENz//6Py+JluwNAb68o/XJk5D37y6un7zHpNeQiVKlTkCnvOaaVZzIannwsFk5RF3XziwRh9z8KYvrAgtyY6p+aFtgA2320i7mzCzMw3DboTSQFgISkrCiXJ7LmZdu7RtqZyVou2Eol7ui5+v/nj9zr/i/AV48m8/b4w6BMdloIu9U4IbdhEyMlx8CtGbMZd083srmmjRerqUQik7z/fQmuxYKficlQJEqQMvK3u5kbzlvT2cjEjIFTSX85x/cWazXulDQy1lz4dH0pbRnX00rPBPC5hmB9HZy+BAflvDs1TWC1GKakQCZUYZFSiXSvu1F7WxAkGl8kwtSeU5O3GxdEW7Rhwc01ItWQmFyqq8UgSKg1WUZJHaC7lVHSmpz9L5TsH98JhWVGvGaxUK7/X1h8vZqzcvMQ0hPl4/97gjMWzGQR9PtcdfffWI/frQ/E7FgrpTXcJAYe2WGenYzDQaKJs9qWsqZz2L0mTPqkEM7i7ieSdFR6VmtuW42izD23WbrudMh3rn3X1NRh/icc3KXTVlysZ4NN2hleOvt7bBIm1G9yyUHlB53h3gQHGeZ7bbePPq5fX7D3PGbX/zqWcSPlESGgsXFc39NwMgRlJuSU3jm1h+ZlIewAORsVXO+a6VJdQ8NWihc+PRujnSN3jYpzATZB8gad/Oh3M13I+NKEgzJ4rcz22BIQTqBy3e29u94DXeUavFAnPZdbn17mH7rrWYt6JylOpbW/+Lvs66Toq17wvhqXbc86FvzWL6jLvFX7zP35s5yP/+B397lx0V/ldSyP8r6Un/V9pTu6WpzO4HwdVOAX0GM1vgz9cQ48nV2cnlNfqFtnNy/ecPJ4GYP/4cafttScxvI+N6bce4btBz3SFyNZKI38widwlta4PlGlFHRjQVYiSrGSdNRFxVdwyKXBKJmCLSRnuIzB4F1ziIxqnXLfZm24VlXPO1zGdmva0hS35/9f7q5+vfZ/A9o9A9eNStu8eNtsTDh99ngrYDdmZtxNyHRy9I160u+eFKcE5LfWovVKHtadcQr4CeSlebZ+A6n5/CzONkWUAqTpZFZm9qzxkv501PcIxgTW0/+HUEnsGillXjW6VPNb3XduxcZcfjOHW1ftY427HTxh3JhdZxdB023gAD/ubPrP8z+LW1d07Ksio85arbnJRb18NYvRiR72G8fZt01XNSVZIqVQixdXzrn4xHykZPaqQ/kZo1dEsP5YZ4nxjxFWROGkaUj61pZrDbbrQuIZVPKifNQTGVi84k1Pnldd8QOSsbFntQpz655HQVUzbZl13X0BfPEU3VVosOAaIvnAJF4IrgmX2XMEyTrtvRg5BBuSOdzr05f+VilCXq5NwVO6X2XMN4oP2rOS2BqM29I1pPdP7Jqc5eEE3eWrsMU9v+SA8q8+4ugF53+YbBWq4DROs63XkZckiLvg0jKem18D2kZYRoXP7ufQR7hbtuYCWtKNeMeL/3lXuKK7Gj0gX83Es661hHrc1tyDiDOzvSD2JLedRz5gUpaDNgXVY5el7a3jLwgfX99LwgFZG17zsNq2gNC5QR2vpnfoZQtclxfQQAZykA9gNrkXdWHQnQdtGDTz+oMbH+FExvRM8r79y4RDQ9bdl95vNtfiA+wMjFOwihlZak86KEFo7Ym9mDUXIQ776ecECQ69Qth7LfsF6oJOWWalxW9mIvuEDGe+rLLaoroGxFKosk6iiA3zJN44vFKMZuMTsm3LBTKFXDGPVJYVZvUg6lzftrux2VCm6OWntRvPIFDaQLdTBqUFpRPi/d0zUGQ9hD1TN7CiKgdprrWZQx5dPMP1uqCWz4umOb8OG8MAMtn0q6YyalrsmWpCDNTBFeFeLeQ74SADVrfa8MrPfDvRfOiaM6uKybiwGbDXk0+5mAvXfXH5dEE18+ZTkrCPeqBGJDKy2p9E/nx5VHua6d4DXOt7Udo5xyNrebzMjd8DDl9Ozad5NWObLQlrM1DQiTZUNLlqXcfM0kLYiic/fVj1h1gx9LhLoZcRtlwM3Ij+sGALmZDDVUUw8pFepu2ZQF8wXRiHquhZclSOiR3HXBliwFMVO4GKmoSHnALC0b1hKN2iAGE49il/BgOZoFKnFjXNPIbZlGnZJB1IZ1sWVHJALMVUCxXlOaNDULmbEVl7FgXNsvgvjOyE0MzLOLmdN2gpsp3oDNIq987XOM/eoIyh4Hj6a1ZkJgKgXNXlz/KX/984vrFK3ozkwmfUp4RbJIug7VzynmyYtAxXGHjbzePo+f3B5AGabtw241K37YJqk1HkzF+cyahmR2achu2963TdCEnMeaaFUcsuEkNnWlO5g/j1zLRvSVP0uirRLgtNXUS/JNcK+I5E5tnvI/UE2Oug6i2xLZkrm9Vw4q1BHHO3XEQScOHevM37D8sk6x32dOYVCZew2TD6I3+TTIYqUl67zxJm7e4Hogkmc1zNSz4ULElJ90HSLJ2DESVMQROqhd/nPtHlJ9IwKjJSljxmgpmtCyxJbRstc6KBil+DTjRLOdH42ErMSOTFSw0MZ3VJI6ZYIwwzYN6uo6wgORBYo2CQ3dkq9m0aX1JB4t3eqWZdwwHyvYgFWBF3N67zkXWFUdHqCDylgqN4K52VupVCnaAuWFUqbjc96v3v/JoU4v0KR2AXvp1eirP7230E75J+o3KyJ1biYBmWO1f7rOybWaKqwrGjL03FVx7p723ISle1foFe1Mr+VpyitEkkJozzbikO1I05tJQxANME4qAEYTGrCzYY2p6M4lAD4dX5rW74ajcEWK43afqRRhQlAJ9yj9c+sGA0tmmA7qmONHqbBwRWgr+AhuiCQ72mSk64aSvLZjOZwDfgtj7i0wHAMGuCrOAyopnFbNqUaIoiXiYlZbNnJdIe4xPSdaywSItdch6fKedVG5QozthqreVai+bQ+esv1LdeCkFZXbWjE6SKdsYLu5gIZEWtcuJ2hDlGZlQQksGm89Wrhn6Z7snsnc90a0JU5zBWpeodWBBIndJ+xWh+AFhYUIx3X6MLPHUN1GkWItRWSOehGHNH1JeYB2/jlzO+GBVwmLJ72GregO03Oo6xihjejcRPiYyyCGirnVAWBiA4hsEusgvYN4/JgCtLSLyYEZ+pWi6uMaVQoN/A7SbNkkNvj0RGC0HzXgoAdFbwiGUKlwgAYx2H0+z/oZmeddT0v5Lnj5iyXCUVngVCXK2BFQZZV/7XMYuvbYsCyPmj/Ffb9nvIKC+CDfIaGdRyQAre6CwE5SpYRpsiG7eu4W+OkuzlzoPfVPWTLVOobF5RZ6D1adjtZUcuIGmMCZESZB3oAq8DysIHjcqgjFCP8gRPPcHl5QqWwznBVDF2ljWxN7QZafU63J1rVC0MwkJVV4i4BsqeS0CfjL51ev/KbmfF10kq7tq8INZ5ZyVREu4KnjeovhtXTKZtS8B+wxRXzNOHy1c+Y2KKWL1s1JXUGumdooCXdsWfZe9xItx60bUnpiS584kt7fsGKwGLxuhAgEqojrRuxRZ7xubH+wFlxjRQp4WLaftcRMrpWOtXMtRFVKpplLi+h8ILl1jbKOgKQUA7bVBL1qLeSeSFs91jL4U3Yy4nDd+ecMrY+vdYffRHdw5NDRn3rhKum652Vcil73ykxJq4rywIchsK4K5ltNDVZEGcx38t0yvn1tNzjMczSDqWkbJvM1dZuHhgrOqqMBDL2ZW5oW0nvrOqq1mOEuoV5bY/Es5cI715ty1L/Vm5I5QritvXTvrzaz++E7MD2TdC+ZpmE/ECUD7xLaRTK35wjI1c+vX7/6kF+/ePXh9fsfp7YTDVtRazDAkNCX1x+ufsrhEkMPJcyGkioyQmxRrJYlXdeY3qHczFpVDxxL0bZMTzjAIUdrQjB0kXQWZU44WpkTDl2vpvzbpj7pUFK2m3DpSIhmIumDVAdrDcetRZZyYxsZi7urW1Iw9IwGsZdKJFxSOIAkJQTIWIZBwONRPLOXFkw4S9oKnPaRS2b3Wb/qYSLtU74GCRFwXxfKBg9AdsVFa+NkOFrNkveHKFIuzYjjeTD5+l9686++9De8L3gJs9Ka6WVIfS5pQ1FVHlcse6NYI+q57wOZTjuBYIfl6Ffv3/9ynftLiJ2pmHd8+8vNTf7u+j9/uX7/4ZifvZBbM7qprGgI34Yxc+RcsuNucX77BT9WlT7q7j6U9wX3HeXHnbmo6J067u5vEEAeUlM4txlqSnUA+dWggAyM6XK7+pSCf/HsNhCUBjkNKRA5K9lcrNc4bQ4dIRk2ymtIkTGl+vidMYWdWiprmrvPbU17kaLXdNaSDseETQBrpu3NNZbjovVvz/uuxqSWvdJVMa87l3+iYq5ZiIbwGr+NtWMBJcEBrmmg8hf3eBh3B/qBlsRvUVkSw5l9DOyxnKMmastJS+OMo5Z4flLL3qsAhnJytbcnqHvWpAvz9Y4FbWWvjc6becYR1lBhQ9zIZq9/8/rahjYtnAcDE/lDJBleFgJfbq0oLLZiMPp0Yl25bGqnaniuYlJpP/Zt6mxTu8Rv6swZgynP2/XzuCoWoJ67NaNNDfR8IDUHo4AdacJ+1wYbTXhmjhoNSoditU+CcusmQOEYQu+62aDO0ZRL0CJxIcEWdDRY7VxUyq95bZRvUhud75WM6XaqMLZmCszMrwkEIM6pA9QSWYoEmj+//GMK+C1ADCxSxK8oJl+dTAHfa6EvUYbpfPp1ygRBrwpAlnB5nEUGaBRTrtLEDV/w55sXQ36ZALan/OnDSx95LUXvzSBb/xybGwdmFrPDnSqJeeqAmIMWyBIuD1MKj/iy1nImSO9mzhttb/0Bulcbe34auEMn9IYq5jLw1dW1vYSSaVsHnTXxnFXBTjYQc9MlTRnSDhzAtnfPPhNZBetZP08GD3Zlf8hnsDAAp6dzuy/ct2rut/ysR7tfKAfiRHeA+x/Cbk4+Ha/pJNzn7+esUtMO9psnR8OlDmGhe4AzmJISyfBrVrJXm9ya/DPsnfJSVOPkuhEiwTZad26gRJIZN/NOE+Vbv5/11u6I5C+cLWcixd7TniQuQKhcW6bKNCAecTGQ+uJk576NlcCSdg10jwO451fJzmLqrErRUWUfR8r1PdN0kKXqU/PiWKmZ0XUA9ewFVazmw6q1Kwce99Zal8ohLshHIStYp0tTEqzM/3H5T8Mw3uX8qMuDoy4Pj7o8Oury+JhLAp/FKpBYWBsEr4KiwdKSrrdibSek0yt8f+av47R0BZd6SRHY+2Q3k/F1098nCowzK5/DJZjSy1QhFrBKT5lgBNBtiMQuD+4wR6tgw8K4prKTQpWEzx46aYIzfySAdQde2L6pE8xbKjBpv/oWkiqLfMD7BCshdYxNacKLvgkj/h3ZkVkwkQrKF8DO/CkAmaM+fz5EteqObg9NM0NbGg7xNksO43DPg9P0PBtSQfkujY4Gm7I7UShH0DxqOncddUnt/JM1bgvRrYHfqYKSXrP1wYtSJbJFMBxywAtjd+nS/J2qNPQFjlu3IXFqky7KWyC4NpgJ0myNu+u7g6Yyc8+cC00LIbb5cOfwP3qlr7yhyLYq7h3hAbp7YHM+TKK29OCfKhAhtz0T6v6WuV2trZllUzAn6qNW6NHBJDXC2y2afHrYjmlDdMC7dItWVMj2FPHOw8AOc9sXFC8ANoRXqiQd2sREUETgjsbRzmxDlM7BYsAOlBakZHuASuxZ6XxTxmcV7dTMHYKwyJqwpvdTBEC6pq+ZN8kDxAxGSbNtqFIbp101tc7DHKmpnXJnCPNSiPGvwwjadvVHo+bhbNTcH3gr+sq51HCDTZwnNfBdghrTLv1wf63T7G5+vrq88UfLnBIPVBZJ1PyBp6TrEOveGSFhUMV9cNhdNcRsbxd0HVD7Z1DLo4YJVB5fKxro3rz/eUelZK6tND2BntQ1ScOKnSM5yexNvXwtUN3oOfEfickMM/M7MSFJcZrbHPh9bk1bbD46u5GWlMIBpKZcC7CHw31mS2ouGkYSJvOjhbSf23COrEmMlA3Qki7QLi0tgYvsCC/pkF86QG7hayyMo7V4u9DUkdqPv60T5w5Jts4AxH0pytNh0x6WVdyxoVBVWyobV1ShQSXDQ7Bv9Rx1Zwfn2Ky0XUvYrnMuogobB62oWmfeY8kAB82xFbwWcX+0Fd6GtRWwy4bpxCFbM0nX4j6DWobGj7azxi6t9BvoVIaBtnWmO6068LjB2uq7eWjjba/92NDueKZZy3g9XJsxLntJ4MsksMg3c9z8zikY7Z7uSJN0j+1efRogh+6AzQ7ag/oU1yCAS/xzgi1mw1SLEy4G/nasRgZgvJjhZSde2I3J0Fh44aymnDv1OWCo/cYbG3DqUsbdYjevpdguM3iE3ORJD8gZvyO56ZgRG+JNe0suZqovGtbSmbOcc3BFEzWE22/fdoPMERUNNrmGaQXHuSUqqmhc7OXCakSOCRuz3G8R8q71zwBkhAt+aEWvZmXDZq4ZxMrHuxZH2fkuiMvkPWHEMZqxZRUaM7myvSXXO5X7IzbB4ov3NfWFBKTLJ4UtUXnvi8kZWPFdm6WnHOf8UOb2nkrPOgdRdjOrlVt2M2sPs8/KWeL7VQvRVIqzrqNuWDY8HBy2XGLhKyQpG5rfSZr3itSuDgpZz1gFC1Bxy1ZI2zyFq3BCWaVKaL+QatQBu0sWCrJzG+UdKTGdBQLUC+wEOeYYJj219TlrSfgNVhSd6fB1puzxTPhy9Lxs7pxbmw/3YzsiTYjGS1QqEDSSblEoXJOLGeQruOi4BRv0gM51/W9fvHT82j1xX9G5reyOdk8cIdeeaApJ91ngNKu8at6tbQF0NRwoO3dMxWLf0dXx7WrcfQGXtFA/6+s2po6xQOO2DV8ZdUTuRhhLogbkgGAFZfhBRGi2DgeQvaV7t+lUR2Pfb3gtZDu3d6LHFJpcmCVRwmloSVXf6DQtSfqxefHI3rjb1mGo7bbMP13euxSlymjXkJJuot1a15BDLUXvzDS71m3Wda0H8MSnc3pkJ+oatxmhdKlUHHg7e4+pI33pxy1pfyzC6/GdpGZS7WmtWWID6aEoyLEhPoz4rItYMKpGGI57x0KFlQyWLGN9lGLe+6XCTooSaV8D6zV8RMwMgEHxwTbEjp4F1TjkoTtGf5/yGWawdLsqp/D7AvgzOj45UDM6KWA1r/fsIa3mMrRT5cw/DJFjBasbNUL1KWSHbz5+g9ZtOHrnvmlI10mxi7O1rjed/gy00+DNQE6A79H2VZw2dC7ig/N/qOguyeEDmo93h44F0m9bmpm4mQxGTentQW98NgI5o7WbJTk+eWcLJe0UoDRnDn3cU/wE3zCPzdzxviFbVmm/SfbpE7VbTcBJsqUfiHJmAu9I1yW7O+7k91wSu0UpC8p3s5q2yo+nFsHplYUzjXo3PKn37oWvtrJSH2jbvWS+8MMtLmG2KSmp9IYmx40kLXyCDHXuSHt/arBfw4B7S1qVIWDFVNmwJD8lNWMG9XR/78pVUrp1BGygxhYhqZn+BG+t0HQGmjryMdD6JO1EWNTC/kwXARfsBHH2MJ7NmETExusbMtz/Mk/vY5lLUW6ppt643DRTXIVl13qL6He4VzHMHXRHLlynl7gay2AkBlTu1QYHHXg5sx8HiEAe6yTinTitnPi8vFMjjI6hvnUrtbIvRCli/Xd8rkUlMHhw9TTySS3tG40OY8ugb6rzAKpzax8db92Zq3M/QVOENX75TxGl8GwceOh5gqiSNDC5MNWSl77btDAuYkDWrY4NGHRuMDAIrGI1n1dFw9wcQpWSdD68pNTfAqJK2WvG2We06qbKUdpoA7f15/H6nbmiLek2cMjLU3FYm3SMbjvqZXDFREMKhVw/9bQx6XEJhG2JJuyN+qErYZIlHg+m/rPBEmvAhay95T8c/JnLsLgQ7Wwnfd9V2ob4ij/4msE3+NsrI89+Q92Nx2tSUhfJfcigI0HN+817Nld9R+WHQwc9vCaMh8z+5oBhNh7CSNgOM13SBen1ZvXy1bvr55fvr/P311fvrj9Yzxv3SKurvUle0lmYfzncl3DYXbb3I/v1MtUQvcHVsuHu2WODBtWSptGk2c6Vdi1Xtazxy9Kq7dWG6Rluofxg+2wl1pqhM/uwZxQOaqiOtESZhuoWllTHOPIrGa/hEIjjDxXssoR+VHWHhP3U+Gc4u21oZ6KiPsW2CuQ5otMMlWVmRmGnfRrW36QUANtqPPL+3dWrNy9/tq4++9UmXABhaD9bUH56bAh32UUu3R0SgNmN9c+0ysPav4JjufHuHbVxd+XA4eJe09zeAvVlV6OyBR/ofqvIDn3I1IdUJOxLpNBfhlgn2W4KG3scxWigoTfMU6692QEGEklbLvZ5HKBT6C8JxvMwpKeQC5qokkqTcjvbC7kNvPYUVVqiMUOzctvg5qUPjenBu3Vkkc0Y8IPjIQHzLTnyUXsxYOqFqc1sQ9TW9AtxxHCLZXXf4JOKYQ0NtySHhW1ejDaw2+lj6ws8oqu+7CX71BNJuGb+MJTqK5ETZT82m6sejGLWvU8W3ztCJPdOhfulDEGaZrYvzYRHBYxyHUwRDG9cA6P96qNnZgVRNJuA0Dbyjs+CJbbxtC/9WUm1w6uDyqV470pyz9Y60WwASQd4g7g1QrV3b+rHU7y8/P7Ay1cvIoliPXC9iecX1EFp6pbqNCk3bCtaEsQEEzJ3C5R5hl7R0K5X1ETWTj/TpeAuyy0Jv7FC63ioVVPSlkwf4i13W9dago5kiCxQDdF0lp5uCuaa0ZeQRB6Y9sciNJU8LnxaDtVSUwsJfIeiyuLeOtJ4j3gwmhvRvRx60mtrZAIXv8G3ZxP3bMB6CwdvyRLao+kHCqXCQDboFzS9j6cgNb3vSOWPEml8BYZLjqN3xM2sdGoxrX05bvrW7bHrTW/mXQWTTlvXbT5YKggRhjJqu9xVYBUQKe4c2d+j9AvR+MquAqKybtO9PlzGm6RGaNlLGQ6qaHcaVfsFdLiHi1GuVd71so5ngz5IP23Whsoi6F8mpXcsmCgMrvKMbGh6EfoL4vFFoMM7PiyK+m3d14VwK+56h1fntX+1+yxBrV986+E82t3tiF3jRl30jtSmP8W0u2rSr8LtqCy82buhZYm40Cslhbar6b2G2YEv8R1r5/ZsV2DTHZ0da4PP0D7izumu3RMZLsHEl2EeuyMzmHo7PqYotibntNbdYHLvHBrS83IzgkfXbwaHte5GoLXsGqCoLe56ChZaWVhE3p+7vNgTpresiUcJ90SXm5ZwVOQA2W54Twv/nFkdctY5m8k9LexFp2ghee9P4BtiBqpJRsqWzsqNmfrzmn7ZNav0+jDy0nUNHGGaKabpjCglShbvkBj5DDujs5bKckO4ntlr8b4YVG0kGafOvGDDOM5t5OyuowoZEhxK0lRkN0ZlNQX7YsOY2rVDrHJtKoVmnWhYeQjtFLl6I1oE1ZSPU7sRBRljSkdTlCmHyRy527t1wQE26XlLD3CR0UTSXT+DENGZpM/Gd4gM/AhZD+FOuA4WYZI2gnhxY0czC5n5IX/orKhRG/Vknivd85mfcyBc+/P4A+yz4CN8J8ZlZC+Br93UfV9TPdt4ld9wrlPbb5h2yxWWb/N47dS+dXXP6Mkb6vSooDW7DqKblc3oqiiDji/7iWhA9vuclI2nPXnvbpkKm/Z/Ts2x70sYpol0WuCf3TU1lrsPCwL3jDP/qvfYRvLemXH5RZE/h0UbC7v7Pt1Ft20T7kU8EBlu4wa6c5EeiOQzM3eoQyoNVDaUjK/OLVtrmg8GQX5P4MBoE49yH9JzsJ/NVLfq227mloLddQ+zh/PHc3vc4DPt1Vz5jYbP/tidv8XyM16L/TxYZPmsNn6w+hzU4M99jyZYlrMM3OJ5lljzn/kVgDPrCGk6A4X8DJYizh7A70P4fQS/j+EX9mDPnsJvvKrzzFs0wc3g9npwe23oIjnQsUhSsfCpWPiNhYVfOFn4ucICTxYWaLYQ7h9f+ExbnNnf2bohnNMmqImLM+cSnjaJ/mFl2xdfWMxCy3P3CAldnodorRvk0wLyaQH5tIB8WkA+LZ7a36fWGnnx9OnCE0tPnHvigSceeuKRJx574okn7FV+i3Bt6sLW8sU9JB9Sv/SJXvpMXfq0L+1BtqyUlGjqB4Llmf31j/AM4Q3tysXT8+LzIuFt6VgW0a6MDJ05wodbIPkLJH8xkL9I5S+Q/AWSv/Dyl/6J5C+R/CWuWoEPMpdI/hLJX3r55/6J5J8j+ecD+eep/HMk/xzJP/fyH/gnkv8AyX8wkP8glf8AyX+A5D/w8h/6J5L/EMl/OJD/MJX/EMl/iOQ/9PIf+SeS/wjJfzSQ/yiV/wjJf4TkP/LyH/snkv8YyX88kP84lf8YyX+M5D/28p/4J5L/BMl/MpD/JJX/BMl/guQ/8fKf+ieS/xTJfzqQ/zSV/xTJf4rkP3XyF2f+GeUvUPtdnKXyF2n7XaD2u0Dtd+Hb72Lhn0g+ar+LxUB+2n4XqP0uUPtd+Pa78OFQ+12g9rsYtN9F2n4XqP0uUPtd+Pa7OPdPJB+138Wg/S7S9rtA7XeB2u/Ct9/FA/9E8lH7XQza7yJtvwvUfheo/S58+1089E8kH7XfxaD9LtL2u0Dtd4Ha78K338Uj/0TyUftdDNrvIm2/C9R+F6j9Lnz7XTz2TyQftd/FoP0u0va7QO13gdrvwrffxRP/RPJR+10M2u8ibb8L1H4XqP0ufPtdPPVPJB+138Wg/S7S9rtA7XeB2u/Ct18/HC9R+12i9rsctN9l2n6XqP0uUftd+va7XPgnko/a73LQfpdp+12i9rtE7Xfp2+/Sh0Ptd4na73LQfpdp+12i9rtE7Xfp2+/y3D8tYF/HCrNOtgHaZmIrs61ytmLY4gP9fdltuvYQ1VkIHpS+8zP7ax8QzTlEc279QTTnEM05RHMO0ZxDNOcQzTlEcy6rjkg734BAD3wUD87sr3ss7OPcPh64xzx8VeKB9QCJeGB9WU+QiAeQiAeQiAeQiAeQCHB86KN8eGZ/7QMEPgSBD0HgQxD40IYBgQ9B4EMQ+BAEAvzIC3wEkh6BpEcg6RFIegSSHoGkRzYISHoEkh6BJAAee0mPQdJjkPQYJD0GSY9B0mOQ9BgkPbYBQdJjKwmqDABPvLwnIO8JyHsC8p6AvCcg7wnIewLynoC8JzY4yLM/XtJTkPQUJD0FSU9B0lOQ9BQkPQVJT0HSU5D0FIQ8y4K2/izzU8VnWTh18izWv2fG2VLgDOS/mx/7fciv/VFd3t7GeVYOP8nUK89DYnK0pZjncG9iOAKe5/ikTZ7b/alQDw3AdJ67SXGev768+vn9ny3dEsaRU9eSPM8HH8qxrKRwWMpH8v4/bywB93S5nM/dlyJQutEnYQObRTKPZNlFGi4SL91yAYL8klN+2evNFVwN84tsLqyvvfs8sGEKYlfBgEB54b9pkRfuY9mW8RfL5ehLQSjDSwLXRjXWJhpYxivm1jbysumVpjLx0qI8cBYk96pxrL/KGdhwBMZSyXWBeVVEMfDdnYJIWGQDJP0IWA5md5Rn6VfT8hcHTq7My1zb4ykJkI0Rqtgr+81+4iyLckiUfVnat3YhG87PW2zdwSXlmHZeJKm90Xq+7nnpl588Q1VkdeKowz5DvnlIXDpZzRl4o/e07DWdKdH0oVIwXmae8PdQeTpxUJ5z91yNmow7g+Voe6MgMA05iN6uT3k6SxjSNA0rlL+nIeBhe2Ho0Csq4fRZcBB1FohwkUY9gOZjKMcQlNhshMxHCA6lApFFapwENZEGNZEIZWKYD4E0WWqcLjVI2M3bn96+/q/LF69fvbHJammb+4/ABYb0WriW5YxogtNayFZBHx2dWvewZ+zfo8/OjcDXr3/68OHti+co8BEPvht0agqmUeXidK9w78f9bVyWyhBZ7WELy62p5lzsRBap0TfTcneABj6Fb0VGpWnAWjndtobK5/uKrkN+Jds9yQJJKpEwCnF2hd7T3gEWR6Vn7u0Y83an8+uwbQeQ8jcEAhUTEFfRw3CjPjV+jHF2nDnYyMVAHyhpr9x6cR5sCsJ9JkDYaPWGtj677W64o9su31sF2NP+couPtLjsbBmbAcqNMb/YmzjfwWfsc7CPtpJ2moUh0dGJg0sycPaolKejtwJ5CpXeM0GqrWOV67JS5147C7Hj7tVur9QX3Nfd+Zmk9cgDGAoeQek9vQBI2vuFgC7tYq+n49swvo5aggNEivj+wNExbLfTmE4cMqQ8COlPEEy7qrEz5NsYdwe1voCnKQo5kqCwhz+S4dEoIR6JBta3VUfb1/14/Tz3H4LM97QgYLDr2I7iVhrZofPwkHy+34PhUo72aC7ho5rwc/KwDF+iInN3+pos6bLulnKZha9Kkgd3WZ2d5+f5Yv7jpZD1XLJysyYlVXMJJv9bpqGs528J43r5Inyb8MXlh8vMy1Ag43z+knHSGDHkjtw/uFPrYCA8/0VRGQLzjH9ZQBbSkYV02K80l0plBVGszEGboWp+b6AXlx+eW2l5TXq3505sbviHb9YkdrOk8I9wezspSvdwGxikKCv/XCztfPWy8JmaEDNrNQt0HFeAza0TBPwl+uoxiYP4xIC+rTGd+LKfdIivVvTWHAkI5NO+U0kq2rKExn4sohwTvglk9IdOE17SPN36BMUiECJSWKjfvEq1lcjZHb3IZ5EdisFe54kgP8CnV4Whe8IcGfe0nVKUiskHGoFDreVgqkZFDqcqqmiXwL+gnNFqKBDsfmgVAVawxo2MFkgiSTNFeEtJG8Nb903FbAIyneRR3N4ujD/r+3Vf7jIFZ/f3df9Wtbvz5W9mW1WYKrrPrCAyySfhbzX0dJjqJ8A4jIWd0j4CmzHqO8ME7A5jTBZjTE3ITN4vU2ZuhBE4GTLkR++B96wH0MgvcRcROdZdIuK/Y4PpUdD4rWvPpzmnhpmmBvmF257jU+9JTqo0E5Vf3Ax8bLrJN3g8nyXMsEqoI3VCTVYKNV0r1GS1UFP1Qk1VDHWkZqhR1VDjuoGP7JCy1Dl+Rce5PNgQX7Qb6k6KkVLN4lgQ70R3ZKaoaOEz337T2jnkw0DjjlAHNcXRTCD3S4PRF/7zLe/AbgNsRfEEDkLS9lNk0AFezztzFIVG5FL3fsHD09mzjPQV0/YS+SmXmyDWw+EACsLiPYQYFLxiOPOQw5rVwXZ95OJsr16jy1SQH38rC4KcIQpGpl7IfrHhHXwpkkpaua9FD72tKRhDj+DmsCeHARiXxEYgGFiPXbqJ9G+07owKQge4tylNIE1rmz+1JN0w6jvRiC0bZlnDPvXMG/JjXNR+cS1Fa2d8O0AZr6/Q0B/cWtJ1sblFOF5zg9BOipbqDe2HDtJ+Y2+EfqW43DHYy+Rq7cRdiWZ33F2VG1r1Da20P3KMHV0zGsKbXldiz4cwnND6SIt1I/ZDNyXGyPsj4jXRTOlx3sUjZQjUG0lJNVGtxlXqWGOfbOrjhj7RzI808mNN/OsNfPQew8Y9kfxvatiTzXqiUddE0z052IuyU98Trf1YW59s6dPtfHNQWrL7udKSkjZxGnUAX2z+U41/uulPNfypZn+80VtbO7/2jeCJnmCqHzjSC0z1AV/pAb7c/r/c+r/Q9idb/mS7P97qh23+WIs/0t4nWvuRtj6qVOmQr0atSg2blZqo3GqqnqjJMlaTWaNQwuw8rRqpRFV+52dCpEJ6WuUuqLNM0KwuK9Lpq9fv3Ypgt+kudozuV9kpPBq6o9ZQ9ysesYb4Na/++kRSlVHDq8rGXTBJKvdueIZaVUGhryqkGFZVXrpb7zydhMobxrcJMsqwam0t/ElVcbp3KaveiIremHbiDl+TqhI8EEl4X/2qqnPnPOGL+F1zCLRSiAy7iphPJOLP6V9a9rkQ2/9Yfnw+hq7jPVDI4Vv9ZXtV2XuhEPhx+R/Px9A3RXTUX4zIvSD1eaJFLMK1ioHhewgZWB/uGa/EHj4XrfyBPVLd9bzUKjsnT56eLZ6cO+Gte8z88jepWpy7bZhbVm2Ye1my8bSfZVVtrHatn0Ia6uApN8mqWjSzcsv2bqEd2mBv7/v1orJ1uY03MRhgsKVIqjb316Z7OnW1+9+wzWWLIDQJTJw40yDLoPCMz1KfM3JH7lESGZ9dvvnw6sefkQ9pL113XK83n8NMGKACy4u5bBjBlXA9nwe0FChsPBlmeaPJhIE2QdJEejRDkPuWZ+RIr4X7ANrAxd3+MUCtBjQA0fXRFlwLoamcD7I17EYPHTYUrjkcoKiLDuyEn3TtFlBuvykSmLJVkRfVlnw+DIO4DT/HoFyEL9silpVRubOIUKMEmJaactmAdZ92I1XbobS6M2qOuasDMw9VGk3ih/31BEtUlzD3kXMfencMqpLhJEHk5uiT0W6HjGCmaRAjIk3tjpVj7jEdqy/qaiyTVGPc+zgudUf3lFvgTmEaObjbVx2zQ0nDpY9u/AvDdMKcIw6lLPR8cYEJaJW+gJIob/eChJKMNQRRJ+cF9H8IQldIOgCfObHQlMHB2GV+1CWfcEEmCAM4GiKMHI6GmIrBtnC/oggOUwkdbBogLB/6CwvWGBi0kSzt7bOpzic73gVlU+3OgtmUkPw4OCkkGR09eDMh42ZKhO3EsyGAevUsHoZLMDMGpX1fgg4jKnHobugKBllmqFF9XVOFysRdx+WYQS/jgaQbi999H/VwwSmxUXFOYs8bQar0Rc10xe3uWmCi1looqW4TVdhadg1CwmCZxvjy6o+JfsN4VHky94APnbozZu5gbni1UnAOq7YqI6qLbPq2f4XI+1Tm/V8vtNvgdCa58UWRf4NXHYjoO6gCvzX8b8yaoZCYit8g4W+QmUaES8O3h7cBflsuxrC/5eVd6KOpZg0dIyqFklUyi4iWptyw0wo2jn4tEaL5C/ZQIZ1mYqISwCQtdyrTjB/ytqSTYDZCp3x6j1Z32HKxb2hV06xSbS2t7Uv2oxR999rduO+K60v+f1FUDryHgSxhprrJwbg2OaJN9MsWQkrjYO8vhZohdjeWlWR2sguIEKuhXUYkS3wIPmAn3kRlA3ZK3zqqbh3VtqaVrWO61jFV65imFfGp9ExoYHhxLPJpGVpsakB2LhPlDrfmZ0N+ormAw3LKJd5wM4VlCYiNNUc+p2X7IF90nU7Y60scUUsQ9/b15WSQlkzCosnRVzs8KDVpStE0tATt4mK92mjd/UuW3d/fn+oVmgFl3iLNWyVbFH0u1gLeBGS4/MLcHRHUNYOkvaHtcMuDUWmSy+q+wtxBDT2Mu8JRjzfV61ts0MvDF0isjp9k2I7RvcrIHbl31s1t11BNwX8WF26yPUXa6FmkEPkkkk8DuYjUoJ9YRHn2hKcj4xxy8TBKjz6WAznLZIoKXIZYnAtL5DA5Ji0n++Zw1thzjxMmcXqSMInT04TBTouzhEmcFgmTOC0T7hxxKJA9sxXvvrdU9Ht+/iSm+UGk/GccLBf9P3iA5jMP8sS8yUKlaASqxg8jFcGYg4/RGz5GBf74cfSDUvgE0fY4FfRTz6JoROaRQuDZA0Q/RDSNyx75ApFnmHma3/VNHDNza2YyqDEOVSPYrmKPYdxR51PT5ty06BG0o1KP0Kbo2zHYVKOZaZ6szQKXNBdAsgE7TGvApoRPNjLrkupECBv5VoopPY0upuHlNHw+DT8YwXsix7ldkHJLeZUCfYf5ai9kNQ7Hw3ZQ5Cd8jWMcWNM5UKMyK7aIFkRWA3YUWtjvmA5xVPNLMnZFFrQWQPGUlCshGa9Hodq6wu0ILzW782oJ340EiLYjpa6KsQOsy4zRZHcgn1rSylHvlQ+2DxyPC8sjo7JBGQDXtg+dC0S7lZqhF/jUz0Ruu08cB2bkzlACK7EftZipamOwfM1kO+nQGb116IBKB9l7AB+O5TlWyL4dZVFNlfsqpuPNlGvsq6dKDzczjcOGNqioJmahOWv9ESTP162oxr5Egash8EvEJ1PVfLLHgoMiQ6yT47JB6mXeTJVNQ9ejsrFXzw1BMbHxM1ghnVwbzQdzNsePZyDOYTwBydNZXj41y7NgGst4uwkWr4dYS/ArGG7KR6Km5oOpVt7SihHMwkfjRnL+P9bevjluHMkb/CwbdzNxt89TRUtyt3vmwuGQJbmtXsvWWuru2Sc2ogIkUSyoSIIGwHrxH/3ZLwBkAgmQpbZn9g+pMn9IgCAIgnjJF96PKTeV0NoFn8rx44rtmGEKw894OEYlIxg3iq8pP1JmnzA65fLLWmzm0GzVy15rMrLRGe9K9i042QZ+mJ17DOnLkm5gr+Z2rlcDUyb5dmGcJOSOdgE2yeRjSOdwRWnK1OuJLO/rmQ/KIKrpezJ0LgDhBCZPCHwn5hKynd6wHGznm8F9DMsJntwVbSjFmo79SIGodQyArGamgopHVYXIawrMfL59rBDCS+NM0XIx5xM4AzE8PXB+sUsAzlS1mWRy6EoM8wkz3cIvlSlvZptUczNOS92Qc+fVg2huu5kvlha0gS2nzfTzqg1brykrk2plVgkAjkmWcaAvhTOfzXKYevqQ0At15Fpm+JyU80BNIXIs5J0h5JkknfeEeLeELSg/aV9DTmtX49x3axzqmcpilKrIzUnMtEVwLUzYqYzqmmmBRpC6Uq0Ay6RdYM/bambeQLUH4kckn8PNHTGyvo5Lv2T1lC6VTq6KTi6KTq5/3gYKzicJbxcSebOVsUFKXjEizhUX1YbwZCFR0ul9HNPyfn3FWt7XTGWaFldsMKPin6U0V5cxMzNuypeVUZWxCcl3oOK9IZ3Js3nWjQ/N7S/q7bNiIrpj8BxZbFSyBjszl8+f9gQFUC+RahrZpQQn5+P50gL4vHoeLSbA3HMl65DJoXBFjqWrYba/VEPxpIutTfLHQjQlnSUiMC1hOvWr8CCJlpfMFCo1xrmH954++bbWLJ8Yk/VQzbu4KIhNfnMdQTQqc4z9HuednKvFxfLl8sWCp2caAfdhaOeSctBCF/PyLmkKnp0q3yVNwfPT8ucT+YwtKH1CZLo37rZ6d1zZbySM0K7r36TLOH7g+Qu+5ry248wEyOWSBeC7Vqo4lqxDpEdgFdmxdn4yKDfG9ffaxFtAhbj8uif05BrWkfo0ZO3axBGvGQUZIZJTzpnlZXKkFlXARCYmSkaPBObe1cyxEGKGT9bMzg/MmpH2EpqQyUMWWqVXJpME4bTZ6eW0yYV5xhWUVT+lXF5Ph6W1MeqntAiWchWTE2Cm2PTmnYump7wkISdAP0VmCxd00eqhvPg6bScHZHmkyURyNrsH/ZRX0PCcH9UUmbsFi2fVMYJPgInIpAYnmshMm8hBD8du8sSZETs+RYoZyIfSp5bAND17oCZ/BMYf7opJzeR8G0mVnJJTsJ2i9OQuuvHYzIHHKUY0GgOmZy80rfyMhmJIypX08oQTNz6z05MmzdQi+iFLcaqCFsDEwVWeNDP6YWI6K0nhZ/LoeXTm6nMH3DRxctAdEu/pqXTMQk+nA5qchCJ6PkFSM2+aMt8OzzXDiZ4/bRk922uD/5cUzQvU4piOhOkXQomdYBOAFGJ4lzBpkk65/E4tFpV2frl+exXS6NsZJyZbRsistG0cTvI5ujNOCtf5ICrek7N+txObcnn+6VmUhdxORtxFbmXFplstqWpq2g3mVFTbkxh9yh/SztFOWNmn3LREOuDHZ9hlq7w7um8LGmiE13pm56xjyUTjzu3T5jIOJDWgu7Y+kFVgYwX6yRqj54bQe0rHZ9pLZTbJDCv2FRl7F91gzfZXZU+Of2W6OIpPZaDb1enWa5ZlZuPVYbFB7rkcWp5YJdy/v4/SdPNniFW4/3weT7pdENL8MuR0ZlAyvn73wWbYcl8CpVgtRJD6zFkba5RvVCahOTwiZXxAEc5rRcYlPVHSdnpYydGAZnQlkm9f+mhGgX2Y33RMthf1Bv0gOY5uKAUncp77Eps93VR8CLak+YWSzcbJvCzdZ9RHTWk6vHo2Jsf6Gla2+UrmkWySTbcXk91FbzzmHu+jM3MlcrSbWSaZNoU9R5833XI0ctjRt3OMy6lRE5I8qXSDcG5/MB6S7uLXd3cR6vBbDDLmkuhWYRyp/xHfo8Mhwl8jJeO778yG8Zy5dats70SKhcleNNyjtZ0z5xtYGPMsuVybgRyvqGiOZsmZVH8IC0JyV+pl2LkDMc26AUUurx/8Rn5Vvem42cj6UV6xtn3tN+x9hmRE3RFNjx3rK/DyBPQqyUehtAybMINzZQR+dz2Dnn7qeJKxE9FFFKt3eTGX9e53qba64F9GMXS8NwUoKqzMcYh6mOt4I+uEFq3AdRgypJIBwkeGwGpaxspwlcxpMEGnXPAR1MQyGt4bUqQgZKcLtEch3mKZUOtW7pcQcPxSqN+ZqTZFnF48sQP+hto/rTdM1+tGs2bNtk+bxj/O7cvgbZttOS/ZEvRcUAX2si3H7sq36+/+FcqgYg4LLm/mEuyo3Prx4Jnkueync9JMTgXKN33L4TQN2q6F72rbhliZsqnFai14WxdDOzb2I1Mzwx7tSKoLF/FJF47zw5o7ey70fl38H67kVSsGr2oDkVdZS/wysxY+pO2gCxLKibWGgRpHR/Q3OzI/jx2vt7cYl649a4/221Jotl/Wbfum4ebenwC6Y7G/Dp55J1p+z8zmdcFNVRDTvb7aSJVrOkePsZ51IaCxjwFbAL1Hr9ZIp9rUA0YK9FRByDmd70nKaiYl1ePOE0gOP/eoUy423lAtejWEph0qQhb4m8HpBuuA7tNJoQJ+FrWsCKmBDs4uLR2qKmKRAjcWBlHg73nBD0MrFSfIXLQmm7Ja6T1rGq5WqyAdoIDEehZZBS0/wxZQBK2/C78oIBzontXYAkVpByFkKqa3hfOO8iUIEOPMwCUlV4q7qNmsPQHrBA+m3QlI7iK63RpE3k8EPFXyDJ0v/r1OuUL0O7nlCKJlRbzgwKotazh8/IrdS3vZ0X6N4tzOipF337OH8MR1zwa9kSZcWg+8mm17wDJ2MYrkPp7JGacqFJtAM42DKW5nuXpOYLaOxSiIUdAgXFjEVsi+UGOopJsh0Vr7eR9FdmeRKgg5d88EprcN00VHFYTc8Haoud4WtdDu+ISkzRZ/Pl/8RaBeBor3td+DGnth8t8oFWesgyj2G8k6fGNd0IDlcMThJQ40pMeHXx/DlTWN4o3bO63YssIv4Uz684kQ6DKmedeYyyrPs+XH5QDLFFiIDgNxGTHQg85hoObaw4DG6QMZnYcwLsIacBiyHdNhKEgYiSBUhisWpZTGflJdsTGAsU0i256WQ1fn8SEPU//nHkQPBe44eZ3k8I6aXLxXciMIT/xRxOJCUngfZ5OWQ4OzyBMC+ksrDL94RuSPE2l65tpNK8tkRA4pA1Os48a+onhCNps4LdP79Qqzi5igqw2PAeNtAmrDWjL09MFNaeATcojCFnWKA4MSmucp66HKIbdRt2S195/GZtJmMxy6P820LNl2PqHFM5NpiqW8x8l5gWTAyBNpINtp6q5j1Qb3sU6mLhW+vcVWlKxn4e1oWd+MYR9rcMoDBaF1YKCStOXAj74jjVSsiW8d7nIMQ2G4Dg5fLdvFl37s0U3YsmTh/v2wmnKLjI2XjrPby2FYXUEIcJtQZTRZYw7D6hrd4w3Dqs7oZDxzytrxvabjnhtplh3rxRq3W4aB943o+aLhPVfMcK9zcTkMt36t9+Bcjz3EFY8LfB2IAMFkLGPjPDNCacD9+Ylcir2puWGifW3UyLP0IueT0TSi7iXVybQxjhZBLHqbjuC9nzM9uG2M59KezUiWoick6KLyeZH87kI7HtFNzOUAVsV2BvgQnMddDsO9nyiG9wTzRmDuS6aLtXLKSHX46gwDGR+n6XNjuf6GGcjlMDzE3dJh2PGjDHPDy8GE6atatMJvpalqwwTs4AEdvxOq2uBA50nyrgDgY3Qhh6fowOJHDliTpsYIcQFJWYgTByzNG+or/oAppFLgNBAmNMqICm/WkbTqDigoHV90CmTnsD7Jdwag01LXrAoBtpDXgdvyNl6GuEa+fLj84L4aI7yQul6HMUgP0ZmAhsFUDz03Kz+DmwBUhGwvemDPS1IF6LeXD/f2DSm+dTNOD/uBlnLQw5FUUnOzXAZSR6ogZGqICxj2Ts8+zUv1Q7dwIa7C6OjxYSztmivO47XhSuhtFPM81MIoSe7h2Fcb56e1yPm4AHWgP8fxzfa4SL1LmZZpLVi/EDVf+G2o8AFFGyVjGKywHZVp2QcsM/8JuM5YIjPWoFIz2rx405mj2sjGl3wELR/0Opd6nLMc3qClUSUD6DYwuHNtaTxVsDR2ZEdHcVgUWBKULyxJhgTL4gCAkQMcgZ7+gIZHaLl4HBu49E6I7wPLEQPv0WycBrN7ZcLh1Gg2yRVSj1kIhKrx3tiPCs95mgOx+pghIlYsIjQnvAVJiB7g0N+Y58Kzd4H7v/qCyDotwcE1BWA8vaD4yuvVlsP0DqGem/QaJDnqKYxmY+SWh5sKR0NAkytJbEGZ1FLm+0ujkbiuDznoM5fpyToCQbZ7aThZPY5G6oqFWdblaOQj12b5EScJznlgjQFwGJzmOMtST8HIsI+uTT1Jeh0Awekc8PAmkFiE7ABr/4PQRbFhw3C0ZHiXDkKfFe7/gvS6g9Dniz0vi+K9zXGZ5TgviihyQsILkDK/joovBjHwVvRkCmLhKOXe2fK8JEicnJeshJD97vF5qIKfLf4u7IwnMHK9FuD0xfHeLDfVW3UcTCosvfKZ8IlbiNTBn4EkmekV/XxLcecdGgdqSEhtNgkYcvsrpxytR3Y7wO7OCn9wGg2PPQXzKGBgUQ0cjfUJEAy2kUMHCoCkHMzKgCPt57lM2iTSJKwvQRpaW5NwMGa/jaf+5YT885msF3xBMp1RGuIEe87vAPoLXiXu3oi5BZBJO+u0HfW0IXXOJk2p07bU08bUaWvqaXPqSXvqtEE1tij1bVeSbg7v0xYSujIQUgLZ13tRwzf0Leu3kQhOdx8V6/Waq9XDze3zqc6hL5QLloW5PTzwcJrmuSKS55Ek9xFYIqkJmRePLaE5/gYAd7jh4WoRCe9Rt9JuR8ob2pRlnIsjXSTMNDkzDAp4pj0Z8PCZShEqSS4Sq/D2LQQSLEtnReHJwWuglBCXy/5OLgMQGEPD3L3kbLVvNYaiDUFLC5pY86GVzgD029OvAwbO5ZMMgjW9dMo0SUE0ZGqOzQoWEGVtPrHhRvhJ0iTp/ePj/VXbm8+82j0r8ADuISYCQsih8PZKV63U/M+Ewkn+c0Inq0NkTtZo0F9GpniMnzeR+J2X8DTIDtRU6sP12HXH216YX367u73WINX7TRC8eB/wuHZ4y3n/uOHQG/mGGZwtlHzD8Z3nbZwZvOV9temY2l5L85Gb5WWySn7L1VbjMrDk2vC23UnVMGpIjEZvZVTAKEVDXhnR1CP1RFECAB+Ft6K5HmFfshRtC9uVQFK42Iq2jTPVEi/W+wVogRy4m0I+/MIEyMdhKJ0fPm165m1WLN+KUiPtjIIXdbkYlKxJHsQJ9Hkj34593YZyDFMNPF3LdXCfPVMCXpa3om8ehOGXdvTDuQ4q6pXClGO15WY66yuFUeIQqYKQS+r8P8dw73yCh8ac4lke9G3YDlmmGcdlmHJizQPJdCbikbAaoLz3SkFQ4kcVkESXATDiJzxFgqVVCvufKd6tJilhaxV4r7pbr/Lqgz7MFJmt8CQtTF7S9I4Fn7+Ka6rXMieIY7R3eed0o06I+yNH2zqtbBYv0Ov2s1Jn3yK1Mt1wSq4zQ32iHfxiTz2fih4VMilpkn41bIZVsAQr6rKSfZ+1wimRcyIz84adeMFOvF/PvF7a2BVU3oP2vJy8NyvfuN5sPbntJCW5svcBEKBjgb/ENrUUX8maEZlVqObX+NkQXx9Zu42b22/bZGHoWbyaZYpgnI+jnUWd6j92jJZ5W4QSvM2VrYC5cyurbbVhRE3EQTpS5OuCDYKHaeUkZrpDkr1Mh2TmLA7bDwswXIbBalGXz6TqJC3O/igQm0U2pLlb2SRMdMReosVO2Y5RpCNk5Tz7nI8FnqlYFuYY5+Mbww+GKc5+V2x4XRDx32/eLm4/vnOdDB8L1Zws5QvZLdXoaQKDVyxHENhr+9vfK98sYckhJTwtS5CHJaVZrEUv9AYmNlKGjvsWtQwwwTEFnhdGBD6wpVTQk2TwyFjKPdE+cJzzgSV73IPNMd/k8hAzxc31t0pWbkOykus15wkE2ypKbukqyrmpjhR8s9TYV5sFTEdiWSkOBcbwvaXuaqY33t9YAW52/AUL1q2jNxA7eQhL4XG95irsd5UjdKWx0cWOK7E+Opee7pqqW22Y3rz+q6hfO52gt6OAD1BCLMT9Rvb800ORQw+iG9tgluey4+Gy17ZJFAAQaiKTHqd6DCZajqY549WLk5l9ittRmktVfM0V7ytuX4GF02nzCoJR5HP0XeoAUFBH7zN48OrThJZtOHZ20MfRmefkF29h9u/njemsu3SYBm2BpTZH2+O0pml+JPEc9pSRdJVR21mjpjRJNEYSCqTcBngZVdTLPVmGH1ZnFUyD8PV0a/hqsVnugkfQ6uxFML6vziP8t78RUm94G+z2K4YqTxVbbv1IU7GStQtQUnGMbb4nXhnffU7Af0Rcs762r3D8cIbPqiMW6J5fB6iIlP7SruB7wdyHFM5b/FwUD1kcFxrIcV2jEtlO9viBoTyJi4ZLxRiBsGKVEYGAWsWrRGueK7bluDQLjeJdiVA6jrUVa1vc7q1YRwrtxr5mhFyAkxcP9RVvw9HSFRviRQenV91LqKVzWKKBgUooDptGV0w1Mmh8YaCpNE6Y5UK1rpgyG9bwIgxCFdP2wSoGlwgOFIFc7itB2BW5QwLQyzk4F4tWGAmQ5ONNsKIAzr09V5eP/3H7cXX788dPn29cItnKqsrDwvtSLjL2SRdfuZIVqr3PK8F7xy5VtQAtc/jCVdWC2G9VFblt0nEqu4TGobaqKkPqVQ1nL+O0p4of9Iq3XB1LzswCVYUADkO4pX0z8N4oDiosFVclV6MG+6CKwzLMEtSji+V5r2QbWbEOR3aWHZTchTRcVaD2pMMg2FG1dq43wKCvWjcF/lag6Hj17vb6JhARKi4n9uQen9qZV2tR82LOPhuuO1egNkwZbeQQXyInhT6wnaPoJE4HjiGNIE+pERjWC8iC0su/nPPiL+d8+pMaKqA8O/MnXeysFnpYkiu61ORULEOT626MW5sv+YG/Of/f52lS1/p7pKgT79gwlyNVgEY0zKITIK9yMrVGsDOLQ9eqocqlOzNFnpOezfDquRyvZrLYNR9MFwKk7JLTG97lWNb89lO0yEpMPk+A/Sb4/oNscIsZ4PPw2GoZHyE/8EC7j2jgBq4iozeE9qfPQFK4UJy1WjT9mHSofeyqZAxtxHIIhYZf6vra8t6l7bJqJgAWT14E+C42AmYYLbAP9gV8M7CGv34QfQOD2Ib1DaHC2Og4FmcoV+8vP/588+HTz45xqRBR2DNJPmBCnuX7x7sPKRIGASwqQ6hdUjVBYjmTS91dp3xXp5ehfBv4KuNj/sd/PKYAfGJiiQlAP0I54Mt4IGR2Qw9JbTQpKPySvrNhcZoQQhQ7IgwAlkllEl0RjziTJ9LYvNryGt2vk0rwahsHocAlZYF9M9LwXljOTd8ji2oXgSHFrH0H3vB1mGNt+Fo0PSxIqg29J1qnsQwL+AreJlGHKFKV6J5kOUhNmk2oqg1q8VdxL7mKJKDFpTMNuG+ZWUvVuT3dwuu24SesknIrOMa7hSLmsv1JcloqqcOfC6MVEcl0//GycUpziU57JcwxPnNhjmTCJMwxYWqutyHfU0wiO0chlFDCVNu1/ZhFIl5xKiIVj/GS5mNPfUuuuXBRf5pvNr5TyEWtnUMJCTO9v5Yp2Yqen4x44vajA5HPyf1mNSEnaQWlfc8LHR3QpmW1GHXx+eby+u4GRzJIXYErM8eKKuzzUD5WVKwFjzPiKwsNDHtyy5n92OEnoOWw7GnhHcRQylE1FMx8yD05Xu6GPrKkR3pe80pxQ2pK0Hj6588n4VXx/nmx77oUcheWfYtfTsfxhA7r42Lz8kA6RvQPCWR+JxrDXiIL21CEBe8PiER1C0RAvwJY0hay2hq5h/Gzld5poiNwzyz0AznWRaDWcuxrdcwU+6t2LCdLQn8OX8CvbyxHfpZti4N8R6blHSW3fAVG5UvHufx3bMuv3JcGv4YWeYdnUI77IHT84KTIEr8YDn6Izjgq+GR29YLpYfHD8iyMFl0wf666GlSWU+4A7JMewh5EB8Vqenv0CXd6WelBySfgCvydppD9VPSIWR0wseZ2loiqqxYxG97Zt3lYAYVx/bw/+kLv1xCWBxfD35Nptf4bzfd7cqRSdcRGu+r0hI5NSaIJWSaYSVSdrmS1HYRJOZ/YV4y+0b1wnTW+zH5guPoURcB0xv5W3Hkexw+1c7u6EX5BCyGZasq0yIyd39ervKJzJbulKLvl3qk+atnyZVRDPplYqLE3ouPRpzv2FdnRF1d24aWV5IWQXcf62BVl1+Eo6MlF/vZ5GOsEwSxgyp9IOYOXinA40DmuIGSw8BBh6ZUk1CXFx16YIzADvZGB9RHXGnSkgUuDVTkQb3PAiZwnV9AmcdAOL0rCJHdLDiuyY4rTb1ludzmxuQzAsIGPFgAFjGC8Jpl7+6Xh2GZO36te7aWq4yxZ9t52D+rpjxtcTw9TA8tA/OQ/AkAOQgMPx96B1/sh8IQuAuF8VoDnaQdUACy9o/oZPNmQ92myN/xgYl/q17ZZG9E3c+KwF0WljewqZhbexHqa8NOStgs9dbO8P4gI5cPolIVlAZ40mDtBqvlWmClykUCwiPBszah8M8JhAfCbJfZ8zzJ/BgNsePWQy+pD1DYJEoYBipDuQ9A/MmgilAqIlJvURkxqI7Iin3TCyD5jsyId9PbyP3IIdx89FA8rCG9vb5VWJ+D0rlKRtO2GzbCAndUAZDV0yDbLtKzBoS2B0mcJyB8ZBK7fCDKp3hJjHlBon1cgbXWLhO8GIsm1J2+daMLQ65mRMN47GgW+0PbXI82ZVi6tGHkrRRMWyX7wiwmUJO5NiE3hFDnSkovLYbhmhi3z973wthKsTi6x11n2E+OwN5WfvqnF3AszMZF/1jz+T0zjT5nFnzKjpN9gWtGa73grvckbgUUvjGCt+MqVLvzqZ+VsWpI+UXgHieGQAEDZb3F3JmsBm1TLnhzmkgRRZ+CgZD1WTGYwmN+nNxa0fdLbI7A4AadDSUzyY8X8VaBq6XzRS4ho9ATQoWtJ067kjisl6kxqQKeFaHEc3wPtNmG8AlBwAZj3Yx/MeFXWWSMC/pW7uRQkYblXzgG++ZbyR4XGz/lnI6aIKZjcIwHTMZQmpAMnTUkGQpqQjodJyv7E5ZNXmCYkgyRJmLnhucKLCZJkTKrJ89bhcy3Dl7pi5CMZy1Nd5gXbom3yBWtHp3GRsWS2HTDn5LNohTYDV+Ar0GFLHwxyVjy4YwSnThYNymfflM9dkOQ6dTnwbIZKV7wreV3zelEpua//RFj6PUzZ67Gzwxmr/4kci471I2vb43dmbUl3fjYLGJwsBiV3ov6eek5zfvNFvWLnAqu7EP1aflPGneD778o2Dl0moQdWcXeXHRMtegWfffwgyg/OSatl7ELnW2UPfyK6bo+ib4Z6Haln5b1uTlfKwzeIPfMOgZzindxxxzwr537iy/l8ofb5kGbNhXEQCQb+sDHtt0c+fry5eiQoflOz2DPVSTYZkjA0De535GkFpZ0J03Rx4NKefBQuYY6reBQFad7a1VmevJOqixsEPhmiuum86Cuf/h6CNboOHT7Wrm8DbVhlCJnchAUmu5sAjzrlJhI0fUyZVDbsW3htzzytoHTiJADAFR31Dd2jBj5c3C7MQwN9+vj4+fbtr4+3H/GY02mViHK084Qckipj03oCSGfQGJgIYxLFj1dUXaFxiAjQxqfjuSxz685gyDQGQcUboY06pnCYcgFPDIdAKLi+pnx2h4jijmuGTbOndfaYnpOEtpDboOHrT2QiFcuy3GrUrAnYlcNuDsEbDRwkenJw44p3r3T16f6/bj/+DAlHJZqNQfzz7c/vH+PTw/mM4sVasca/Yt5o4Nbpgcb7ULzwKn7E7V+uhSLVIDG2SBYjwrG0C48YbwtIuJFxkD1sMkOs3OALzxEr0CnHAEOUXqK6cwDC4tTzkHMfq+GvQAyuqqh6VMVFKWwiD8XDhimu34yaq9d/HZQ0spLt6z0vvU+4v+5eny/98o5siYZud5X2mBmuiKRz5wA86NPzgwt9EbfGhjKqmA7+LRninH0gG/QKtRkVW8NYo5jehDHGTf9Wk9Aeqa9P4gozY9EqlULYywiEzyNCRc437hgqjl+fb65vHx9ASpIe5F2FVaqDIuBbo6LvKUdjY1gaduYUTvMtkSWg4i4pYqW3I+XrIlLBuMmyVK1DSa1r6SLJhpuWe+clKX7v6EddyX1Pbu5Q1BxeL/wU+janJ070NIY86+SEJT1g0TXxQVjpoWiY4Xt2LHRbFSd8eoI6daWDgQ4+bA3KD49X0VyzSLi33C99/kTkDdplXz1ybeyfNx3Ag8FqLHnQgx1bzmqpWGhrvwj2pDaSBI7wfEFIcobhAB9mV0cAxhqgnQvQwitqUZxEOQ4xuhMmvBABwB4UADz9DQBuHFEAj40ohqfCAQsNgcABXtCdPzb9zVsfVDv4RP72UNzYjzkPyZ8hOEK1I/0ojpNukhBOp+oXrl8nHE/Z0FVqVsMPFsW6mKbLjVPiBW4TrGUCE59lgFLpYs2+hK4a0Y3cGzmDD5vBWzhgFQz8kDM6y8E2An5R7O+i19y22dL4R+sc8MFDdDQ8P6ThMTmWZoGnZekiEFlwPY+NRuqxacBln8Oo7ZQDoka+Y6N1r2OvZWWU6Pmnz3d37rOey08F7pU8HKNA9MPl2DDgOU5zv5SJCHpNxP1LSuM7EXhYlgQeXpHAk8alTksDTxocedLoDiKNTXdu57dsT+3VTjZpEUhutZhHs7BQFKcmdDPy56cypAnxI3CNyOU0nFpII95NQgn0G509FE2brJaxb8nyyS8tBSLxTOGaGWq3X7OdC84Dz/faBZWFZ0u0/mvqwKIuF+uxbZfOFNcDZCwoQ18K++FxZK/L0JNK7EPXZXZCcl0uo8Z1XS7jVUgvKpNeEI4g6zK4aoPpaF0WWe2LusxYjNxVl6mSV1064+PQ28si6Rcl6RGL8xnsYooR5GRZ51OhmdIvplIBCk1WoG++IvKxYfa81F9a4M7ibZ4lLX3uf1Yr+xRNbJsV6R6r1A1QAGD8KVcwHuVFaOcIMwJpBIC6JJdI1FjSRzhjul+HIS4Zj0pirF+XzoFDSPL7WpC0BvVR0jmqxDGf126hLmFrzuplyw2snq5vLq9/+XQDKS1XpL0cT9hybAKxkKMZxmD76TccwkUtg68V3YrwDN68Z46RTgrDdyV+kBw1DEquMzZPLhqp5GhEz9841FtYUoENZ0OOER/3FA4xPR3ordVwTg1aUISkDe0B2AgA9jwKXHvkd16Cn5uat9x35+ubDzePNxGLTeaDD9tfeqVOUokiEPypzNbYDpZPeuAHU4DmkXeRrZdPmgUR+8YlyweLkr7QgWVDzfumHSNFwNSDaM2HSnZIcitTHReK12PF68Ugu/jAh1YeI7UEkw3g/PFjzf1hmf0t7L/lU+vbVIkdr69xbkT4qzhx4X7kFjIauXs9OaC2kFdvjQxmJLVnC0q7FlqtFet8kA6fZsBZkaegnnAPO/rYdvGp7aDcnZviwRCHwf4cUQQqNX2FA1xCLniDkywP+Fc9MJpwTjdsYMokGZxvTu60DCdweJXTc2PHY8mi4v5kwc3+VravzacIzL1euW8YDnNrveGsJX42I4L9MRoT1htCVsMKvRHUgrU4+gpmURk042sfvqYWNDBrLeIEWpCRTyhemYwFM8TAkOcqdNUyAStB57UR4qAincq6nS2/cwXQwEy1cephO9YK21px0W2TW3YkZFIaXie9BjTyE+sbuWrX1ZI3jTu0KXb3//Hz4vbju09OYNtFd41+QV23pJ3b1vVOP653urhsGsUfYATvdHF993A9wjve6yVrhw1bbseSq54brpfeS2tNxhEfBqKWPniN/cUYMpbmfYFWKqEfyMpZu+XDmqwK7YPHkTAUtay2XC1A3W5hX7hjkCcpKepffkfi98BzauyXbB/1CWtZDcLl8HqOKxcWpdgYMxT7/X6peO19MIiyW1ayKz4j0Os1Mpeli+JsdKGb85evXv3tJ3dTbz7IRo7mr5+572GP8rUt9+9Fwf0W7hK0TWMl0KsVqYYuzs5fLV8sXyzP/v63Fy8vClF2BTmSuZbVvbfr9sb7G94ORZbw3mLYzjn+3nTtOVRD4y9tIF0EYhU9CTh+aqfl4IlFk0P9tGfhPnUHIu36gp9ZVZsXZ2lRWaJ+8fK59Av94tXJ9El3g9QwqNoSzv9M4EKf/TAjM1O4HQ0N71lf8aQd8kguDnQjquiTFvvhDCi3PC8SxoepKLjtWaTvJ4mmO5CkNCLQNQVovSNaTJFUxQvToNdsx73YCkpDCXG3x+2GAlWtG/sSpVzxRg4cJaQ2Sh6XZKjp4WShltHKopbQYOYyCu7DbxGIcPaE5hqUJmMtIEXCQNjwsOZE3CuvZih8NgI3LRyGKML6+AzgOpXicH6bpbwTbZxSUvcM0RYl5ehjgP/ZeWetWJBQwwJO35EdxrIVfpO8VqOoi0pKVYveGW3vzoqWh/ueS+64YX53KuwS6CicvT0R4y6zYXobIxnUahy8pmgddyrrsdoqO1UrOllt4ebHrjsGItwbft7smsz7U3UkLnaARlUlx4dX1TI4e7I0FQLnqp6G6Z9b920iCXMjoJPslgfXqcjjytiyhpRO3LAGnuSkpeBwYmnc0ET3gd4vHG0X7JZjhwvqHdm23e1ht3Kfh+eq9/rYh9A29dEPMcfez9hvHm5zvuBa3PZs56ZG/sTZJnei+s+Rq2Nx09mVAufvnLmcK/RrqOjXF5E8Q9K1FI87SXyBDkf52YtXcUnMz/m98yOBH0Ef99r7lnACUZQ1LV/yYe2ZrtiJ8o2ofTRDFwjPJZQsmkHyipLEPwev/BKXVxvpf6UPoRv6FocjRl4pASH3eO1PcOzvopKj8jsNzr0+3nYwrfRUiheEnDVTBCjxp4BiwXsBAEb0x1VX8RkoF5tKpUI6oSdXHySd/FpEC8Oz4SqBNcXHaLUWllF8YzZjV2pYl/En/HkQ3cCGgWxV8u2edJeWaSP83BZoiLPnEWLlGRgkwrNou0UIrMzbjm2W7OBe/OAUl6eRyz0Lq1HHFIEidXPaQQlXykOgjVwrkfgQ5x1XjV20h5p1XImWnCfyDh3hOs5j6D3RM5Ws+QL8PsVbTOHVD8sXxTx+Nov/eEL+x5Py5yfwixP4y5MlvST4CvHFRXIFil+cwOfLeZnc2Wq+4QI8J7q6wJo08ANaHp4ioz8AMM57riAkGvwGU79iair4DaLEQPCk9LeX+0yxZAXB+wanHy68WuyxIdha4AxzIfwhn1HHQYreLDH3Dn6W6HXc0t6kxVMwdPS7JSph3nz8DSXxVyjpLgK7WZxoWnDVrrxqBc41uFLwQ15GFZxwWhLvUympArGIAp5JxJKyovW7Z6qBMoYw+NH2HGyNJXuiibfV6F71RWRNN5AyTMLQGh7IpYpITS9wlhTy0i/zAk9cyiauKQODL0DgaS2o8MAaspN+Y6F7C9Gr3WOQOZf8mdtL8/hQdKSyJ6CTR6CTG9TJDeqkgrogpNO3wc+Xh+aKS4MDuprSb5ivJOmTk/nWjTasdn7VGFzf+caNVMH6XhpmeL1IZ3uQPAsOchgxBCA3FfwU+Jva1FgkHKxiVzGVczStkWlFWQxXG6bMOW6caG+zfMeG9Cwmdd7kuC0/cKxFvZgEEAWrF5cYnes5FgINYaObqo60qLbQzqNTQ8H7Gdtwtm/pFe+RvRmVHPidCK93MCf2VPyq3/zu/QyurqiFbUB/Hrk2b8F3KIcYLjcH8oU+EG91PCoL4qZT7LIAYONB21K6SJgnPRR/Of/hnLt/lPQOnZXfCpnkyToKTdK9/ZMymNWHVFQ6f7CptGdnAvpU8SEdS5qoT54W/cy/2GZ+79a0czn2vNTSdgK4+iG/vD8SKm5+eRtd0XtHEvmdgmRyUpOl3bovXmXEjrvl0QmxT6rm6p4pb8k8J/HgD0dnmhMEIIy9qLi++eVtLAUN6+ENuDlEh1BIw3OfY7zBN+l4gCspyTzfFoTB/K3IPtDwBh94FTvrQPr4IBSPu95u3lTzeoHR9oqAwvAGUc0VHyR09/B1cRStquNh84Uc3HpyNTj/9iGO7I1Def2pfEIpBabCQEJkzTDROWBxpljiiZhl4kar5aIKtOXA5HwBE5qDsWOkkbINrPEnMSH9jni/tLyzP+hDgd0WiqyFCjVAx+HIq7FfGK6Njs/A+I1tYJ6C7JMuFIdNnqKo7NityR0rRtYwltWRmsYu59GPNv/qN0XiYOeKXP/tZRBZs1LBcm3trCie2I4dlo5eYqXQlvxN279eLtGv8/fk+e///u//TrONrR+o16QqWx7P8d6xLdeXWvOubDGswZr1xi0ppY916Px7wwfj3eV/epEv8BM75Zp90f5Xm5b1vLhXfCf4PoyBIcGFvOKg4U9Q16kPmbCuFOd9CAMfcPvQV15XwONwXL5mO1HJfikqt6Oxjlsfa+J+cU39LwYGt0ESAAPBJfsBiePxkFIkSRm3wh0Ocn7fpiLwY1sdv13ochrdogQ/T3reydS/UNic76l/trhZl1TPFvYv3ViWGdZ435/zu5sgzx6v/F15/6Xmspnhut+SExa439lOMdf33STkm9YxvDTnsBVBgLMcOM+Bixx4mQEZm18iv0Iun5fvi19z5twjUzqszNfce7+3v+iiGWkySgKyekJPexYBQhwE64Ma05ob78IYv5FrcroSbDAssYLWzvko4Ns+Y8ODT6FDjoEZO4VgYZpBbY6RyhLoIsf0tLhQ9Th8I0NLJd/cwK0GJSuuNa9XeYrh3ZCDLkJpdtFwGPFOtPw96+uWHpcRMOTIngCwtKr5M0nfkDlJ+/V0IXtnXUlbyc+ctV3CZMqkFldj0mRqjA0WZMiegWf9EZSnu/qHyJCSQuQ+z5iMwcOgCDSkUNgOjFrczplaUfo9aqdhDsb3SUKM8ehzRq1xL3YtKx9feOkdd45dTAMf4P4IL956UA33UiP1sOQEQoAUK4BR+zA1fbNIP7LC/0e0LQtTGtHyrxlguCqeOunchz9pS9iR0lE+pANr29cNN5/Z/poZ9k7JDvWl//rFLrpex8Ghr11ACM8obmXSoM7vhOLv5GH1mfu50TuhOrC8JY8/uiddt6zBXyJgOZgOWloD4ef1jigiNd91bdK7f9zjDsW6lXu0ncSO2452VYqrJ8+uWNMo3jD7kYwpx73XWlp38X2TLRzQrSVsaKylNAhZityQ43M727VUjT/D99TKbeFIavixliruaVgGz00srQORZtBJDh11xNZS+c7qiCTT2IU3zTFwYOsZQ1PoaxcAeO0cj6+dZeJlyVGK52Hlhb+xXW1iprztwBW9LcuqKrsFOyyv/Uo/MW51iWluoormeB2pgpD+3a/LlVf8iy9tXIUD6XMNxN3f2jea8kFb7G/rbIWOlC0os4JAFas5LU8rFJ6+4joqDq6VM4KuVykSiCHsO679dvjahPPx9cjbgg0DGeUiFN0XBSzYwKxHH8p6PfYV6swAnQz1Y+89zSj+ZRR+GwIxnTC+hP0ycZq8jmtgN040rG4gOH3U7WtYy5VghCwIDcJty73WI5CxigAUXwfCxbb82QN3vB99esehyL5pw6W8JSGlvacfj3wNCibNxJdoUzrvNn6P/Gfe4WgLZOhyP9/c3X689ZfgPf5yxSCjJQ2vV1ey5pAq/Xcl2yiEkIM/3zwCF+rGTbVuCPfOL3TfbKQ2r8tRDZVsW+biJ0m17H05Vs4ZLPopXMNN8hWP0T2btZv2NT5ediPMQseYow1YaTbCbMZyEVRGgVfc2TEfF86zJXZen4j5WlZGKoD+u9SIXZzmNX6rdt77r1cojxR5UJ5nXtM8cuj0hiCg3kIR5bexCGRnijmUI4eMnV7rML3YYeZqh5nLHbLr4RNzHGmtwO7OI6AJiSpEmTK+ZTls8EOLS60ZvIbtIPDXJ0r/nzS4lOCF31PYX+KCqJFG/vr5g11SvBlV+9rLLSvZ/VXUr19e/PDj35yYYmXJ4/qhUaxu+YINA8axjGgB5Jr1LNBrYUiMjUaxYRMI4ZVHkSbVd8iXltKhjYEvEmYt+pZ5g1OPGR4FSEFf2nCMTzBY7CFHr0Qv9KWlWrQITS8BypSxrVP40M0Jo2mYhQfegoPrRrEjKrb/rDjvN3L0x9aRyxLfHn/n5cOw4YoXQRU3Jt/88nYGCXGvI/wOv4TfJumCZGcl63hoMAEz0d+9u8UEmIrMFhhxaDIpd0dCJs9MjkMgaIeT40B6KXKZRJVn4YeB9Ro/4j+rsYcRPUScc1gW0a6ZwaIc9kUsi/A0XUd/Xo0OfpdQPyrZAm3itLYZWd+KSBWETAx3fh6ZqsMHdeTaYPDBZpaJDROEi0SgCBRYT8eUwR++NqPwhmuO8Hc5tsOCfR0VX+hjXy2Y1t4fu79QO8Qaepq28hQKUk86kQA2Wq43e7MYe2Gi9ZAbtTbnpC9tWAU/BfzqsGqPM8yN34ogZGwpADSlp6lQ+jAc2UEE/9AbNgSL6w1T9Z75GeKGhKfacL/2fX9zeY08KT9o33oqT8lnWx7VQLZmE6kw0nk2CRTioa9ADqjegjTJKoYff4CLgpL3hretDMTNL84C+L2l3z/efcCmCMANVUhxWf5Deo/FTuSeqx3Twu9buGR0/B6YpMjf/pFdwwLJNRz6eyb1+1xFfpfKzzXeB46cqG7AEZWL/AzbbcEowxLhkb5/d1fMmGm/v314/PT5v5y41zonJJzlgAzOADExsCYYLL0X5soZLOEddBX8+It9vLz3W7Sbvv7Vh4dFI9ANBLWzv6TrWA6nEI7BzmFpWD072qQ0LpcD71fLjoXFsqUHcOmDNPaf97Lj2thej70sIvi9tTP0Bd3+S4BYaR00PzY0zEvQO9lIQ8O+b+RomIhUQchkoHUuJxwx7Hn5xE2c9G2iytpGr7hSq0EEjZKNAXvkuOlGoG3Co4VYAGDiG3jsBOS+DNr2bEz4aobWMB2Z3TsOHxzQ4cEhDw/OsvjgUPHDEfTIzwPUF7FDnnTRCV09q4p4QvC75YhioRU9H+pAVxAvz9I11C5qECEdn4Hni4SZSD0+Ng9o4/7eQGRtR1wzwz6w49U62EZvjBlWqTH6+8fH+6u2N1et9LNDBD6gAQsCn3m1o/wD72sstA77dpFLulcAiQU0ovD5cRzsmTimiJTbAUkrPklYTRMSzb8cp/LBZnsz1hpGRiCDIc9m7FgfO/yxVKImuzXvjwNXP9uZ+X9+8AIDV7h3tDlqo8SBkEttFGduvHZ3TJY6Asc4cfZTX5nDQ9AISoBiioRJu4jDiYhU2cEPXYyIsotuEltnRGjh27d3YG8+0Uu8fXv3Oy8vnY8sURF3IKISfeMXcKKSPf7qQPhvlqhXtV+semo5DFvgVMCVxb1T8FvnKsQc3cTygbdrdOv0bCIEGsn0BkTt+kkcgkR9WEWFFyGYrrsBXjoh5FB4ParwehAsvCEEw5eEQPieCBEn00gXkbEXZdWmWW6MylB+GObR8xNwOY9fzMMvT8BzpfTSzKO0bJyUAFlQWggYOlFdAj5mQmhqKkJYfmBCFRu5F2Yv1VYXV7LmM9lm5Uq1P/sOWT0jq+utO1X3xqZe7vzP5Gx5b7+9vCjXwYTEh+6M3bRDNWHo14QkIZwB8btrBHg4dqnIi7NIkxfY8/DByy5OD1MFDmyia+CHloIKbmlQas8VkVwl47PHiCu5BMBsSnR0weGQPird3N75YclXBN6v6OcO9syEXRASrMDf1DW/RZLlcAKETNRUifKJQJZOktux5oSkMKkPuWVIy2uWgrSYfD0GsKZ0kTCslrtSk3bwcAjrP0lJPJL/kST9j+pB/U+UOqcN9C+XO6vq822l/s/c87O6Uv9MEf98M/2J9tR3F/I/07ZTXaVvK+KkYtX3Zv8nG+KkqlXI/qTzMWiCp6/3M8ub52TI0iaIzV54/qrpMJhgKCi7Dg4G3PFZIBaw2vGMi6wcGqHmBzq0WfbFixeUOYuM13/xdFyfIL8ljF+FQgRxDIsJLKEbUiDsv6Qnf54L46XTu2c7RjhN6gDLa2DgRAnMTt4TueTuh82QNJCLCpFyeXIRFRQCdpFwLxPuh4T7+9//7+vLx8sE+yNysC3jGVT3AS5tFkMlyeI/ArR98TQNuCSJpuzKSB/o5WD/wDFnSZucJQ8v1uE8kTpP2v0i4aYfWefqCfd1Pevf6cDHNvvD9dHbvj6So7vbj++Kju14X1SyWzLjYp6yfvkkFCsC68tYt+MBXOBhcAXnd5TUZy3DZhZ1SepoWNVa2nYXkqSQ0BEV8AOzsr4VPe8knTEGKOTRgxuHgTFk+qUNveWHx8sPH3xjOB2VIJOQ1DwxtVBA1RZSFw+EUTuwB8qH5+xZ6A5QnxArHPkw34zibZY94cP771mY8mJpPjw4cn7TFUvuapoR0lASfVWGZAQSiayhUhAlg1PSoBvUZGU5IC9rHtwMGfsGnOW9Jvs/mKzqNWWzaoAhI1YCNAaQxZtA4bQeKVtQOoxbb8ahUSzMu31q0DxqCLoiF46rHbj0qpbm6u5h9Zm3nPiBxawd68WaR4OLgDcqu0owRaF8HJ1SrJ2ASXdJQipRjN4sCSZ5i8i7OGx5RCXMzNvHVXYdrlZRCRSwPyLTh4++4Y0/jwhH/CKxuXb2aB2vBTMxi+pZS2n6unukwF1oAOwVaB7Yi+qNYoSGgXMndFzi9ju5xQZwZEHpm1/e3nrygRwlY+ovd/9IU59NTLIqzmrZt8fny1BcGyUqw+sTcjJM2T493PZPPuAKuiNxeNBLE8OKBhMTAzieEMPRbGRfGFCrI67uhKoWHavIZpYiIbmF8qaNkPJURMcnQodNe7ovlob1FRq9uwlNXPELPXQNPAWtR16kUQMc5h+9v60d/hT4K3bm2r7gOPfyEPjpAM5rBqgJgoVF6ahJnAntnU/tDe+NqJjhZOa/Z4XYs5WbySLoAjQ/nfs2tr8nzVLnAts8sUpW3pXnL8QA74npgSuwQx58/6YYBAbAsQSnpvZ3oY++I1gm+i6O3LzOAEmni4MI66Ic+xoGmDnrt+VyWTyXBrZwaCS3fPJndk+l1BpCvxZ2FPceQAtQ8Fxy38snYqglkyTgEv8bykDR2XI60YuOPVuXvQ6qMR4bugWGbWDD4BxS6XCT0fDtqS4r/7vVwV/VE+dVsyjBvf4T77cC1DyRjk/yF4+ErmKnlYFwPYwX18Ex/pMefNfw6hlPW2Ib8URrAHRBmf/PMZ3WHF0sPXXaKBaYA/wsyNEEYYucf2+69rJmg5HqjY9q8RrmmHdvOev/2rOOv3bNu/Suj/5ujgN/7YMW3sIM+ak7OF0I1xgfP9y7XnV5f//h9ury8fbTx6UFnWCYLT/J6L35SZb+jiXyoocRj2hjPMlWbr2mLJAFpfmBV0W1WX6R7mjLmRW59aaopmKyW+qxX/qW73hv/F1dC9b0UhtRXfkY1gXEtFbXzmZW7Li+rOvi3wpuqn8jXgv+ydLdTv6//wsFPK3Vg2HKuI0O96j+rTDd8G/FWsp/pdhdZ8Rl485m2P/c7e66D7IpaqFZCR3zXynHG7fiDQ/7nv9rdXtw3fs+sQ9KCrPD6LJlfePLuOOdVMeiSboX+p6h/JuOHT45p/v69ZnfUcFkOzfJy/334j1ngy/9Vw3L3OcyQEWyXMWo0wYBD1j//nf7SXy0GX85v7nxL/L/Tjoh8eSK0F4Jw09c+DeuSql5YdQIdZVdyyKF+xjAwU4CcLCV4LmCkCzq2MD30D8RGA9JRDngT3rysmn97ioTT+yVn3QxKD7IOqYPinJfWKS9i/MGuGf2AJ/+bPcv23DM9xmfkr2+p3SX70kXx1HAVqb9AjvFvMCTS8zaGOX42YuY4mcXlC4SJq1zBs6LBvVI9sQOdFc24+MzIwXMXSpeCTqqhnzDIvGDYgHFbY8Os9QnPRT8YLhXG/XzNpKEp66W3gm+5yp1dvKkB+fnAehuNbBqG84Sn/QALaeDEwL3WXy8vMFr6gc0dUc9g9lUZ0rnv8mPilWwdvpGUV+Z8WkEAjeZnvbbqILumb0fsfYafHO7aXA0c9uy9da/mVsmlNSwO7ZlqvNRveHN2FbErV5g/FEPPtYtPy4H3gEZL8GPDUcqVm8rSlRk3wq6NN52wrCYu5f73gfJDk5dt7I3bOtubBsDtG1ViDCyHUsePQslaIxMiEpoSbKb6SSIrja8HttUrkBCRcp543asGwLbeHhKFt7tiyZox3y4KPGeW1byVuMmTzRxaJkb61rpLQ3t6Iy/pEzWN26aH1U0LDTC1wVpnTA0u2LgEt/HEoyU8xG7cE5iN1IbOwchiaPmaoGxmFp2lCOMJW2c/bU1G5xZbsIsddDWsZjPxJnqi2osvXNFp7yKrZMmKe6szFZ16bxznBJy3q/SVDWOpdhWnS6caxPY38f4JCdEI2X/wqFMXcbQrN+Z1V188HOW8TvzggHn92Vymsnfl6XzHvu+t3rd2BrREkP+b8zX873+Jy73TzYimPx9b5voXgwDN//EBZ1P6m/P5/vlWqruz+UnH2H7wW1Fvw3EP1GGBfAcP9E/+SfLMC7cT1+zVvb2U/0vVsmUK5gmfFNZe15qO8PFKcaTsx5ftqLZmFIeFi+WPyTlNH73zc5bVE21jluutewpbzqekLEQx8LIhsPruirW4uBcZxR6HLhySvEwZ27X8Wn7tvY7JW1TtE1QHW0Fi2ErWlHCz6KSOyAL/PUbSKroWB+wZBMqAaJIyw9x5gnRMB9c06Xrpxlhy/6pEGzvnEgFu7c0844pwftvqgyKWuaDKP9Eaq4umJbXZNgMbqaV/Z5K1qoqfjWiLe7f3xd8x9qFNjXpITNZvlH8O0r+EzE62ad8QYEsnST/+BIpxVRsYs+kSc5wngl0GxLxrAoZOiM8K5uKHglJJjqiVHxgwSVEK/zO1Ifbq5uPDzceqnjvdVgBhbMiSMg4aEkUhXkdpqbsyk2PsenXXLEjIWOdHAv30nh971SnO8DpwCxaSQYJqv9gvwH4G4cuZGj79Fu0WkYafuNV+q0ORJpVJ2UbOcb4Mq3oR5+8yEJ92pSDJ76MAgO34UaL/V25+ZxGllxEG95z0gDa4KG+pUMO7Ig6BKp3z0zs+K+aq1UMzdf6PVuqPeQ8ugZiUTWiCBy5e8cmFhUeSv3RBPewS1bXIh61RdzwbkBXrQ6NVysgqk50z5LBw8ZvxDh4Vdarnu9DF0RMtnWKuSWe132pZtF4qRWOh+AowoFkyWFZZ8cDZ9MOiHmy0pIENKCZpoCqzzQBNWZmUvbDfAK9cZrwh0fhLpoF9C9HxY5gOXgcdO0lGzx2BrJFGhe6lgbTE0vGAkk8CXJUjAck9jd78QOyoshoNlKJr7znhkrORBezcDpoILDKgeSiE2ejFpyMphaTE5bcVXiWTTGwY14xgFan7gfTB3YcWLsC552JhJL1WOX1TPcALOLOEwm/3+8XebOszkjNc60lC4VAwZZJHUhbJPShVdKHVrEP8cNQjTQPnjABmaX4LxXQBWEe3M4vAR7hSL6VTQMGpUDSLtmg6atda5AahoqLftGM7QD7Px5QEDeriNAYS0lbKJrgeQYsGMNJasK0kSN1jFt3iesVYEgeHJAsjeNv49ytJkVrtY7Mvu7+cv4i43ng410R/0CUT6wMSQLuapMMldukyloHUCIWtDk9mz4MEmUPdi1GiEDo2LNIRRnXb1Ouz9isUqvsXlewH+gZOSaPYAVWUIEhomOcHQUg1jY6n3fsumUGu7To30kVO4fcRjH6sojefgBI2jikF0ybx3EoLfF32QjsEHKljzq5ebleRyppptA/ZZ/hpF/LpF9L2pMl6bCSdFi/Xz0ptJgprZiWCdAwESLXKk5dUaelf7D/76XoTeahxybjeJD0htgV5GjSGxgNeUtIL8FyNGk1Ta+kyWdTxxvT6XczbqeiA6g2ISbfUD39iOrJZ1FPvot6+mHURT57txgNqu0At6cMFqUrrdvVNHF6sT0o+Tijy9i6evZrpVcktrHjqUaABQx6pmtlGx9b4l2lldqgnzffnmbUq2vZiV7SWbJmA1yI+rRuR1YtoZ7uaXYv0Qf2snuJgJFuHqEppMeGKQrACSWF/pClvR3DEfSz1USpKvpR61itBxl2hoHVGx61LjvWsK8QtKVjjaiozW3Hmk4UkbKT3MKRaHqLam9pjCAMERST4BGFcEF3ltCdGbyXgUJ3rN7h65HEDoK1MsbptazbD0wu1rGekAWl6XIIQ/y5x0ULCOHNLV0EInx5LEdrBHFl7y5vPz5e3n68+fyAL59LZHZk1wkEwRaTiyKILhZzDNcJOX6eg6SpAxaeb4CKnKeWETkelNepf3akl74hAgsT2o5tOYQn8GxXgsNuIOdVwKKau6doIzk+VNFzx8gUhEzmIYDNXKdIpmQeW5Fn6/gwAwE+dhzUsEi5tIohajFh/frQroN1lhI6dtCPwvO4rB1UehVVUHrm7qNXiUkMDASoSlOOFW8abl6/vbn8+PHy7uavzJjXd/91+fj4+fbtr483f93y4+u7//qPm/86nXdWkcIVNKP7MS3CK63GGsjh9d3N4/tP144b9OurT3d3lw8395efLx9vru3P3c3jzeeHZ4u7Yoa1omd/ubi0tfrLxTXYgNvy16Kvr4IRmL3GfFlf1PH1w+Ov797NJ+vnGm7H2tcfb37/7fLDrzc0OxlsCJA/UtCWA/sGRH+7+fxw++mjH5M+3r67eXikdBxIQK8c1xZB4O5dkt6tE/YYupHjiSfKAIW5RkDQoW7HeiN0seNKrN3G3xtRvz77q3shVLfaML15HeXePn6T5MjaSGVzMw/GxYvn4bWDxhzoyzXQ93+gtDgUJyJF+8Q/ExlAgwZITenwEDqGY4ISTyPrWXzPFcTy6Zg2XC1I1bQ7/Ay6agCAhVTk0ESKIN4QCgBQTPJcQchBKvNllIbrVc/3MLyEr7gOvnIjP8fSVjaGq05qHBl3HJ/Ogd7XQRDmK++NHEgyxBDsolprV8m29UqLvrjqEH676gCqsku98/OkmhkOpj8dZ3teFlIX3WHgCh8Gr732pSNCgyIT2jMA0JyOx9a0TBEpiC5dKWF4iC/tkkgbclDot4ToG6DJXI53JXweHLWI44XjSVN7HjuR4wpCpp8Kj2WFFdk2RoLO5Ix9noJPM4Lw9aaQX4VFSNKKaNH0tGZZe+S9jIDJ/ZPZseNxYz1yeSGakJM03MQJrNfHQRbWcYRtKZ+0S1hHIYszUWCT28DVX+COlFNJRp1fFrajCRs6b0BgOYkIzmCBPbS0VQpKZx1Iz/cgPdtd9Fx/0XlX0JO+oGXfYgO4T1KNVSKDPzgF7riy47Mh/UdVoxKsDUsZBPzU3nHHJYQaIhAUq6UGQW2nMNdK7Hj/lrOeKLydSKNeJDsv4i9w83iJYXuQLhKGDcMCjldgGKFJrfDRZTGC3DMik7TS1m6CXt18flw+pBWqJCxwJtI2hR+m1+VVKwZtVw3rFH8qF09sWo5Qsn9iFetm0pySvvMLO59y4tZ9ojersLPuhTZqrMyo+AlRW7dny+JP5cWJpH2MVDYvUXXD4qkuq0lqNh8LuBx4v+ele0gJk52shQz2g+bOBavpDSo2gR4+vXv8/fLzTf6s9aDstyjpWyce8p6X9q2rFs/1siA08+jjpNQyOOXkhq3o20w0IjFuexj3DIbX8uTKKFZtcQaWQnHy5XBNyDzJl7im852mM/hLRrims5PeQh91ka0TNyRvdNnZiUpJLddO5g6ZhddVX1y6Oc3DEfzNBOEFWGf5mHsa013+B6OY4c0xmIIZprf3SlZvLHFbv9Ybqcyvnz/81fI3/e71oWsdfeX80xunMG8xrapfP394vTHGz02T4n9/KCZ+Qn39/zjDyupI2H9xxBdrTFrroirqgvW1kqJOJdIPgkVGPXGTHvFM3GtndqKTmuF4Gb2zprg/1umED0brY+V5DqqpK/wN3+IYoq7bujAj0Fvvtsl2SEtdmndxKnd39/vtvcf2MGO0BOlKMp3CSDJ9kSVsxniKZrJ8EaL0drLaQpa6GgJBM9S8JRHDKZ/PqyZJ4RlMUkKlY0LmdmOaNFdaorpBE+JUIwfnL5FNOSYp5BLBDCMwaZEeokV5JC+iSLnYCVJopvCZ5qX45EJJYxBoruhpQ1CcFh1PHwnr33M3H1rqY7fDObJDEvUlAiUIkddJBR0gFdj30fCOSNM3wCMNN270j/V28KPoj3dXN/jr63vr3VlQuR3va6me02VDyVSjHFAyoksRt8Fl38giUHBo2Em0S3AU9rBexJ7iaBxTAgeJssY3XsHvTmBb7uzHDP3Sdt4rS0c3NJRpcFi7+/z4c4GgJ0h8/U6zGr41jnoIEWhbtx1W6I3cV8SbXqdrVvlAqfzA3xTV/wLTik5j6c0KA2F02qkpXLzwDCxFNLi973RAAuSfgVl4L8+44DKLQ9eqoYpApIqZ1IIKvJqTeEVFxtaIuAUw4nJjRO9w3ahY1ekl14OSTx4B28tuNKJtRc1gI2K/IP4+uz1zyu6utf3Jzd57ou/iGHckD+MIzoe6I7oD7o5oYtYdw77EMdmUONIdiWPYjiChUrojq5z/ZfL6HVntowB1RypnySB0d4wHXzTsD9LJYI3CqGasuRmHeJfsTxPPs8Hfo6Xi/CsnADXbyqC81K/kzuwUlLY09WLQHWsZNvuPDaucD4IoO2zI/uCRWO8HXyqOoMUHtsj57Cbtghyi8XsGNwYck4jRa8W+AEzsDghgj7B86BThRXNUVsMChy5g8uRp1Qv3PzmacPBwd0m5jhHuxNNySXNlYdhlx63SNl75KGfQMnfHh//8cBkmXJZLxWe4ImOn9/hsz9VfWmerQ5+NBegdCMPrcgkbPKS9ch5yGNbEEJGutvEUsmeN6MNcw3JeIcFTAHZcL3u9Lu65HFr+5tPA+98E3/vEXgblwZ7ZxcRKm5qrcJ4eQTmaCO7g50EYHgeFvlygV8dk6deXXlVdR2Ag7kQiNyixY4bjb7awPS03KRadJpwuwKdjxriX3HMzoeM4GRDY3aN8mwCwDgm8JhJBXa7nzpmsJ90T+cj3fzl/8S5ErfO8j2L3l/MX/8/5/wvCtE57+E5YCrqiJeFL4VRfExIHB2SbkBsGhp7vV6QV9gltDKs27sCTVqEsob95MkxJe75XfGiPibDG3wUtWacySQ30avIk9joRiK+v5VpuwPd05NKLeSzLMCOBdTUblYS06PnBVK0c64Tx5cHytm8WVSsWXh0lzKb7RvSHRaqJ47FEk8VDWrfLOVGLz4lHPxoOCErwjltFlxt9c1jZGaMeOK9XJWcVuHjqqUlNL7p4zNeLroZu6ztyYn3Tyzr8LpRs+TLagS6FxKTwxsmaF2dvVi5yonm9Ye0qtI+s+YqsFShfIAApm3FAPZteau7jv+Mlhi6NemkBvVGi3+4VI89D0duI2hC9Ni5qeWD3Bf76vpatsfIEzEfGk7Fq+ZjFkC8wOEYYICBkn/1dbowfqEct/bFlT17G/eB34kDTgPJoKFYL/WXUi0p2fsfTeX4ANNTwaAYl19iQ7ll9uly9f7z7ULzt+bXcOzOAhxgGjqR+Wq9b0fMPn36bT/8VbJnmU39zVuf/uPswkyxKfnVZDQ8Pnz7zBsdTTPx0iYiEKHJOJTQQ8bF4VdG4feh5f4zggfJpOWxbIBHilddakVX4vMtK+9NsCW50Pq3X6FQeSKdBZuX/r4OPFS+f9FDzzn+WZZxxyBYsfWGfSLZkaLGMH9EthYEzIh+PfC0Pw7yzZkhIHOaRbUKRMMzLtsY6fMNSWLYkdKVlgia2ZTRGQZNtTaWokJP58wt9gtkixNORfdxAk85LZKRImzk+E2wUq0Xf+F7v4IH5MWHh51MyzuTl4Be+9jfEHXur0DmaqPhtb9b34Kf8z6VijLJE9pOquXqEHeiTJc5KnSjxflTVhmnu8pwscVYqKRGHQDnwfuEC8y6qDVNmqffrNw03zrr99QE64sB70nS8Z4MII6qdYl7JHXxdbareiLWJnGGwLWk5g34WLLMb+vght3M3VksVGdg3QZo8/kH04MhFDhoyQCuEIKaf7h9vP318ICgpQLHK77BIxbSWnoJZmCOobB2NKDwDh6SOWbG6XhFzDwSxtRwLud3juPdhyqXCeHlTNDxHF//uZzCL+hY58owVxtTyVHZD4QQbOHp/4eA4cjiceIDeajgj9ly8VeG1qb36wMFLtO4Eq5I1b3gPfpIlmRdmqhmSTAulJuQVod3XTvmvidTDOsaacY6QQJ8Gad82ZgOP2sChtl3vwI6QJfEGQWXbu2SK1MI5SiFSAwru7BPxk3u5dwPap99hfNsz+F3Hyu/7MKlEukgYsqEkD7wUX2ODuEE9fK7892UousJfZljZtXPNdsWha42UrXau5mrZWaDQ7GD/RiNaXUhdDPZ1PH9TdfVr2NID7y+EjAFgEXDxuXAcADDw98A/GKn4pdayEsk6EeQLpLlaxelnHKmHUAmqJ2o5VY/mWCCnA5FK6ShBtjwo760zwxrmRFJe6lQAp3Sn0vFJueToWSHM0gcm0CoGSHj6cG41bIYl+ADyMltuFtEoytnUBGIRLXIqgQ9oihcnE7IV2DMy8b5PioRbn5HIjoqekXn2QsnezawEecKnUv+kGvlzPilCq5GVCS0+wOA8MGV6rggZYHysWuPvEgJcOhpGH0vzhENNJ6Rpmp9IQogwVj+NfUXSUGsUuCRf4d9pS67ehU53T6wmhhma3jwgsfkAgC9G4EEdKvBRSSlAtGZS1ZO7lKrWCTO5qs4vo2euoyeFwiMx3uzw/vLx6j0gmyIQdur0yMoW/d3ownGPfhR2CoJ6v573XzYwI+ySzvejWlJM8UY4HU6EIWCvI8g4fEz3azKL0+esTZ+3NIVUTWlymTJ+x4eSkN2E9k1VggtUJJa1XwoPpVfoHOI+3f31lfOopvgXpyXsNL9fn52/Wr5Yvlie/S8n7j1IDfWafCO5IDNXO/1kG39aN7j9UU8pIqFa/EX3aguwngkJVVfjXCEo3ZhqA4Z8fvbCWkqHvoY86WrcOG9NlPblNKtNycJcZoih9YEMT6WJbXq/YUpe022QYSP6A2orDBty4DNsJO99zLlhI/06yxH2klzxvsLzyGEjfSBJR9ACjF/qeop0BRj+XNyJalvLeGDuMOwBm2FRNSKE+HN8GyyNHKsXa3EgNv4WDAoPgYl3iwC+uAjoiYimMmvR11pW20ViKuVShq6g9OR6FpxYptkE6uzB8vS0j/JFBLL0NDnrj7FgI/rjBE2eBm1i0ryWXEglGtIUFiNOygBZEfoPpFvvXMOR4bZJFbDmfhLAaR8oar4Lya6CjSBsdusvSZ1/WK6j7A8kYVW1YjV51qv8saQGhwHI+aQMep5KzwORLhImnYkA2h1RaFK8/ZrepfY+KYo5193ibPnj8izhX03484y/yPiXGf9Dxv+Y8a8y/qeUjxyp/Tq8NGiJl3k/IexFxr/M+B8Ir5P8IkxYNkNbs+TBBB4rYkdcf8R9/uKcFBNwgn1ITroosEIk3CCcb3oqf/beljEw4egvciEz7wjplZuT+ttpZl7PgKHQnUyqTfXI3GuVjED5AHR3jIIRu4wgq4PPd+CJWA2Go4HridyE+7d/S2UX5zm/PHuxfFHMoWez6PksejGDns2WezZb7tnybF74fBadv9zLWfSH5dnChapBx5TzUrPoj9+Q88dZ9FV+1cVo1oufFi6UxDdlmJeaRX/63ov99E0X++nEo/rbFD1fXsxhc4I/zmFTwR+WZ3PYnODLOWxO8Ic5bDG0Z6fw2UIWqjo7hZ/KcH4Kn80wB/44h52oyo+nqvLjiar8eKoqsw/m1Rx2ohlfnWrGmZ784/LFHLZg7bBhp1OK00nnzyTNZyu5YWenU05nOj+dMp9prr0AP5Xh/BR+KsPFKXw+w1xvAvxUhvNT+KkMF6fw2Qxz4Fwdz04059mp5jw70Zxnp5rz7ERznp1qzrMTzXl2qjnPTjTn2anmnC1lroTzk936/HS3Pj/RpOenmvT8xA2fn7rh2Zuaa+OLE1W5OFWVixNVuThVldkn+HIOO1GVl6eq8vJER3t5qqO9PNHRXp7qaDbhVFVfzmeYb52Xp1pnppRXM2P1q5Pj56vT4+erE0Phq1ND4asTQ+GrU0PhqxMj26tTI9uruXHnp5kb/unkDf90+oZ/OlGdn05V56cTA+1Ppwban5Yvlmfz6Lzw+Tw6L3wxj84Lv5xHZ4XnwLnbODvRfGenmm8WnLvn6R3nwMVyZrV0MdeyF8uzOcmzecnzOfBiDnw5B/4wBc/nrn4+d/Xzuaufz139fO7q53NXv5i7+sXc1S/mvw8uYQ68OCV9MQe+PCU9vZEceFmkS+kFaBWlyGQrArIn+4KIPSMfr55tJaQbDXmqZ6+cg4wPYasL8VpW3jVNdrCXSOgTIlixyV7LcX7/DeW/IeszpSD++eby+u4mK3pWQZxkOpUO+V9k7TblT9zTWSY45U9kPE/lsjHnPCtmyp9onfMXZ3kVzl+cnU+hiyn0cgr9MIV+nEKvptBPGZR9GvKr569YXpWX2UuwKtn2VMu+je7oInjq/QrbG/R4ZzPcN8nLRU94LBt3HD/zWuhEVvGEk3GLTvOK7MUCFxIHXsVTouHhPyc7oNqM9ZFUXx81LYB6Fhs2w+Nm7MqcR9mxF4Ye6Dj+EC6ObPCN/J3u5b/Dtfx3lvi8CDrvC4jivJRyC0dkx2Qf9JiOmEctKtanp77BN62n/B4RWK4PwrkyABoOu5P9dTAtHMSwqHnLDV+YjdAL78VWqmM48hEDDdc7iIErNG4cxF6AdSOQIb6ULn7VXF2BKx7LowfvE+faYi+2gYAiD/Dj9Vbu/+Pnxe3Hd58cuIWjx20TOq2vUsv6XvRNARaOgcdwvgHQyqnt3resN/rt8XdePgwb7o/BJiDNbr4S/wNDy45E8clyzqMkcjEimeUaJce+TrnlodpLtdUDq6AMrrdOdz/lCtbLfrU2g2OytBSGmuqiZnWBGuReCTy8R44rQkQvUBEnZDiBAuVxSs967QtRVuZA9D/QsLrhRheZZ8BvEHszqta7H/h7UTRSNi1fVrKby+21ul1kmUJUoPaAMuuH3995PfR73wZ7Xs6ger+eRrb7lwohAfBo5BY0kc6xIgdn5HIxqC2+44Cm5spD66WA9o+8Wxm5KiFoyv3dpQcZ/Ezni/eglY3fGsunH7DJYVfH5qc593eX55PCz1+8+AFyIQloQeAi4n8j+N8ijtMNiwPt8XOCnxP8guAXBH9J8JcEJ/U5I/XBeYjDfyT4K4K/IvhPBA90uGj4LlD9mI51x0kbd8d88tVNHp0dmaEI8slJPjg9OQiUdcXgLfWkpvSKCkJKKyowsnP0ESmDXycJQ5JsqfqbbNtSSmqucS/bNrlCF8YvTy6Zd8aBbA+BkZFXPpy+n3TRBOMdrCIL32ZNBYfVoKRz34FNKYdxQGO/wLSBW4mOOCf1kJYQSsFDGL7cU0UkzyPpLeKRXoH6uedJU1j2chguiZERGMEM0j+u+0/e6aPlSU21WYsDKUibRnH9pY26RNI7yE3yOAeF5FmFbpAEKx7knivn0bwIrNM88axt0EB4yH8liIqVAuuWQQnvLMcR5BLK+aXdUXppuiHyKpC5md6gxO6n8DSU2DHonJ4kHQ+A0AKeX5H+7JEMAKUtsERNrmsBMNxHFtW+gCVaXx7Z8iPN0umGFikr51loy5XXBVZ8NTifij2mc62jUivhw1CgZIWefJFe1nyX8NLbdGEZYe6nZL1ggyhqNYo6X4X7eBOETCrugKCP6PmV4juRmH1CQiWr7SDMFCkIRCJbAKIpnRSKd4xvd56mKR3GG+BDQHb4XYbpJwr4aG6qDsRUxC6G7BQUfqlAo1hXEFpH+o8zpEdbPDAYowtIP25rmprcoAPWijWg8kkV9CF1FozNQE2mKWSYajhFNKWTSnTcbPioUw4KCCi2CNHaUXLgwTtfas09KGl4ZXhdBHvqCKmxN6LjKQpu5xHcCWe5s6asps1wOAaCVOFwXA7e47pntFGcdW+kEo3oT01XnU9g95J9fvw5vjo+zTQ5AkMdKMQpO9W8//yZawNGZsXY2wkv742omOH15f1tsfv/ifvb5rZx5V8UfX8/xV373ll1b+2S5YdkMvNfNTXHcZxJZtmJJ3Ima+3aVSyQhChYJMEAoGTlRT77KaC7gQYlOZm1zznblYj9azwQBEGgATS6z9KUhY5Lk16c/TwKI+ePNF7cLZJEkM6nDmOJlzleWzBrAhTrKwNmkTg5Ve0D7ko7hqzThk5xICee0QNGETuWBOdGl9olLc0QcvB24VhJEZTAH3k2Ip4FCxjdACANo8gdgAWzKzKMJaUJqyLkdGoYhwHPDw2jkUyYgqNBdx/vEbndiZHQV0U/VMO2RisQwzY9026Gjvg9+hx+oG1/TscqP1OP/Dmzkv/5M1XCZzTr8dnWs0Mqt8HlYySoG/3j4/WHf795e3/y5v42Bq6Uo2b5eVRV8pn2h0c3Gn2SfB7VGnzM4iz8czqn/HkrjdsNWo10nJlx2PgNP1RGc3oal4/M8xeMlMmhqnn+ItNyNc/jWG9+/jmSoiyV6z7PAVTrAr3cTnGY5QKzhjPrnsAD9UlgAaqenTF+jbRqNZlHxAM/YS627CjYztEYRmKEVbO8c/vALO4bbpzaCD9+FHojzQngXTNCqzPVEq8PYi1MRh84mG6qm7imwY9lmFrD92ykqFZzqwaynPxBwhzSX384P72NbpmCyAUG9zxZUMl9xCKPFoPiormPdBujp1w6Fo+aYEJtSprBLkGTQ0x7+4qBrmbZJNARMBxQmnUWlCGsWox5/697hrAS8GYMdVkFJQTpij+vb95fXUNwJQZXgYKRkZVUG34s1XN6BycnohRjZLWSplrxagFrAHWW0jcoKFAg+SkeDB2Os3hOqZsiB1mczmIq/LDCArVkJLF1BURwcc3IOEgb2bDbwVkYTvPbIYdaf8Bgp2aK54yxQ9DO8aBdwQQhnGsycmJx5sP1zfXl4rp49/7+epHecohqkSZxHUlq6gy2HFMTk512cnaZJBri7PndMhAg+/Q0njFfNq5oRd/86n9+mZ+cpH/H/krVz61tN0Nf/8WMarmZV11dYvIi2MdNnTBkxOrC44KMksGjFdePshrZC+r0Rr7TtbxB75fA7WtO8RbQO9Fa1l4mx7qDnRokNF3nRBiXqCyNNs4yMoV9AMb8Lmitgk2fePIZY88/yVK06gsKY5AErL9iOmCBoYwsdbypjWW0ymlDjzCCfRFe1rCqSsM9wpUAx8j7LD+EQaEC904Y0V2n06boNxzOfMWmbcY+ARvd8Xm6benFWBkjONbArW5HJ8HpQ9f8kg65UvCIh7qJ5s8GHJuBA+GpX0TGPEcnvsSzIJP0op0NMEc9qWyec77kndhWWDs/8b+zdHQ5BZM/DIOL4P4aptQJkGM7jxLh45zPa2FXYQ9lwlfWjnJeGSmc7KQTk+Csx0JuK/xUdN4YPQ6jlWZQ1Tq+HjcvpRPz2KSUtPNGQ+QYhVajz+adqIwXYCQddA/hm7NEXsxjX26dMI6RrC8HATK9b2eUn7bliE/ijLRjm32NHtObGkmW8BS7TSpleLUsdViOYGQeFrbyVF9lmNo62g40jQWL4dgn31R/BCHedKzj8bOYmDCb0iQUtzqN1vE6JyLm9UFrd3V5UmGV6rGvq7GU+fqvGdjczaCdEzNUTKocqq1yq0oavIetwAMOIosXlk3a3DUj/JZGfR75NznWNXUsY48X9JCG8/OCTN/TxPTDaFcLlUy6hRvH1VQ7t0urnLRzMZrQyu15bVe4YBBjiUSdJ5Ke1YpWMgMTAZLpCwDYQQJAwxcRoN0LwPjaAKDViwDy7Jfad1a2WknYYLGidckISjpaB1TKldDXBC0j55wOtsCV2+Goap8KCwnRtutvwvfLO4g+zFeiF/NHO19q090k15uxl7bCFezhwHTgQmzQ74KnXmtzIzLhy6bDv7aENmUr0e4MkitZj62snbCwNU4ck4F5jqKHBVavgYqvDBDqMNhqpXWbG2W3lZI9DCm2MlL2doXOymDfKlFzRj6EiXG0sPW/cLQbd8cYOed01ajgOE8+yoyNI8+8Wi/9d27CSvC8Ip9Vc2GHhMhS719J/Zgnf/xL6YcVvzt9fpRa9xtp3EkpbM4e/Yg7fdLlAHZqJ2yl0Nqfst1J3ba/rpwb5milhCL1embHajWD7ZyWBx0wVxz3KfmXNeGhwfCtLFfK2Wmhsh1OYvLdXs6bskJjaaSrzWYvYwjs5ba2fQyroyqN9QMFlLfG/qT+kjZ7kkdkO6HY5xlwMUkD9nb14zSeF5NFJesy9a0TftWqaVAYl/dzAnbsW2RlQDJcBGqemIxMXUmAlpHkIBJhTKT66EeR4NAMHNq1QUgTQiurEVRDgOKF93jOyCu0eirvwh5dENz/hj40/cgmfvXixC+DHsZWmDyhE5XL5mx5Shb5FUl/04AaLfS9Vm1WrLAfCWo5d0G8e2n01kozTf+H78+udDfoXvbub68O395PQXxWb8LaUx5Y8JdCS6EJVq0U/TgkRp1ISYuZASq343QcCgk/dlncOTYWAElHx8pW9mrsCGAiwn3dGFWn1tLXqRB9jTIJf+G9HSmpCwVOQkKaVlup2XMbJTBHs5mNtH8AUzvic2pGW0IIkxWgjDFPufACHsRenONw2TD0wPKmLcfcPTwivRl6dtP4YQNSNUP4dnD+mgLm0c8GfVuBe6Ak0JAK2wncQEa2f3gWjXVVHu6veUA0kIKzUt0o66gmGCe2K0MuDSbraAAX4R3wCkKjlUjO4qqR6q0TfSUn7/GpOFn1qEqeCNs9ctyYgcNhWzP46ydbtwyTjfcqtQFVyVra9QTOq9E63UnD3Kg8HcWqBr9m3I56LUqjKqbnSmboOJ0FkCErLz2VwsroPoWZU+cusoj+4er0h8tr9vuah4phlXltJn6luxNVdifCPjs9FfXJVpZLUfl+H+chJ16CqHTvjPbS8MlVJBf75aHcEJ/IvlG99JmKYTjB3vPaGG1g7SZ95d9O/TY4KP3rd10oL6P4AeAvJ/3YV2JsVg4TXj9WckiD4Pfk8EmWl8PAnpgnfbIqj9bSSrat5ow3nvFJm7Y+kM0b5a58Y+e898GgY1D1efTTtn8t/rjBpHOrxRCmD/AANjDmn65fkgsz3zQ97yrzsxaVDf/vy/qpUnvGvFXl3DP/esm+Izm0ogMVbHuthz3GeZbWcw4k/b/M/RRleL+S14+D8mLbm/vbmwO3jDq8OMU9ucqs0ifFyKMJXmvThZ/vyf3fejRX+uSd3Nrws58magsjDlpj/KGoc4wL4rQhCZ1soNnSazbH53P6CNCcPCbNSuQceaElmgsOyEkiOTLisJ9wEqkZj5atMiYeR8p4tHaQM7f7d4kiYOJ9zRm7DD7mJccqRDCqk6FNRSSZ1E/d/FCUUBzi+awuAFpd8AAqfbomtXTDbCrxrHDha7G6SNvVdiVwiuGJeaIG0XixPo3FnlsnKsmZKylT+VYk6YY98fRW+RY5AChM0tML1JcURwX/xDwL/P5X3BevR0WG9kGeB5xBOsB78fOPF5GxXB5I6mWQA2w0HuxJOuFAdFEJvldjV3pL15wLapzFu+Gy3lwJd/db2IMIX+0vS9Fa+fdKuF/O/r5UrexFJ385lPC1FPGMy19NC3OqQwlPn074tu+lWXhp+T+57a1Q/Wsp/tOkd7/9xw+8kJXua2F2H1Szcv9RDqqW/2HZF6pvWnm30k7/R8nH8i/cmH8RW9G2oa8gfLWkBpt51fI4bLbYvJ2yCe5Kb4OSbxYOyq+ADLux69Ii4mp0td72nGaZqJLNV1Qt1+ozIwvmu8xPAmZ4AyDnRBeJXTB24mbfMGDUVEOEe+AJtQziVgEi6rIQ8Yg4MAAAB6EIbJ4lKyKeJCEG+kRAMi812YJO0yGg8ljjcCLSopLqBjHA1AlIPjSrOL4Hak9tC9jp+T2q8X2D/D+RWALz98VdAknlZ1/WUzicoUayv7Ku3qNWNzFKesqwX5NFJJ8Egabx0tOO8ZmHgohxbyVAHPY9jf4Koo+BQFS665LtaM8qskIU6OjfkjW3DKQ6dUxxL6GJDeJpwF7qibHgaQCLT8vlwU/HSnfyaEBae6fQJBBknDmtGPIE0y/bSbQvx6uM1VEnhklImEekV2IjQatZAFgiOxdtmGQYETaNs13yQxE6odpqpbrhO/xCHEqf61alGOQv5kgBKPhYcreS3ZFgVAM6gWfH97oIQf/s9baVdSPnt+CbfKWG+dveDsrIOqyfXrFO/jvSuNHp4I3cp80GiJA2Lx7kRx4b/5OyfFfarEzfk8fdaFffHRm2Hg5Gx1XFaEdwypuT2f/5Uo99DZpctQk6ckeyOZjk1eLdgfjwMS9VX29w2fJYnuv4MLXtGsO/zfjq0MwxqBqrvplv9l7wF9xRtWv84tdZ/7JW/RkpecP2vGexHnCNZzsDwRK2Ipk/tq0YknME22q3mvrZsp1gzg8DCqPqIlDJDJLtSiaddEu8qhY14WwvBotK4Gk1wRNxPPNgHqkwMOwtKvQaNRQseDsIqytEpB3h/3ARRovBsrVrvXRsANRLvvOtl25Lkze9Ygv/uqXUrWHuBRj0IuL8V//7i+dWkzK0Y1QPtroXlFsvTNDsiOhzQqQXhVpRNNgExKLMVW8H2JaN8k8IKBrZ5wg8YoVCLALzEusdkP82QSUt8XApY1a1wtoUiC+XzjoHAgNSpQ2io2uro6VqX9h5JLDjTUoXntmqMq4hxyVkCohLAq2uRJsFk/pdZOBxMk/Txk0wlA1UO/a4tzro3mrcIRi0xpikAwi+8oGK6v122KWBGYWhzB+o/cwn659bUjJiLj+Zw0/m7nPi7DN39RkQI7HWkvtPcv6558sTPHlm5ZtPzU8jj5usJdZutheNW47JWed5UpHz9uppzgudOe1EBrkHRVehefhWlnUWzHIr6rHDhcbPbW4jGu6TKGy0k7uXY13vOJ0FTOTA3E+o/dwqis1MAk98gXqoGiOcZNn00iWKFRg9C7MaWfxxs9PN/dj3MjarxedRinVmHt5+HlU9y74Pz0nURRGnAZ9HZYxs4+Yp2FewBr9aU83FMND+nqmwlSWcbwCCzgGQG8xhE51HW1tsOhv3B5GX3oatgl7j5mxeji2sS+LxHmtX7EXZlq6sN7dt10CVW00zKt4/WTaNj3pvQYPLOm2wMB46IyoZq5INnE4sl5FgX7uH80jx+A31JEBmabphtjpD2rCHI91K0KzkKUxStAWEK4CeXuTbvp41DnG7GGGMb+lWVL1khcITcF4MqOz+Hp8kOrwruxVNE96/7o8E7UQssw/KPhrPsnTAPKEoT0QONH+E61jWmM7mJbVZgSx73c6mxHUkR5uo+GHdX95/jBr/GPZo24RY8rmV7fKVsuFMhazn00x/XY5t+4szo0w8RQ47AdL5eo921u3WAh9aV+s/Ro3zZgbjRmxwBlWL3ayWrdjJevbZh9u/GD15GQuJuMiWjvohOed0qxs7b4URG9mmFoi+CQLBRLCgH8zelYc0xAU3GWIY5tJVcxjwSaTyQUWeS4ZIRCXleev4AvEinO9UfbOYNDije1GccfqUgyzknIMLDp5x8JyDHzl4wcFPHPzMAL/NOS/NOS8Nvz+/Pb87vzm/N791unOz0m2dNFgSizdla3c2ruy5HSx1LTxxpQfYBE6vbEeqroGaD0Zb1QalEc9InZMPXUnp7Lwc+zom+vJY8OWa2PWN5YxNU0amlzqWHS4zBKoQxqmKnxW3Y2kro0qZAZ41aOxlZy7sWKKhCbxjI0xlOk7HVo84yWK/wjLFL5egymH/DguJvyxWevtqHMJ5Vnzgo2lRw+zJtP1GtK3csboYkogxDijke2LGxDiPs1hniUoxskxNJ7IUIN0cYJmIRzsBWexodiKgjbJygm50o7IUkdtzls5z0XjY3o5DVGcAkr/ZwODxCv6wgcHbmmmC5tgEdU52wzxgL6i5oZ3DFl9co9ozSfQfJWamiOxoNqjvFShWajvIvpb1CbnYs5seLyd04iG0hT/fzZEPVxitGTnLDuQQc1Q5Sh/PVBKYDv+AvWgwo0PuxJt84cjdL9I8v+/xkCyfrMjzzdnJ6cFChIAjT5EHTh9pc3Ykwyeyy4LmR8L2bnR+rOznT5X9/Kmynx/J8Insjmd2cax8F0+V7+J4+ejdLfHCPt7tEnw809yDPpMMxA/mEbuDx3peMiW3x3owcEBwsYuubuy/E7nDmcGuCzrnYVGfOEvd7zI6LFQtTVj/j24+jR6DvRBau3gqblzumEQ+pmq32HWt6tesVnbdsGLFAnDwXn5el27zRMR9BT+K/kROx9P21TtdpwnWbmCrFh74CUIaIxae9SqwimgNzO746R8CFDSPFovsjtmh8iBOe3eW5qmBSgWwdGAVyJg023Fa7Jh9Tgqc85DzLMhmgILKaLYKzW7GucbOsoKmyVm0rwEU81IZT9RCCG8PAcfKDr7jGZlOOBLD6D78sMJ4fuaAjXjgSVDpHpQJ912bfkfkuPSXR2cVgNBynM1DAqs4WhtJ0zjAaxPnycB4P7q8gmiuBy02PLE7PaUC3l+EN3wrINO0QIDWyZxoWlXORqMQWbqm14KLf2zhLy36eQpvlazzADUH0q6hLu7Fo+4192PmkjTsKt33cWOA76w6idaKnITDJP7aqyq2v4B1q5sgYdxHRHs9l3XtX+VLrdffjDD/dgxGs0nn02m4YvF+zJfCqupKtNXYkr/xb0Y6ltXYttKp/iWd2f1GlO/Jxj71lFeilX0tzNOhR25D4+5+yGvVukx/90AUOi/4jeD5N8Ltd93k6Tf4++Xl4omyxOBvJX+yLNNYRzK71RslP8Qzx09G+HYW58Xp90Q6OxLpTjTyg3SjQWMJT8f4jkyerKEDEY9k+UGKWvXNDSpmPhnhSBYLruvyRPCTyZ9s4VmUY9mwRYBvx/iOTJ6s4AMRj2R5H4aVp8KwT1/3Gg1V5rZonGwlGwNaGR3E3stWGrU++STLk49vT14p0ermDViQiNtek0ifZPmBTDiIx/pXtxvkL0aMlLmt9CARDKvk2NbJdmxGVg7YtPPXmZPW9c0MTqrYkZ0h98FxUJRpAfn++vZuTsxItGjRkWieSzBmzYHNQB40L6X8km+s5WEXk/j5RDbxH8RsJVulZ0thrDqW42C009Zh7574ZjWui061691W7I4lZrJdZBZZPQOrmsCUAg9iEs2kFWnEkvZInIS1L39V6BKZ6CxJZyPBasQ6us6CGet5hKDnEaEe3YDaeQHDdhbHdmxjZvzONipqEP0YAeooAr3qIo2rCUTHwtJORKDR8ie3ih/oZAI0wPi92VTcObMyE7CL7dW6Oa4vFpx5Ggl+r7NIZNzzCw7PI5E9yzmPkyV4xsFzDn7k4AUHP3HwMwdFJFAngWimkRBYauDJWFu1TnW6V6JFYSYY3IxBiURTjiiXS+s+gDWRx/TQ8W52nijUSCtMtmLtw3DP1clHmJBJbDr0Sh/dzE9Wwg5Fcr3v+WjFFe6yEv16ttMja5aexb6pe4//vRdjkkaCaiHosiVqzkjUTZqvXFCXWbbCrg6bKnArZepBGLfLderuV9qQTbekfgyUn4wnZDL7uMDDYo1dGQkeZezKHveWg6a5RY0Ktw/gqdRa0TXN8RNieau1Cj5nrBNlK8kaNAVtY0bJqJunW9XLk8eKSGCnI/6ZIfcIopV81ZIKZlJmid/YNHZQOKfoQzAFpbrpGKH6Hct1dh69Ox0KOT8SQu6X9kMuDvFTfWTsGJXVBa8KTz8csovgFKhdOOWgGd3fBiEONXIcG7yph+uG+TlngkmgKCVETsE5fA3GM2D1otO1bO08ZyYn/pOAYBUo8RqFCuceXTUKD9pEVhWcHYl0+CYwh6wYdQZOO+GbGGfp46x4o/pLFv7ljMNMlyUyeN3kUkE3zNcqHINlnJuLksNO1HbQLjtZ5Pm96NF6pEeZ8W3PCJY3GM4OrwXG5yw7tq7qIeuKu2E+Zg0jd4SQODZj2fypNqIRHG9XXZUleGQ5jio3uh44iT3fyrbSXdTPdzADeP8quC9xuk5LJLqrhAvr3HMxDLXcoI2R4FMiHH2NmWgN41ggYlmCSZBEFbAayFkTs7jAPObvKoTupaAL6HQEIvWpEbE+VZMvGqfHtPEXVGJCVXy4BDuW90FJRjzWGfiv//r/vrq8v4xJ4lK/R2v/hAhqmcY2I1RPY7oRsFYaiCVKg55uRTqGEBidgtOVpBrlgvoBUGrYKjyL54zaKFCkcHZyoM+hLGpp0LcxMyaMOLYn6HjAWEpRMdUG0qqGB9jAbwrdKi8fzMlihUPLfH7eZJGIZx3dbtAXkUis+cQp2x4zbxLT0IN2bkKsAvW+AvDVNL+sa+UnpaLNT97yVCGifHTzyohtG4ZEV4TBONrcyuMN22KlmpVtVS2LBqxWfTMR6A0VXh7DeP9rSQoI/e+idjNtVPO/lsXh1G67rQoY8b9V1p1oivAxDKJaF2CY6slEfn5WLJVs67fMNVQIj7PgNMEeSxzXA+F7D9mFgbBOOxgxaHeUxwxDjBU7HjVWW/i6xrpWdJ37n5ZZ9PRYPg6tNgk3o4oJp3GjSviIhqqG1TBvpAMjom+5ww7YIKS8HtJzh65m7EojKh30RJPZilpeh2wXYpMsdIy9F+D7mnr4sVdLJdGSjOphN+Jjr4KY6XZsnWnsg8pM+qTGocYVCKBYdQHGeB/vXl3ex8MfEGYZmdJ9REaMyj2cfLz77cPlq2sIaHznyshUJoDJLDMmS3lCBIQYWuQHVD5CpBvdnPzr9gaTRccG4xBH/o9xK3acUDQ3T+iRQbSyjQhn5Qm1DMYHI3TBoM2Szhl5lidMUijiMjhCIWuCORPNAyIziAxvHx/kJAe+PsBZsaID69BTTMqSBh7EbOeaVEJYOwCW5E+LnxTSk4iGRQz5ZG9mP2dwrZGx1HKXgb1QdgtWdZNcLI81F8vldpjVXKGZgrjuKPJ4HYEbh4L2vEaTBmei441hd240kBeUzaLKTCDIlsBoZSlFlBhJmclfZz5OfK2ccaKIxb59m04cBTq2Z8uUIrh4G2iW/TwSp5E6i9R5pC4ilZ4/Ip759Mhj4qVbpaOxHhZZjkUzKuxtIvKixDwt7U0CKtXKR2m+HSGaxDsSPuyQOpFNM4tOK0Ns3t4s01+LIEathkTl1QALEx+tNK9xaYTomO9yD8R8w+JRll889hlB7CqtNDdZnfeiY329Z+hsELHS4Ar/VpYgZXQ7NBaVz2+CN71I5FlEi6kA4IGBxrOhAHjLjBN0AB1PxNqVJcNWAOiLJYAb3RHj4ilg9tjRHis4BUxU9kYRTh5unlW43W/p+BWbWRlrHj8wt/wJrqpVbscUAD0HyrMZRC9BD3Dc2kZRjYX6BKvJmzNw4b4hx9ybsxMMQJhpSm3O5uhGZQe1tTkLo8b8IRjasrpNeqr7QYV4EHQqY3MOv3h7WDLanM+LSjiBr2+i9bU5n6/lzs5/NbIajVUbGVXVNxfwO8dLlgxc3aVJzmbyJjaiMaJ3s+ByBWdfcIgfQ0L6P4GmJUgGT5KKzEa0qhbMHOkGtsg3wvD7mTld+Xw6YK2ddUYEKe0kmvPxQUkJxqNWlfOq1WMdjbuFtLOl6pVdgQmXI/ECJLsx2JCPRPUjRTr1dyQSWnG3T5VNlw8nw7p9Iga3S3ssCu4cHQneG+y+Jx6MgUdiwlHx78lzEpPlik0ZyDmnxehW2qgvkh2oojBJxtGmAa0qjRxEM+Wj5SOCg9ihF67mALt46tYUZxC7QbQFakRNYqX35CeEpOPkcbbSthFGwQSRt35F39Qm7AkECr43tii/Kcm4w6akvnlT0pHCQ2/m4CuAw/6MFNYGJf7gTbAiW6SWxxid5lIvskHtnzFC4iCxYIIinEjtxDBJuR8xE1KPxgoj7CCq74g6WPPsm5GMFO03I+ERqiPRrvwT3mRy+jRK+CbaVtZxTJ7GuHl7df1ucc2CnjDGcCTGN9xmH0n1/Sn+Wv7fjGmpCW5OSrGOAAmDk5JfVf3L2d9Dz2y6YiXs6heMQHtGf6Kj7/iZ/Hn9YfH2/Tv0HEQofhKG+w4giCuJ/LwIJlzE0TsysozjQbONqqWOxOzB0vZdwOwrVnI7YyOIkttYMUpul9qMXR5b92HvK+PZSMy9CBEaq29NrXTQnc8FxQhrwzx100tHKhMbpVvwzAYPrYwbRXvdWTioEaf5GwiQ+wEd/JI3NMhVG11HIj6eBxQ+1pFg4SOGD3285ttum8+drufVSlZrWTNpILBTLxxgp2s7jbL5zIQGpwrVL1PeTuGxBaDmiaxQiWLjxj5ZbYgvbuu/bndSgxdxRPStb4WZN1tXlEbCfT0jGkTwvQe+C86v5dBqmIV/Ekau9Gjl9e8v9xlxeSxyXxsNuq/fEy8dHoz8T/AtcLwXgelGHWDj02xkJ9bh2NhYK432ak/IYvavnXQrXf/SSIfmJ/+u+o+m/SXYaJhPduq3sf/dVo/F0g0kuW9lORPDMGcu1Yk1qWMKQtF7PsVo/3XKhhO6YckWJ2c89NApUbwvI0/mGdjKknQXqIycFsNA/hJn4NFkGpvFKHIbFgdiXIFLvGmMUoreTpmVsDMyNLsfNPGwNW3DYoi2F6dpUwwq1bfzijF338zsyCNSTP9UYal+RgZhnr45mLeys1Y34fj3t2KD1vw3Io29M0p+qw7r8lsR4Angeb4vbgEOdb4Vt9PH6m/pBa5vvNqomfKN+6xUKU0vXDhHeiyzVvTNGHzTHIugm2cP37gTxDmegZ9oHguOvnGevsXt9f0lfW7fqJ8YNSo4VPLo3XWp2qOh35FBUEisdPtdbz65yPqulkwDybeiOTM6Gz84EBMOR/qunI496vd8B7gG8e1eZyNbXSm3+0a0A/13mjbth/RLWKmwJCAcCjpyxxDjydcCMYw8fF9tZFEd6R19hFpI39U9lfnxLilshYaP/skMHgbxZBkenKp3T2XQjk5W8qkYnerkSdySz4IG0ciiFxvVhFWoQwVApyxP5L+VZSfAh+UTkbr2ieADXQMdpELfIjNmSONw1Cc7YojSSSfChP9I8Chmsq8HrY401XCYMff48U3jXZMIuAR8MAxkp8OtFYKXrd4+/Yj+ZWyqI3FqWWnw5bIf4kVqaaDsR0SGWtlBuGolzTE5SD6Uswex15CeejWNNLpXnZ4d6Dga36cslV3N9vwk7kc5kP7J8VQJeyiNKjvPnpV9ffLYqUNBUDVZ0IN4nG3tDFejp3k+lNraI+IqhEH9d7J3M9+lV27cbwYQ01fxUznJh/LicMiBh40BceCaRpDO7Way3xwOOJSl7g9X7IMZ+0P8Vi2lEbuZb12t2B0LbsVOj24WlfyPxtN6PRN9PVtK2R6LBBOiGS5GHo2ljTvQyIMRl9nDcKxfz4y8JOZBmQrMzCTTcsTXg+wfj3wxWCw8UnIkdMr+PArjvsxSiacRgmtb1TfHPm0jrTr4/r5TRDLShlIfzf5RDYeyJ68yj7bO2MrJTtrVXvRg6e5IzWWB+VTycI83SYDL4DHJN2+R3Pp9X3TSy/mu2IORVvbu+0tDH/lfi4xumr8jDarTzZfhWKY9HveJqv72GIMRu011JGRrn0769BgJcXw3fywTEN4h9ezQk2QRtqpu5L44kUXaCxz72YN43NpDAQe+EadaGaYTewncQ3UwgVG9qkV95P6jaY3cGnZWjULYbOFwiDYzM7b73UsYUrVpRRhW94LCcHIg4Ajr5MEuJ+zzA1Fb3ai9VrLVZh3kqP2+0Of+4gtRyR9LQuRbJOeMw4SH22uMQ2cCOWufA6vlicN0jz0TDCLm5cJdL09+QF/veQTcDPOkS3HZKX2CTXxyl0hWM7iXRvrE/jrRzfYsNHcVo0xUMJHFFX4nsTJ130nYQWVfH+d4ABjoqwhz5Syyw8nptBcQObQEHhkp++whABzJZX44r/nhHCdW3if8vUymVXbQ9PuEv5dJpr8TuehoIOJgdjF74uz1g8/4DKQS5D7lt3toGObbbk6uz9KCMoi7uLfyyApOC81RYyjTE9rKshabE+54DVhzRu7VqGfSUv0kehkJYjVG9ZSxF+WQJMOjSIbdQfgouRplnDdnYC+U7sVampdbT6LiP2d26pFzQPUPyexFZOec619urj/85H4WCwxdJA+CCTHt4MS03ErDPIV9PSM6HMXBI6p+poGKUUieNMpxmLqoqTMGzor9E3fDEB1gZeCl6Nd7jPk+Jyt/ZL8CV/PH+EcT2LyujgTvJz+W7mCCRfK8/d2uxaYRD+Y4B0800UYJaOFd9vU9HmFBn/7xu/lGBm/7ygQpeK6IOp4U3JbNO5F3UmkYI+PInnTCMXJGVnQRc9pyOss42k/dytKpai3dBEWK5iJ2U307higpV/WohE7fdf9lJeBo0HYl6ZBfdsIrgMSOjnQtO1BHR0H9FaIquyIXYp+QZr3/Ac6XbpcZi/5082rsut3bXrnf/7x9+wqqrLWzrRVufqW1qVXvRbw7bYI/vBCuTQ0qP/Tpckb8eDMmfr6RRx8wMeZZ8ARth1k+VGmzDmovUVYhRj7YQ2TmJYzoeQbC7yyoHtINKAhVVfb4QeiY5QaifOAQ3bVth1nVKtqs28bIJE1GRqNBNyBx0OZ6YpBseeCOiTHby3lYDaA8mbPO9lnn+6yLfdazfdbzfdaP+6wX+6yf9lk/77OS3uSUvz7IPPBo5YGY1QjfTM6tlRVlK+uDIQfi770mz0Rvhznz0Ps70UY1h7lkjiIPIS+FE+62P8TUh5gHKpKmHxmTpH7OLPY5+5VdHHovxaEqKd4fqJKvieNk73I0n0ChzrbdDLVjnwqbJgT2jCS6aYCd1eMwI2uK+8GH2ZOeiwV7GfGkVmYakPRuOJMHHg6zh1Nm50wYX/Yb4fSxulD9UvXKye1w7PFgOeuJ8HFGZgImIbqtZweLSvFxKuEFBNw2m8xqDiRZK9tJN5lCPREPrk/FbNuZ6me6l7PtMAOnBkr3c2Yr/EAqXxnbYRyClW8NVo9mGyW3RaubmVoaAcYaft0OorS/HMtFt8H7O76d+bF4QRSbDUEneTd/sPNdNa+TIb8DKWplP492FnwK9W6GNnWA+0SyRuumlTP0uTVrZC/BjzlxwlbV8fRwXvx4+IOxFlfH5tHmya+jaY89ebCCPFtq09ljrWg7zODAASyKClOt1Eb6RtWOtbRhWZ3OgIGnm6MZgUHHGfkHmhOxd+9xqI1Yun12OFW4z+YiyR5bKL0dbHHk+6JYEBz8d/yVqHENaj8aP4R2INhX1YwMarS6yYeKLKoCEy4z2iidf6OAXs6PPcqROENZsOc4EumJF4QRRl+iY6FBRNO9PB5eiLblpxUPRvLhyo3DsfeyXR7sBkk8n03yN5r3bNSOJ3A+xf7LWo59sKzOP/Folpno7TDfnM/TSSSSrTnN0qdTQ9thZmSj4upFgiy6sZZkSfQ4mcImnv0SZzZo62z4nZ0dDxaNPBgcniUPmbSLVIgTI2gkTmIOMvanGYOooxLrYOdVp2wR+q35yrlhvt1uT4ysS63XNvikr3Q3/0CM3i4JXJbWGVE5O7fN+bMXL37+KcxGf73RjR7d3z/IWhlZuXsdXIz/1zx69qt0F28elPD+N94+tFo8yTP/2+jmw7xWjbTubz/Z9T9fl59Mcb+t/ke10dXPr/qLZv7raBTl+P9oWbvd/65aurssPl3dFpewa9g3xce3c1aWv5zCHkryv+XhYp/yaVG8vr8DHlc8Bv7JzfvfGKIt7oDmjASni3kOWzROHUyu0CI08jaizTk3aGrhJLK5/Z+t7UQPt3ufeJqR5yfPT84yHJ/PpjW2bVpGGrfjWUqwqZVok+L7djvLTBt5RrSb51/SGrwchPeFaybbbRx9t9u4kgJkXENBiKsnHiWS+q/t9vheynZbRmu+EYAaeRzQt9tU6mAV6cUXjlJ5A0xlDtDloXnZI6vJcnQ5TM8R1/aAjC5a4vP4RgndNVCTbaU9ZlYZe6EHd5Aeq3BsWjiwB5KsLj0uw4HnQCqhk/+QxzRGPuLSHg5Fj11LcF7kToI9a49DLh/BA8096r2wlfnHrjVDlahYhIAKdGJGzGE1hFYZj+Y9TnbmHgejS5Yg+4YecWHVX2PhwW2UZ+1xHMb+3CaiVeX8X4s/bnL9uH3OYzw68riNH9ljfHM70UWPTJ4ugpAUGabPzSwETvY9es5Jq8Fu006p73Dxu2u3BjwS73QvnaoUp+NqcmRQUQPuGDmJGq2I7cZoz/6LKEsFvnLQN05Ugjzxs8q/R6jqX85SilDRX2RpROyKvsiVii/0i+zr73jUL7IfVtrp+RdMZXQ1Nbr4ZRnEW9nH7+GL6kojEgWFUcMaG9cXP6dexdj4i/f4GqJ8RecFX+MC7df0MX9lhvDBwONX0et+12kwc/FVDLRK8jVNJb6WmBFo8iIJJjC+ko1+AGFv7+tSGbkV4LLs69JBJsstXlLBllsymfG1EWjF8muD5W/0sKLAEW3Dfl2JFgnZDpGopV0DcHgzVeNi11eMRnuJgehHLFuPp9y+9rrUMCX62tsqLKN91csldhFf9SBTjQ1gOu2rF6HTzuNXI/HwMCANznC/Yt/ir/FhuZf+r9j5f40+BL/aHayCfk1eHb6SddxAxIycxjJFjifOInUeqYtIPYvUc6BGsHTxFQ8oft1u4U09LkPd/Lf/V62CqZH/+n//t795xv/H//xw/vxchh9A5dXi6v31D+clQPkDBXjqH4G8KMPQAXR40h+uTn+4vGa/4UBT3Fr5AeojLLefwm94tNPwWKfhkU7D45yGRzkNy+SnYWX8NCyGn4b179PY4k6Z/6mQFfh0OzudLVvR92Ak7uwUmfGKUfFyDpdwe3ADB/7fzs6Bdf4CEwIMBQTXb+DzDZy9gZc3cO929vPPp3g9w+s5Xi/w+gyvz/H6I15f4BVz+xnyiw98FhrSGUoUZ48h+5A3+I87P6VLvGLcc3xsf02sc7om1gVdE+sZXRPrOV0T60e6JtYLuibWT3RNrJ/pGllnp3RNrDO6JtY5XRPrgq6J9YyuifWcron1I10T6wVdE+snuibWz3SNLHoV56n052d0TaxzuiYWlB7iQjBw4BGg1FBQKBsUB0oQRsnzJLp5GFJfnMIvXELmFyHzCwgOmV+EzC9C5hch84uQ+UXI/KK4KM5+u9SmMapaBb11I/tamrVyNHT7OBeReK160WrTiAfx+OzBLkkdNkQQP/18evYTRA7FvkBjxZ4OxXl2Cr94OYPLBVwgBvDCgzyDAOCHB3kWHuRZeJBn4UGehQcJgc9P4RcuIZ/nIZ/nIZ/nIZ/nEDXk8zzk8zzk8zzkE9g/hgx+DBn8GDL4MWTwY8jgx5DBjxAzZPBjyODHkEFgvAgZvAgZvAgZvAgZvAgZvAgZvAgZvID4IYMXkEGYHwTGTyGbn0I2P4VsoG5/Ctn8FLL5KWTzU8jmJ0gVsoGfkAH0VdBTQT8FvRT0UdBDQf8EvRP0TWEs+Ac4i/1HbHj/oJPM/4gLZ2FN+f/wP0Fx7/LV7dt3QCzCWZpA393dvL26vH/7HoIWlze6Eu2HsQd4txCwVnt5nzasL0uc3wbiYxjkLoNB4VeyV7BXCfiuFW6pwab9vvYGcJ3ayFdhoq/NDowQhsnAAiZCIVItBnd1uwD6oO1MDOKucxj8/fzTy33W9YTFFIsY99P57y/3WZiWasQT/4jUlRjcaOQHrd3VZeIG9TGbsO57WUVn9oF3vcmi/P7q5VUEN6qSPciJmZOkAO6MHlK6D1K0XUT3yZY4YDKaG9CfyUzDZeblacIBQemy3nzSZg3Jm8bIxRA6kUtlPgmHjaotx+4KjqDgQfUJi6kXXQ7DKxSFL4fhLag2LMKJ7UUW6zbqsC+i09TLYbiDsxME4SQ4guJKgwU1T7O70MbMndFLRepBT4Vl5Y3GlC7BBSrcenT6HkXMly8vh/DRvIwzAKCuovoTaYMdcKb0Usr+ntTHXsq+WnXCrF9p9w4K8FKataUivFTNK7Qi/1I1dSR7QV57X6q+WSgnL0e3AvzlXrTrVE8vWzQd/LKXr1DBh83uX/by/XLZql7evP8z539EU4c5908lt9L86/aGs8k+VABGV7H8Rq9jBm97t7xDf6IvRwWb8Xs+oo55e3oZFH79O1mKCr6hq8v7f759V7z97d37D+GDvbr+cB+ur9+CTc+rN5fvfrvG9UEAoZe5uhVreUVTuYCiebqAbhS6P0gIl64Cg3VeV+9vb9/eF9ev3t7fLuA+79+9u766R/L+w9uXH+/fvsOgu38z8sPb395gvNj7Xn3wWUEp769yJcmM8VLCcuOVb5f+P1X61Z+QWqxlZDHHWFdiSGzTaCTcCreew2es+vAxXTVqQU7VycB7oINl9xtYSQDQEpDLmL1yRoX5DDPQE+EgoMVCv4kDim5VtUvcl1gnAVy1GrpHgNHFFcAPstoktJCgMHvVjn4C+kG3tJZLfYa/vjQwvfV0abZnjEY+fdBAMeZo5F2wI3jne6e/4RlrDOf9/hUoD7/B+Tg6JM463mlyZ3TbZg7HrrReK3n9GHuyI1pyV8G2XqBGY3CKT6r9ry7vw0j3Cn6vL1/9/v4ayJvre6T+LG7fw7fz6nZBfc+rRRAfXtGKEAAnbsTuCjxRe3RntIMHn/1T7iyxS2FlsT/0xKDUi77ChUd86FdhaHkFVfNJltjrvopnGNmX8UoatZE1DQIMxq/8lbRrtOr+Sld3Rj/IyiFay+jFA5AZewFt4BUa7HulK2dUL99/uL0N3oWROXZ0OCowdj3c8XrxlnCnqj9GCb7Vr39/iTZO2INe/+6/ZRgAa2i/gf3uz3D5VI7O6b640l039gqk+sj9bZTWkUx03YXztfK16vFTuwaTF4E0Rps7/MoDgDVfjOgZvFDWiTqchBaQejR6kLfKRwv4MXZZ14/VCgUBT/reAOiQe/2+fPDw9eUf4XL1z+Q+JYLzHJ3m8CyHk8gXOQwy9uvr+6s3xZvry1cBibW0l9bKrmyxMnx3j266CHK51eP/odpWEKBEuSPA18rI1/qx+CArjbjD7z9A3eJryPwDHvL2FywB/Yamr3+7vn377i1QYXz4Dey938o+OAn7TXbUXH8DfRlZR2HoNyNlH6wB5ejlLtNcTwHXIAAnRrRelFj4ejMGK33iZ0w9olhnAI+9I4uwAcSHGIWpE5DWldigfxvbOFrR23zz+jZc3i7u33/4dyDfXd6FNvLm/v7uqmVDBTFi3RODhgvCNGC8EcOwu3xU4X2/kWK4lZ02u49k3/iNbFv95h4MeEdwTV9F4NxJsxFWbVKCP//FEniQJ/jEQj/tBWrT1qzN0UjyRrkrP+MKtO6kdeh96I3r2nMiwtwKc8PF3ze7QZrfjBhWf4Tbvn15i53sXqfw9uWt73iDPPEWJmhoVentu8X95c0NI5N5Y2QEtW+Gh4bwYvHxuri/vr27uYRx520te6fcLjSEhWyXrGuPWv0Aauay9W1vB2VgRko0uZJAnsNldiSLWvuZZoFn2FiIrONn/jZ4bQsz19hxB14na4WfKLNUlfnbPOQ98/fbf+13+r+/u7kjE1W/319ePzrZBxOV7LjF70yE+132a9XHmcE/e71tZQ2N8uYifJ3MguGN2siPVpoizmFvdBMmPHFtABn3uPCP0CKt6NpH4jXO9G90o/s7reCN3OB5pBvtRlu80p3qdbrr7eXbd/eXb99df1gAfPf29fUi9Gm31yCWkFWeQN/67xEElNvbT2/Dnv/th/sgMd9iSW9ZrdzKrpTGrmA791aaaoT3dQvWg155OaD3w2so5K2qjF54KUSCg96M8WkRWfYskXrpZjCfmsFyxgL3H27XsRhRIpg4PM2dl+5x4C67VF27xR83OYqN/Z3c/nB+moYUwMuAfzg//f+d//899/0l/BbUR72/Bc7d/dv378IDvv8EnLh9836Q/ZXG+eJ7I6pWPnbtI36t700tzZ0wlsI9NNqL69rg2BGY90ZUa9U3fJ733qBgdHd5f/UGiD3lk8B+FVZC7t6EV373z998kwiug+7gAe5uL8/pisvlQP4cSVjSBjLFhSVsIJ8lMuUAS9VAvkjkT0B+xOe+e3fZYCd09x5a8N2HD9JyKfQOW+rdIqb6eHNTfLj+4+P14j7r8e4+QhawvLFw2shLa3Wloig59VZ7xPHsHa2O3AUNiyL2YnfsQOKd1DhxuFsJo8MB34Ba0Ts7kQzudNsy3wB3JrbmO6M2AuZnd2yWj7J08SrNYu6MfoR4QU82UnbFps53o6lWwsrQeniruRtt6KL++Hj94d9v3oaaCj3xFZl4+hu71x+jqtY3KDCAz41EFX9e37y/YgywHPrh+ub6cnFdvHt/DysCH26qPz4HgvUuHwRMOT7gyOqvP5yf3koCiSoSyVz5fogeQ7yEuPHfUXopUzUpxkM6jlGwbjqDSTJnTNfvgF9cP8pqpIYEA3paETqq6QEBsMCTMN7vsxfL3kg/hWfzUOTfCSM6zl7pl9Ew8Qfc6k3rpR8Go8Oc4MNoVws8qbl4//r+0yUs5Cz+uNnp5n6kLcfF/eX9x/CeFn+GqSgbJJFEERk4G/lamxuBUozHocbT4AdUaOOlfgROZeCLWqBKMdBUa0DtVXgyTZkQvX2s2teiNKpK09wF2KJm1YUcJh0spHOqh5F1sboAGWaxEgafWXWDgNVQSsAdQO+5c87OSQIDK11BC8BnVOhEZ9EJ43Yz2Btb9FpntwobT5eGAT/3SO0GeNhHzYLFNhb4eZRiHXugBdrbWgPQ1fqPUWPZPOL3DS5KVN8soo0uYO9aeaUHaK2BM3FDfcSj9CIo+sfRdrHr8NIqWL1d7Ab5+GrsBmkKGl0WO8tSAH2OwMnu2pgE3sOK0/1Ftp7vRwHm55E85CX3cKJsZVzDZ66rxaPudcfE3z1n1szX9CdZfnybeaOeBrLT2bkL2InfWPK2CrS8fhyUH7e9fMEdhjNHqOCsNFCq393iYwEJkhJ9L/fROZ6fe4MeUhAjsLg4Iy8W12+T06eJ36bc29JRT1Mfk4uo5Ikpd7fkB+0r3bZs9e6oE5PoeYQAm+h6eKf8Q7w0eouSwEenuAlrbr76kCMHaUqcwrINHP8V0TTf0/gEnvT3fEMynGdUMR6Zk57axT10DPfT4n2ucJuppnJrxhnet3d8wIJxfuh8YiAgHek/+4+NA3BTAH/xpP43DuB/47z89x6X39vSnEagKdaUD4fV36E21iduAONTsqpGb4Wf0KYzgrkOpEeQp6cyj8d7DNAd+Z/7f+Z/9uGEZpDlYRPgI/iEKvIl1SKtitowryxu7t7c3f47blkXdxtXpBlwYC1gcaK4l6K7wtG4wC8Xuvok6hafrl8W2KyL4vby6v3iX0BTLqnTLIp40LEoav8FALlS1mmDICpieVK5Ap6z6ITqiR46UUR6F/IkaEDWw7zsVjSNNBRIimoF6iGykgWqSCTonRVJJ7HCZsNYLrKS3njBTqgWpVgjgRJyUWovbyOT9uFYrVSgEM193hQV7KMA3bEyg0ouktS0CtJ+LOpk+qYI+rIlbEIV5AenAG1hIMcOqiQuRBTLIYgPQBvR0DpQsRz7WBtIUxI8kZQBCFo9F9D+VNOrGAfPVBd4ronTFgG1BpUWlArVO2nw1HQBZgMhOtUZWWopOtkVqCJa4BN2HUhdbDZUMD2jopdby9tDr3HsKnq9CR9tgQe8wVUmUJmuUjGsG4XjbDEMjG/U5qdIiVpz2iYAUlgxwFxf1gVB/3oMAZjmFWyUKMj2SiDSfVNHX4A9CCDBe2oRjl2yyPjVBEAnCgNBLPyMoqP6Inl6L1yUQArXDcUWGx3Sxd6eUhGc7EKCjVPx20QayxQQyHSBLhm/AlXoAh0acFpHQC3D08MmZQTSaYS401xkho6K7SD5a0Et1GInTK1DFYYvTvzwHMBZrcA+kTiLHYM4l+fNcA67LeJZmIKJohEjfvoCsqALPbgo4bfCCypyihIUgf317BzU3gTpDgViBmocgS4YTSRdwvyX05bdGzcyBNy9ErXsVEZbBLG3ElUlh+ABifVJwSV6JHSkEi8Ym0/oXq9lz0ILRqbiAQa97tzrekI8EzfJNUh9MDsFhiqD67TEyLLTtJknqtDz1nEAQB92jCxkrTLMhjhkCdRGQogSPyIeYtl8VFSVK6IamqhW1LqqlcQxQlQrzKmTs2rlp+a4KSgqO2O1F/tmJIssjBo70vFJndrI7nOkY3UBTb6ekDfSVJ1oCIAqZ35CRV08YBB7uroAlWgALHLF6VaBjo2oMdt61ol+FG27Q/xO1/KGueoVdXbruqhQzcLTNAEVNb9jvRQbpIKrF/bC65o09UVd6z4SxBq0pYhGDrFQJBgiGUUExBMoKa7TqbBLZD74gRbpDi+zkoreBd9eRINcw56sU/0PsOcLNCm4g5Gcy3f3b397n3CeMNjQYchIwdDoVl8SLHk6tBWGALQ0MoYzumWMYAY3YX6uAzlyk8BSa/oWAHNBBFgrSfowgFmjQ0h9acBo0iSCqmN56XotvuwYbmsGUn3PooIIQhVsQLOcUlPxyE8tEsITEAgemgjSuztl5E+J/DmSZ4k6Z+RFop+nLFIM0ocn8IKDnzj4mYGzUw7OOOBZn6W7n7NIz9MdU4SLi5/S7Z4l6hlr1c+K7OMMnEq3Or3d55FKD/KCFfAFq4QXL1Icdu+fGP1zeuh/ROplpLj6l0Dd1GUE168i+brVJn0+N1mDhK22CHGnBugP56km0l5DgHwlExjZ6l1g3bN29a+UbZGo02eMfs5oWSVwxshTDn4uHsY2fR3FQjXBEXriiDhl4NgyBu8tgcF7oQIVcAlspHEMt+XYcdjW7CMssj6rENYq66b4bMo4nzIupgxWZWIrDC8gHqvLGePAcU3bFMToe/b2Peb5RVEDoWMPVK4ZTUsMDFrJkrLXifPQCKJ4BwyWTSV7GzYTGatrat4geG/JJq0RDzkSlatLzopiJOFsdCjyr52PcMVk4EDM65I4rITs4WgujYiVimkNEqOVTmb1xgelolbsrnTADlD+Aj0qlsp0E9aQfTSSp4+a7YDjFB6hNiN/A420g9EMG40LFoi5EhCw6EQjIt2xkqiOJsGEm07XHOuSt4aA2RcUZ/gEl6xsajC8Eh/Yfdq8Elu5ZJXopTgeV2fDfZEP9x7qCRxdhlleneBJuYQasKyV4DDoSHAGqJERAj9LjLMrxEY4Nl6Q85asj+ylM3LJ8cjBNgM2R5mUUfS6t5Z9TVx6KcD1IsPDpGse8tLnEk4xCOOynmsQNou9y7oV9DPLGBWnOajZsw+yr7P+Z1AVf/lD518Zz5ZV5BC1niPmD6CHgk7nEsfmQ2oxZKXkD2tE04kfOSPNqpChq2xgM3EfjeMsQtZjJ/UAxNrFGRcwxqwrIJuCiNICGDLiHi3HhRqmrOy1BTNQPNup1FEEgwsMrjRHileJR2QWAjl09pigzm4WZ9UIxyzyOPDmR4eXAbmaVyWtcyXUZu8qeiXhLP4hOc0HJUebiAR55gOLOObd2Bi2yhi2/AGCqQpe6ugon6DpGh7f8bbLpxAFs9NMjLbKOnY+yUhdGlrxS7ivU/1n0hRbCUfsxRiGU2lKiZrOiIxUrB1mIk3J2156m5VwYRxLjDIVi3Udlez53LBaSZYbLUEDYmNmpWvJEZPgp7NXZswyYi6uMPGkyrvLCp3CAghnCFjPVIs0DjJBpJZdGi5TKTKRQvouLBWfPb40s4tnpxM4Y7IFcqI6KTHx/CqDB+KcnU7ggTjnpxO4F6cIGzp8kJWPbOaxlLIuRZWElVz6WUadPYS4DE6o41ENmymgaQig2bZGxkiJo40IQKwKm9SQm1GxBpaJUWj5huhUAWmhRJVZ385bfy5DTbaniOcke9iwg7IUrDIUC7QmvxXr55R1k5ytm0aWGTI/ZUjkqBJ6wpATrB6mSZTeY/QTzjRNnZfQCO0mjCmcFMM+TO/h5BSPkzycmkbZK6hTm704m8njuWnZnTaTFStin+9xsgVlHnA4g2k8q3Z5TU7erdowcVehRZAIUm7osCHQ6Vtdp7Tr9NCp8bdywzrIXKhveav0IJM5gocuyTF/2lzgT2VmJjgQW5vJf8mmCsB8XSYT7ruolxxgul3PevKeDeZcbM+k9l4bt8q+1VRXbJbGJfeJ4K57tgSj82EnvZdshplL9pMkXNQZWAZGLlkaNsn8HCkjapX6tKmAGz2NJQ5qMAaQ2DZ7u1NJ1ka1OoBc4LQrPrnLZCA+8ORiZy517n3Kudhpd5bT/KMAmIJTQZwoWWvZlzYzYdOlMSUTO3Op0+lhwxvYmOp9tIxkNZXLk6mdblLHskkjPxco0/Dz+JjotAHwRaf2GPaIaCGnDUM8W+MJnyor1RC75oE+kLgooDe4kUkrbGwvXNQYacPWCzeir3DLD+ls1gOsjCONU7TVACBONtPka6PY9mC9YRnIx4Gu55Eoibog4lkkIGyZyrzMaNXSMZgIiv3wwkkSbYhFaDuA9bQAm5SUNOwDwbJsVCvXcletaN1jaohdqBRZ4U2ZskZu7xg4ZtlqqDnaQHoQj15w4x3wg3g08jPaExMPy5Ww9bKxolmK9cOqgZe4BrsoYi1lKfjSKlgCD2Rb0vpXS0vDWLTDxsApaFsNZPpBtG2rsKm1TAdHtBTuBC7wdbi92S3ZxLhjQyxw+rik2ot2F5fk+2qFo31fG60gq6SRArAZW2FmVQvfc9/7Wb+sZ0kK7HVfLN0QJ9LcjloEPoNZJ52J99YUGxe0e6uoUwKyMFYg3FJHEa2yiQG7cCg0LosM1aw38AqHlQNTlBmipe5B4WVGOhVA4l1UVJcSg0oxWIR4hfNCommMbKLwdIA/q0QeVMXzv4mHljzxNIIYmHeR5PUcUcGDCtIC9XRcSPY0dl5ML0gMQ5WqcUgx0ER5QydNkd3KSMx8KfwoNhP5GRYIrb0EpQdpZp001Ur0blbrTqj+YHRHFFrqmMCsgvY8a07YVwe5RVZhxLWEd5EILiJnnaWo2riZanr6fIaB0mzkDl+xmaG6tu98Z6QjNhvYKpmvAoXfgalW6ixSKIYDaRhtGU3rssZg94XdCVgrYaQleimquELF7Wd4sJZtagFcNcPi8qZdGQG5ovRsh166gr0FYKQpL2Du9U7YgYK2A+c+0tWCmRlhaWnRE0nW9ihRW/UFto2SuO0lYgVGDoV1RrOb7PpqxfYkAy7pQKBwrbBWgSWNCGaqluhiAvi4f+M0Ts6dEzi0BiquGEcU1z4iB2/njCpHGgjHGmeRI0X3BGp1B5ptq4w4ayVFitGtUIeQV8ToVmFBriDlW89JtTG6leydb/Fyius9xm7CoY8xHN1LFHqq3WPwfgn5MgN1sUY7EZFFomLAMYiavCf1WsZbRQFtdJqulfbCV3w8nRVC18pWpCXvMan+E10EddMOLNlEZmrbxOlFJ4Pzp5w9WDAfGRlGgoJoZICjyMRq4ovR3bNUaluJyLdj05DgPTrNVmcDChrRAUKHnbZ6t3SJ+n94rt1fzyLBPvpHBab0AzHhR+2PL6ORs0EN0k/vbGTF2CFWeZ4+/7JgJL2zUpQwmwtEeksBgk5oKeiypusMRatAJwOkAcLCqyeLPCTdPclmSNJA6GGeKOUWHPckcJrIM0aCBguA80Rm3jOmbFrvBx4upu3Fjd6BGCuP+7llIEf46QDKwJYfDSDnMkDXwuC7SDVXWxm1r9HlUinWBdZGV9JVYzH7eqtq6KrContd+BvaiE2izhPJbhgX6knLqhRWVZGIGmWAwncrMT4aKoPF/bJMDblkT1RKWlUpywFG9BKk61KKYttaUnrPNL0pLHnSPxysRNPrqOVC7ElUsvlCEOPKL3SFNiVXIEKXciWx3mTLvilpnWzbjTYNOvyjzYoyTa1KldFkSqxUbYtTyZIC+zQ388CkY6hlNCtT4jpIGSZZyHLlWK2ly/uGMhqBAgoNhseNK+DG3blS7eDyhT0gAfL1VaovKZDsmwWCFuTKFk/5lCCvlyiVla2u1nEaGZBFqqEru3GrmwzE2U10w1q2Y4rRMbIKCgvnYS2u5JPZUp+COFFqxkO1mEAwduasCViw2uavV2mbJx4aLnGpyl9nSz/hW2H74jbaIsCZbakNNjFKjac1AxE0YsKxa7wFVEGS5MpwZA9DjZ8/Jip4UsLMAwObRbAMx3LQW2xj6cgckjABLc3oc2MDRVISL20XrZVD7iO2iXGJBn3KEd8XzeACMVN3K93L94spZ6G6ZLIvBLwbaZk1QJxD8P104HtZoahWslpbnPEDX1ndkpQVOKTPEgBpnAQQ1o0BtfgYLc6LyrEbNulAYBkPWQNlEom3ZpU0Wv9NWk6zQOc0ozAWfItp7arcsr70sTirCtWRtkDomqv/jjpG1WwF63UVmouuwGxTBaqK1c8/R2NyMAOuRCla0qENYEgmugK2oq+x7cWJaiBm0XFpZBW0fwVIkbZfgPERAsLNaqB1T6apAqYMnQIiJYwrwfiqKtHi7mjFlC0r0bYkvlSiY+m7sa8FI2ds67sSfSUx1yGs2MBiewV2R/G2eANTx/saiSMmqWf7K7snhtkZO7boYTg4M2PaZJWwWGTrK91gQZNdQKaNh2TB7gMMhzbpEE/D0/Kkn2s0ceUSUWh5FRu6q/JxNgSLewFBa6tmJcjJQOHBmaqapVNlVUXHOqqKFZK9y8oPgkBVjt2wGs6eJZR65Uq20uxKKdzMVitJOywVNWfZwvp3JXtnpMY0ppRmtChDV7gG6K9sc95D2RvdRqSWca7m4WD0hmgbCVDRrpa0J12BTb5qiTu9qOleNYo9XaNIHR7Jc6LxEJgn5SNlMIudkgeDNJG2q0TuYsptzDvdheStqoFpSLUCLV1/taDhW63AhHq1Or2woOQdSDDXkmzLAYVLqBU3QAkA8xdUTShB+WuqAt9JRyJnpxXFAKHbRrLg25mBF6dxAeHWDtEp2qBV79JBS8azqumFw4VaGDzcrk2IJk3VChTu/DUtRFUrXnpems/atrqJPdBqBJEY/IpUqoZMVSsfMX/VPehy0JbVkjK4rFRFSa7CEzf+yr4p5XYZILcT1UNir5Pxv2q9jPJk1QqjabswHvkMREqbRHwkC9RxCBDmBkAulWTfaytFD9KTJ/F+Ci9YNXE5Cyj2VIBtNA+SMWziTFLIRLJIdhKLbRoiw1EBdbV2JIZV1LhbDfo5gWDCUMBLPfa12U3WTqt2LPnjxIO8Vce6g46Ta8lPulZgMqfq6pmwwwwMvFde4hqQKvH6QBzyWQfI4oXfju0lVJ3NaLKKUnW20tV6gKWxyo8MLFGvZqQDVeGb05UWtBZf6RotFdESuL9eh8a3QA3ECky9njOa0nJfJQG2qqN+2EPshnUtl0aCsaKgn4WGyCqwIlEzukV67FBugElApVnN6y5bj6x0p8pO2Genp6LeynIpKtU3Zuyd6uTKuSHtXqboOLbDov1WlrhpAIFby1TFKt11oq+JpPaP/lt5qeL6ZaBRe8nTytHqeFKp504DEw6HKxucalbckmlQt2c3G0Sf+NZGkko3qFj8Icja8BiW8Qynwfi82kh7WdPDwmwmAzG9tjG9HalQ9FXq3n/1eP8eTNVjSmyLul8WJd2oXxZfZHqKfimN7HHRkH28MJXgAhhw9EYaQ4N4YK0SiUtAEeBUjrBKgHwHAEoDeYBZsrjXWCV7x0jSpiFAmr1XU4sWGeNWOkG7TllAVnbkZQVBnuUcmQEeneXm55qsKG2s4Hb0NU8opaaoZLO1ys03I9QmAxSUPqVAFrSV7PHYRqqjFgU0pXYi3tKTrHNDxshjcpoFkC4l0/lEMs8vG6Eyx5qME7PFTbPQwahydPHDRRzrg2BMSaLspGsixONFhZ5K93RgqtJ6HRczqmD2OlHFSGZYAVMkMoUNcBikIUXUSg87o5oV5k1tyIST4ekpjSwG4Zw0WD1m0CZ29yPVKvOIHRm8kkdS60XSRjpObvQ4xFPOeEoo7kcEAg/4cH1ToGlSoZN/MEw/MMsHFetKU/UGKu4IVQOuasvHqG1cDSU85ADvecAs8A5sgDYkTBoBh10qI3AANGJL79tIqr5A8fOQwOlwiRLQIBrJ1d0Dlz5jI4N1WOy0IrIENRKavQs4uVQZykL3fKXCQ7seia6JICnLaGthhxrhlqJse3YP+NShHFy44bINq7lMmrE1VC1KTDhCWFtpWEqv7AYv8CQWbjaWMk7ux7SCXY2tFDWe3ayS6fd09gwoONZjEwNfF9LpTFJ2JC0C3FqoNhYv6eFSqwxVVcOiT31KlQiUTGTIoobdtySrJw96QGGsDi62XNFCac1t0Ucws9nhUvSjTEOQv856K+lr9HiRVP0YjGOk5wWDbDFGQbOpCGBqwc+DE12w50LOpP0SPwO7Lt67hhbpSV3SaphHyZhKQpQJCiu12FD7gE6lZsspdTlbope/ujyDyzlcwOYR0iwBf9iSb2nVZYE2F1hCG7241CU7UVKXyeoGMw5Ux6or+V1ofAZKRgX4uqQNjLqUj/Rd1+US5qd1iesszEoD9HM1WvKspWilYU8XMIO4ARKImR7dAJP6gMFmEcBKJ5VlJsAhOWtF34zYjxMv9NaMcc7oYqNQ6xbOcgIFxyv8lZWw0xivb9oRqAEvdJ61loPsa4GL+oBkX+1mRtZjJevZAJ0DbGYlShowE8bUZ9J+V47YHLSW2BxkZn2xllY1RK3pioeRaumoiQYKM9jgpeg0vbdN/IpJHzsQ2bo6KhoxciabxjIsTQZ4UHq2CGcDLSAFJlGqktCgg15AEWtoGoCqtfUyntesl3YlRQsbl3VaE61XjKwGMiFTK9EiV4nIC19BdAD0pD90iGDwAmt4NqGGMmctP8yWJhCXY2tl/FcNL0RZUhaula1aoXAsCRoWONQTXYDcE1mbGDVoWE0RX5/23Fbg7e1n7FECNaOpatJvrnH7r1abLxI2zOsH0Te6aJdhjlCvYTWihhbUslfQtrGFYZzeinZYifVYStNLVNqp8dF864jnNmv2YYJaYK3JiCVQM5xa7nNoz6PW1aBYIktXWHDxFK8XdEeCdO6FhBiYxXrcqrUCOr10/PSjmAMUZtjhGnKtO22dwc5B9/T20a9qjT2Ldpfp+V1Ul6FjhbQ/w2myqkmYnpvt5ICIVCeRFnciakPqcbVBje7a6AH3hmrjJduo0u/hAKanAY6wn1ibccAx3ox2VUQlmTpJNbXFzaHaLaEGxmptYjdFxgPjWBRMxRKFs1JP2kiAAOVJGqQ3TPjZbAVerYXQLV7o1Gi9g5hf4BeErC+hgYR6kGmElzMa/eXZ6Ys01Mlz8lyU9tfSlpgUDbwXCUKXLEVa1JUVJ9nekqyWcFlpuLZqgLYuK50+TwkzFlkZBTMxUpPz11mlR2MjGxoYUJZIOjbu6cy4XMbA6GNaA6VRQK6SZTjpu7ZAPJR4mT3AS5EP5b6FZbneskpshUU9LiTTfpZs07q2bLtZPJgh205AjE7A5x0INhxGgT4Q7HbB4FOGsLUH2umlUajYJLtS1rWsZ3HaIjtpGjrH6YFq2WxFdnxgh/V0GRYz/VfUajxsNWEVzw8xfzzIfJa4xX6WkTW7OMQ8lLgAd6uBS4qPEhYoYNkzUfiVeRkJO4Bw9jY9vUeDwcMVATkRDlFhdcSpuyd3A3m9kHAuRfabZFBV9hvhND+VIPsNdu5AcTHDc+IYIfuNMprddjMYsF+B5BhFX9lv0hK57De0EifZJF1+HlW6kWmLOEeXYJ86CrCBoA3SAM4ihY5hJbmNshGxuTRgngGn6TRX2o7FXFhZLY6Y0qq3vdi0qqalnMDZiIzTqt4ZjO/wgss60lV4+Rtea7rODunXhwBQPghk0rWVzg/EEGmkabUc23hF0ydyI9qZdTU+SUofKPb5bqBKQLKXj3hMQz4ylQCZzMEjWTAFCGRZTifzlcQh8+3ykW1fSOaSy9M4NWKLP7RvLIPXADmzuh1TauyhHwdW1EEZutPQat/bcEV1/E6RpIYSqFlllJOaMWh2A/CDbMLZXUk+Km0KK4ZgeYJxggYuaXow1mPkkH4jkswhEHKU5n3GIxbVFS5O+hNC5d3/Lmp3NGCmDfYGjw6EZwRg2zgDlP0DEdjQPMEaj4cD+EYdIwOSJDU4+cV+bvmIGEac5c9Jg2EZ3BAAhfUaCDaDW4pqbGFXZsnSrWWcRi1F78Jwp0EpmvTtluIzXjCada2ASo1z4kAYnIBHsPaydQusjaqgipZJ0FgyTYUl3z5eShG1YZYSJoD8ID7RaLDHQyTUo0JFyaVEVdFl44qWmCiZ+uuMHQbzOHreDWpek8BijKbkPUyPoFpJMqKnybzj5LCZh73o5C9/I2TGmN5GIh4rDQgHOE/nd/9C3uuWwWldojCnviaVOE9veLZ9i9uCS2VkKcIUBddDiMN2vz1rCcKIJ7f4fS2VXaFmylI9pjeVVBWWrWjoapGAUSoQr8ES3LIFjUs6rRc2clyiivyM1bLdqb5B2zzLdreFueOyg9BoiWGpewfrmv4VqyWOJp4NZQE95mTGEaj0WS61abRLVMEPki21WbuYpVk7IyXSHV2jdb2gIMmy7cJOBAGSCKOdiEBk8W3Lshq7SGSF9RAGTgCD0Uvo/+jz8+w8BZt8JwNegaJmp8c+maBdDhenBmyZLNNosYRDeMshLgsshyTBLCEfNO0NN6DKMlKSSgjRNCYWk0UmHx5rykib1lOW5JogECgkE13k0WDzA61uLN0wo2kXO8e4HLG6cPWUGSLP7JBzex2ZqY4lNOO0YL7cpve3JU2fZeraQ6EaUTf4waU1i0a00oDtAyQxQnSFg2TBkuBOUSO8TIxpncTvpBHOlkh9gUC2BtyUtJfdVPBL+igNGH1FfRw4KtgiCfPtRurUxzRyGKRzegYtspFG96rTdMSkAdmrke51GhM8wp65kQ4cHUUrjo10uGLRSEfrOJ40sFfRyLQq0UinoLNolqFraVZQCtBKa0DgaZSb2eSColEuUzNrlFuNZaJmUa0LMTkBmEW7PY1ySWerUa4VZaJmoJMVgYYpo8d0w00aURqo21bUeJCwaYW1vsudZdYLEptqttUlvphAsRwjBL1dZMBZ2wgeE7JESibpNq22VmDba+E4LbiYbrQfX/EptcZVBqCooi1nKSc7MdCxU3xhISzoo49OFklya/SAy4iNxgMLhPToYiSnP364Qb2lRj/CazeiLEF8aIxAdWqgZqg80xixFKD56smlckyTsjFiWEUCd56AhtUeoJ2MNGN/brNZtucNsgXltMZE23SN0VhWrTe7RDEVhGh5KhCsdHocqhTg5fgoiQaO73HSwmPDnbQ23EkrjNFNGnqaUfRY0hHHusxsYwS4DRctDwUCchvbYQYHynxXO0sHPRvm+LVJfWWzdbOxVy56dW62rihxwAhvYXXOKmX17BEazur+vglK/is4U7YSlY0dQhosVgJE1RW+baYhgSQmGIYdHaZbiajqtBKm3qLVnhXTNl6h0JssPgOVx6DMJS5/pp0CoKK+KsAvSA50JRFzJdXw43Oed9vqSKCTmED/U+NjRj+zEdE4RKcU/BUXw+BMi2fwWwy0u7NqCpgMQj+zalKnt2qgv1+pUppeOIl9NjNMv1IuygmrDmL39Uc4qhOQLqHMqCzvr7TM4GmUTFakQ7LCJUN/5dI8YNRCWHGNVw+8HE40ZoO5OH70auXlHyQc+BZZ6a1yW23o7ls4mroatrJ8kOwuaRFqZQtpTDHAQLlyxRZWf1cu7ZWuWEpHuwOrZG9u5eIZB5oQ++s5SsKeRqVFT8J+sKeS6wmPqPKYjYQVeg3214KXxw0xvCbtNw8MuASMsSIR7Wqtxho10lZjh6feVrvSqDpNRf9P6v6tV3YbyxPE3/NTuLPh6u7/fxRxzj6+FtqdOD72yXSWL6e9neUaIIEAQ2IoGCGJ2iQVl4NGvc7bzNu8Dxrz0aY+x4DkIrkkkZS2066qATZ2rMuPFLVI8c7F472nwvXojnfpth4bG6Pal738rCvV7dF3KNkPj990J7tUjGa40T0eDFHSNYxsT9+8LvvHxx9+tD1Ytm/hR0OKvc1nx8JMAdu31vUkU3fkspWVaOmflayriaV4536lJ2xfh1W7yra1rHIeLiz1z5akIILBD4Mbky3tL51g1Q15N2CMyKrtbUYyZueYma22GAs1uaU9TrqPnjGJfNkwaxBXzAzxna1+DI0+LuCDTgbK7vm3NLKS5cMY1p8WYG0NPxjtppUsFVbkLY922lhBC9PllutDinrhFi4NDca1Dwl7fWAth+kmCsncBBqQu6lOAs3bFjbQMXyZNesqRN08UcAxR8u4caThXnrqwVOvPIUToFnfwgErSGs7OpYPfoMND2bQJGyPNDTUCayrXA+NdQfjWu0KoEMz3GyN4o6x6V8fxwFypjtwCM7gR7lfZu+5AbUe6IH7ZtbJ3n/L6HWM1MWL6m60bR1IN7ntWDvDANwO03gewMtqgVg/0mXuznDMiBEzeS54ZJBI5J1MAu/vRzc8bFZ1dBH207BOUfAS5PuebLSqgY8ZOzpsyAaJ2UWAIFAPdUoQREN2wiw8JOnCZPg8zc3mgbJWsMFsAeh3aDcx6+2EG+vv6gjGRAkXZdGSEvHoHAeDlsXSJ/vDuxMpSQtlVLqZQly5SXDrw6StwCTaKMikq0dk7/JayoF6Yuxz14iAUqTb2z2+UI7tLsxCoutjmb3kiV3UV854FwXrjeyiwoAYmGbC2dB2VZhdiT80bV7+9GC7vafQBPku4okUR9owXhyIsHfunUjJS24p2dsrpO3TMO/cDJzIhbjfwhxK7YmL+ULcQS9Nhw5E4Lzy5qeaAyfQjY8nciuuskDHCU/kvb3H5LTntqdhCDcSs0xYw7E82o4klRhKd5LKaulpPwtBT/tXgYM+gGfwcNQIy7YvTpW9AMsIrqDrW3x1zCmUXI+uzuHLPVFa1oU7on2yN/pbUql7AYuKlnFpOohHBTs+T8wuEJxsRpxRg3vCTwHa3ARyau1+7FMrJXWr0qfWuCN1zA1+Rq/S3nyFcbJFgofteidu19BP3PGsw/2+E2/42U4unXgXelknzls7K33qCd6CfXoaqLg3rD6qPb8VLz62k/ZWbD3xWIHQOcQqmCE6icHfSgMhcAmUpf+1A4+TW2w8SWcX6InqX8hUOz1wkn2BV900L+iFwhaFk+z9UfKT7Ntdb29yd1j4HZd2xaxPndNwGuwv1B2nob8rKsw1f3rEjPpwp0urmLl6/lvoGZ2udmxxukrY22XKQ5hYP5ODdWp6JkxwaZvmMxEtcf30cxm2KIQFGHAzdqZhx8eZ3t3OzDO9w/Se89qjf2Gv6pntYchsKX988cxcy3jWT/SrN2emyiNEZ0k/lwh8WB33gvN5FMLv0j23TIXr6s66GbcEv+78CC5w/+zYhla1R3Y7N1QMnAxsuLjtzDtFzhbp99ifhbXysKfuNyw6e0k4B4GHokblvzbDuYPFXh8IvxPNPLcJHdLmhW1iG7KHvYpheq8hLrs1JUtiz2a7JS+8TdXREIMgsN3SNILKUgO4eEDXXjahdmgq2/PXv72wo47GT300lNhjFg2tbfY1tCWiwuPqhkrJO8yrljrSpcfu6GsOplW3B32a2rqwholtcPrRsH0Bg9+G7e1+lIbthd9DaZm7I2lvF6act8WG7Z2H04aVtLPfA5A7+GoadqCCYLJAyydOZA1WjDoVXsf5uSBdVRwovCEobP1XQA0z0nChoJdg6k4Ykzs6DNedxI+TGmbnhBo/9HCrkvo3GJ51Z5jn9t7YDDFCKHDr2LAOHE4U/bF3gwEthSc8DcxVJ27lWP/ugnd4zaK4w4V51ruyi1EqfGTEhzQnf8yilh/iabEl7NtBJerrDkO4y+Asc7K1t2F2+8rdZeJ5cHJseXSazAqwXzojCXW5YV0tYzfjTsFOgKOE7QyOvrSkPMKUNvSaGl4XYDJe23s9G17bG29Gzhk045ZHNB025mjOY9waesNreuvLwSHcjCyQTlxTH4c74gnkG/TuzsS1fwzrinpo+sAJGvZMWIl/NNwcZ6hvbifqGfNyYy7ED8epLI2mGa3AXmrv6PDUHdw56hnhueBxxbDhe9LcoSEhEn72ZHgHd/mJZYZ+zLiYuPvdybvELwSrQt51uCZc5P5lwps4lURHNwyLOnqaV7Du3kAlx+XILSrkkIQ+eKPcluFGoct4GiWH2o7DGoV81DTqn/leP80OgJrBzsA3Q0dwI9gMitpukqnBW1NLt2inWWvD4eFhS0o7XGmRqJI9V4j0fmZaUpP38N20pGYQXW1LjxvPjnZaaqY8MjuvrhmbVk25pXxNt8Sju8E9zMfQ4ei8f3Z/H5AhzDFO6VnaufE/Yt1+CS26QorO9McwKG5Ju+cKYoEHuhkeS+1QUgzva3/gQ7KNY7LgrMIK3MxV4NDuIZSZlnSJDNMqLekUk4H68iegB9IEylcRlgU8RNbjd+gxzeBF+h7qICBdePgV7DRAX7Ul4mx2nPusELDtL/jYt1SBHiRH+0AsP2Fhzszu5Gi5e/kL7TxRXM1aH+Bu+AE3hpj3tFMcOfx1M5kt+gzAxQD4j21LANzQ+nVbEUVh8qulBMZM/qYwQ6CX0qx7CQomodQdA24p+uD89QOWCsdKLD8BumYfXUoGpLsfAFiYC2tpa8pgBQyKHb4jcCmMniPKQcBxUbP1eQdD0/FcjlGhtfKWSu4ISWpqPZQhAVKyrsYFH1aR9G/hWlfN7FBq0QClRcfire/rQNmbyL2dvWPs9oDLXN1aIx6RLKxitqwUXHJ7PNczhfM9bZ0hwM4Wd392yw7waxe+WtZySfBLso7BmRFNtmBf5hrAlkmIUDrn9O3ZLVS1Z5jjrBjkeYO3M7SoOLVXO22Izrq1fA/9jhYWAVvnt6/lVQnwCgY9lvK78TXr9w8YBuKsHHpwcWvqG+hiWg5B0FpFy1loLjjsbzCE7W0Y0k44GIdinnCJMKQzEu/O2G2Q5sNBG83ZZcGW88olVMDvhbkUXlxs1pt/i2tJMTr71gplkegMQCtJZZMrK2hlJYBq52OnlWa/7KsXloGv03+mvjzZl1CFn4psVXFrG9GD+lP7A55PW2U6q+1QoEmediAF7Sqz2R4EjWJurGqYUHENsFrTDoKAq5l2AGdA7aBY07DKOrBur7g4X4nZRxuu8W1dnWhrz1tv6iRD23rpjgyGdlS1d3S4vb3D9dftHQNGt1oD/4DovaDUOkcGAZrFau/kPYprr/v6iEdz6+09nOZq7zUpjb+0AO2PPebchEN7R5PNflHCEPhB8ql58NRurNj5DaKGHSvdvgTPQEG82x3L8M1oDvcgNO9aoLsiNWzj1bQRmvhD16rTlbL7zDVj6/LObXfrwIee/i0toavBnVQVnIkIAvgSwaFyRy6PTNHX4UmXMI3V7YuZC5Ruj24P7va1n2nt9mhHP/Im2KFtAV3YvtZRs4/Aklf42SHkdUSPPJF39ArObDt6raQD+cvf3VkE/VvgaOToAXLENNRtTA1cEUFERP5hrtnu6NVlJL2qo9sW3tGb8hOBnW2SdFvbMOQDtavhqhdDFGGWw/J+TGZZKZspQspmCvKz54bfYV7YkVxX3+xVoz2l1W5PCazm29XMzlZHHWt9l7ljrXXxaGfq3KRUxws5lMfCjaU7vud2WriDw876txC8oeP5Pi3eoXZJ8ydPBcJ+yB0/grW41DHYyqTr27CZWzPyKFh3voJf2M4uMHTSHp3pbF+tk8pdXtBJ+4MKrLrInbk/RNqefTeUDQXbwWCoGySHB6Aye+0L5LSmu6tecDO8NR8qt7sjuXPzzPcn+KHgC4fblp+DDw0OKy7cnjXktIU7+5F/+uDim9cV2x0YtVM5/CR7f6JeM7AswUNVxhv7BjD5w5sqbPnkDdpJzBvkMF4z7non3lQYhDEIAl8F7Mzi6GhmuE/LUhOFrmf0aMeftuQ9sXld2FLCQ+3PbWvMw40fvKed+y3M/vvCuE90MhSUuntSNOlKsaZZNa8MtZxbb+KalEd28HFKBdNMmlGwTqHpSz9+3pXuvXtszd9QQ677Ne5mPUMrR7POpwFCwpN95QxkoUv3zsyhmS0SRiUIuD201K1tbtAyckGktGVUQM1uiB2pKrcPxwncSxgW62SgxnL/kBpO0ZZc0NGm3qA6Vcr5NArC/tjPhVeprB82aIEOpKQqCjvJSg3MzEb9BB5cuWC1e49G50PJKwrdQvhkUCPC5RtEIxtIRGJHclz2B/tNyXDujivYz8vt9jOuwGS2bQ4eOSxV+MU4y9szNPxChXVT5zhXj3G7ps6v4ZwTv4YlKH6jIw/kJgn9G/1BmD5Q/91r82P2j/S2y4ym54EMFYQTuE2MwKNrv/DyoaZpVbiL7AwrdqPIQOHT5x9cU3dXt/0M8MExTYtqsFsT+vA0BmtYPQHjG6LwFZRf5DJEMb/zsifOl0ZP9AekAufu3gbSi4GQ/pd6yk0RhD2IeDLS0SOUu1mgd67/e6Lcr1v47wnM6qIrvoHcTe8fcfKe3HvS7NBBQtBYGvnT6Z1HHHOzg5UgZYvosCbY7003pg9dQdiu2VcHVPgoQ/WvriqJPWbf+1ttetTpcr559a9bsS78JKiWgkNPnWdmgaWkI1aNOec7146HCMSi/LHbvt4d7ZbcPpxM6WtYmvabmvojdNr6Ixob9UdOOwZy8OVgCO8sEQa2/ZHbjbSGwOGVrYJgwaQ/9qan6DxUGN5he7fOY8gmkLI4MNj/pnnfOfSMe0RxYF0leXlGFtXSvnWkW6PSNB4yWn7EzjPn2BeKdfeR5CP4/Rh+37KGfhcGSv2x/xYPTzC/A8F3bhINo77jI+7uideBgpUVz3RjrniY8va65ZHk5Vzy8Vz06Vz02VQ0e9osnk+mglm0s0g/m6b41ZSfAaZv9GqasFfTOD4a85MYJ/FNYpvENYnqSz8qCjLoooJAepqMcnB0o0Z/7N/VOId/pBWTWPD436fF7KfjYH3V9cd+VzZsN/pSdqWn8Oe0GzkM8IIp78OO7ojWAjz1gic0HN26guyfP4rw0HqieInITxDtCg36lP3mVUOzQPnz3v2xbyoySs/oPDbmP3x44TLZJaclnnCrTIbB33lL20DZDxpHr1vlEc9H3N0TxVj+esSRCpFuox+wY1zLuv/wH8Z8EYoeSF6M2Zdj9mHCvnj5ciaZY17NJB/NJB/PJJ/MJJ/OJJ+NJZMHuafgdu7Yh6wTFIkF95aUtERFSfbW24ImFRetWz0w/FC5bJJ3iQK5rTf9sXd7xoDc2euLkURQCSfuQQD7B/ojvjqkPwpKvafV/ngfZfBdMriBzA71elgm6Fnpj3L3DOoWn07XVtsZ/J71hfViV6gjk8XIl5hWuo8ergtytD/20bMrq7mjbD0FfQV2gx7p2Tmv6M81/PjkWERDus4lrCHqfViU6RtyR310zfmlcM3Bh9eQey3cQZ++ofJcuMPAvV1yCFcFolnsvgmHGfrGToj07U7xnbuMyJWclvjvpiUPL158HMjPPQlfhiEfAvkqkB8FMsQAxd6QnwbyMyBdGJ/zLYGKQhPwHEgaKh8dqkJ4VRIonJaUmN5hIGhqOGLb88Y3BLxhJaxmBLdqmnK+PHu4FUP/7jmH7r1dkOp568q43W3W894ccIfJiZ73FOoa3g/Oyayme0+EO2IsKzmsHBsWKHf9iKUeAgmdBKB3MD9g+dd9H6pYI9nBeZLANQMJAjJGw+quE8BEPZBFcPGqJU8DV1S6HUs9h8LMXQZJVQRfnJotJWyN1cyB3dCzpaoFdb13HnZfWdoZR6qwVt5zn/tXKvzGGcOFLq2b5uutEo1chDlxC/euOkkYwAcOzf9oYT9ID7f+KQJXUlgW7wXtSYgBVri01B41Md5lwIneOH4Y+QmqFKMCzBUudPXHhgwBm7gtLTwZprh7wbg7H9ALdvnMEXBfAZA79BlYyUQAeWhJ2ISoOf9iHH5K90tl8BSheV/PCmcBbjwlOXooCQ+0QuTOvr1EInTkauywCjiH9d8kOs/j6NHeuV7wWpCXgWwR6REDuABGKytAFsEXnJNMojcTYeB5ws/MWLGbIQR2onWqlqojTHVrzhmrd7+oZPOeNp4SivkXl6xxswGCK1qCK1PPoDOXWsZL3uyw7RV3PmB6wS+soiPaoW53T0CEOylD7Wvk4545LBP3AoozrI5CTYjrdcn+//b3aYCzz31YHujt5lHjgbEMlL+fy7IGDim3AnNPs5/jCTLpefjkLYnCyqNr7Ye9Q/s+19A0Zk8yVAlD30NtaqjCbQTq8X2mMNHYDwo+WvvVX3dHVh9lwyq6Qx434BRlf+0gIyGn7gW6u6K/o0t3+rtthowHpSfTDjyFjv2T+0qfRjvTnlpiT1092WC2mn6SVTGdAdG5ot4X44JnzlV44mi/26eBoXuQngZ29pM8T2Hd5ulKhbr3nJk5RfMI8eKFiUB8/Cn8gDs+8fGnvt4XH5uaTtgL4OxCkyD7PVPtk6XLs/MjbXm4HVl4LxehqbBUhUg7mhOENRxfBu69dQq8c0wQXQ/snCNaQe61dbUkSu+WR1iflqI8kbP9wGxNI+AIiaBwB7Sr2PWvd7KvGUy3nnL7nDStjtRtkRGUNJLVcFGRoCXpVXkkwFDn8VTTHRwck07g3eAIWh6pgA6toNZBbuWYEIUm8aQqPmaH9+BqGp5SuSsVBPUGgOtMgHEX4QC5q/bu+3Uz2YLW6DHW0xumx17frDQsJQHPRlowZQM/7qZSIF+P7tsGoaM5wTcoaYHLeeNbJlCF8f2IeLfZxbI72PJhOelJ1tXYk7GWXej3vKLfom3tVmq81lnWndOw1JlB2E6RRiLj+aUnQfvGe2X26/u6V+N+C7zfLIwWLSUdGQizOYmOeRfpoFB29IMe2qFrG9ABTSCRA42xxH2e9GlgglaI9tPrwAMNvtB0J82tmWi68bFLZ2ZJFVzY7OjC9XAElcwfGBPUODp0N8kY9jIrMuH41mgRTvj3lMr1mSwN69XC+GbzGN1VHxUGX7VqUjDX7gcONfxhRG8pL3S1iuuKom6ZJn1VSm+s969t+z+iluh2MnEczruWNWfnME2w8ugPb2KHY4KDO3lDyEDB5YuCc/+LAg1dVcLZKMF1uYENvYaRjoKWGzaLiR75UBF96cYToi+vTB3dJYpCout7BFhMymLkdUtAdtlGa9jz0nbTgNwpbu8REcNesCd7AFgMlfvI3J4LMTSwsObK49AVfneFGLo3s+uL4L4uRO7whlIxDHt2hp1r9t9DJY+o8yjNGF/+r6aSsZ4hJHmwPx5DIIGGKMbyMXfgUJ4NB+M7SRrll+ODdzbk/UHa/JKwZKd/fXdJ4pvZ3BEHSa725wY/g4KmWIaVMWmvnZElacih9fRdWMoegqsUkXaaanQsTjN2BkWWR86b8RZ1WTLXNplLz+AOAlnyno7GGUYClKC0k0co1uFkM9qNJ0uhiyl779KAzWBrHem80MvKmrN6H4bVofay1G6i0TU4KSlcxjGVwZqVE/u6INxOaCl7WjHw6CHeb6Mm4XuT4WYNc5ScBgqnr8S9YsuiuxWtoAqkd8iHT8RL2njPDZrumHVYKGlz+AruBnCRNBAaAC3pj9ylrTMXYzs6PKmr4OMCVjLekL103ACECifOpG/dJeXo9XhLwMO3pG47ua7Bi8FRUATstmo3OwJs2EBmBY8THq6Aki1pGiT1Xugtj5KjWeM8lNfFi7no5Uy0U20fhP6gB+o6ouMBQBajcaMT4q4WyNCWV5A490/47LyjUTfLi6ArNdY0VCHST80CHzzJgABoP2QAcuSKE2QARZ890LCa41h/LnByEM9fUG8InOzD489v/2Jmet/5aWB58L6YJbiT1L84WP3w0aeffm6GRLbbLI8wejZEFahQCI7UXvHix1SGeG8p5s+96NbD/aKm4MjRCGjcwjjm5Yj79PNPXnnB4TCClwM6p6kFUPcd+SgZmt65G6vk0bpw1b9vDg5ztTOvu+/719XlDVHv/hhTvKXErzdOdX9yI5up4puuo+LRf2IT7XeEdW+tW6WY6t0fkw98pCXvKiLuP7qr5WYIVtFE3I+sqxv6zu1nmKmHPQqITXwlTROK1ZFf3c2mmjaOwLzGD2U042Z/NR2mISVyQCbdbIw8Dspd2iHZHlVirKJn9oTIHTrRoBtXOH+qyV0gAwUbt8IQV9obFhwJHQ5DjeYvrOgtFy26jMEK//z4LjB+4G5ZuFpMMniCou4XfRKagwkvTe9Gmh10UUcXTWjG7ZvTdLCWwg6wEAsrE+DPEpEFjqclPQbCUDpktyZCk8OU83Mn2XuoK86QwDPrXqIXOeMzsdI5HJENCVuKZEPsuXHZELftTja26Wu4wn2UllQXIJpGEXumWrb4LhDD2bai3YeC2B7sD2tgbClbqBhbOLUuO9JL8LPnaIvsWN9T5baxyY5D/aaJB6CgiulAc7cpg23H+jccRdacm3bRNDIsP6CbbzW3G3Guo8cPyvl5lPyIeg28gXisB314RAd5pQk3CjLMk2fcINNS7tCN3dnsZwcMEc64Sy8TnnIyn6LezpvrX1fSYTJU/7p+jd+dJXsXrhmsPwDZ807CBgrZgx8E6ecOZO97kYbCbRwWoD3BQe5m6UASvwIKlO2lRNxVziE/073zEm4FV7ofo+zcrOxt8YShDz7mIp+ar8a3AprTLe4OH8343Sye2QXXGPbwS6B8rH5bIDoQI5+gOz86+aI5VrvrR+VTA3sSw3kY+dTAWF4+wW1GhijQlI4RvHKz+ZoTgja+n2wXsaQojy65dp5fiosve3J3cdd076zrLHQZu7Sn/STUU8jhtpQN/OywDLxrSdlc+m5nnCyFfpsR2hexK6dS8kfccZPc1ee4bEvUPlobKXcpmRnMhj2zhjXbLTzn3VHijowi9oS9IbDY+TWQirR9cXwJtO4FVEALjBfKE4+hetGshLt+DDM4UrrfIxAuvBuDGGqnRxnoborxdZdh8KAJlyzXghvKuaC0nFtT19xdqrv1GiR1YYb0svLsRtuKuwtp/dSVIdDHo9ndmB1xruZ3E4pSwdeqBOshRsE7snuJ6ReYGWkeMPMKMx9h5mPMfIKZTzHzGWY+Rwx+zANOzQNODX4+fjx+On44fjZ+dHhyfeRNFQaWQYRzVQwKUbj2xQLnsHQstI60cHB0haVUEnZ/STVUjD+i0aIaugKWnL2nJ0NY/96GDDf1GFYG6kj9Q+8Nk8fiSOTZjWjUe+TGUg77cJ5cDnusaFhLvfsQOexhk4CldkQoBgc45LCXpWB7zPgVEzns0aYoOZSDsK8w1ETANcJy6IoTudl5VRk8jsmhu5CmQe6ynEcP78zDEIW/u8GwLz01CidgLsuSzm8DYkOEbiLUMBe4vMoxXIy5Clg37w8kNrIVIEOLOkzeaMa/sLhArhsKRSHN3aL2WRcru5LaJdqSY9/0TjgwxDnmAD/h0lt5PYT9VJ7ZHezncmUH5afhbhX8wB4IeW/h58C7O5D90dN2MUf/fu9GVPceZks0Ec6sug/ijqdY72gxXDOuzTWuWwLlAWFfgrzLcKoRbfiTdxki8W2BP9hlKXQOwxdmo9ilFDgRirahFjHxK3tlsyLlkZ25LYyhZVTW94gidcP2BXwkCi5ugX6JIgL88lkKdPL8DjahaDpMhPlZXWVuC+4q0vAOTjSq/U6x7t6Wng8pcZcC4/GagusKFbWTq/q3Y9bfpaF5w+u75c4dDzu5FEUX9WjGH0PQjJkbBkZ3kYEc6gGFsZ05/WtWAnTP1uzJkgMMOrXKnjV03gXwopmji1BhjvxUeGY3eqYVBbgzNxXEuaZRNPyyzr0vVEWKihHSMupg1hLdfhfXrdW/4YiV4eAkhaHDhZyGDYezDBuWHIF1i1mafeGIl554eOXIB0d4yUeO+NgRnzjiU0d85ojPHbHzBPRtDc16T45TjOws1V5KR7KWd+7ibsPbLqEm/RYb33fyi0KacBW2pqEuVfTGfGm4KfdbuN1rmumN/xiblCPpzsXdOnkyjPSUl8K90tYRraWYqHo3Hg+TP5Zy4xDLuRGH5SA4TIAZooMWIVyhqeBaWf0bKkTNXb2moaZXAXhIIGv9jl9L887R77mXO/uy7r5rS+roveBXZ0/W3Se3aE1E9ojKTPgiKvVY/7Qe0q1sV0KdStf4W0eDMMeu2v4/2F/bgKnWerxT1pmEsm8HS4xmbWZnb1lRvC2JKtxsBLC6uCDeFmjOoeRpAm2YUjBPBsMKxXs7YjBEyBTutnArPoSOh7KbpP1YyHifcd7fjI/YUKoEYW4jtRJwGtcQB0iIps2K8q7XnQYv8zUdMC63A1v4cZsRwvwG8ODvUVNMBsp2NS0NXkjdNVtKsI5Vo+0deoRxhVtnlWAXexZfiQEkA1R0mrBT2Uqi0KCVLvNRHaFQV0phxbCnpETDIzXoIZCrPy72f9BemfOuoK7XcufPZ8K6urrDKqW6e6dW6t7zV57YwajeMM7Tq2FcGxVaLedRdLBn6IfSnocdqoq5X3wvjebrwauwX0bNu2m2ITjGADD7ytz+DtBTeL4pYEO7F8Q20kOn6zo7BzB0ZFBH2ilWEkWr1+++sdIKkOzAaOUdMVkZqNwCseFsmvx2Z0sZJ8dDi1bsrFwgcocOrlqR9KR7Yl8JYo+yD/6imqE3zj6AdFtTB/uNhd6rpR4CGQoQ8KFX6Lq5/gnmrmwUjUulpscov73WssxeYW0ZJJf46a39kUpQ0u5cIRqQmw/o+g32kOkgGkGvAjo6tl83uOVXQ7iNR4Oke2qPlAwSXgBqcf1bIJxloNxr/qUjHhzxyhEfOeJjR6DX0ZxfpzScv4MocO6zMRJfJjSDciyw0vGjx8BnJKmwlYemgv0lFThiP9DSjPdQYxiufOpCH9U3B4Zw0+CGgTnMQYIhhTvsOqjDZ/aXNXA5iVPAuvfgvv2LP989XKXt1ZnK6WLMbtupizH4xVj78u4f/lh88/3bHwxDwi3boTK7EHvjyYXUgljzA1nInpahYoV7BXwE6K5fzxR+982FNIOjACOYnwwzjHuYYBSihM7mxeTLxbaBF93DhR0JF9qB+whLFYh0hRKxUCxBAmXHchA1WI9aj9D614EEfINoxgFIt1h/sSeDLqyyl+QaAvx3uE1e+ndeixlpWEfQrFsf1LT90jTl74jUjNlTbNfy/TOCnxG/mUwTvmNx0RW6gjrxwiAu3oQtTxcm1EAaakcaF4tov7VD2kv7aIaf70Ybki+j3c0Xbqe1Lxw27l24sJ4ZLr0FPPmp3csT3BVyUUx/v0BCd9BSMJFzUXCKy9jxSpg6MzvtdCUNLBJcbcm6kgttCTgAvJb2/20Hi/nQDbjSvdv7Z0mnLPZcuEtUNYv8rVpWeNp4+wfmAX6/ch56rnT/Y9jUeqX7x7B740rDmNjRkFy6t/epOMani/S9CxtuRNCM/yAtgxJbWS9YmnLvHFr5K90fWFf7Jx0ajp2sXem+Fsyb4ciUe7qujkpMm4M/LNQlXo6u5bcyF4WboDKk20msGW+S9lKOE9OT8jwTtPZIoeFqikj3ILyjRbPQ2AGpfNokd85LNPPkEufmb4AsYH0EWBdriCb4QPEM2qhzpXtYJ76ae4y5JZsSrkO70u79ETzlXQ/+I7keKbhHvB7bEghO7PF+N1i7sq7iV2m64G7IfmXy6LZxOxq54rqy92OPb9dGFlcJb9za/za5nPzMReWPU12jjDMDF2dTlsanFpzYM35l1DP/+eG/jPlXE/6jCf/xhP9kwn9qefu2aDuNpnsnhX15hoLx6xXv9vEM7CYau77SnOAuVnx31LUv3AUV1z7MhF/7Ah2JcXevgwZvrNeslA9Ahr0XhvH7EQJXmBN8hS79dkfZXMWlmqlMVyRI8dr9td+RpkEd2mtvu1TXXsuYGnpQAtze6VngzQBX0AWHub7HCUVB+oo5zLQCiTfbX2Vly6LfQHWV4Cn5atcdr5I/uN+P7QuFr3S4Dnb96XqpYOH8er3CT3Aaohk3cXa9XvccxgHX6xVmda/Xq6CVOXwN18xpCWycBtJ9Cderr0CuKC1X5z7PVF430tqyeDObpF23xU6E3w7U+Ve42XkYXW/YCd6bL1M3Wz1A5XJrG7QtIvjvtNRupFK8Iveiog2506qwJ1C9CiYtbmMXIreRW4ZbLziMR29W4PPnJt2Psr+2Wr1d7X+TGzdjgjupd2auojd3vvsDTndi30j/7txndocrKPRv8IdnOJ+N99L+b3f2Qn43GLo7p3F3Zj76e+O8593dfcZ33lHF7ASFpU0m323i73ZsfLe9sPdkv7ct0PuSt+YST7c3sqLyrHhf2FNV7+neHpp6T4/Wt857GC+/p8E9znsqeNmw3pe693BA8f3BfGcuCGtdbKyHnUPveUcLM3v+3rzO+8Feb+U8Cd9sLf/739n2f6Nu6u8/+B+/++CD7ds3/2Bl2x3sGN/CQuLmqNrml0OI7LeWfvFyQ2S/DHtYB3u1DvaRgx3KM8DgB80bbuH4ARdyq7/7yAvlA+kH2uZh0x/7xZAw/+nsh2Pqj8+KyY5on5HozKN/eSTAm8B/+One0y/Mtd5/98ZF/gV6zMnayrLPMfIvyhlroF/FPgQnXBerP7zhbUu66os/UvWWNxUV8nVXvWUNlX+HrTAIQTtAfLFdLIx/k3VniVx8XKwIPSt9qSz6RV/c2kCRfKV+YLO1W55My+hs8DPdf10xp9t63S0aNMy/ufA2mJU7Wf6JsO9K3UMkswApbbVH3Kat9nN9tXfyKTMPWe23Hz68WooxCrHvLfmgjqwqHZgoIifCbAArTBlpijYOO+b1+7/b+i9bf68t0c9sQ37TivHXa+FXvXOkSn0jKFHU1pnpyvTDh7emo6mD/t339GrF35OWfvH+74aBVV+8fPjoo08/+/zzTz/+5LOPfpvaf5TUSWWPkz5On0/335io2zhVt1/UKH348PZvScaoSV9MwK/77F9iAk1Oc2qcH+X565Xld/rw6LvowSavdVWwk7058Wymp7ZjBs6d2aOKVmfuYKAiXZc4wW/Yu/ll5fv9Lyrb876OzSvf1dlstptNNt3/So/5215NBbOVq7tx/1+sJUZv/SuMB369ocfm9K+QibHa4bfvXD+7S/8b9MZD0GRnIgKJdSbysId1sFfrYJnpAlzTphC2nv+bh1H/ViPNeT8WktAf/w2S8GtVW39TImZVxr+bQf9Rqf7vt9vr9bqRTNFNydvt6g92lr3/3hL4/HmMf/0E/s2V+2+cxGhz98sT+Iv6LL/dTNev/HYrJtZwfr/+bfL72Z8oGlmQPR8yTfdvNwb5d9pf+k1Ghv/WjZkdmOiU/MKHrZtYsY/ZbD58eJubt/i3tgaMSH6Vxv0Xzlv88s9h3WgoxP8bz6Vtn1hXRybSbs9dQfs3mNT79Tvav8Kk3t/YNDx/RoIxaZd0f7/dOO/F3fbD77/+6U8//PDVh9u/dtvXxiPdu4aoAxdtREIGdUyJwdsctA0l52dG5eYkf/fBB6tC2In/k9Tor61Dra0hy+PPdO9I0tVU09/5a2/tlrnitbn29vHelVr9w3evzc/P5ued2UyjqV1D7nxQckuapmF7qS2Kxc4r0FTutvg6+UWx3d4m0NOGIIPaHvpXLwStN1XTOH1/UQb789df7r75/q2myYcfl6Zu03TFL3u5YV2pGdl3VNk75jSwpEKVvFOCN46lneCN56S4GJIpwW6ISmReRjvOkVXZ9tdu+8ZG+AtKxZu1ScGFAwK9+/51TTvlVkVurTY2dUVEcK60df/abc2GWEzviChHfC/4wXoj6GgDGsakL4OW7q/VlpRHPYAXYyG99VHhQ1y6j4pfRaUfxaWRKDquosIQL5FWaiFH2vSYZExuWyZLPxHj7eBmQjTX9oK1VDgl7GUbF2Bz3bBGd0PTbI7q+tdu667F8gR8Hc7xvKna/tptnX9GeAAqZY489GY784beKJKWNWsJayZSsz9pa69IjapqqipxkdPIeHehQm32ROrvpWaF/r51CsFnIIYOuiadRIDvAN30+r2Mqy/9GuaMkSb+qwX/N9JQof7zf/qnx8f/9F/+K8Tw31zF8M/LsHWom8mtit42Eix9g5y5bVhF4PfJvi56E/8ZMNnqLPuDHnNuKyYQxpUP67ZwCzuBtUl+/7sTuRC0k+jnr78sdP13qvblJmz+xKqyMbfFZSG8OyzpWZ1D+JPqOVDMv80yPob47uufXqfeOxNhtV+wURqgLZTVsjqtD9ZJQqK2WUDP9d4uM00yqooosieSLllmAWbss4zRVsqjkK3ywLjF1oRJoYL14vqFyNv7nigmFwy5gNJ2XIawegEUrJjHRY24JkgC5E0YV+djNvtcTLJXFMY80BXHRRQUyCxuXCSz0GShXBEqjRsVzChi8RHouMiCcVcgtXXXwVi9Ahjsu4yNGnhtsAzQmzgNWX7KiVIzb7zQEOdRpi1ehOjmOAtCLXIWF2+UVwRJgELTHFXnY7Z73Bfslwdp8y0iWJ3HBONlYVHbrQgRx3jLRbUrE2J8YsgjE1yP4GLmW4XVVlwLZPUqaLDpGnTUtOsDZqHe0DnQMxLZXsoFY8cQyMQJdTBsBDAzZwSTM2ISHgFMDYZUS7EpZ8G8hdKwYKYsxtsqiZoaLAnMWG0hTAo1sd9MvxA59JqKMDOT6VimUKhjmYGEjmUCNOtYJnC5jmU2SAI07VhO1Asxl1zQb/qFdmUBZQriIkSXwywIFcMsLl4KVwRJgEIZjKqX3qxa6tXkINp0C3pW5xDBaBlQ1GKL+BjC2yqiy0RIRb/Ydenz/ZZ+qdPSr+ix9M/rrvRLfZU+3VHpZ72UVGxhR1feRIs4bag1IFYvwoLRlpBR060LlIR5M6YAS/H3gt84bxYMuoDS5lyGsHoBFEyZx0UNuSZIAuSNGFfnYz7u2w0XpGxoqlHNILTh8mpWZwDBYGlM1FhL8AjAG2muSsemNcZXQc42cYAzTVILlonqx4aJQpJ2yaDn+pFVRppkVEe2p6Ijir6Bo0PZL28l2lhrNVSbbhUY2XEVPm7UZwRdAAdzZ2HrnlgR1twXZwkzGDtBmAeYucE0BE8LplGJGcGlAFEImgecKxfeRvJmuQuXRdle3BLEdORyINyXy+ES3bnlIAkQ6tTF1KsSQ0rFLkyxheF+EobG/DlMGPinULPRfwqYmwLIh0mhppMBU/26BME1EwuGTKGQHTOQYMYEaGbFBC5nxGyQBGhqwol6VWLAx9EKA8ZQEwMmIGMDRkBRA0ZwSwZMBkmAYgZE6mckprjS/fJMaQo4nibNoEZzpAlcbII0AV2YHc2GSuMi86ITxJp3NdOlJW0L1qnDcouzCg5Nz1qsbYPWoEeN0ZoAqVZpfdglNG6ncriVD+2JIO3SkkoeZIaISwg9Qsxh0AAxB4uPD5dDxDFhdBjTZqN1DvVSlUNSr62VU7I6qQ42SiGi5smDZ2pvlKkiFY+X5wvREmxkmGxBWkBFzPSMwrQqTAo1t91YvxA5WkLe5WfzVyAnq/C77Kz+MjC6Cr97xuz+2mAZYGwVfgJZfgpCFHbX6wojp5ATI2dgYyMngFEjJ7BLRs4GywBjRp5Alp+CEG/yC3wrkBMjv8ku8y0Do0Z+84zFvrXBMsCYkSeQ5afsKelkyq5xpTZlUsPquC4YLKqO2iiDHOu8JUbSeBqJXBoY5iCml5jX655hGoF6g2lQvAe4hI8hQk9vrsu9B1nqzmUQYKOFzjNZ7sWlMSkDLfSKSbLzNlelYyN9Xyy2rEW+RS2WWtJiRQtaPK/lLJZazCLdUhazFrJYbBk398XaegaZbvu7L9XPU0R8o9/9eTVyHB9DRPf03WeV7+w9iCyMZ1R3u9/y17YO7+qntWCorNbAxzXXmhDJamx94EX4qILLAddbpW15J4uG1zXr6sXZhVVoO7mwFmrmFtaA8dTCGnxiZmF90AUwmlfIwZ5jieXZnYVlr3LFale5bpGrfPba1ooQcQyeoZlrF95p6JRgdLEFX8JZ6y2DjAHzMGzDPDJhxjWBkjBkzDhgKX6oMXbm8o2lJcE1WLM0uBLI6lVQtFS4Ah1fMlwdMAsNS4gZ0JpnAcZW2+vMnscisy8Cg9mz0JnZs+ic2VcEzEKnZo+C1jyrom1yZ3dUZ83apnZux1TYbO26ndlp4EiFzBCEsbAHUtKlDa9ZjNkltgBgdRaCdodlUPGdYYsBopCwIyyizMXpN01sykPSXnnQaBdKCoE3n8QwkT0nMVh+q0k6RBwz31iCtdloG9LVA6lpcpIlDdD2ympZndYHOyUhURstoOd6b5uZJhlVw+uPTgsVehZjLLMA0MbJQJB9Mqi4iRYDRCHBUBFlLk6rSxWfqDIYKFFsYrqpSVYVlzRyrJu8vSsiseANr/ekPGfeOKqGd07p7FvHtKP3jgFSb57GTrX47bE8EYm9SXOxC78EMwcyljGsXkKhIxl5YPxMxpowKVQ4lRHXL0Q+WmZYuxxWrFsOK9YuhxXPWA4rftlyWLF2OaxYXg4rksthiaf0VEhzp1N6s1AOYhb/83pW5xBo4T8Nii/7L+FjiLDkP9dlImz5nqW3gSe05hNOqvSXG1WiDzaqj3+nGehEGb7KkTgeQy+44iVvVo2f14HhSME6pD1ZsIwdHTBYhqfOGawNmcfiUwdp1LrHwW2JS4fTFmBmJ9oyhtVLKLQLLQ+M70FbEyaFCvvP4vqlyJUYlPQzyJc2ascsyFhxCaFtmMMgC+Zgcfsth4hjgu1i2ny0RrlU/rKgYLeFspfDTO32rHK3HCKOmdhtWuKy0VplavNoXIssldgmGlXObLNqQ2gGOlFOzeD2e0ZjWDPltzjVt2KKb93U3rOn9FZM5WWn8GLKXJzhzu4Fmy0DteFWoVi9jAsmXIRG7bgyVBrnLZpELD7CXUy+ZNkFmLHrMkZbNY9CNs0D4xZdEyaFCtaM6xciz+yDT+18T+91z+5uX7ufPb2DPbZnHcmi6Wp73tEuXV9nELBAnFHbReEEYLQQnMCkFn+z8AgAL/JOVJk3IOWRyk1FVHx7Q1RrNzOkVGbrQkyJNyrE9IltCWnoRIm2HGBxIqVWurS9IwdCZljYyJHBzIzyrC0biyHimKmlpjsysu8k6G7Br0sWY7+oPMB8U2kI/qrSqMR3tRQgCkHf1lyZfxtBc2ZKmidjlrw5Vpsh8/rR18avOw1bEdrybnEJPo+y53KXIOZkbg6Ez+bmcInTuctBEiB0QjemzsdsnT0suj/Lo4wfkUUIqxdAyJ9IFhf3KbIiSAIUfItE1fmYTz1ZqpZyEON5L69ndQ6BfO6lQXGHe0v4GCK42pvrMhGeFKuWOsxZjLHTAkAbKgNBlsqg4qZaDBCFBGNFlLk4m0HRRY+keZBZ/FpCsDqPQQthOVh8OWw5RBwTlsZi2my0LWvpRt37xOpYXGtm1JMqVieUaEY9qo/PqGegE2WYUR+J4zH0pKa7jlxYTRQXyTWXPMqeuVyCmEOXORA+dZnDJY5dLgdJgNDBy5h6IWbj93xxQjwHstPhCwgzGZ7B4KnwDCwxEb4YIo5Bk+ARbTbaK923RCoqlg9q5nEwuF8E2ZF+FjYa9meRqTmAFYGSMDw7EAUsxX9tl9xrZRDGjO2CW600AJmufZY7rSV4BBAMNVMtvUF6ZJNcps8uzS8txz9jCT677J5Yah+L4zFURB73nIiqkIooJhUrk/NKq7B21LMOaMY+y1A8AlpGJ8ZBawNmoWhMlAateVZLFamIIslV+pTebrVJK80em7gab66JIxK7anLgmRrtoxkrUvG0AyloV/WcZaY08yBjlCWEtkwOg8yTg8VttBwijgnWimnz0dJyEEzdk6t2Kb3tUKSVpi8RV+NuRByR6EHkwDM16jeMFcl4OOnfZGvwDMKYI6vWBkkCkEmSmLhRFuARQDDMTJWObZBUJL+ruFKbJKlhdVwXDBFVR22QQY51/s1H0mjwK90XuWnKpB66ikVmujKlHnUNi9XTlnnwTI27gCNFKp4r3R8afl3YkLiAArMsQKxxMqCRiTK4lKEWgyRA2GgRdT5m3ae+lMv2y4DcACSLgNFHEjMeeiRhyXHHQog4ZjTimGmz0Va05IKY6c3kAZ8kwh7zyanNYZ8UAB/5SWESB3/y8AgAHQKaqtKxVbRv+J0KW10vuBxZB7YmW4k01luBxYZcAU/YdHXIPBZZOoNa9biKyZ6o8kjFkoeOFUhj+VUwbfZFILL5IjZu8JXBMsBg6iRk+Sn0tC9OJDllmFKbJZ+0jtUpLVrkiQPiqzs57FQb1nPG8kQkNRW8Yy3PuWXMYrQtlgCszkKCVXKoqGmWA0Qh3kgxZS7OWpvkwOSx8IlOWm0F1BhvHU7bcBmJTLkMjlt0bbgcMtg3jVnxoADJlc4saGzhTPnMYWJWXV1Cl0PEMREb4kKai5YRmbNYSq1tldGxOqUN9kkAopbJYqdab42JPBEJ27daXOy7anNrWdQKGYixRF6vrZFGIIukQXGrLOFjiGCduS4ToVPZ7kfWSjEItlJCj6wUQcytFAFlrZTExxAzKyFdJsITuRVXWZREkYYnx1cLKLOEvwhh9QIILeNncfGF/BVBEqCwmB9V52M+7bmUC54hsxhjvAWANl0GggyXQcXNthggCgkmiyhzcVqdHSS0tFOFVGIo1ZCeLHpGiGDKtXBv2DUBpmZeEyZj9PXBVwSYZEgOuv7pFqk712vKdwYXMiYP8tmRhk0zIY3MmH4pUBI2MfMcsBS/179aNOarvBlfLRnw1QrTvXqe0V4tmetV2lCvZiZ6FTdOpnOXBgTTpDt4Sf3UMGs7eQvouX5iFaRJRuUV/rzikm2SwJGNcihsqxQuYrMUNG+7fKg0bm7LKWLxESeq1L2g3SVp0yTA3quc0ZorlRN6fJtyApK4SDmLnuvR9ckTTTIqq8h9g0lAsEnmG0zppzZZ/Q3m0XP9xCb4G0xFdeJdftCZBhib5LTaJik9skkKErdJHj3XB5tMNcmoTmLosiZJ6Y1FMkptkIQa2SOBiJsjC56pgzEmilQ8DTtQQe5FxWTfkORugCWY2de7jGH1Egrt7c0D47t714RJocIO37h+IXKnbsidD6pQtO0bojIOtdbisW3XgJGRl+Bzay+FyJp9XeBF+CwjUsC1z/U4zs8F6ariQGmzmC9Z8ChTlpA4R3LYSHbk4Pm8WA6Zx85zIYZa9TgH6puhZl3Rk/JMarqUAQtonAPLUJQFefA8D/L4bCasCboAnmVDHLbuiR7FhcosXC7BRqZPY7DN46iIsePAvJVzYVKouV3H+oXIG16Spjj1ctE/4ALOuoNbBhm/cHkYdhCXRyY8xa0JlIQh33FxwFL8Rp/2phdTeuMlPelFdBMzrfSil0SOdWMrBP95keC8p91tYXNQFqPffgnA6iwk2CKHippkOUAU4g0UU+bihA+xKAepeJs8TJRHmcNEixBWL4DQYaIsLn6YaEWQBCgcJoqq8zEvVPq5yj5fyS9W7s+p1POVeaoSn8gTkTwNRKj3Rah+UrZYBmqrrEKxehkXLLUIjdpsZag0ztsxiVjxDi1XK+6zXcRpy64BsXoRFuy6hIyadV2gJMwbNQVYkXyWnadIA6wRM1pjvYQemy0BSdgri57rkYUmmlzaTBW3WMryMLDPEsZaKYca2SoHTFlsOUwKha0X0y+m/Mb6fOlKAaz1Mlpjt4QeWywBSdgqi57rkX0mmnRU7p5kWWVcT87UyOVkTBdcTU61MxeTU0DOtWQcO9VOXUk6eSoSpmhL5TF5EialNzbIKLUREmpkhQQiboYseKYOhpgoVj101c3Yy7dir7kRe+Vt2M+/CXvNLdj5G7Cjt18nEjLxx5zbpf6MEMiiK+HBvCsCzGy9IkzO8KuDrwgwzZIM9NmJJ4M6csHer/FA/pwgOLtW4lF+rQgxz7AVgbI5tjr8mhCzPMtgn/8CLelITc0+mFVZtoxH+bUKHDJrET7LqcUQuWxaGXgRPs2gJPCZibb+/le3H4twnDErsChfFtDzbFkIkM2VVWGX0LM8SeCel+BeUEk79Ywabk0IlC8r4SFrVgSY5c6KMLkMWh18RYBpNmWgz0682/WyLqOW0CiTVkBDBi2AZ5mzgM9lzKqgC+BphiRgz0qsR5nJCvrM/MgHimXLYohI7mTDpDMpG2xVXq2IYV2YZM5F0c9KxoE1KnOCP6U2t8aldaxOadFdcXFA/Jq4HHaqDZfDjeWLD1wxBlkx7lg11lg7vvgFY4pV44iFsUN8vJBPzPqDr+sDILOuPga7Gj8z9i88FPvM0Mv4aW6kkc9N+FWuzJsMEOVJHhXyIo2b5UEamrP9Uqg0bmrrOWLlI650v862OWCw7QLK2zaDm9o2A83YdjFUGjexbQSx/Ah7H4tNWJGrnxeB6MqaPCpcW5PGza6uSUNz19cshUrjptfYzBHLjxgBrqyq6dItLUvguY0zyJmdE9iUrRPwFfbOhsxjE3afoNY9DoNW2X3Z3mvsvNK+z7frGnvm7Ri13yzaoStO5HZNl9UkwNgrp9W2SumRnVKQuI3y6Lk+2GaqSUeV37EuMxvWZXa/ulzari6fsVs9i51qR1ZA8kQkijXUXNyVLBYZhLlnKatmdQaA7lhKYuI3LC3AI4Bwu9JMlY5Nncpc8UipjVnSOm2TuBYZJA6IWyOHnWqDHcbyRCRKsI5VpFqobpdgxiLLGG2ZPApZKA+MW2pNmBQqWC6uX4h8EI2gV8FUcod2BmF8/2XVrM4AkBfAJCbuCnABHgEEp4AzVTo2dA9XwjgZxOTSsrhx0oDoNWVrjLMEjwBiN5KBKh0baLgoxNCkd9ctwZCZcphgqxRqZrAUMGe1fJgUamq/qX4hcuMXhIuGGN8gSUeUKYjzRZnRgzvKBGLskTIBSjqlzOJjiJFryokuE6FWmYOPORvFAc5CSS3YJ6ofWycKSdomg57rR3YZaZJRQdO4OclD5ga7mRrdYhfThZvsptrZbXZTQO5Guzh2qp3ebOfkiUiudP+QKRAPqbLwkC4GD9kS8LA28x/S+f4Qy/IHlNuzsFcuzsb36PJ25jVQY4R1OG2TZSQy0TI4brG14XLIYM80ZtXb9FyovJfoLMbumcwDzLbJNATvnEyjEpsnlwJEIWgL5VyZT2rQfXRlXcXTo/lV2Kn5csCJGVPQuDlT6EWz5gNmoVEzT0HrXglhGtYNt1VGjyNnJk/CpgaPAhPmjmKXjZ0JlgHGDT2CLD/FzGaTQ9ZDeFTv+hwpJXQ5YupxjyOGSHY40uCZetTdwIpUPFrecdGmz+1lEM4caTUYJA4YmySOSRolB48ARoYZqzIJHLonRrofTYH6ltcLJ0XXws1nuR6rv811aPSBrgsQ/0qfE3YJHb7XPG7tQ0nv5jwWrtRaBJqJ1TUoVi/j0GTrEjQ+7bouVBoXpmJTiMVHNBXpV9l2GWhO9a5BsXoZh077LkHjJ3/XhUrjwongFGLxEaRq2dKV+VmMtugSgNVZSLBjDhU14XKAKMQbLqbMxXlQj+ZyuHxvfQFlNkAtQli9AELbobK4+K6oFUESoLBHKqrOx3xupVz1LS8DtRlXoVi9jAvGXIRG7bkyVBrnrZpELD6Cd3TVrY6LOHP6fwWI1Ysw5AVgARn3BLAqUBIWPAIkAIvxS76yWV8EmmZ9DUo360s41KwvQePN+rpQaVxo1lOIxUe8DkeIfvTe4PNWfk4Qbe9n4ln9nBAhD54RKJobzw6/JoTPoRXYZyQg1EJf0QMZGrW6Hl/Aj6vzZfCoVs/DY5V7PsRCHb8m8CI8UuPHgWufWzd8T5p19dUqrL1IYR3Q3KewDMXXKiyjE7crrA2YhaK7FtKgNc86KtWDV+O8zZeB2uCrUKxexgVTL0Kjdl4ZKo3zFk4iFh/R8q7m1X7BsAsocwnnIoTVCyB0DWcWF7+Hc0WQBCjcxBlV52O2zlUW7JcHBX80eetlMVM/NM+x3YoQcczE98xEm08v2e+Zap+WZtYWYGZGbRnD6iUUmkHLA+MzZ2vCpFBhpiyuX0x5xZb6dVmMXSzIA8wyQRqCFwjSqMTSwFKAKAQtB8yVKxLhvuqFs70JFD7Sm4agk7xx0PwAbxyXPbebC5IAzU7pjtWrEtPe90QxuWTABAobMA1BBoyD5gaM47IGzAVJgGYGHKtXJcZ/1nkLJmHIhDlMsGEKNTNiCpizYj5MCjW141S/LkH2c18wYxSDbZgCIAPGIHPrxVBZ06UDRCEzo2HlikTIIxN86RhwFINP/aYA6JBvDDI/0xtDZY/wpgNEIbMDuliZi7OmHTX3uOYno5dg9jLHRYy5zzGLwlc6ZoGJWx1XhEmh0N2OUf1iyvdpp91xpe2U7JNOuaM63A3Zr3S6nUGOdajHgaS5B9FjScojXfjUUij0sWUg4XNLgGYfXAKX++SyQRKg6Wc3UUekJ7lRN/X3H/yP333wQTs0ivUNHfqGk2pHqmpz0t24w9CVZvuy4VIoJ9/1gldDqUBPK6aiAVMKK8O0vLKeWvJWEsEHSRvLWkf2J2k51lX0Zkm73AXSA3fCKjB70nVUWNoUDiB527o3hQkSQ59KXkEaTtIBNPUykA+QKF67ZzesOweK1BAD72kXKNL3lhH0wugV3rkUrFcSM0DThqLcsKylX58IvH5FFWFgo7JyGUdcsgR9GpiAxBwaIo8QWcMqZxNLw9sN0ol9du8FvzqhVmPeXI5vqEdF3Et8o2gLalP6DHlULSTzKw7aemCW+IlzXS4s8xdJxTfdgYuWhJd/y0X7j25jOLwNFxDPZaxgXT8on69KcHhuS7sBgrIGUhWK5g8XKlCm8PJMXT6QC6C/My6O4DEVUcTluHTlu/oYjNf3G1yo/qJcJqm7K+GVqkIiXOJr0oIaXBX7DH0ZSCh++htXITGK7BsqXSF97+xZC+rKYEVb7vH6MfRG2t7ZouUtdfEJKnveQfp+JJ0rz/pTxe/1NUp6578b627iykUV8r4nwhctqw/4gLw18ALWWz9kaOu/p8rOINsIXJJK0kjFhQeRQXE57FuXtewgvFUVB7M09KBCZRLeu+UXagsfljiD4+/WfI+kcfnK3CNYJ6lQoRYR/OoJX/f092nZ6YlUEOLCKspdQdSti6vIpDMY3fu6xN3t4WpYyUpkBl92USWLaxX3CbZEnB0lgdoPSjlcz/uhn35He37zdamnK2Yu1ARr82ZPRAiHo7TF3ifA+KqiqJ34zj/H1FDOhor4xJfHUDIVvSkiKAmVgwwk/sJG9e2h4a6qaFh5Dh+vJU7kpusK20Rtx2wM4grpBV7jSalZg0U7oz1/htrjkhRnet/0tDVGO9NuRwZ13JTyYrSggS9PUtqZFPOhKnrBL6YuvxPT9JOeSSouVECYly+KQ6NbwMZUSCgWU7JMOdGVYMProDsSecRxodSVHTO9mI1uB3/3wQfnYU91Im53iCIEInUtaG2O8pRkU1KhEmqng4QDV5LNmd61xVRZFfRCOyXhGeahsjzSamioAKGuTwrBG7rRatFRReWGcQcPhrHwPZGsxGYOghcPIKo6uSFNfySzKKOvEZLr0tnxa7czGSohSpMWaJcaKsBtnkuUthM2hY1RDN3GZIixRHg0rD0gK/nwulskJePdLjxrB7kLJQW8JJGy5EOnXLhp5CXkRaFzhR1Yaa4RmoCBt3auKt5Jm966pK7U9ZdC0PJe6nf2VRakJP5aNk5TtHYjUXgsevMQfJSkadQkLh/FNzEMekhPPUhn+85H17JaEEULdig6SitabSYf0CirRu80jX5qykkJGZflAn+8dbMvDanrX1O3/P7Dr//ppw+17K/ir91mTyoiasxKWptGP4jOuxeeq9jlPRXc8/TGAtQ0xIKSai4560+lCXIuzopKNRYISr3gSJsmPOZELqTYD6ypelKevRj96rdzNOsCZUq4Y/kAmKEjOzDiVjPYogbR7WtBKiTo64ohTjAumLp7geQHxZDVZM9C8vSb7qUMvCCd1Dktd/0g6vDSV8LUmTXBTndGG2/NXcPrLSlLGqIyIioEF1giIyipYTNBCDcOYbldYBW7oNc1I6xt7FFYgx44EfOJIhZHBGZEE9jMAF4cT1o8ZamEBXmI5kzpnmz2pDzTzucN6cojF1Norwc70bQgzfixPQuk38LiRVJSJbdd3xYV3Q91kCsqmPQfhq8CLKOO6AHgMZd2FCO4LIl/zJ4pwW7jhIGs5bp9let0G95UEb1sVV8lwg69HoeIvHbXE6G6KWpn678drldMleGYstyjbwt6isC9+dPr7//49bc//NGrG0q6ofcs7xTt1HZk9lLo0bNnQj5pesfangs1Esnz4HkzlqOhsOjxmunOe/7S6nG8Y/eBGpelUZIqeqEN73ENXg2tfw1U8Ec5GLLshWe3c4Qcc5PiPumUOZGnbyXtcWk+MEH1G4/L8uFqK+5Nf+w1f5Q7KsSuZz6io1L9bmwDLapiHxpSjF7HZs5uLOukGbyNWSh0E+murX24E2/4mZEtvdFyWx43T9w8XtcQGzO7xEoNOwufhfPep5fG+4Fe7bvVXjLq82ppQzpouKRhKRHdVgzDnp3LViJKse6+a0u6tSNrK9jrISmdZH7D9oL2pA68ue8tsLWx82Zsey+exNWdj8N+C79BLBVF3/S8rTOSSO2l5ZFiP2sYvGAU46xUauHsfbWMj9ie3KdPA9EulUin78m9J82O3noxeT2YPZ2kZlxKtARXcZq/Xq/F9F3l3HxyOwfNLOKvFxzJcFVkBLNHYkRrGiRzs9TTwBWVu45e4RiCg9B2j2q/9i6ffPCOKHahO6kqVF8FIR/8y3c1627F+EWtbJQ2K5Ky2cSgWj6GT9tXLlBX0DA+ip5IaSarPD8qF7kykS8PfT2y17sjEfwrnKj+2I/f0gsklhz6djuDaeEsB/tjj0g9GNnNottNQ8whE4GtWzw7K+FPAxW+rAn6NKCyLUlDfVBJO0V1KUMS/GFY7lERNSCECm247EmLvmL51IzfRj41KHcenwZKziOLS0XKsxKkpEgi1OM4GXbe0bY5DRHkEsY9cqiJKEXr+XtXfs+rEN1dKuq1j4b7OnwCVvBDKP6KNv0xlBHV9pOPXktG72gnpeSWHA7XflzIB4mK9YWIbarCdbpZ1ekU0+rTySffxkS8yz0r/62EWzG1zUMWX/uC9D3iot24nx93b39651HTz+I2K9N30jaY3uG+352IbmxYIxlFeR98Jv/+d3Zhbs+5ghH6lpRqIIoLrd+avrztVQGvuJ21Meyeks4qzMoKkLyrmM4Zzx5Y3QveW77iJRBDa/pYW9pdzO+huV/J3ZBHShp1dGTvobpJN9+A4Vh34EAoKmq7ilkL0tuQ0DUydMPrA2uoo2sqbCIa9jQw3Q80XEuVYJC8lvQ962w3RreNLVVHOlhW0IOg0j7FdYEqReTZqiU1U13AHAdV8auZFdiGtKujoKTyL+asPre4UwRbexGykpdNrI/lo2zwCmf9y8OW9Kzw2SOvRJupGNjmqNoGy2wEGKxHjlNUMTDMbkteUY/e2hloH0aLpim4PLiwZnJ3EvfWh62YVJeHaYzusTNx9M3086NvrIhi5Twdur7KmUgnMJ6gohr2ez5+UzcBmYvRJWUSq4nNz7qnbOH80JeDYOpeCCpV+pUnYK6rxsJtLIhbzxUm/AEFIf6SvNR/vF6Cv0tcxvv5V5L6eiIfY4hpVHd4Ma4lAvYu9ah+I5WgpIUS0rtPxY259LDB1nENH6oDH7pK3NHMia2y5lG1vGOuhgV69t07efjsnQR99U40+eiRePTNO7l7D8f7rHACnBPosSEjnHCSD048qkdBFskaH/UoZ3wkuNg4Ic4tH3xuYfPvP26vpGn2nAgzEbT98OFFtPQ+wgfmPlkoCs2WCMXKhv6BVV988glI23FBmT4j1ONTpJ3Ty3494yoVSePYWR2KdUsPmtW2U+WsygsAUR4JG2RcGiQdKbmsmCz5hYr7FD037bwFxLVFrIVHYUb9knGjufCtG8zLSWsZujMTWeBxJ2AKMj8TzdGsespUcz1LZaheIuiXydZ9Yv8xLt48BPWsMFRiYGYKi3Ux/JrGB6Gn1TXtLqj6H3XFRpgTuZDNkbcRlW2tNqf2tqEd2Te0imDM0GUsP1CiBjHNYycNkp4K1h+pIE3+k0KdVy+riaIz4fFBDwQkb2isM7eNChebSA2KZLers2cRRMGuFl7Tci80+bi7PRWi1vqat6lLbFw6TUHsncIlcImOhHtDJIm3qbOnxaWzaFxbO1MkO/qxRnj8TRfOC0gwpLWi3/057eTYYL4unoeEvvo4QKxGDSOheSSRnu20tox+WMmmSPdTiVC5Pt7cbvFCK2mnWEebqdQsrReC1kwqbJjJiA+FsGO7bUIcsWykZKdHCaGLmxsTRDrCc0PkOsORjnBySAMdAr+2PekhhFIXU+KIUEs7ag3tzoMRjUxlKu+tPPLrD/Ib11P1sKYZvdRIKcmF/iD+YpZQYq8+bU4rXqKBFXcfuW0DR90wKzI7dEIHyQorogjskpvApyO3WNNqhdCoTaVPzVSkO58zmd2MN5dCGY1oBoHeTX8o6q4t62ZnJu2vloS6NjTCE3bWJtuFvVkxnYwh6CDo2ebjqI2GxnQ8PzUVzmrVGSCMp2aqSY0f04+GUzOAq+tnCjRki+lCuzTXjoZGc/V86DPD+NHdTIO7wzMlbsJjSt82zZSjCniuRf2FmTJSZc0xkZplBpoUqrk+2JQq9/sHaA6+Jy39IsyMPhST5tOO68f9OJeNoTqAvBnNGJhVWi7qjY3dbAS+cnHemBmEjbvWjXYXJnin+y1/3+nEIAFs+v5f1L2nX3w9k+v3eGePwt7dh4iqJLdi9O8rVYOw2dgQqSKNKszU7qXLe+itNLzeXhi9/kEXVJOiLVXl1rxj9Xd6KPHFZrPN/KViAaet+nfDOvacqFiXGenb7uivlO50ZL80+ane8qjL65gWRlTz3veE2l5ebksJtWdS/gddHL6pvviOyb4hJTQZHtjJrdn80MFXG1M86/OFCB4SSXtYm7SHVNIefnHSzIRrWPya1XzTjoTFl0danu3e3nmI+NwxBDS9pS2ExP1w0GsriBY2vcw6Zgg5aeAB4FpFi6kpetQ0KW6Q4AG6FzbSt/xCkTr6QlMb2GSMWiUMbNh4MhwBTJc4PC3e4Q1QOzBOTL4tTCRkhkPmdO/2TO/y0RSH8IAtVIQW0dKWi/s3k0R4SBhKuftoR8z25ZiNzRF65YF11eumAdTLDOqHjnpUGEF4SC1Ip2jlEHELe/S4Qz8OEluEmUQzlaIyghfp5rjJMUlYGXkWGD3r+esrSw8Zr7RlYOlU5JeExrL/GBMm5419HZRZ25osFYZsnUcTfQSqioCODrkmNVKsZogPN5H0nfczYhcpX27iZfDycvOQUrxKKT5KKT5OKT5JKT5NKT5LKT5PKLak1g2EpM0hOiyfWWSyjPtyWxJF3GYyVupPt0+oZLILf3nYxJdvLg+pHHhI5cBDKgdCffeHWvCh/wJQ//K//9//z//xP//l//zf/uX/+p8W+WrykvbMJzGr3EZypfte988y5fH3v3Ml2Z+8irTxWDr5MJDKvQcW+XoARzHrCowjmcVPemamQiLyIqoIcWEYigqBzAVLL2NxY3BoZEaSh6lk8ixcEseBikgynH0QnXiljMXN6cFRmM3dIlDVOmG3E35khZkxY0+fiHH4YNy5ZDsXJcKix89b3LhmFNHDLBEP80Q8xBPxEEvEQzIRD7FEmBXDJwdCCQ7BPPUKKJS3sYelpmdH1/4vtK0xbL438Lsr3eteVOl2a73WY01T3xjqDenVIOiPnKs3r5EYTbBaAe86e+wWCb++jEF//urLN4H7lpW0g8U5I/iO4Ce/89Nihv2RkqYN7E+mLkf6f6RCuh0SX7L3P5HmbHcyWgnnSipBbM3/Jpz0s3xDpOyJWyx7Y2dh/kSbfspbALj5/JnuX0O78xXtG2729D3aZsdI37KGPtrLrw3/p59+evem6dSbhsN7O8m3viPrJD/S8jISPNLOjhOvjSyukqjtG85FxTrdtr3jQv107+ki4OXLMeSdWTdnPelUPI4IYBrHj3atw3QJHebHd29WgXJx/Wi3z9LE22WhEO+OyHtXbl/r/z+aI/+S4hz6s+xxBn1rpyitg3Qs+YmwxvHm1L7N9u9ef//N268ff9p899by4LTE7gIxrgckpm3EqNw84mHCI2t70o8SpEUNtV/bn69yJnsHK+XftD1sPVG8POMYfno1/rb+0rGL/lTUHaNgyymmN+6SNSwcy779amjb+zcdU3/+x++++com72e6BwvjB9iMWJUnGf2flII6IQP6c7sIeeSkf/mwDrXqmRbqn6zafnclYsTs5rUGeaAPdf8gHrY3X6TspIjbLYtqVH+Ej3WbirsdZM6+aJOYWzXr4cSNZXWicYZgwRb8qfRzjaAlZRc6V0hXHenmhXbK1KbV3S3LFfVARMVIV5i+fkK8TcltfYrTGwGZcyMu1RH9BTUJe0p210Z+bvNwJyD7sC6nKptB1y47s2uoI01WuX3x4uNP3r7+8s2Lz199+dXbjz5/89nrr198/vLtpx999OLFx59/Ngpd+aYjHntEn2hufAhG6o5L5RZFIvJxMXOA6PP9Q+PSeZuWhIRGLgnxrV4S4ZvBGSJeHc1h0fppBot9mzOQc8WV13pXVtPmYhaipool8mTLGO+3ttbP2BqhMuZGqLTFESht9F4+DUTQiJHC3L9HPywCJh21LPTaIPkILmjLFYUvh3p7dnbtyL5JOekDQmZhejtikrlY8tb9bkg5tLQjajNUFdvAiZ6jUv3mL1999c23cCoQFzwdak/JxtVdG1N3baA7uwLpO/DzOnMxBNO93vI4CdNCnYl26+CFSaCLo+sfY8G24uWWdsUgdUza6rrDZuywLbmg0wk0CAsLXabIvrV+r0Zxu/kdYKePNk/Gydj0XCjSzDDOTY0Lzc9ukgkcL01OlHCzaDNPtlFEZB+7fR+t629Voi/oTSdHer4f9g2DjZ6VrrPsPoUH+s6k+p3gJ1oq6GuiN6Gnvft9ePGlLtCuNI8kX0PPwwh304JPT/tXLxwV6XKaNRdLWedZEvVYxqItjPr4qERPMF//+cuQAlud+AyYQL/R37bxzkD/uzlHl8D9ICoq3jl/W/0fbm2jO+lfvPl7W+CgfH/2cittODh06uPZSlEG5tY2Wx6itLTv5U6e/fj4rasTk6+sq0sqsgA5/bqnCNPJf3xqMpif6d5Ncn795y9TxvpZVs0DtHgpDMxeFf/tg1D2I5BtXKHLejSMY3O6cVaUvL8LVh8V2j00Dmd8pUVjHH/bE2VLK0HLmEaGWQJ6U8btQkPVjnQdV6g/ndDZimtUZaWQsPnAbkQiUu2UIOU5vGiof/w2GbO71VNhCsRzyEm5VbidFlt5pg1V+rmuiv3/LSJKKVegTg6EeiuWdHJB+qPrfBrPN//AOxI4VJ8g3tLBHHOVM7DVcGHdccQ7RlMhJC3aPYr1hmKdH1T0wrGOcakb9aBP1b78kV8fKVT9iHdVtBbtjI8Ch2mlNLWH45Rx3GM52dtq4SdSzwQ+RtkbNyGWucqd9folDS4qdHUNGkmcrrJiIuxA8e+nP3WUfS3p2EGPwtoDPuII2zigtWrvqDls7xJVaFzUG+s8ZrOn9MgudNNRNbBNT2p6aPh1847U9G3Dr6/NSPjxWWFvbaO7Xu4U9j+1jR7Lw1QRjkqHAEKZrQujUbYT2i29VHj5kXcQ7HiXrCST0bltuF/3/Ws0cneGnHy3xhGGpWYdatNbKHf+w3DpwG9g/TbiLBxJtvMma6w3LW9Je8XFErQUlCj6WigmbT2H25UxdPxtSNLCCEBTxK3ta1oEmqkRvduTEVuWfgHfJQ9o9HWCBNorXO9K29/xNHwSltS1OH5v2XEOUMXLc6Bmq8BI6N/WyKCnZwYBI3BQ+ACDuNA7Why2BzlJ3bB9MQi7nq2HFZ4w/5ynES+lt77hIiKYzF2OVOO0z+OVjlAMtlhf6d79+q6S3Sj8hpRH1vkKyfXGRswG5kw2fxR86L+zrjH/RLqqGZfrGf67oVGsJPr7Nbn6FVHkR2r3OmUDPiqi6FdD20dRdqi4ccXZVePWt5lxfGQGcbN5l2hkp8mbb8IwdQNFc+PHudEYIgHesoZ+xaQSbD9Mq0IfblKreLk4XdrNN/BStv7+FuevB7qnmTnObzqmoo/BacoC/vz4zqytREGKSgUuAt+QptmT8gwlYIy7Sko3Zm5uM5p61cOK9Ug05evxqNwawecvRuxWUAIzmlff1Z6w8s9XadtPVN7lkQi3WDGdoxhJxjNucdXLnC6yYrGA9CsZcdxDTocWB1OI8fxNCjUtzFlwzIYMT0hcG7kbVInpbbREgW5PUSvthNajhasBnXRS0Y/FUzB4+P3WOAceq6wvZT0Um6o+ckwYhlwbGb4NK5HUvuqtbXyxv7XNDvG//93/CwAA//8=")) - } else if typ == "extract" { - return encode.MustDeflateDeCompress(encode.Base64Decode("nFbdbts2FL4fsHfw3LQmLVPWT5Layo+srUXhFeiKtii28tCBIjGNm9gyTBlqIwrI/a4HbMD2DLvaC+Vi2GMMlH8kx0oWD0isw8PzfeeXlEht7I+4U/skvv6qVpvyj/zzRDhKrtVIrY7O43giUqNlZg4dAIjGzfVvUL+5/uP4EGHZBKAstVrWnpG5dHDUXFgcHzoHEmHKAPRPAtdXfEcAim0/o1BvsJx3qUE5/0DBW9rx4cFt+jlVjivxPQxVAHL8HNRoFbnkOOdud8syzaaXlXVa5bVZMKhvlGojnnY5ICePqLdzO5fbuc+huT93zVdvowTV+ZaNVuSPyuxFbx61dNUuK2svPbWODw96Oxs8aw0uggX4bBnnU3623F+bhJvrX2+uf6+ah0br+HCnd1BRwNXkJrHyEvsfi35M+DjmIq5qFeJfvqce+eCTK4N0TwhLTaOVgV7o9KVSrptCW6u0LvS4iGrkDysnpYEKKMBslxsGAZh1z/y9E51hDXqo7JJArtSXSlWAToYbGxkPx2eRkgNf8EKritAzLVsPotFS9/dfP//z5y+FdhnxMAz8aXgn8UYidGCQLkMIwrSTIQNCaRrSNKVpYUQNYjEIpW1I28QQpna2g6Uy3c+Q2ZFmV1qG0lsZMqhJuux+MIJQ/ig/Y4znXhtF2JPzaMwfHjUCzTXczj4QF7smtUmXQZh2sxLjcHIn3X/NFrLQHjXIHpPUILsMQoyVZDIXwtRsWRlGoD/ACqd2VgpoHPMpqQjrnlBW7TGtp6Ab+Z+JJTIN0HMvdrYpqP2nlorQpPuky7BEFoRYIpsaJsO4GtG1QDf3OxWbuFTVSIitjin1pM+CgAtBX8oLxr/QvhwyGspnTG7uvZWC8WDK49IRFPZWDhFC1CdXHvmwuAM00IUtha16JoFg7da2vMMcdH/kX0VjPxGgjhiWSNgOtKFdAAjocMK0fEsPorGILrnuJ2IBVTBoCxvap7PggseiGuuPrsagj5QfapCuT85Y2snISt59gGxaqok8sHIVYZoehITO7598FY0ms5gXOS1Smgl6QpjLfRHngjlfXp7mz5V1vlKIUmP8RBD/4n9Ns58IpKv3kJFhF7lkiGmjAXU2T0cVCNoaS3eNbK7HEiHPfkfnlWPSe9n3pPfitSe9/jNPem9+UJJavsp/3nvSe9v3cFFtlpr7WcW9MxU+ueBftptpwrRvn7/ov6rRAQim1V6/6b/33j2vvXz+EyWsVKJkOA6jRJCz4SXfslCQsNUkMwcAuQ4kGoCLm1hWbeCmeuiQaGsHduILkUQVb4R7M5ww5Ashk1Aq+Pw3moYYUxBH9YbDtOL19k3v0c7jgas3n7DUVi2l9QYrfWsJPlXSgy93RGcMCT6VCiXV/4LhDu+P9aVfEGueEx5Eo+27G8jvWDSlE/maDUO5WE6okG837qZP4WmwVV8VwGm3FwcTdCAnzsERtHtu6wnTSm37OIzPZ6ckji74eLvwV19ETYeuvj+Y1psz5ldZEyvzfwEAAP//")) - } else if typ == "port" { - return encode.MustDeflateDeCompress(encode.Base64Decode("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")) - } - return []byte{} -} + if typ == "spray_rule" { + return encode.MustDeflateDeCompress(encode.Base64Decode("hFPNbqs8EN3zFEfJsMQYU5rwsfpa9RXuKrLktKQlTUsUkvvTxX32K48xcQJRJQRzxsdnPMOxOR3f1n/2puv+w2yOtenq1WH1Sal971wI/p56wN/nHvD3sQdkXBABlNlwju6tObRwBWxGp9ACOsX88cdTomQmk3x5nwdLvKo76C0G0l0i5eLOkSJAV7eYSiZZWSy83IhH6RSzcm+rnEKnfrdhAYYUgxRo0/d1hgK0BXV+ADEoB609jScx5ELuFfEWR4Je0AfBcA36ExReXnFwb5+gwaxclqOjmZCRlzkPP0gtikyeS4lgvwLVVxDOKBeZW0wbWMnxJomL+oqP1GQGTQaJJouHdZXkqsiVXXcG25qfJgKe24+PllN2hMYH4b/5y8Gc31VwBBE0KXy+4t4vBVKvKjAIeNP6eEimZ/PYeANte9dxkKsuYxHAGlqdybOo/n0cLmlvB8nn2IM+Qa+BX/4f5VcrBqOsbfHktSS7amLnwBgMOsEo2Hu5VfyGM1knBj15M5egJQdL14vV/Jb7wM+VajVVJwc99P82WJlFm2ZXr827na8zCt8Uevf/fBqClM+0oB3oxcOdLdL6wsJfdBHs+AI1oL2HR5Y8ePgK+mI7OG+JfhQd6BdoP4v+AQAA//8=")) + } else if typ == "spray_common" { + return encode.MustDeflateDeCompress(encode.Base64Decode("nJOxbtRAFEV7S/4HKxUUIM84m93hZ9DYHuI49tp4hjhJR5UWmkh0FOloqJDIKn+Tzf4G2sy7FxSlAKp3ZFv3zN55e+Hs9CZNsuxVpswqJymSJhWkQ9KCdERaklYkAzJ0GDoMHYYOQ4ehw9Bh6DB0GHHoPM9JiqRJBWlBOiItSSsSkxWTFZMVkxWT1SGJDkWHokPRoejQdGg6NB2aDk2HpkPToenQdGiTJv2wDo3cONpBN2gml2T0g3bQDZpBL2gFnewbqe3F31r+I/1xYlewKdgTbAl2hBuCHmSiXXSLZtErWkWnaBR9Sl4heYVKk9KevnXnQX75ZKcIlydjhGCn18eX5Ah4sJTp33cRSnsaYd5/us9e295J+DzPAq5UJL6bhiFI3ElwYnQ+PEkubSVU22BL6+XTWpJCj5M7EK4zDhvHQXbwr/v7+z7++Bcsn/m3yD18GLvB1pG74fhJVw/X37eb24frq/vNj+3Nz2cfZi/Uy/hie3N1v7mTj24/7b5+jLy7+7z79iVN1g53aP0IsIRzviM1pJ5UCdWdHLJycuWVx2xC36VJa8+sCFsIW6a3fga84ztQDHhEeyZHrDrrfZqMzSihYzMSCtICxIixCWnSeh4lTgcIODYe9K3/BQAA//8=")) + } else if typ == "spray_dict" { + return encode.MustDeflateDeCompress(encode.Base64Decode("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")) + } else if typ == "extract" { + return encode.MustDeflateDeCompress(encode.Base64Decode("nFbdbts2FL4fsHfw3LQmLVPWT5Layo+srUXhFeiKtii28tCBIjGNm9gyTBlqIwrI/a4HbMD2DLvaC+Vi2GMMlH8kx0oWD0isw8PzfeeXlEht7I+4U/skvv6qVpvyj/zzRDhKrtVIrY7O43giUqNlZg4dAIjGzfVvUL+5/uP4EGHZBKAstVrWnpG5dHDUXFgcHzoHEmHKAPRPAtdXfEcAim0/o1BvsJx3qUE5/0DBW9rx4cFt+jlVjivxPQxVAHL8HNRoFbnkOOdud8syzaaXlXVa5bVZMKhvlGojnnY5ICePqLdzO5fbuc+huT93zVdvowTV+ZaNVuSPyuxFbx61dNUuK2svPbWODw96Oxs8aw0uggX4bBnnU3623F+bhJvrX2+uf6+ah0br+HCnd1BRwNXkJrHyEvsfi35M+DjmIq5qFeJfvqce+eCTK4N0TwhLTaOVgV7o9KVSrptCW6u0LvS4iGrkDysnpYEKKMBslxsGAZh1z/y9E51hDXqo7JJArtSXSlWAToYbGxkPx2eRkgNf8EKritAzLVsPotFS9/dfP//z5y+FdhnxMAz8aXgn8UYidGCQLkMIwrSTIQNCaRrSNKVpYUQNYjEIpW1I28QQpna2g6Uy3c+Q2ZFmV1qG0lsZMqhJuux+MIJQ/ig/Y4znXhtF2JPzaMwfHjUCzTXczj4QF7smtUmXQZh2sxLjcHIn3X/NFrLQHjXIHpPUILsMQoyVZDIXwtRsWRlGoD/ACqd2VgpoHPMpqQjrnlBW7TGtp6Ab+Z+JJTIN0HMvdrYpqP2nlorQpPuky7BEFoRYIpsaJsO4GtG1QDf3OxWbuFTVSIitjin1pM+CgAtBX8oLxr/QvhwyGspnTG7uvZWC8WDK49IRFPZWDhFC1CdXHvmwuAM00IUtha16JoFg7da2vMMcdH/kX0VjPxGgjhiWSNgOtKFdAAjocMK0fEsPorGILrnuJ2IBVTBoCxvap7PggseiGuuPrsagj5QfapCuT85Y2snISt59gGxaqok8sHIVYZoehITO7598FY0ms5gXOS1Smgl6QpjLfRHngjlfXp7mz5V1vlKIUmP8RBD/4n9Ns58IpKv3kJFhF7lkiGmjAXU2T0cVCNoaS3eNbK7HEiHPfkfnlWPSe9n3pPfitSe9/jNPem9+UJJavsp/3nvSe9v3cFFtlpr7WcW9MxU+ueBftptpwrRvn7/ov6rRAQim1V6/6b/33j2vvXz+EyWsVKJkOA6jRJCz4SXfslCQsNUkMwcAuQ4kGoCLm1hWbeCmeuiQaGsHduILkUQVb4R7M5ww5Ashk1Aq+Pw3moYYUxBH9YbDtOL19k3v0c7jgas3n7DUVi2l9QYrfWsJPlXSgy93RGcMCT6VCiXV/4LhDu+P9aVfEGueEx5Eo+27G8jvWDSlE/maDUO5WE6okG837qZP4WmwVV8VwGm3FwcTdCAnzsERtHtu6wnTSm37OIzPZ6ckji74eLvwV19ETYeuvj+Y1psz5ldZEyvzfwEAAP//")) + } else if typ == "port" { + return encode.MustDeflateDeCompress(encode.Base64Decode("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")) + } + return []byte{} +} diff --git a/pkg/utils_test.go b/pkg/utils_test.go index 7fa07b0..84f9a9a 100644 --- a/pkg/utils_test.go +++ b/pkg/utils_test.go @@ -1,122 +1,122 @@ -package pkg - -import ( - "strings" - "testing" -) - -func TestParseRawResponse(t *testing.T) { - t.Run("valid complete response", func(t *testing.T) { - raw := "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: 5\r\n\r\nhello" - resp, err := ParseRawResponse([]byte(raw)) - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - if resp.StatusCode != 200 { - t.Fatalf("expected status 200, got %d", resp.StatusCode) - } - if ct := resp.Header.Get("Content-Type"); ct != "text/html" { - t.Fatalf("expected Content-Type text/html, got %s", ct) - } - }) - - t.Run("nil input", func(t *testing.T) { - _, err := ParseRawResponse(nil) - if err == nil { - t.Fatal("expected error for nil input") - } - }) - - t.Run("empty input", func(t *testing.T) { - _, err := ParseRawResponse([]byte{}) - if err == nil { - t.Fatal("expected error for empty input") - } - }) - - t.Run("status line only no headers", func(t *testing.T) { - raw := "HTTP/1.1 200 OK\r\n\r\n" - resp, err := ParseRawResponse([]byte(raw)) - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - if resp.StatusCode != 200 { - t.Fatalf("expected status 200, got %d", resp.StatusCode) - } - }) - - t.Run("truncated status line", func(t *testing.T) { - raw := "HTTP/1." - _, err := ParseRawResponse([]byte(raw)) - if err == nil { - t.Fatal("expected error for truncated status line") - } - }) - - t.Run("redirect response no body", func(t *testing.T) { - raw := "HTTP/1.1 302 Found\r\nLocation: https://example.com/new\r\n\r\n" - resp, err := ParseRawResponse([]byte(raw)) - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - if resp.StatusCode != 302 { - t.Fatalf("expected status 302, got %d", resp.StatusCode) - } - if loc := resp.Header.Get("Location"); loc != "https://example.com/new" { - t.Fatalf("expected Location https://example.com/new, got %s", loc) - } - }) - - t.Run("chunked transfer encoding header", func(t *testing.T) { - raw := "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n" - resp, err := ParseRawResponse([]byte(raw)) - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - if te := resp.Header.Get("Transfer-Encoding"); te == "" { - // Transfer-Encoding may be consumed by http.ReadResponse, just verify no panic - } - _ = resp - }) - - t.Run("large header value", func(t *testing.T) { - largeValue := strings.Repeat("A", 8192) - raw := "HTTP/1.1 200 OK\r\nX-Large: " + largeValue + "\r\n\r\n" - resp, err := ParseRawResponse([]byte(raw)) - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - if got := resp.Header.Get("X-Large"); got != largeValue { - t.Fatalf("large header value mismatch, got length %d", len(got)) - } - }) - - t.Run("invalid status code", func(t *testing.T) { - raw := "HTTP/1.1 xyz OK\r\n\r\n" - _, err := ParseRawResponse([]byte(raw)) - if err == nil { - t.Fatal("expected error for invalid status code") - } - }) - - t.Run("incomplete header no terminator", func(t *testing.T) { - raw := "HTTP/1.1 200 OK\r\nContent-Type: text/html" - _, err := ParseRawResponse([]byte(raw)) - // Should return error or at least not panic - // http.ReadResponse may or may not error on missing \r\n\r\n, - // the key requirement is no panic - _ = err - }) - - t.Run("binary body", func(t *testing.T) { - body := []byte{0x00, 0x01, 0x02, 0xff, 0xfe, 0xfd} - raw := append([]byte("HTTP/1.1 200 OK\r\nContent-Length: 6\r\n\r\n"), body...) - resp, err := ParseRawResponse(raw) - if err != nil { - t.Fatalf("unexpected error: %v", err) - } - if resp.StatusCode != 200 { - t.Fatalf("expected status 200, got %d", resp.StatusCode) - } - }) -} +package pkg + +import ( + "strings" + "testing" +) + +func TestParseRawResponse(t *testing.T) { + t.Run("valid complete response", func(t *testing.T) { + raw := "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: 5\r\n\r\nhello" + resp, err := ParseRawResponse([]byte(raw)) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if resp.StatusCode != 200 { + t.Fatalf("expected status 200, got %d", resp.StatusCode) + } + if ct := resp.Header.Get("Content-Type"); ct != "text/html" { + t.Fatalf("expected Content-Type text/html, got %s", ct) + } + }) + + t.Run("nil input", func(t *testing.T) { + _, err := ParseRawResponse(nil) + if err == nil { + t.Fatal("expected error for nil input") + } + }) + + t.Run("empty input", func(t *testing.T) { + _, err := ParseRawResponse([]byte{}) + if err == nil { + t.Fatal("expected error for empty input") + } + }) + + t.Run("status line only no headers", func(t *testing.T) { + raw := "HTTP/1.1 200 OK\r\n\r\n" + resp, err := ParseRawResponse([]byte(raw)) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if resp.StatusCode != 200 { + t.Fatalf("expected status 200, got %d", resp.StatusCode) + } + }) + + t.Run("truncated status line", func(t *testing.T) { + raw := "HTTP/1." + _, err := ParseRawResponse([]byte(raw)) + if err == nil { + t.Fatal("expected error for truncated status line") + } + }) + + t.Run("redirect response no body", func(t *testing.T) { + raw := "HTTP/1.1 302 Found\r\nLocation: https://example.com/new\r\n\r\n" + resp, err := ParseRawResponse([]byte(raw)) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if resp.StatusCode != 302 { + t.Fatalf("expected status 302, got %d", resp.StatusCode) + } + if loc := resp.Header.Get("Location"); loc != "https://example.com/new" { + t.Fatalf("expected Location https://example.com/new, got %s", loc) + } + }) + + t.Run("chunked transfer encoding header", func(t *testing.T) { + raw := "HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n" + resp, err := ParseRawResponse([]byte(raw)) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if te := resp.Header.Get("Transfer-Encoding"); te == "" { + // Transfer-Encoding may be consumed by http.ReadResponse, just verify no panic + } + _ = resp + }) + + t.Run("large header value", func(t *testing.T) { + largeValue := strings.Repeat("A", 8192) + raw := "HTTP/1.1 200 OK\r\nX-Large: " + largeValue + "\r\n\r\n" + resp, err := ParseRawResponse([]byte(raw)) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if got := resp.Header.Get("X-Large"); got != largeValue { + t.Fatalf("large header value mismatch, got length %d", len(got)) + } + }) + + t.Run("invalid status code", func(t *testing.T) { + raw := "HTTP/1.1 xyz OK\r\n\r\n" + _, err := ParseRawResponse([]byte(raw)) + if err == nil { + t.Fatal("expected error for invalid status code") + } + }) + + t.Run("incomplete header no terminator", func(t *testing.T) { + raw := "HTTP/1.1 200 OK\r\nContent-Type: text/html" + _, err := ParseRawResponse([]byte(raw)) + // Should return error or at least not panic + // http.ReadResponse may or may not error on missing \r\n\r\n, + // the key requirement is no panic + _ = err + }) + + t.Run("binary body", func(t *testing.T) { + body := []byte{0x00, 0x01, 0x02, 0xff, 0xfe, 0xfd} + raw := append([]byte("HTTP/1.1 200 OK\r\nContent-Length: 6\r\n\r\n"), body...) + resp, err := ParseRawResponse(raw) + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + if resp.StatusCode != 200 { + t.Fatalf("expected status 200, got %d", resp.StatusCode) + } + }) +} diff --git a/spray.go b/spray.go index b1a4c6b..58234bd 100644 --- a/spray.go +++ b/spray.go @@ -1,27 +1,27 @@ -//go:generate go run templates/templates_gen.go -t templates -o pkg/templates.go -need spray -package main - -import ( - "github.com/chainreactors/spray/cmd" - "github.com/gookit/config/v2" - "github.com/gookit/config/v2/yaml" - //_ "net/http/pprof" -) - -func init() { - config.WithOptions(func(opt *config.Options) { - opt.DecoderConfig.TagName = "config" - opt.ParseDefault = true - }) - config.AddDriver(yaml.Driver) -} - -func main() { - // 启动 pprof HTTP 服务器，用于调试 goroutine 泄露等问题 - //go func() { - // // 仅监听本地 6060 端口，避免对外暴露 - // _ = http.ListenAndServe("127.0.0.1:6060", nil) - //}() - - cmd.Spray() -} +//go:generate go run templates/templates_gen.go -t templates -o pkg/templates.go -need spray +package main + +import ( + "github.com/chainreactors/spray/cmd" + "github.com/gookit/config/v2" + "github.com/gookit/config/v2/yaml" + //_ "net/http/pprof" +) + +func init() { + config.WithOptions(func(opt *config.Options) { + opt.DecoderConfig.TagName = "config" + opt.ParseDefault = true + }) + config.AddDriver(yaml.Driver) +} + +func main() { + // 启动 pprof HTTP 服务器，用于调试 goroutine 泄露等问题 + //go func() { + // // 仅监听本地 6060 端口，避免对外暴露 + // _ = http.ListenAndServe("127.0.0.1:6060", nil) + //}() + + cmd.Spray() +}