From 3bff6309de7286dc7539819aef4bf0f8a0135aba Mon Sep 17 00:00:00 2001 From: Ivan Fratric Date: Wed, 19 Dec 2018 13:40:04 +0100 Subject: [PATCH 01/50] Stop special-casing freememory() in grammar.py --- grammar.py | 5 -- js.txt | 200 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 200 insertions(+), 5 deletions(-) diff --git a/grammar.py b/grammar.py index 07e3361..1857238 100755 --- a/grammar.py +++ b/grammar.py @@ -292,11 +292,6 @@ def _generate_code(self, num_lines, initial_variables=[], last_var=0): context = tmp_context except RecursionError as e: print('Warning: ' + str(e)) - for i in range(len(context['lines']) // 100): - context['lines'].insert( - random.randint(0, len(context['lines'])), - 'freememory();' - ) if not self._line_guard: guarded_lines = context['lines'] else: diff --git a/js.txt b/js.txt index e6f5081..b0a55c6 100644 --- a/js.txt +++ b/js.txt @@ -5834,6 +5834,206 @@ document.all[%document.all.length].appendChild(); = .style; = .style; +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); +freememory(); !end lines From 012252b1d21c7f14571716b91efcb993837f8025 Mon Sep 17 00:00:00 2001 From: Ivan Fratric Date: Wed, 19 Dec 2018 13:57:45 +0100 Subject: [PATCH 02/50] Update CVEs --- README.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 2b3e8a1..7bb73f6 100644 --- a/README.md +++ b/README.md @@ -256,10 +256,12 @@ The following attributes are supported: Some of the bugs that have been found with Domato: - - Apple Safari: CVE-2017-2369, CVE-2017-2373, CVE-2017-2362, CVE-2017-2454, CVE-2017-2455, CVE-2017-2459, CVE-2017-2460, CVE-2017-2466, CVE-2017-2471, CVE-2017-2476, CVE-2017-7039, CVE-2017-7040, CVE-2017-7041, CVE-2017-7042, CVE-2017-7043, CVE-2017-7046, CVE-2017-7048, CVE-2017-7049 + - Apple Safari: CVE-2017-2369, CVE-2017-2373, CVE-2017-2362, CVE-2017-2454, CVE-2017-2455, CVE-2017-2459, CVE-2017-2460, CVE-2017-2466, CVE-2017-2471, CVE-2017-2476, CVE-2017-7039, CVE-2017-7040, CVE-2017-7041, CVE-2017-7042, CVE-2017-7043, CVE-2017-7046, CVE-2017-7048, CVE-2017-7049, CVE-2017-13796, CVE-2017-13792, CVE-2017-13797, CVE-2017-13795, CVE-2017-13785, CVE-2017-13784, CVE-2017-13783, CVE-2017-13802, CVE-2017-13794, CVE-2017-13798, CVE-2017-13791, CVE-2018-4089, CVE-2018-4200, CVE-2018-4197, CVE-2018-4318, CVE-2018-4317, CVE-2018-4314, CVE-2018-4306, CVE-2018-4312, CVE-2018-4315, CVE-2018-4323, CVE-2018-4328 - Google Chrome: Issues 666246 and 671328 - - Microsoft Internet Explorer 11: CVE-2017-0037, CVE-2017-0059, CVE-2017-0202, CVE-2017-8594 + - Microsoft Internet Explorer 11: CVE-2017-0037, CVE-2017-0059, CVE-2017-0202, CVE-2017-8594, CVE-2018-0866 - Microsoft Edge: CVE-2017-0037, CVE-2017-8496, CVE-2017-8652, CVE-2017-8644 + - Microsoft JScript: CVE-2017-11903, CVE-2017-11855, CVE-2017-11793, CVE-2017-11906, CVE-2017-11907, CVE-2018-0935, CVE-2018-8353, CVE-2018-8631 + - Microsoft VBScript: CVE-2018-8544, CVE-2018-8552, CVE-2018-8625 - Mozilla Firefox: CVE-2017-5404, CVE-2017-5447, CVE-2017-5465 #### Disclaimer From 39a0fedd165dcdce2dc2a142dbf9e277ce4ec39f Mon Sep 17 00:00:00 2001 From: Ivan Fratric Date: Wed, 19 Dec 2018 17:05:30 +0100 Subject: [PATCH 03/50] Add vbscript fuzzer --- vbscript/README.md | 3 + vbscript/generator.py | 146 ++++++++ vbscript/template.html | 731 +++++++++++++++++++++++++++++++++++++++++ vbscript/vbscript.txt | 307 +++++++++++++++++ 4 files changed, 1187 insertions(+) create mode 100644 vbscript/README.md create mode 100755 vbscript/generator.py create mode 100755 vbscript/template.html create mode 100755 vbscript/vbscript.txt diff --git a/vbscript/README.md b/vbscript/README.md new file mode 100644 index 0000000..4fb1413 --- /dev/null +++ b/vbscript/README.md @@ -0,0 +1,3 @@ +Script and grammar for fuzzing Microsoft VBScript engine. + +Usage is the same as for DOM fuzzing. diff --git a/vbscript/generator.py b/vbscript/generator.py new file mode 100755 index 0000000..b545221 --- /dev/null +++ b/vbscript/generator.py @@ -0,0 +1,146 @@ +# Domato - main generator script +# ------------------------------- +# +# Written and maintained by Ivan Fratric +# +# Copyright 2017 Google Inc. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from __future__ import print_function +import os +import re +import random +import sys + +parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)) +sys.path.append(parent_dir) +from grammar import Grammar + +_N_MAIN_LINES = 1000 +_N_EVENTHANDLER_LINES = 300 + +def generate_function_body(jsgrammar, num_lines): + js = jsgrammar._generate_code(num_lines) + return js + +def GenerateNewSample(template, jsgrammar): + """Parses grammar rules from string. + + Args: + template: A template string. + htmlgrammar: Grammar for generating HTML code. + cssgrammar: Grammar for generating CSS code. + jsgrammar: Grammar for generating JS code. + + Returns: + A string containing sample data. + """ + + result = template + + handlers = False + while '' in result: + numlines = _N_MAIN_LINES + if handlers: + numlines = _N_EVENTHANDLER_LINES + else: + handlers = True + result = result.replace( + '', + generate_function_body(jsgrammar, numlines), + 1 + ) + + return result + + +def generate_samples(grammar_dir, outfiles): + """Generates a set of samples and writes them to the output files. + + Args: + grammar_dir: directory to load grammar files from. + outfiles: A list of output filenames. + """ + + f = open(os.path.join(grammar_dir, 'template.html')) + template = f.read() + f.close() + + jsgrammar = Grammar() + err = jsgrammar.parse_from_file(os.path.join(grammar_dir, 'vbscript.txt')) + if err > 0: + print('There were errors parsing grammar') + return + + for outfile in outfiles: + result = GenerateNewSample(template, jsgrammar) + + if result is not None: + print('Writing a sample to ' + outfile) + try: + f = open(outfile, 'w') + f.write(result) + f.close() + except IOError: + print('Error writing to output') + + +def get_option(option_name): + for i in range(len(sys.argv)): + if (sys.argv[i] == option_name) and ((i + 1) < len(sys.argv)): + return sys.argv[i + 1] + elif sys.argv[i].startswith(option_name + '='): + return sys.argv[i][len(option_name) + 1:] + return None + + +def main(): + fuzzer_dir = os.path.dirname(__file__) + + multiple_samples = False + + for a in sys.argv: + if a.startswith('--output_dir='): + multiple_samples = True + if '--output_dir' in sys.argv: + multiple_samples = True + + if multiple_samples: + print('Running on ClusterFuzz') + out_dir = get_option('--output_dir') + nsamples = int(get_option('--no_of_files')) + print('Output directory: ' + out_dir) + print('Number of samples: ' + str(nsamples)) + + if not os.path.exists(out_dir): + os.mkdir(out_dir) + + outfiles = [] + for i in range(nsamples): + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i) + '.html')) + + generate_samples(fuzzer_dir, outfiles) + + elif len(sys.argv) > 1: + outfile = sys.argv[1] + generate_samples(fuzzer_dir, [outfile]) + + else: + print('Arguments missing') + print("Usage:") + print("\tpython generator.py ") + print("\tpython generator.py --output_dir --no_of_files ") + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/vbscript/template.html b/vbscript/template.html new file mode 100755 index 0000000..fc42c0c --- /dev/null +++ b/vbscript/template.html @@ -0,0 +1,731 @@ + + + + + + + + + diff --git a/vbscript/vbscript.txt b/vbscript/vbscript.txt new file mode 100755 index 0000000..9d00f26 --- /dev/null +++ b/vbscript/vbscript.txt @@ -0,0 +1,307 @@ + = + + = -1 + = 0 + = 1 + = 2 + = 0 + = 1 + = 2 + = 10 + = 100 + = 1000 +# = 1000000 + = + + = 536870911 + = 536870912 + = 1073741823 + = 1073741824 + = 2147483647 + = 2147483648 + = 4294967295 + = 4294967296 + + = property1 + = property2 + = property3 + = property4 + = property5 + + = property1 + = property2 + = property3 + = property4 + = property5 + = compareMode + = Pattern + = IgnoreCase + = Global + = Count + = FirstIndex + = Length + = Value + + = class1 + = class2 + = class3 + = class4 + = class5 + + = function1 + = function2 + + = sub1 + = sub2 + + = arg1 + = arg2 + = arg3 + = arg4 + = arg5 + + = Date + = Now + = Time + = Timer + + = + = + = + = + = + = + = + = True + = False + = + = + = + = "31-Jan-09" + + = + = & + = & & + = String(, ) + = 17 + = 65 + = 257 + = 1025 + = 4097 + = 65537 + = Chr() + = Chr() & Chr() + = Chr() & Chr() & Chr() + + = True + = False + + = var + = var + = var + = var + = var + = property + + = + = Set + +!begin lines + + = "aaaaaaaaaa" + = "aaaaaaaaaa" + = Array() + = Array(, , ) + = Array(, , , , ) +set = new +set = CreateObject("Scripting.Dictionary") +set = CreateObject("Scripting.Dictionary") +set = New RegExp + + = Me + = + = (, , , , ) + = .f(, , , , ) + = f(, , , , ) + = (, , , , ) + , , , , + +If IsObject() Then Set . = Else . = End if +If IsObject(.) Then Set = . Else = . End if +If IsObject() Then Set . = Else . = End if +If IsObject(.) Then Set = . Else = . End if +If IsObject() Then Set . = Else . = End if +If IsObject(.) Then Set = . Else = . End if +If IsObject() Then Set . = Else . = End if +If IsObject(.) Then Set = . Else = . End if +If IsObject() Then Set . = Else . = End if +If IsObject(.) Then Set = . Else = . End if + = . +. = + + +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +If IsObject() Then Set () = Else () = End if +If IsObject(()) Then Set = () Else = () End if +() = + = () +(, ) = + = (, ) +(, ) = + = (, ) + +Set = GetRef("") + +Eval() + = CreateObject() + = TypeName() + +Erase + +ReDim () +ReDim Preserve () +ReDim () +ReDim Preserve () +ReDim (, ) +ReDim Preserve (, ) +ReDim (, ) +ReDim Preserve (, ) + +#string +InStr , +InStr , , +InStr , , , +InStrRev , +InStrRev , , +InStrRev , , , + = LCase() + = UCase() + = Left(, ) + = Right(, ) +Len() + = LTrim() + = RTrim() + = Trim() + = Mid(, ) + = Mid(, , ) + = Replace(, , ) + = Replace(, , , ) + = Replace(, , , , ) + = Replace(, , , , , ) + = Space() +StrComp , +StrComp , , + = String(, ) + = StrReverse() + +#Array + = Filter(, ) + = Filter(, , ) + = Filter(, , , ) + = Join() + = Join(, ) +LBound , +UBound , + = Split() + = Split(, ) + = Split(, , ) + = Split(, , , ) + +#dictionary +If IsObject() Then Set .Item("") = Else .Item("") = End if +If IsObject(.Item("")) Then Set = .Item("") Else = () End if +If IsObject() Then Set .Item("") = Else .Item("") = End if +If IsObject(.Item("")) Then Set = .Item("") Else = () End if +If IsObject() Then Set .Item("") = Else .Item("") = End if +If IsObject(.Item("")) Then Set = .Item("") Else = () End if +If IsObject() Then Set .Item("") = Else .Item("") = End if +If IsObject(.Item("")) Then Set = .Item("") Else = () End if +If IsObject() Then Set .Item("") = Else .Item("") = End if +If IsObject(.Item("")) Then Set = .Item("") Else = () End if + = .Item("") +.Item("") = + = .Item() +.Item() = +.Key("") = + = .Key("") +.Key() = + = .Key() +.add "", +.add , +.exists() + = .Items + = .Keys +.Remove("") +.Remove() +.RemoveAll + +#regexp +.Test() + = .Replace(, ) +Set var = .Execute() + = .Item(fuzzint) + +# set return value +f1 = +f2 = +f = +x = + +#date and time + = + = CDate(param) +# = DateAdd(, , ) +# = DateDiff(, , ) +# = DateDiff(, , , ) +# = DateDiff(, , , , ) +# = DatePart(, ) +# = DatePart(, , ) +# = DatePart(, , , ) + = DateSerial(, , ) + = DateValue() + = Day() + = Hour() + = Minute() + = Second() + = Month() + = Year() + = MonthName() + = MonthName(, ) + = FormatDateTime(, ) + = TimeSerial(, , ) + = TimeValue() + = Weekday() + = Weekday(, ) + = WeekdayName() + = WeekdayName(, ) + = WeekdayName(, , ) + + = Atn() + = mod + +!end lines From dd898d388ea3110794b30a3b5ab9e89ba4eddd82 Mon Sep 17 00:00:00 2001 From: Ivan Fratric Date: Thu, 31 Jan 2019 15:04:21 +0100 Subject: [PATCH 04/50] Fix SetVariable --- grammar.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/grammar.py b/grammar.py index 1857238..8ee9f8f 100755 --- a/grammar.py +++ b/grammar.py @@ -1018,7 +1018,7 @@ def _add_variable(self, var_name, var_type, context): self._add_variable(var_name, parent_type, context) def _get_variable_setters(self, var_name, var_type): - ret = "SetVariable(" + var_name + ", '" + var_type + "'); " + ret = "SetVariable(fuzzervars, " + var_name + ", '" + var_type + "'); " if var_type in self._inheritance: for parent_type in self._inheritance[var_type]: ret += self._get_variable_setters(var_name, parent_type) From 2982099ddaca5b340145c5bd1887417001bf7e70 Mon Sep 17 00:00:00 2001 From: Ramon Benitez-Pagan Date: Fri, 1 Feb 2019 19:21:08 -0500 Subject: [PATCH 05/50] Modified generator.py's sample's numeric-format naming convention Example: Generate 1000 samples Result: >Previous: fuzz-1.html, fuzz-10.html, fuzz-100.html, fuzz-999.html >Now: fuzz-0001.html, fuzz-0010.html, fuzz-0100.html, fuzz-0999.html It helps with processing the files sequentially. --- canvas/generator.py | 3 ++- generator.py | 3 ++- jscript/generator.py | 3 ++- vbscript/generator.py | 3 ++- 4 files changed, 8 insertions(+), 4 deletions(-) diff --git a/canvas/generator.py b/canvas/generator.py index 43e7d5c..fb1b37a 100644 --- a/canvas/generator.py +++ b/canvas/generator.py @@ -121,6 +121,7 @@ def main(): print('Running on ClusterFuzz') out_dir = get_option('--output_dir') nsamples = int(get_option('--no_of_files')) + nChars = len(get_option('--no_of_files')) print('Output directory: ' + out_dir) print('Number of samples: ' + str(nsamples)) @@ -129,7 +130,7 @@ def main(): outfiles = [] for i in range(nsamples): - outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i) + '.html')) + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(nChars) + '.html')) generate_samples(fuzzer_dir, outfiles) diff --git a/generator.py b/generator.py index 6c80a93..1544884 100755 --- a/generator.py +++ b/generator.py @@ -446,6 +446,7 @@ def main(): print('Running on ClusterFuzz') out_dir = get_option('--output_dir') nsamples = int(get_option('--no_of_files')) + nChars = len(get_option('--no_of_files')) print('Output directory: ' + out_dir) print('Number of samples: ' + str(nsamples)) @@ -454,7 +455,7 @@ def main(): outfiles = [] for i in range(nsamples): - outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i) + '.html')) + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(nChars) + '.html')) generate_samples(fuzzer_dir, outfiles) diff --git a/jscript/generator.py b/jscript/generator.py index 58bbab5..61f120f 100755 --- a/jscript/generator.py +++ b/jscript/generator.py @@ -128,6 +128,7 @@ def main(): print('Running on ClusterFuzz') out_dir = get_option('--output_dir') nsamples = int(get_option('--no_of_files')) + nChars = len(get_option('--no_of_files')) print('Output directory: ' + out_dir) print('Number of samples: ' + str(nsamples)) @@ -136,7 +137,7 @@ def main(): outfiles = [] for i in range(nsamples): - outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i) + '.html')) + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i.zfill(nChars) + '.html')) generate_samples(fuzzer_dir, outfiles) diff --git a/vbscript/generator.py b/vbscript/generator.py index b545221..33d4bea 100755 --- a/vbscript/generator.py +++ b/vbscript/generator.py @@ -120,6 +120,7 @@ def main(): print('Running on ClusterFuzz') out_dir = get_option('--output_dir') nsamples = int(get_option('--no_of_files')) + nChars = len(get_option('--no_of_files')) print('Output directory: ' + out_dir) print('Number of samples: ' + str(nsamples)) @@ -128,7 +129,7 @@ def main(): outfiles = [] for i in range(nsamples): - outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i) + '.html')) + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(nChars) + '.html')) generate_samples(fuzzer_dir, outfiles) From dd5540b6360c7ee60ca9bc2c2c65fa69878f0168 Mon Sep 17 00:00:00 2001 From: Ivan Fratric Date: Mon, 4 Feb 2019 11:21:11 +0100 Subject: [PATCH 06/50] Update LICENSE --- LICENSE | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LICENSE b/LICENSE index d645695..afdfe50 100644 --- a/LICENSE +++ b/LICENSE @@ -187,7 +187,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright [yyyy] [name of copyright owner] + Copyright 2017 Google Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. From db562cc0aa426b94d9f16fc8bc552912b21b7740 Mon Sep 17 00:00:00 2001 From: Ramon Benitez-Pagan <11214492+rbenitezpagan@users.noreply.github.com> Date: Mon, 4 Feb 2019 10:47:48 -0500 Subject: [PATCH 07/50] Fixed 5 digits long numeric name convention of sample output --- canvas/generator.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/canvas/generator.py b/canvas/generator.py index fb1b37a..d3b89fb 100644 --- a/canvas/generator.py +++ b/canvas/generator.py @@ -121,7 +121,6 @@ def main(): print('Running on ClusterFuzz') out_dir = get_option('--output_dir') nsamples = int(get_option('--no_of_files')) - nChars = len(get_option('--no_of_files')) print('Output directory: ' + out_dir) print('Number of samples: ' + str(nsamples)) @@ -130,7 +129,7 @@ def main(): outfiles = [] for i in range(nsamples): - outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(nChars) + '.html')) + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(5) + '.html')) generate_samples(fuzzer_dir, outfiles) From 84d11ec45a2d5c2a18bb0d417e4887a20a9813fe Mon Sep 17 00:00:00 2001 From: Ramon Benitez-Pagan <11214492+rbenitezpagan@users.noreply.github.com> Date: Mon, 4 Feb 2019 10:48:38 -0500 Subject: [PATCH 08/50] Fixed 5 digits long numeric name convention of sample output --- generator.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/generator.py b/generator.py index 1544884..5ca9da9 100755 --- a/generator.py +++ b/generator.py @@ -446,7 +446,6 @@ def main(): print('Running on ClusterFuzz') out_dir = get_option('--output_dir') nsamples = int(get_option('--no_of_files')) - nChars = len(get_option('--no_of_files')) print('Output directory: ' + out_dir) print('Number of samples: ' + str(nsamples)) @@ -455,7 +454,7 @@ def main(): outfiles = [] for i in range(nsamples): - outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(nChars) + '.html')) + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(5) + '.html')) generate_samples(fuzzer_dir, outfiles) From 7c0f55803a2d45c5fa216426344a52d812e0878f Mon Sep 17 00:00:00 2001 From: Ramon Benitez-Pagan <11214492+rbenitezpagan@users.noreply.github.com> Date: Mon, 4 Feb 2019 10:49:35 -0500 Subject: [PATCH 09/50] Fixed 5 digits long numeric name convention of sample output --- jscript/generator.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/jscript/generator.py b/jscript/generator.py index 61f120f..13175f7 100755 --- a/jscript/generator.py +++ b/jscript/generator.py @@ -128,7 +128,6 @@ def main(): print('Running on ClusterFuzz') out_dir = get_option('--output_dir') nsamples = int(get_option('--no_of_files')) - nChars = len(get_option('--no_of_files')) print('Output directory: ' + out_dir) print('Number of samples: ' + str(nsamples)) @@ -137,7 +136,7 @@ def main(): outfiles = [] for i in range(nsamples): - outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i.zfill(nChars) + '.html')) + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i.zfill(5) + '.html')) generate_samples(fuzzer_dir, outfiles) From bba19b0226eed065c8f3ffc73b848b5a0874df81 Mon Sep 17 00:00:00 2001 From: Ramon Benitez-Pagan <11214492+rbenitezpagan@users.noreply.github.com> Date: Mon, 4 Feb 2019 10:50:09 -0500 Subject: [PATCH 10/50] Fixed 5 digits long numeric name convention of sample output --- vbscript/generator.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/vbscript/generator.py b/vbscript/generator.py index 33d4bea..e5ff0c8 100755 --- a/vbscript/generator.py +++ b/vbscript/generator.py @@ -120,7 +120,6 @@ def main(): print('Running on ClusterFuzz') out_dir = get_option('--output_dir') nsamples = int(get_option('--no_of_files')) - nChars = len(get_option('--no_of_files')) print('Output directory: ' + out_dir) print('Number of samples: ' + str(nsamples)) @@ -129,7 +128,7 @@ def main(): outfiles = [] for i in range(nsamples): - outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(nChars) + '.html')) + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(5) + '.html')) generate_samples(fuzzer_dir, outfiles) @@ -144,4 +143,4 @@ def main(): print("\tpython generator.py --output_dir --no_of_files ") if __name__ == '__main__': - main() \ No newline at end of file + main() From 71701f3850cbe23d15b8b9fdd27e9fe30292d7a0 Mon Sep 17 00:00:00 2001 From: Ivan Fratric Date: Thu, 7 Feb 2019 15:45:40 +0100 Subject: [PATCH 11/50] Fix a syntax error --- jscript/generator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jscript/generator.py b/jscript/generator.py index 13175f7..b63487f 100755 --- a/jscript/generator.py +++ b/jscript/generator.py @@ -136,7 +136,7 @@ def main(): outfiles = [] for i in range(nsamples): - outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i.zfill(5) + '.html')) + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(5) + '.html')) generate_samples(fuzzer_dir, outfiles) From 85de0c3a42671e682173f495c45bdab593b84a6a Mon Sep 17 00:00:00 2001 From: Tyson Smith Date: Mon, 18 Feb 2019 22:04:49 -0800 Subject: [PATCH 12/50] Remove typo fonty-family --- css.txt | 3 --- cssproperties.txt | 2 -- js.txt | 1 - jshelpers.txt | 2 -- 4 files changed, 8 deletions(-) diff --git a/css.txt b/css.txt index bdc8570..e1b6d35 100644 --- a/css.txt +++ b/css.txt @@ -387,7 +387,6 @@ = font-variant-ligatures = font-vendor = font-weight - = fonty-family = grid = grid-area = grid-auto-columns @@ -885,7 +884,6 @@ = = = - = = = = @@ -1383,7 +1381,6 @@ = font-variant-ligatures: = font-vendor: = font-weight: - = fonty-family: = grid: = grid-area: = grid-auto-columns: diff --git a/cssproperties.txt b/cssproperties.txt index 142da4a..749ccc8 100644 --- a/cssproperties.txt +++ b/cssproperties.txt @@ -1893,8 +1893,6 @@ = unset = px - = Times - = px/px px = px px/px = px px/px px diff --git a/js.txt b/js.txt index b0a55c6..84acabe 100644 --- a/js.txt +++ b/js.txt @@ -4254,7 +4254,6 @@ .setProperty("font-variant-ligatures", ""); .setProperty("font-vendor", ""); .setProperty("font-weight", ""); -.setProperty("fonty-family", ""); .setProperty("grid", ""); .setProperty("grid-area", ""); .setProperty("grid-auto-columns", ""); diff --git a/jshelpers.txt b/jshelpers.txt index 0b96c8c..93b6f20 100644 --- a/jshelpers.txt +++ b/jshelpers.txt @@ -1201,7 +1201,6 @@ = "font-variant-ligatures" = "font-vendor" = "font-weight" - = "fonty-family" = "grid" = "grid-area" = "grid-auto-columns" @@ -1699,7 +1698,6 @@ = "" = "" = "" - = "" = "" = "" = "" From 919564b804b755301f786bb74b892bcef7413d6d Mon Sep 17 00:00:00 2001 From: Tyson Smith Date: Mon, 18 Feb 2019 22:15:07 -0800 Subject: [PATCH 13/50] Remove invalid entries --- css.txt | 6 ------ cssproperties.txt | 4 ---- js.txt | 2 -- jshelpers.txt | 4 ---- 4 files changed, 16 deletions(-) diff --git a/css.txt b/css.txt index e1b6d35..46d5301 100644 --- a/css.txt +++ b/css.txt @@ -492,7 +492,6 @@ = overflow-wrap = overflow-x = overflow-y - = oxverflow = padding = padding-bottom = padding-left @@ -506,7 +505,6 @@ = perspective-origin = pointer-events = position - = postion = prince-hyphens = quotes = resize @@ -989,7 +987,6 @@ = = = - = = = = @@ -1003,7 +1000,6 @@ = = = - = = = = @@ -1486,7 +1482,6 @@ = overflow-wrap: = overflow-x: = overflow-y: - = oxverflow: = padding: = padding-bottom: = padding-left: @@ -1500,7 +1495,6 @@ = perspective-origin: = pointer-events: = position: - = postion: = prince-hyphens: = quotes: = resize: diff --git a/cssproperties.txt b/cssproperties.txt index 749ccc8..77fc12a 100644 --- a/cssproperties.txt +++ b/cssproperties.txt @@ -2811,8 +2811,6 @@ = -webkit-paged-x = overlay - = hidden - = = em = px @@ -2904,8 +2902,6 @@ = sticky = px - = relative - = auto = '{' '}' diff --git a/js.txt b/js.txt index 84acabe..4d3b265 100644 --- a/js.txt +++ b/js.txt @@ -4359,7 +4359,6 @@ .setProperty("overflow-wrap", ""); .setProperty("overflow-x", ""); .setProperty("overflow-y", ""); -.setProperty("oxverflow", ""); .setProperty("padding", ""); .setProperty("padding-bottom", ""); .setProperty("padding-left", ""); @@ -4373,7 +4372,6 @@ .setProperty("perspective-origin", ""); .setProperty("pointer-events", ""); .setProperty("position", ""); -.setProperty("postion", ""); .setProperty("prince-hyphens", ""); .setProperty("quotes", ""); .setProperty("resize", ""); diff --git a/jshelpers.txt b/jshelpers.txt index 93b6f20..e5738ab 100644 --- a/jshelpers.txt +++ b/jshelpers.txt @@ -1306,7 +1306,6 @@ = "overflow-wrap" = "overflow-x" = "overflow-y" - = "oxverflow" = "padding" = "padding-bottom" = "padding-left" @@ -1320,7 +1319,6 @@ = "perspective-origin" = "pointer-events" = "position" - = "postion" = "prince-hyphens" = "quotes" = "resize" @@ -1803,7 +1801,6 @@ = "" = "" = "" - = "" = "" = "" = "" @@ -1817,7 +1814,6 @@ = "" = "" = "" - = "" = "" = "" = "" From 474693142af3b68fad1f8a184bdbb9fc70363947 Mon Sep 17 00:00:00 2001 From: akayn <30512781+akayn@users.noreply.github.com> Date: Sun, 10 Mar 2019 20:26:34 -0700 Subject: [PATCH 14/50] add WebGL Support this commit adds a WebGL dictionary, generator and template... --- webgl/generator.py | 148 ++++++++ webgl/template.html | 79 ++++ webgl/webgl.txt | 871 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1098 insertions(+) create mode 100644 webgl/generator.py create mode 100644 webgl/template.html create mode 100644 webgl/webgl.txt diff --git a/webgl/generator.py b/webgl/generator.py new file mode 100644 index 0000000..a24dd3e --- /dev/null +++ b/webgl/generator.py @@ -0,0 +1,148 @@ +# Domato - main generator script +# ------------------------------- +# +# Written and maintained by Ivan Fratric +# +# Copyright 2017 Google Inc. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from __future__ import print_function +import os +import re +import random +import sys + +parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)) +sys.path.append(parent_dir) +from grammar import Grammar + +_N_MAIN_LINES = 50 +_N_EVENTHANDLER_LINES = 1 + +def generate_function_body(jsgrammar, num_lines): + js = '' + js += jsgrammar._generate_code(num_lines) + + return js + +def GenerateNewSample(template, jsgrammar): + """Parses grammar rules from string. + + Args: + template: A template string. + htmlgrammar: Grammar for generating HTML code. + cssgrammar: Grammar for generating CSS code. + jsgrammar: Grammar for generating JS code. + + Returns: + A string containing sample data. + """ + + result = template + handlers = False + while '' in result: + numlines = _N_MAIN_LINES + if handlers: + numlines = _N_EVENTHANDLER_LINES + else: + handlers = True + result = result.replace( + '', + generate_function_body(jsgrammar, numlines), + 1 + ) + + return result + + +def generate_samples(grammar_dir, outfiles): + """Generates a set of samples and writes them to the output files. + + Args: + grammar_dir: directory to load grammar files from. + outfiles: A list of output filenames. + """ + + f = open(os.path.join(grammar_dir, 'template.html')) + template = f.read() + f.close() + + jsgrammar = Grammar() + err = jsgrammar.parse_from_file(os.path.join(grammar_dir, 'webgl.txt')) + if err > 0: + print('There were errors parsing grammar') + return + + for outfile in outfiles: + + result = GenerateNewSample(template, jsgrammar) + + if result is not None: + print('Writing a sample to ' + outfile) + try: + f = open(outfile, 'w') + f.write(result) + f.close() + except IOError: + print('Error writing to output') + + +def get_option(option_name): + for i in range(len(sys.argv)): + if (sys.argv[i] == option_name) and ((i + 1) < len(sys.argv)): + return sys.argv[i + 1] + elif sys.argv[i].startswith(option_name + '='): + return sys.argv[i][len(option_name) + 1:] + return None + + +def main(): + fuzzer_dir = os.path.dirname(__file__) + + multiple_samples = False + + for a in sys.argv: + if a.startswith('--output_dir='): + multiple_samples = True + if '--output_dir' in sys.argv: + multiple_samples = True + + if multiple_samples: + print('Running on ClusterFuzz') + out_dir = get_option('--output_dir') + nsamples = int(get_option('--no_of_files')) + print('Output directory: ' + out_dir) + print('Number of samples: ' + str(nsamples)) + + if not os.path.exists(out_dir): + os.mkdir(out_dir) + + outfiles = [] + for i in range(nsamples): + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i) + '.html')) + + generate_samples(fuzzer_dir, outfiles) + + elif len(sys.argv) > 1: + outfile = sys.argv[1] + generate_samples(fuzzer_dir, [outfile]) + + else: + print('Arguments missing') + print("Usage:") + print("\tpython generator.py ") + print("\tpython generator.py --output_dir --no_of_files ") + +if __name__ == '__main__': + main() diff --git a/webgl/template.html b/webgl/template.html new file mode 100644 index 0000000..59805af --- /dev/null +++ b/webgl/template.html @@ -0,0 +1,79 @@ + + + + + + + + + + + + diff --git a/webgl/webgl.txt b/webgl/webgl.txt new file mode 100644 index 0000000..09a36e4 --- /dev/null +++ b/webgl/webgl.txt @@ -0,0 +1,871 @@ + + = true + = false + + = true + = false + + = + = + = + = + = + + = gl.LINEAR + = gl.LINEAR_MIPMAP_NEAREST + = + = + + = 0 + = 1 + = 2 + = 4 + = 8 + = 16 + = 32 + = 64 + = 128 + + = 0 + = 1 + = 2 + = 4 + = 8 + = 16 + = 32 + = 64 + = 128 + + = 0x7fffff00 + = 0x64 + = 0x3e8 + = 0x4141 + = 0xefff + = 0xaa + = 0xaf43 + = -0x5a + = true + = false + + + = 536870911 + = 536870912 + = 1073741823 + = 1073741824 + = 2147483647 + = 2147483648 + = 4294967295 + = 4294967296 + + = + = + + = + + + = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + = 17 + = 65 + = 257 + = 1025 + = 4097 + = 65537 + = String.fromCharCode() + = String.fromCharCode().repeat() + + = 0.0 + = 0.000005 + = 0.0025 + = 0.1 + = 0.2 + = 0.255 + = 0.275 + = 0.3 + = 0.4 + = 0.5 + = 0.55 + = 0.75 + = 1.0 + + = 0.0 + = 0.000005 + = 0.0025 + = 0.1 + = 0.2 + = 0.255 + = 0.275 + = 0.3 + = 0.4 + = 0.5 + = 0.55 + = 0.75 + = 1.0 + + = 1110011 + = 1010011 + = 1000011 + = 1010001 + = 1010000 + + = gl.PACK_ALIGNMENT + = gl.UNPACK_ALIGNMENT + = gl.UNPACK_FLIP_Y_WEBGL + = gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL + = gl.UNPACK_COLORSPACE_CONVERSION_WEBGL + = gl.PACK_ROW_LENGTH + = gl.PACK_SKIP_PIXELS + = gl.PACK_SKIP_ROWS + = gl.UNPACK_ROW_LENGTH + = gl.UNPACK_IMAGE_HEIGHT + = gl.UNPACK_SKIP_PIXELS + = gl.UNPACK_SKIP_ROWS + = gl.UNPACK_SKIP_IMAGES + + = gl.STATIC_DRAW + = gl.DYNAMIC_DRAW + = gl.STREAM_DRAW + = gl.STATIC_READ + = gl.DYNAMIC_READ + = gl.STREAM_READ + = gl.STATIC_COPY + = gl.DYNAMIC_COPY + = gl.STREAM_COPY + + = gl.ACTIVE_TEXTURE + = gl.ALIASED_LINE_WIDTH_RANGE + = gl.ALIASED_POINT_SIZE_RANGE + = gl.ALPHA_BITS + = gl.ARRAY_BUFFER_BINDING + = gl.BLEND + = gl.BLEND_COLOR + = gl.BLEND_DST_ALPHA + = gl.BLEND_DST_RGB + = gl.BLEND_EQUATION + = gl.BLEND_EQUATION_ALPHA + = gl.BLEND_EQUATION_RGB + = gl.BLEND_SRC_ALPHA + = gl.BLEND_SRC_RGB + = gl.COLOR_CLEAR_VALUE + = gl.COLOR_CLEAR_VALUE + + = gl.TEXTURE_2D + = gl.TEXTURE_CUBE_MAP + = gl.TEXTURE_3D + = gl.COLOR_WRITEMASK + + = sh1; + = sh2; + + = VERTEX_SHADER + = FRAGMENT_SHADER + + = 'vColor' + = 'vDepth' + = 'oColor' + = 'oDepth' + = 'oVertex' + = 'oTexture' + = 'uScalingFactor' + = 'uGlobalColor' + = 'uRotationVector' + + = gl.ARRAY_BUFFER + = gl.ELEMENT_ARRAY_BUFFER + = gl.COPY_READ_BUFFER + = gl.COPY_WRITE_BUFFER + = gl.TRANSFORM_FEEDBACK_BUFFER + = gl.UNIFORM_BUFFER + = gl.PIXEL_PACK_BUFFER + = gl.PIXEL_UNPACK_BUFFER + + = gl.FRAMEBUFFER + = gl.DRAW_FRAMEBUFFER + = gl.READ_FRAMEBUFFER + + = gl.TEXTURE_2D + = gl.TEXTURE_CUBE_MAP + = gl.TEXTURE_3D + = gl.TEXTURE_2D_ARRAY + + = gl.FUNC_ADD + = gl.FUNC_SUBTRACT + = gl.FUNC_REVERSE_SUBTRACT + = gl.MIN + = gl.MAX + + = gl.FUNC_ADD + = gl.FUNC_SUBTRACT + = gl.FUNC_REVERSE_SUBTRACT + = gl.MIN + = gl.MAX + + = gl.ZERO + = gl.ONE + = gl.SRC_COLOR + = gl.ONE_MINUS_SRC_COLOR + = gl.DST_COLOR + = gl.ONE_MINUS_DST_COLOR + = gl.SRC_ALPHA + = gl.ONE_MINUS_SRC_ALPHA + = gl.DST_ALPHA + = gl.ONE_MINUS_DST_ALPHA + = gl.CONSTANT_COLOR + = gl.ONE_MINUS_CONSTANT_COLOR + = gl.CONSTANT_ALPHA + = gl.ONE_MINUS_CONSTANT_ALPHA + = gl.SRC_ALPHA_SATURATE + + = gl.ZERO + = gl.ONE + = gl.SRC_COLOR + = gl.ONE_MINUS_SRC_COLOR + = gl.DST_COLOR + = gl.ONE_MINUS_DST_COLOR + = gl.SRC_ALPHA + = gl.ONE_MINUS_SRC_ALPHA + = gl.DST_ALPHA + = gl.ONE_MINUS_DST_ALPHA + = gl.CONSTANT_COLOR + = gl.ONE_MINUS_CONSTANT_COLOR + = gl.CONSTANT_ALPHA + = gl.ONE_MINUS_CONSTANT_ALPHA + = gl.SRC_ALPHA_SATURATE + + = gl.COLOR_BUFFER_BIT + = gl.DEPTH_BUFFER_BIT + = gl.STENCIL_BUFFER_BIT + + = gl.COLOR_BUFFER_BIT + = gl.DEPTH_BUFFER_BIT + = gl.STENCIL_BUFFER_BIT + + = gl.FRONT + = gl.BACK + = gl.FRONT_AND_BACK + + = gl.NEVER + = gl.LESS + = gl.EQUAL + = gl.LEQUAL + = gl.GREATER + = gl.NOTEQUAL + = gl.GEQUAL + = gl.ALWAYS + + = gl.BLEND + = gl.CULL_FACE + = gl.DEPTH_TEST + = gl.DITHER + = gl.POLYGON_OFFSET_FILL + = gl.SAMPLE_ALPHA_TO_COVERAGE + = gl.SAMPLE_COVERAGE + = gl.SCISSOR_TEST + = gl.STENCIL_TEST + + = gl.POINTS + = gl.LINE_STRIP + = gl.LINE_LOOP + = gl.LINES + = gl.TRIANGLE_STRIP + = gl.TRIANGLE_FAN + = gl.TRIANGLES + + = gl.UNSIGNED_BYTE + = gl.UNSIGNED_SHORT + + = gl.UNSIGNED_BYTE + = gl.UNSIGNED_SHORT + + = gl.CW + = gl.CCW + + = gl.TEXTURE_2D + = gl.TEXTURE_CUBE_MAP + = gl.TEXTURE_3D + = gl.TEXTURE_2D_ARRAY + + = gl.FLOAT + = gl.FLOAT_VEC2 + = gl.FLOAT_VEC3 + = gl.FLOAT_VEC4 + = gl.INT + = gl.INT_VEC2 + = gl.INT_VEC3 + = gl.INT_VEC4 + = gl.BOOL + = gl.BOOL_VEC2 + = gl.BOOL_VEC3 + = gl.BOOL_VEC4 + = gl.FLOAT_MAT2 + = gl.FLOAT_MAT3 + = gl.FLOAT_MAT4 + = gl.SAMPLER_2D + = gl.SAMPLER_CUBE + = gl.UNSIGNED_INT + = gl.UNSIGNED_INT_VEC2 + = gl.UNSIGNED_INT_VEC3 + = gl.UNSIGNED_INT_VEC4 + = gl.FLOAT_MAT2x3 + = gl.FLOAT_MAT2x4 + = gl.FLOAT_MAT3x2 + = gl.FLOAT_MAT3x4 + = gl.FLOAT_MAT4x2 + = gl.FLOAT_MAT4x3 + = gl.SAMPLER_2D + = gl.SAMPLER_3D + = gl.SAMPLER_CUBE + = gl.SAMPLER_2D_SHADOW + = gl.SAMPLER_2D_ARRAY + = gl.SAMPLER_2D_ARRAY_SHADOW + = gl.SAMPLER_CUBE_SHADOW + = gl.INT_SAMPLER_2D + = gl.INT_SAMPLER_3D + = gl.INT_SAMPLER_CUBE + = gl.INT_SAMPLER_2D_ARRAY + = gl.UNSIGNED_INT_SAMPLER_2D + = gl.UNSIGNED_INT_SAMPLER_3D + = gl.UNSIGNED_INT_SAMPLER_CUBE + = gl.UNSIGNED_INT_SAMPLER_2D_ARRAY + + = gl.FRAMEBUFFER + = gl.DRAW_FRAMEBUFFER + = gl.READ_FRAMEBUFFER + + = gl.COLOR_ATTACHMENT0 + = gl.DEPTH_ATTACHMENT + = gl.STENCIL_ATTACHMENT + = gl.DEPTH_STENCIL_ATTACHMENT + + = gl.FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE + = gl.FRAMEBUFFER_ATTACHMENT_OBJECT_NAME + = gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL + = gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE + = gl.FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE + = gl.FRAMEBUFFER_ATTACHMENT_BLUE_SIZE + = gl.FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING + = gl.FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE + = gl.FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE + = gl.FRAMEBUFFER_ATTACHMENT_GREEN_SIZE + = gl.FRAMEBUFFER_ATTACHMENT_RED_SIZE + = gl.FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE + = gl.FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER + + = gl.LOW_FLOAT + = gl.MEDIUM_FLOAT + = gl.HIGH_INT + + = gl.TEXTURE_MAG_FILTER + = gl.TEXTURE_MIN_FILTER + = gl.TEXTURE_WRAP_S + = gl.TEXTURE_WRAP_T + = gl.TEXTURE_WRAP_T + = gl.TEXTURE_BASE_LEVEL + = gl.TEXTURE_COMPARE_FUNC + = gl.TEXTURE_COMPARE_MODE + = gl.TEXTURE_IMMUTABLE_FORMAT + = gl.TEXTURE_IMMUTABLE_LEVELS + = gl.TEXTURE_MAX_LEVEL + = gl.TEXTURE_MAX_LOD + = gl.TEXTURE_MIN_LOD + = gl.TEXTURE_WRAP_R + + = gl.VERTEX_ATTRIB_ARRAY_BUFFER_BINDING + = gl.VERTEX_ATTRIB_ARRAY_ENABLED + = gl.VERTEX_ATTRIB_ARRAY_SIZE + = gl.VERTEX_ATTRIB_ARRAY_STRIDE + = gl.VERTEX_ATTRIB_ARRAY_TYPE + = gl.VERTEX_ATTRIB_ARRAY_NORMALIZED + = gl.CURRENT_VERTEX_ATTRIB + = gl.VERTEX_ATTRIB_ARRAY_INTEGER + = gl.VERTEX_ATTRIB_ARRAY_DIVISOR + + = gl.GENERATE_MIPMAP_HINT + = gl.FRAGMENT_SHADER_DERIVATIVE_HINT + + = gl.FASTEST + = gl.NICEST + = gl.DONT_CARE + + = gl.ALPHA + = gl.RGB + = gl.RGBA + + = gl.UNSIGNED_BYTE + = gl.UNSIGNED_SHORT_5_6_5 + = gl.UNSIGNED_SHORT_4_4_4_4 + = gl.UNSIGNED_SHORT_5_5_5_1 + = gl.FLOAT + + = gl.UNSIGNED_BYTE + = gl.UNSIGNED_SHORT_5_6_5 + = gl.UNSIGNED_SHORT_4_4_4_4 + = gl.UNSIGNED_SHORT_5_5_5_1 + = gl.FLOAT + + = gl.BYTE + = gl.SHORT + = gl.UNSIGNED_BYTE + = gl.UNSIGNED_SHORT + = gl.FLOAT + = gl.HALF_FLOAT + + = gl.RGBA4 + = gl.RGB565 + = gl.RGB5_A1 + = gl.DEPTH_COMPONENT16 + = gl.STENCIL_INDEX8 + = gl.DEPTH_STENCIL + = gl.R8 + = gl.R8UI + = gl.R8I + = gl.R16UI + = gl.R16I + = gl.R32UI + = gl.R32I + = gl.RG8 + = gl.RG8UI + = gl.RG8I + = gl.RG16UI + = gl.RG16I + = gl.RG32UI + = gl.RG32I + = gl.RGB8 + = gl.RGBA8 + = gl.SRGB8_ALPHA8 + = gl.RGB10_A2 + = gl.RGBA8UI + = gl.DEPTH_COMPONENT24 + = gl.DEPTH_COMPONENT32F + = gl.DEPTH24_STENCIL8 + = gl.DEPTH32F_STENCIL8 + + = gl.KEEP + = gl.ZERO + = gl.REPLACE + = gl.INCR + = gl.INCR_WRAP + = gl.DECR + = gl.DECR_WRAP + = gl.INVERT + + = gl.KEEP + = gl.ZERO + = gl.REPLACE + = gl.INCR + = gl.INCR_WRAP + = gl.DECR + = gl.DECR_WRAP + = gl.INVERT + +<_glMgg> = gl.KEEP +<_glMgg> = gl.ZERO +<_glMgg> = gl.REPLACE +<_glMgg> = gl.INCR +<_glMgg> = gl.INCR_WRAP +<_glMgg> = gl.DECR +<_glMgg> = gl.DECR_WRAP +<_glMgg> = gl.INVERT + + = gl.TEXTURE_2D + = gl.TEXTURE_CUBE_MAP_POSITIVE_X + = gl.TEXTURE_CUBE_MAP_NEGATIVE_X + = gl.TEXTURE_CUBE_MAP_POSITIVE_Y + = gl.TEXTURE_CUBE_MAP_NEGATIVE_Y + = gl.TEXTURE_CUBE_MAP_POSITIVE_Z + = gl.TEXTURE_CUBE_MAP_NEGATIVE_Z + + = gl.ALPHA + = gl.RGB + = gl.RGBA + = gl.LUMINANCE + = gl.LUMINANCE_ALPHA + + = 'ANGLE_instanced_arrays' + = 'EXT_blend_minmax' + = 'EXT_color_buffer_float' + = 'EXT_color_buffer_half_float' + = 'EXT_disjoint_timer_query' + = 'EXT_frag_depth' + = 'EXT_sRGB' + = 'EXT_shader_texture_lod' + = 'EXT_texture_filter_anisotropic' + = 'OES_element_index_uint' + = 'OES_standard_derivatives' + = 'OES_texture_float' + = 'OES_texture_float_linear' + = 'OES_vertex_array_object' + = 'WEBGL_color_buffer_float' + = 'WEBGL_compressed_texture_astc' + = 'WEBGL_compressed_texture_atc' + = 'WEBGL_compressed_texture_etc' + = 'WEBGL_compressed_texture_etc1' + = 'WEBGL_compressed_texture_pvrtc' + = 'WEBGL_debug_renderer_info' + = 'WEBGL_debug_shaders' + = 'WEBGL_depth_texture' + = 'WEBGL_draw_buffers' + = 'WEBGL_lose_context' + + + = this + + = + +!include common.txt +!include cssproperties.txt + +!lineguard try { } catch(e) { } +!varformat fuzzvar%05d +!begin lines + +# Image +# = new Image(); +# = new Image(, ); +# .src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw=="; + +# Uint8ClampedArray +# = new Uint8ClampedArray(); +# = new Uint8ClampedArray([,]); + +# ImageData +# = new ImageData(, , ); + +# ctx.rect(, , , ); + +gl1.activeTexture(gl.TEXTURE); +gl1.attachShader(program1, sh1); +gl1.getParameter(); +gl2.activeTexture(gl.TEXTURE); +gl1.attachShader(program2, sh2); +gl2.getParameter(); +gl1.linkProgram(program1); +gl1.useProgram(program1); +gl2.linkProgram(program2); +gl2.useProgram(program2); +gl1.activeTexture(gl.TEXTURE); +gl1.attachShader(program1, sh1); +gl1.getParameter(); +gl2.activeTexture(gl.TEXTURE); +gl1.attachShader(program2, sh2); +gl2.getParameter(); +gl1.linkProgram(program1); +gl1.useProgram(program1); +gl2.linkProgram(program2); +gl2.useProgram(program2); +gl1.pixelStorei(, ); +gl2.pixelStorei(, ); +gl1.pixelStorei(, ); +gl2.pixelStorei(, ); +gl1.pixelStorei(, ); +gl2.pixelStorei(, ); +gl1.pixelStorei(, ); +gl2.pixelStorei(, ); +gl1.bindTexture(, tex); +gl2.bindTexture(, tex); +gl1.bindTexture(, tex); +gl2.bindTexture(, tex); +gl1.bindAttribLocation(program1, , ); +gl2.bindAttribLocation(program2, , ); +gl1.bindAttribLocation(program2, , ); +gl2.bindAttribLocation(program1, , ); +var buffer1 = gl1.createBuffer(); gl1.bindBuffer(, buffer1); +var buffer2 = gl2.createBuffer(); gl2.bindBuffer(, buffer2); +var buffer2 = gl1.createBuffer(); gl1.bindBuffer(, buffer2); +var buffer1 = gl2.createBuffer(); gl2.bindBuffer(, buffer1); +if (buffer1 != undefined) {gl1.deleteBuffer(buffer1);} +if (buffer2 != undefined) {gl2.deleteBuffer(buffer2);} +if (buffer1 != undefined) {gl2.deleteBuffer(buffer1);} +if (buffer2 != undefined) {gl1.deleteBuffer(buffer2);} +gl1.isBuffer(buffer1); +gl2.isBuffer(buffer2); +gl1.isBuffer(buffer2); +gl2.isBuffer(buffer1); +var fbuffer1 = gl1.createBuffer(); gl1.bindFramebuffer(, fbuffer1); +var fbuffer2 = gl2.createBuffer(); gl2.bindFramebuffer(, fbuffer2); +var fbuffer2 = gl1.createBuffer(); gl1.bindFramebuffer(, fbuffer2); +var fbuffer1 = gl2.createBuffer(); gl2.bindFramebuffer(, fbuffer1); +if (fbuffer1 != undefined) {gl1.deleteFramebuffer(fbuffer1);} +if (fbuffer2 != undefined) {gl2.deleteFramebuffer(fbuffer2);} +if (fbuffer1 != undefined) {gl2.deleteFramebuffer(fbuffer1);} +if (fbuffer2 != undefined) {gl1.deleteFramebuffer(fbuffer2);} +gl1.isFramebuffer(fbuffer1); +gl2.isFramebuffer(fbuffer2); +gl1.isFramebuffer(fbuffer2); +gl2.isFramebuffer(fbuffer1); +var rbuffer1 = gl1.createBuffer(); gl1.bindRenderbuffer(gl.RENDERBUFFER, rbuffer1); +var rbuffer2 = gl2.createBuffer(); gl2.bindRenderbuffer(gl.RENDERBUFFER, rbuffer2); +var rbuffer2 = gl1.createBuffer(); gl1.bindRenderbuffer(gl.RENDERBUFFER, rbuffer2); +var rbuffer1 = gl2.createBuffer(); gl2.bindRenderbuffer(gl.RENDERBUFFER, rbuffer1); +if (rbuffer1 != undefined) {gl1.deleteRenderbuffer(rbuffer1);} +if (rbuffer2 != undefined) {gl2.deleteRenderbuffer(rbuffer2);} +if (rbuffer1 != undefined) {gl2.deleteRenderbuffer(rbuffer1);} +if (rbuffer2 != undefined) {gl1.deleteRenderbuffer(rbuffer2);} +gl1.isRenderbuffer(rbuffer1); +gl2.isRenderbuffer(rbuffer2); +gl1.isRenderbuffer(rbuffer2); +gl2.isRenderbuffer(rbuffer1); +var tex1 = gl.createTexture(); gl1.bindTexture(, tex1); +var tex2 = gl.createTexture(); gl2.bindTexture(, tex2); +var tex2 = gl.createTexture(); gl1.bindTexture(, tex2); +var tex1 = gl.createTexture(); gl2.bindTexture(, tex1); +if (tex1 != undefined) {gl1.deleteTexture(tex1);} +if (tex2 != undefined) {gl2.deleteTexture(tex2);} +if (tex1 != undefined) {gl2.deleteTexture(tex1);} +if (tex2 != undefined) {gl1.deleteTexture(tex2);} +gl1.isTexture(tex1); +gl2.isTexture(tex2); +gl1.isTexture(tex2); +gl2.isTexture(tex1); +gl1.blendColor(, , , ); +gl2.blendColor(, , , ); +gl1.blendColor(, , , ); +gl2.blendColor(, , , ); +gl1.blendEquation(); +gl2.blendEquation(); +gl1.blendEquation(); +gl2.blendEquation(); +gl1.blendEquationSeparate(, ); +gl2.blendEquationSeparate(, ); +gl1.blendEquationSeparate(, ); +gl2.blendEquationSeparate(, ); +gl1.enable(gl1.BLEND); gl1.blendFunc(, ); +gl2.enable(gl2.BLEND); gl2.blendFunc(, ); +gl1.enable(gl1.BLEND); gl1.blendFunc(, ); +gl2.enable(gl2.BLEND); gl2.blendFunc(, ); +gl1.enable(gl1.BLEND); gl1.blendFuncSeparate(, , , ); +gl2.enable(gl2.BLEND); gl2.blendFuncSeparate(, , , ); +gl1.enable(gl1.BLEND); gl1.blendFuncSeparate(, , , ); +gl2.enable(gl2.BLEND); gl2.blendFuncSeparate(, , , ); +var buffer1 = gl1.createBuffer(); gl1.bindBuffer(, buffer1); gl1.bufferData(, , ); +var buffer2 = gl2.createBuffer(); gl2.bindBuffer(, buffer2); gl2.bufferData(, , ); +var buffer1 = gl1.createBuffer(); gl1.bindBuffer(, buffer1); gl1.bufferData(, , ); +var buffer2 = gl2.createBuffer(); gl2.bindBuffer(, buffer2); gl2.bufferData(, , ); +var buffer1 = gl1.createBuffer(); gl1.bindBuffer(, buffer1); gl1.bufferData(, , ); gl1.bufferSubData(, , buffer1, , ); +var buffer2 = gl2.createBuffer(); gl2.bindBuffer(, buffer2); gl2.bufferData(, , ); gl2.bufferSubData(, , buffer2, , ); +gl1.checkFramebufferStatus(gl1.FRAMEBUFFER); +gl2.checkFramebufferStatus(gl2.FRAMEBUFFER); +gl1.clear(); +gl2.clear(); +gl1.clear(); +gl2.clear(); +gl1.clear( | ); +gl2.clear( | ); +gl1.clearColor(, , , ); +gl2.clearColor(, , , ); +gl1.clearColor(, , , ); +gl2.clearColor(, , , ); +gl1.clearDepth(); +gl2.clearDepth(); +gl1.clearDepth(); +gl2.clearDepth(); +gl1.clearStencil(); +gl2.clearStencil(); +gl1.colorMask(, , , ); +gl2.colorMask(, , , ); +gl2.colorMask(, , , ); +gl1.colorMask(, , , ); +gl1.createShader(); +gl2.createShader(); +var tex1 = gl1.createTexture(); +var tex2 = gl1.createTexture(); +var tex1 = gl2.createTexture(); +var tex2 = gl2.createTexture(); +gl1.enable(gl1.CULL_FACE); gl1.cullFace(); +gl2.enable(gl2.CULL_FACE); gl2.cullFace(); +gl1.deleteShader(sh1); +gl2.deleteShader(sh2); +gl1.deleteShader(sh1); +gl2.deleteShader(sh2); +gl1.enable(gl.DEPTH_TEST); gl1.depthFunc(); +gl2.enable(gl.DEPTH_TEST); gl2.depthFunc(); +gl1.depthMask(); +gl2.depthMask(); +gl1.depthRange(, ); +gl2.depthRange(, ); +gl1.detachShader(program1, sh1); +gl2.detachShader(program2, sh2); +gl1.detachShader(program1, sh1); +gl2.detachShader(program2, sh2); +gl1.disable(); +gl2.disable(); +gl1.isEnabled(); +gl2.isEnabled(); +gl1.disableVertexAttribArray(); +gl2.disableVertexAttribArray(); +gl1.drawArrays(, , ); +gl2.drawArrays(, , ); +gl1.drawElements(, , , ); +gl2.drawElements(, , , ); +gl1.finish(); +gl2.finish(); +gl1.flush(); +gl2.flush(); +gl1.frontFace(); +gl2.frontFace(); +gl1.generateMipmap(); +gl2.generateMipmap(); +const info1 = gl1.getActiveAttrib(program1, ); +const info2 = gl2.getActiveAttrib(program2, ); +const ifo1 = gl1.getActiveUniform(program1, ); +const ifo2 = gl2.getActiveUniform(program2, ); +gl1.getAttachedShaders(program1); +gl2.getAttachedShaders(program2); +gl1.getAttribLocation(program1, ); +gl2.getAttribLocation(program2, ); +gl1.getBufferParameter(, ); +gl1.getBufferParameter(, ); +gl1.getContextAttributes(); +gl2.getError(); +gl1.getFramebufferAttachmentParameter(, , ); +gl2.getFramebufferAttachmentParameter(, , ); +gl1.getProgramInfoLog(program1); +gl2.getProgramInfoLog(program2); +gl1.getProgramInfoLog(program2); +gl1.getShaderPrecisionFormat(, ); +var source211 = gl1.getShaderSource(sh1); +var source122 = gl2.getShaderSource(sh2); +gl1.getTexParameter(, ); +gl2.getTexParameter(, ); +var loc = gl1.getUniformLocation(program1, ); gl1.getUniform(program1, loc); +var loc = gl2.getUniformLocation(program2, ); gl2.getUniform(program2, loc); +gl1.getVertexAttrib(, ); +gl2.getVertexAttrib(, ); +gl1.getVertexAttribOffset(, gl.VERTEX_ATTRIB_ARRAY_POINTER); +gl2.getVertexAttribOffset(, gl.VERTEX_ATTRIB_ARRAY_POINTER); +gl1.hint(, ); +gl1.lineWidth(); +gl2.lineWidth(); +var pixels = new Uint8Array(gl1.drawingBufferWidth * gl1.drawingBufferHeight * 4); gl1.readPixels(, , gl1.drawingBufferWidth, gl1.drawingBufferHeight, , , pixels); console.log(pixels); +var pixels = new Uint8Array(gl2.drawingBufferWidth * gl2.drawingBufferHeight * 4); gl2.readPixels(, , gl2.drawingBufferWidth, gl2.drawingBufferHeight, , , pixels); console.log(pixels); +var pixels = new Uint8Array(gl1.drawingBufferWidth * gl1.drawingBufferHeight * 4); gl1.readPixels(, , gl1.drawingBufferWidth, gl1.drawingBufferHeight, , , pixels); console.log(pixels); +var pixels = new Uint8Array(gl2.drawingBufferWidth * gl2.drawingBufferHeight * 4); gl2.readPixels(, , gl2.drawingBufferWidth, gl2.drawingBufferHeight, , , pixels); console.log(pixels); +gl1.renderbufferStorage(gl1.RENDERBUFFER, , , ); +gl2.renderbufferStorage(gl2.RENDERBUFFER, , , ); +gl1.enable(gl.SAMPLE_COVERAGE); gl1.sampleCoverage(, ); +gl2.enable(gl.SAMPLE_COVERAGE); gl2.sampleCoverage(, ); +gl1.scissor(, , , ); +gl2.scissor(, , , ); +gl1.enable(gl.STENCIL_TEST); gl1.stencilFunc(, , ); +gl2.enable(gl.STENCIL_TEST); gl2.stencilFunc(, , ); +gl1.enable(gl.STENCIL_TEST); gl1.stencilFunc(, , ); +gl2.enable(gl.STENCIL_TEST); gl2.stencilFunc(, , ); +gl1.enable(gl.STENCIL_TEST); gl1.stencilFuncSeparate(, , , ); +gl2.enable(gl.STENCIL_TEST); gl2.stencilFuncSeparate(, , , ); +gl1.enable(gl.STENCIL_TEST); gl1.stencilFuncSeparate(, , , ); +gl2.enable(gl.STENCIL_TEST); gl2.stencilFuncSeparate(, , , ); +gl1.stencilMask(); +gl2.stencilMask(); +gl1.stencilMask(, ); +gl2.stencilMask(, ); +gl1.enable(gl1.STENCIL_TEST); gl1.stencilOp(, <_glMgg>, ); +gl2.enable(gl2.STENCIL_TEST); gl2.stencilOp(, <_glMgg>, ); +gl1.enable(gl1.STENCIL_TEST); gl1.stencilOp(, , <_glMgg>, ); +gl2.enable(gl2.STENCIL_TEST); gl2.stencilOp(, , <_glMgg>, ); +gl1.texParameterf(, , ); +gl1.texParameteri(, , ); +gl1.texParameterf(, , ); +gl2.texParameteri(, , ); +gl2.texParameterf(, , ); +gl2.texParameteri(, , ); +gl1.viewport(, , , ); +gl2.viewport(, , , ); +gl1.enableVertexAttribArray(0); +gl2.enableVertexAttribArray(0); +gl1.enableVertexAttribArray(0); gl1.vertexAttribPointer(, , , , , ); +gl2.enableVertexAttribArray(0); gl2.vertexAttribPointer(, , , , , ); +gl1.vertexAttrib1f(, ); +gl1.vertexAttrib2f(, , ); +gl1.vertexAttrib3f(, , , ); +gl1.vertexAttrib4f(, , , , ); +gl1.vertexAttrib1fv(, ); +gl1.vertexAttrib2fv(, ); +gl1.vertexAttrib3fv(, ); +gl1.vertexAttrib4fv(, ); +gl1.vertexAttrib1f(, ); +gl2.vertexAttrib2f(, , ); +gl2.vertexAttrib3f(, , , ); +gl2.vertexAttrib4f(, , , , ); +gl2.vertexAttrib1fv(, ); +gl2.vertexAttrib2fv(, ); +gl2.vertexAttrib3fv(, ); +gl2.vertexAttrib4fv(, ); +gl1.validateProgram(program1); +gl2.validateProgram(program2); +var loc = gl1.getUniformLocation(program1, ); gl1.uniformMatrix2fv(loc, , [,, ,]); +var loc = gl1.getUniformLocation(program1, ); gl1.uniformMatrix2fv(loc, , [,, ,]); +var loc = gl1.getUniformLocation(program1, ); gl1.uniformMatrix3fv(loc, , [,, ,]); +var loc = gl1.getUniformLocation(program1, ); gl1.uniformMatrix4fv(loc, , [,, ,]); +var loc = gl2.getUniformLocation(program2, ); gl2.uniformMatrix2fv(loc, , [,, ,]); +var loc = gl2.getUniformLocation(program2, ); gl2.uniformMatrix2fv(loc, , [,, ,]); +var loc = gl2.getUniformLocation(program2, ); gl2.uniformMatrix3fv(loc, , [,, ,]); +var loc = gl2.getUniformLocation(program2, ); gl2.uniformMatrix4fv(loc, , [,, ,]); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform1f(loc, ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform1fv(loc, ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform1i(loc, ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform1iv(loc, ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform2f(loc, , ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform2fv(loc, ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform2i(loc, , ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform2iv(loc, ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform3f(loc, , , ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform3fv(loc, ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform3i(loc, , , ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform3iv(loc, ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform4f(loc, , , , ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform4fv(loc, ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform4i(loc, , , , ); +var loc = gl1.getUniformLocation(program1, ); gl1.uniform4iv(loc, ); +var loc = gl2.getUniformLocation(program1, ); gl2.uniform1f(loc, ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform1fv(loc, ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform1i(loc, ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform1iv(loc, ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform2f(loc, , ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform2fv(loc, ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform2i(loc, , ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform2iv(loc, ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform3f(loc, , , ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform3fv(loc, ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform3i(loc, , , ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform3iv(loc, ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform4f(loc, , , , ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform4fv(loc, ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform4i(loc, , , , ); +var loc = gl2.getUniformLocation(program2, ); gl2.uniform4iv(loc, ); +gl1.texImage2D(, , , , , 0, , , img); +gl1.texImage2D(, , , , , 0, , , img); +gl1.texImage2D(, , , , , 0, , , img); +gl1.texImage2D(, , , , , 0, , , img); +gl1.texImage2D(, , , , , 0, , , img); +gl1.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +gl1.texImage2D(, , , , , 0, , , img); +gl1.texImage2D(, , , , , 0, , , img); +gl1.texImage2D(, , , , , 0, , , img); +gl1.texImage2D(, , , , , 0, , , img); +gl1.texImage2D(, , , , , 0, , , img); +gl1.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +gl2.texImage2D(, , , , , 0, , , img); +var buffer1 = gl1.createRenderbuffer(); gl1.framebufferRenderbuffer(, , gl.RENDERBUFFER, buffer1); +var buffer2 = gl2.createRenderbuffer(); gl2.framebufferRenderbuffer(, , gl.RENDERBUFFER, buffer2); +var tex1 = gl1.createTexture(); gl1.framebufferTexture2D(, , , tex1, ); +var tex2 = gl2.createTexture(); gl2.framebufferTexture2D(, , , tex2, ); +var ext = gl1.getExtension(); +var ext = gl2.getExtension(); +var ext = gl1.getExtension(); +var ext = gl2.getExtension(); +var ext = gl1.getExtension(); +var ext = gl2.getExtension(); +var vara = gl1.getFramebufferAttachmentParameter(, , ); +var varb = gl2.getFramebufferAttachmentParameter(, , ); +if (!gl1.isContextLost()) {var info = gl1.getProgramInfoLog(program1);} +if (!gl2.isContextLost()) {var info = gl2.getProgramInfoLog(program2);} +if (!gl2.isContextLost()) {var info = gl2.getProgramInfoLog(program1);} + +!end lines From 2c7b195630b411a9796531fadd322af5bd264ab9 Mon Sep 17 00:00:00 2001 From: akayn <30512781+akayn@users.noreply.github.com> Date: Mon, 11 Mar 2019 23:00:58 -0700 Subject: [PATCH 15/50] Add files via upload --- webgl/generator.py | 2 +- webgl/template.html | 16 +- webgl/webgl.txt | 506 +++++++++++++------------------------------- 3 files changed, 152 insertions(+), 372 deletions(-) diff --git a/webgl/generator.py b/webgl/generator.py index a24dd3e..da9db2f 100644 --- a/webgl/generator.py +++ b/webgl/generator.py @@ -27,7 +27,7 @@ sys.path.append(parent_dir) from grammar import Grammar -_N_MAIN_LINES = 50 +_N_MAIN_LINES = 100 _N_EVENTHANDLER_LINES = 1 def generate_function_body(jsgrammar, num_lines): diff --git a/webgl/template.html b/webgl/template.html index 59805af..0c8ec92 100644 --- a/webgl/template.html +++ b/webgl/template.html @@ -12,10 +12,9 @@ function trigger(img) { var canvas = document.getElementById('canvas'); + var gl = canvas.getContext('experimental-webgl'); var gl1 = canvas.getContext('experimental-webgl'); - var canvas = document.getElementById('canvas'); var gl2 = canvas.getContext('experimental-webgl'); - var gl = canvas.getContext('experimental-webgl'); var vShader3 = gl1.createShader(gl1.VERTEX_SHADER); @@ -23,20 +22,17 @@ var vShaderSource3 = vShaderScript3.text; gl1.shaderSource(vShader3, vShaderSource3); gl1.compileShader(vShader3); - var vertexShader3 = vShader3; var vShader4 = gl2.createShader(gl2.VERTEX_SHADER); var vShaderScript4 = document.getElementById('2d-vertex-shader'); var vShaderSource4 = vShaderScript4.text; gl2.shaderSource(vShader4, vShaderSource4); gl2.compileShader(vShader4); - var vertexShader4 = vShader4; var fShader3 = gl1.createShader(gl1.FRAGMENT_SHADER); var fShaderScript3 = document.getElementById('2d-fragment-shader'); var fShaderSource3 = fShaderScript3.text; gl1.shaderSource(fShader3, fShaderSource3); gl1.compileShader(fShader3); - var fragmentShader3 = fShader3; program1 = gl1.createProgram(); gl1.attachShader(program1,vShader3); gl1.attachShader(program1,fShader3); @@ -47,22 +43,22 @@ var fShaderSource4 = fShaderScript4.text; gl2.shaderSource(fShader4, fShaderSource4); gl2.compileShader(fShader4); - var fragmentShader4 = fShader4; program2 = gl2.createProgram(); gl2.attachShader(program2,vShader4); gl2.attachShader(program2,fShader4); gl2.linkProgram(program2); gl2.useProgram(program2); - - var tex = gl.createTexture(); - + var tex1 = gl1.createTexture(); + var tex2 = gl2.createTexture(); + + } function start() { - var ImageData = "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEBLAEsAAD/2wBDAAYEBAQFBAYFBQYJBgUGCQsIBgYICwwKCgsKCgwQDAwMDAwMEAwODxAPDgwTExQUExMcGxsbHCAgICAgICAgICD/2wBDAQcHBw0MDRgQEBgaFREVGiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICD/wAARCAHZAvUDAREAAhEBAxEB/8QAHQAAAQQDAQEAAAAAAAAAAAAABwAFBggDBAkCAf/EAGAQAAEDAgMEBgYGBQcGDAUACwECAwQFBgAREgcTITEIFCJBUWEVIzJCcYEWUmJykaEkM0OCsVNjc5KissElNIOTs9EXJjU2N0RUdHWjwvBktNLh8Rg4w1V2hJS1xNPi/8QAGwEBAAIDAQEAAAAAAAAAAAAAAAQFAgMGAQf/xABDEQACAQMDAgQCCAUEAwABAQkAAQIDBBESITEFQRMiUWEycRRCgZGhsdHwBiMzUsEVYnLhJDTxQ4IWczVTkqKywuL/2gAMAwEAAhEDEQA/ADNt3syqXnYRt2mpzemzoQcc4ZNMh9JddOeWYQjM4AkTjlu2DY5Uf0WhW9C+e6YRkB5rVl8ycAUMbpN+7ZtodSm02GqVUKg8X5CycmIrJ7LYccPBKUIASnvOXDM4APdq9CegtMocumuyJcjmuPT0pZaB8N44HFq+OScASGo9DfZa/FLUOVU4TnMOB9Dgz8ShbfH8sACTbHsD2gWvbrIpqUVm3Kfmp6RESpMhKU8lvR81cBxJUgkd5yxIqXDlBR4SIVGyUKsqmcuX4A4qTjdLtWJRqcoSZlSG8kKY7eYPtZac/u/AYlVHopKEd3IrqCdW4lVntGHGf39ok9YqVlbhsrYqNBc1La4pVpTnxy55gE/hj3edHH1oHm1K7y94VV+/37ker1xvVd6K+tlLMiOgILqCc1kcQryOeIdxW8XlFnZ2fgZSeU3n5Ejt+5LraokidIbbqlJjIca6vMV2da2kshZB/WJbSkAIz78VdbocakfEj5MNbrnnO3zb5JD6jGFRU3u2PVJueHSrdVU0VdMyoIaQXY7aUNOrdK1FCFqyaf0slfu5jge7LFLXs5Va2jRpjnnlY/GO/wBn5lhGeI5zuC151x11britTjiipajzJPEnHTJJLC4IZ4x6BYA9x5D8d9uQw4pp9lQcadQclJWk5pUCORBwBdXo89IuLeLDNtXO8hi62hpjSD2UTkpHMdweAHaT38x3gAGi47co1yUSVRKzGTLpsxGh9lf4gg8wpJGYI5HAFC9tuxOtbNa170y3Jij6NqWXz3L2XBLqR8lDiO8AAZ4Aklm3tfVvy0sWvV5cB2SsI3LDhDa1LOQzbOaD8csDKEXJ4XLDBDhigW9uWG1ynYjSllCO0t572lHxOpWJPCO3p0/ApYW+lfewb2dcl1zr0ZbfkurDy1dcjKz0JbAJV2D7OnuxqjJ5KCxuq07hJt78ome0G2J9wU+IzBDe+YdK1KcVp7BTl59+WNk45LbqdpKtFKPKZCEbIbnPtOxU/wCkUf4Jxr8JlP8A6JW/2m6pm7rCgtvrqEd+K45oRTu2tKu9RTmE6cu/I493ibmq9lHOpNZ4NO2b4Jvlyq1DJlioDcOcey0nhu/kkpGZx5Ge5ptOof8Ak65bKW3y9DPeWziselHp1IZ65ElKLuhBGtCl8SMs+KfAjCUDZfdLqa3KCzFm9Ydiy6VL9O13TEbiJUtppahmDlkXFkcAAOQx7CHdm7p3TpU34lTbBJrZaVMeqNzBv1tR7FOQ5wyjMjS3n4bxQzOM4+pYWi1OVbvLj5Lj7zFaqLraaqSbrKTBAKkKWpKuycy5kR+z0+OEc9zGzVdKXj/D+8/YBN7RvV7v9XqOj4d2I5yD5PGB4LACwBL9mG0+49ndxJq9HUFtuZNz4Ln6qQ1nnpV4Ee6ocj8xgC92zPa7Zu0OmCTRZQROQkGZSniEyWT35p95OfJaeHz4YAm2AFgBYAWAFgCvO3jpO0y3o8i3bKkInXCsFuRUmyFsQ+46TxS49+Se/jwwBXy1KNRapRFqmqRPmynFPS1lWbyFK8T7QPeT54t7ShTlT33ZzHUrutCtlZilx6Ma61s2lNanaU51hv8A7O5kHB8DyV+WNVXp7+ruSrbrcXtUWPfsQ1+NIjuqZfbU06n2kLBBHyOK5xa5LuE1JZW6Cds4dmroajIUSwh3TFKu5IHay8gcXXT29G/qcp1uMVV25xuaFmNU2BNql5VJ2RCp7DzkajzIhRvhOeVwdaQpbZc6u2rWpI4cs+eOM61OVWfgU8Scnqknxo9G8PGp7I6+yjpppy7LH2khuSW3VqTP9M1WGmmMriKqVZpsR1M+W4lLjUOM9DdLCGVtJQ4pWWSeXPFRaQdKcfDhLW9WmMpLTFbOUlJZbT2S5fyJc91u9iE3A7X7XjO2/BrLsm2q5HZnNJRm22+ws6kKUyrPdrC0ZKHiOZGLq1VK5fiyglWptx90/n3XoaJ5jtnZmzsRaZd2u2kh0Ao9JxzkfEKzT+Yxamkuh0kZM2PsUudcTPWplptwj+SckNoc/FJIwBz4wAsALAHSTZDUJdQ2XWrMlnVJdpkbeLPNRDYGZ+OWeAKHXDaM+o3tc7dMQgRolTlNpK1aR+vXpSD8BjfRt5VOCHdX1OhjV3HG26PcNPS5S6pC6xR5XBelSVbtR94cc8vH8cT7elUj5ZLMGU17c0amKlOWKkfxNd2JdMKtIoLdQWqBMSvdOOEE7gAlzTnmrWlIIyTxJ5Yg39xUtYvduPb8idY0qF1iWlKa5JRVRQIUiTPZbRTjBjIEdUILbd0NjcrJSnJKs3S3lvdXM55jiOOsq9xHGmTbk988b7/lnjHbHodQp6Hqjs16E7tKj1agWjV2rri0+5V1JqLcdxWkjfsVVqKFpEdwOo9Urd5BRjqHz8epbIVWrKpJylyzTvauWdFjXLeUKpy5Fx3WpCd3UYbsaTTacMm3WEt5oS8l0KQzmDp09+Yx6jOhBN5fwx39QOXLV22KWzAgKdTHltpdR2vV9XzPq0hXrEjeA5pUogZcMZSZNu6+IKMc4f5enrz2yPlr2/OpVCTNfp3WRP0PF1sbx2O2D2SWTlq7OZ7OfPiOHGuv7KrUxKL4XB7Hp9VU1PGc/evsPpk1ObcC63SHo8pjLcKp+rdyCwhR060rUshZ9rirs8hwGWLLo1nOhSWMOT+JZ/8AhyfV7inUbhUUo44ljY0rnqV10OSl9mUtynSOLW/QlRQrnu18OY+OLG4qVaTyn5WRLGhb3EcOKU16d/dFjehhVES7KuBtatU5NVL8nxIfZRpV8y2rFXJ5eToIQUVhcIrHtipE+k7UroiTgd96RkPBSvebfWXW1fvIWDjwyIdgA0dEaBPkbZYciOD1eFElOzSOW7U2Wkg/6RxOAJt0wWY9U2kWdRkEdZfYDbmXMJkyd2j80qwBbGOw1HYbYaGlppIQ2nwSkZAfhgBtu2uJoFrVetqyIpkN+VkeRLLZWB8yMAcx5kuRMlvy5Ky5IkOKdecPNS1nUon4k4AxYAWAFgBYAWADd0Rrsdo+1VulFWUSvx3Izie7etJLzSvj2FJ+eALy4AC/S4oqKhsdlS9OblKlxpSD4al7hX5PYAopgBA5HPABRsi6/SbAgy1fp7I7Kj+1QO/7w78Xdnc61h/Ecl1Tp/hPXH4H+Br3LMuO3nxLhvdYpTp/VPDWGlH3c/a0nu44wuJ1KTyt4m2xpULlaZLFRem2THT9p0NeSZ8RTR73GTrT/VOR/PGMOor6yMq3QpL4JZ+Z7nFd61ePS6QULgQ2lz6jKfKmmm2Whm4pxelSkpSnhwB4nFZ1vqkKcE9+cLHLk+EkWPRemzg25c/4PtbtmJSa0+m050iDccV1LK7bXnIfWXSMupyGUlEhshQOS0pVlzBxQWHU6ulSqpeG1nxFstv74v4X8srJ0KzTlmDxL0/fI8MX5V6LKTTr2pT9MllOpLxaUjUn627P8U4u7W/pVo6oSUl7FzQ6xjasse//AEWl2CWhIo1pKrVRa3VauVaZ0ptXNpjLKJH/AHGuJ+0o4ybyUNzXdWo5vuPG2W5a5bmzmsVKhQ35lW3W5iCM2XFNKd7JfUE5nS0M1Y8NBzj7alnPMrJ4+OeAOg3R82cfQXZzCiyW9FYqOU6q5+0HXANLR/okZJ+OeAGrpP7SPohs6ehRHdFZuDVBiZe0hkj9Id+SDpHmoYAogz34A6RbLb8N92ZDuU012lpllaUx3VBee7VpK0KGWaCoHIkDAAX6Vl3VGs1OibJ7dO9qNWeZdqKEn6ysozSz3DP1ivABJwAZtndg23s4s5qlQtDbcdvf1SorySXnQnNx51R5AZcM/ZTgCv203pjz01B6nWDFaENo6PTMxBWp0jmplngEp8CvPPwGAINR+l1thhTEvTZUSqR8+3GfjNtgjvyUwGlDAFqNkG2W3NplGcfhJMOqxMhUaU6QpberktCuGttXccviBgCuPSh2Vt2Rc0O87cb6rTKo8d8y2MkR5o7fZA4BDycyE+IPdljKMnF5RhUpqcXF8MGCr6YMSZJZpQbqEpG5kykk7vNQIBI8eeQxPd8sN6fMymXSJZSc804vZDqxDgRqPShCozdUjTEpEqRw1hass8zxI45/DG9RioRxHUnyQ5VJyqz1VHTlHhGK42W3ZMC0KUN2zq3krLjpT7XE+QzV+GMbhZaoxM7KTUZXVTd9v3+AxX5JgekWqfCaQhunthpTiQNRV9Unv0/xzxGvZR1aV2LDpMJ6HOT3m8lu9g2wu2ads0iG6aJEqNVrGU+Smaw28ppCx6loawSnSjiftE4hFqSGqdGrYrUc9dttx1H3orr7H5IWE/lgCH1XoYbM5OZgT6nAUe7eNPIHyW3q/tYAiFW6D0kZqpF1oX4Ny4pT/bbcV/dwBEp3Q/2vU19L9MkQJbjKgtlyPJWy6FJOYUneIb0kHl2sAWV2QVzac5TPQu0OiuxKzBRk3WEqadjy2xwzUppSgl0d/ceflgCZ3JbdFuWiSqLWoqZlOmI0PMr/ACUk80qSeII4g4AoVts2J1rZrWvfmW5MUfRlTy+e5ey4JdSPkocR3gAD2m1CXTprU2IvdyWDqbXkFZH4HMYZNlKo4S1R5QTKBtciO6Wa2z1df/amQVI/eRzHyzxuVT1Ohtutp7VFj3ROIZpMxYqkPcvrWnR1xrIqKTx0lQ493I42FzDRLzxw/c0bgn3RCSXaVT2KgyBmUFag8PHs8Ar5HHjyaLmpWjvCKkvxIHI2vV5txTaqcwy4k5FC95qHxBIxr8VlLLrdRbaUvvIxcl0VS5ZbC5KEgtJ3bDDIOWaj3A5kknGEpZK27vJV3mXYtnbnRLsyXs1plPrrTsS61N9Yl1SOrJxt57tblSDmhaWxknLLuORGeMSICe89ke2rZmyt2A6a7bjWZEqOjfbpH84wrU43+7mnzxkptE2h1CtSWE9gXpuCs3RVIkCsVLdQXXRvQdLTQHfwGQz8M+/HucmxXNS4mo1JYi38kEV6vN/Til2/ByTEiNLL6Ueznuju0fuJ/jjbnfBfSuf/ACI0o8Jf4IPtDuOumt1GjmYv0e24AI4ySMtIORy4kfHGubeSm6ndVPElDPlyFjosbE6LdsSr3FdUATKPpNPp8dzUkKdOSnngUlKgWxklJB5k+GNZUjptG6GUxnezrDn9Zb4qFHnEJcHk1I4JV5BYH3sAVxr9uV63qium1uA/TpzftMSEFB+Iz9oeY4YAbcALAGzTapUqXOan02U7CmsHUzJYWptxJ8lJyIwAerG6Y970hDcW54bVwRk5DrIPVpeXmpILa/6oPngAvUfph7JJraTO6/S3PeS9H3qR8Cwpwn8MAOr3Ss2JNt6hWnXTlnoRDlZ/m2B+eAIhcXTVsuK2pNAo02pP5dlckoitZ/IvL/sjAAK2h9I/aXerbkN2YKVSHeCqfT82gtPg67mXF+Yz0+WAB1SqRUKpI6vCaLi+ajySkeKjyGNlOlKbwjTXuIUo5k8GxVKfULeqaWd/pkoQlwOskj2vA8DjOpCVKWO5qoVoXNPOPL7kiou0mS1paqze/Ry6w3kHB8RwCvyxLo9Qa+PcrLrokXvT29uxK+uWpXGUqcXGkpTxAdyStP8AWyUMT9dKouzKfw7i3e2qPyGW5bqhsxPQ1CyekPDcjq4zShJ4aUaeajy4YiXd5CENMf8ApFh0/ps5z8Sp+PLZIp9kwKdbEOLPiO3BSKeZFQiToElthOgR2FzQ67pda3S3RoaGYdzB4cRj5xT6jKpWbi1SqSxFqUW/rSUMLZ5S3l9U7R0sR9Uh3hLjTxUqnHhsVKJWoa51drQeTJhRpLTSpCGJFPWM0NsFIaQtWSzzCuOWIdROnpg5OEqctMIYxKSbw3Ga5cvia47NdzNPO/ry/wDoB1ertRrlRVPnrSp4pS2hDaEtttttjShtttACUISkZADHbW1tCjDTDj7236t92QJScnk+25WpFCuCm1qPxfpslmU2PEsrC8vnljeYnSF1Fv39YqkBXWKJcUHILTz3chHPyWnP5EYA587SdmtyWBcT1HrLJ0ZkwpyQdzJa7ltq/vJ5g4AieAJhst2Z13aDdMejU1pQihSVVKfl6uOxn2lqPLURwQnvOAL+3LWqNYFgyZ+kNU6hQgiIxnz3aQ3HZHmtWlIwBQl6PedAnu1g5S25ai/N3faQpTh1K1DmOJOShiwVOrQ3W6KSVe2vFpfll29f37G/JW5WoTlVtye7GlNjVLgF0gcOZAJyHx5HG+T8Raqbw+6IkEqE/DrxTi+JY/f6ma2Il1mLFud6ZCkMziqnlE0oKmUZ9l/JQ0jdrGv5ceBxxvVb6FabpT16oLO3f/bt68flwdVaWsaUfIkkyTGgpuNTtPqtSNFti1Iaajcs9tSpLynXHNDTSQpLa1OrV7Gvl355DPHo9ssyrer22xhe3K+42V5dgj25tfpUm06xModTqlfj0WOk1ePU91EryIGvLrMSfF7LobUrMod4/a8b0jgnrlfdrVWVU3J8mpQN24jrlddC5zUEkraACf0ZaeIUU5ElWNunTjPcsrCtRa8rWVnXnlfLOzQPaEF1+66e1UXNaXnUIUMglOhHEISkZBIyGWQxgt2arf8AnV4qXdkqvK+q9SbvcZhK3cWKhCOrLGbbmY1FWXzyBGM5TaZZ33UatOviPC7djbhS7SvpzdPRV06vBJWH2OZ08zrHBX73Hzx6mn8zOLoX20lpqfv97jzbWwPaDfNFrDkGrtyItFkiPATJ1JTKeCc3kpc46S1mE8cxqzGYyx5UqyezeUjnKlhToVZKOM+qMGyO7bh2JbSFxLup8iBTqgkRqqwtBzCQc25LeXBwNkniknNJOXHGoFktqmxSy9rtLiVyFOTHqZZHo+uRdLzTzJ4pS6kEa0gngQQR+WAAY10KtoZnbp2r0tEPPjJSp9S8vHd7scfLVgA92XY2z7YZZU2dLmgEgLqtZkZJcfUnPQ02gZ8OJ0NjMk+OAKkVXaFKvjbhTrolpLTLtWhCJHUR6mK0+gNo8M9PFXmTgDoVgCGbZ4z0nZPdrLOZcNLlEBPM6Wyoj5gYA5v4AWAFgBYAWAFgCd7CA+dsNpbn2/SLWf3B7f8AZzwB0YwAM+kmpI2JXRq72WQPj1lrLAFF7WtR2uqfJd3DDIy3unVms8k5cO7jiVbW3i+yK6/6grfG2Wx3e2XTx+pnMr8ApKkf/ViQ+my9SFHr0O8WaqbCuuE8h+Luy60dTa23QCCPvaca/oVWLyjd/q1vNYlnD9UT+Fv6jSy1Voe5dWN3JYVkUq+0kjPgfyxawzKPmRzlXFKpmnLK7MF10W4/RJ2jiuI72oz3iPqn7QxSXFu6cvY62xvVXhn6y5CTs8tumUFylt1qaqDcNyNtSaGI4fjyWgslLGU1JLIL5/ZraWk8NRTjierXc66n4cdVKi2p5w0/Xy8+X1TT5xku6MFHGeXwOSZTTdxi5Zs2lxhUm5NMRJntSKfMnKV6uU6vqe/RGdbJLJkDJJOfDniM4N0fAjGo9DUsRanGHeK82HJP4tHJlnfU8b7EbuWv21QHqJb64E2pN0GrOzanS6q4jW1kUIMFp9vUlTS90VlQSAcxwxc9JpVJ1HcS0YnCKWniXL1NPh74x2NFZpLT6Mtps36Quzi+A1FjTPRdYXw9FTsm1k+DS/Yc8gDn5YviOE7AEEuDYhs0rtwwrhl0dturQ5CJO/j+qDy2zqAkIT2HBmOOYz88ATvuwBz26QW0ZV87RpsuOsqpFO/QaUO4tNE6nP8ASLzV8MvDAA5Z78AdL6tULesKyX5hbTEolAh+rjo4AIaTk22n7SjkkeJOAKr9GeRKvjb1VrvrGTkxqNJngcwhx5SGEJTn3NtOFKcAFLpgXhLomzdmkw1lt24JPVn1g5HqzSd46n946UnyzwBSLACwAQ9gF0TLd2tW7IjqIbmykU6W2OS2Zag2QfHSohY8xgC4XSToseq7GLiS6O3DaRNYV9VbDiVcPinUPngCLdGC1bAc2UKhIfg1yXVz1i4YitDpQo9lth1pfEBtPiPaJIwBqXl0Wm47j1S2c1H0U8rNa6HMKnYLh8EL4raz+fyxupV5U+CLc2dOsvMvt7leqhS7hsOfVnLupz8K4pOfUy4jNhwZ82nk6kKGfgeQxJoXCjqk/jZAvLGU9FOP9Jcg9h1ByNU2KgpCJLjLyZBbfGttwpVr0uDhmlWXEYgNlwljYvlsc6QlqbQ2EQXCmlXMlPraW4rg7lzVGWctY+z7Q+HHA9CvgDVqlRbp0B6a40882wnUtuO2p53Lv0tozUrLwAzwBCqdt72Pz1aGbphtOZ5FuUVxFA8siJCW8jgCW065LdqfGm1SJNH/AMO+27/cUcAOWAFgAZ9ImuUembLaozUIbdSkVTKBS4DidW8lvfq1JHPNrIucPDA9jFyeFyVHt/ZE1ukvVx9W8PHqjBHDyU5x4/D8cblT9Tobbom2aj39EST/AIMrO0aOoKH2967q/vZfljLw0WH+kW/9v4sY52zuq0hap9pT3UOp4mGs8VDwB4JV8FDGOjHBDqdLnS81CTz6GOibWUhfVbgjFl1J0qkMg8COeto8R8vwwVT1MbfrXaqsP1X6G9tAn2tLthVQyYnSHcmoL6D2ws8eJHa7I45HHs2sG7qVSjKjq2k+xt9FXZr9Kr/TWprWqj23olLzHZclk/o7fyILh+HnjQcqXnwAsACjaX0bdnd7b2WiP6Era8z6RgpCQtXi8zwQ55ngrzwBUC8LXrGybaAac9KiVKZEQl0LZKiktvJOSXEnJSF6eOXwx6ng329w6U1JcojVXnJuC5FyuzCE91AJdV2GtWSSpSsvZHPPLlg3kXVbxajnxk6L7OaLb9Esij0q35DUulRI6UMy2FJWh5XNx3UnMErWSo48NBJMAMt02Za11040+4qaxUop9lLye0gnvbWMloPmkjAFato/QyfbDs6wp++SO16HnqAX8GpHBJ8gsD72AK3XBbNft2orp1dp79Omo5syEFBI8U58FDzHDADZgBYAWACLsG2Z/wDCBf8AFpkpCjRYg63V1JJT6hHJvUMsi4shPDjlme7ABb2j9DOazvZ1hzuste0KPOUEu/daf4JV5BeXxwBXGvW5XreqK6dW4D9OnN+0xIQUK+Iz5jzHDABCpAj25Zom7vW4ptMh3L31uZaAT4DUMXlLFGjn7TkbjNzdae2cfcRBUW47vnda3KQkDQHstDSUg55au/n5nFfpqV5ZLvxKFnDTn/LJNB2ZUpDX6W+6+7lxLeSEj4cCcTIdOj33Kmr1yo35UkiMXdaRoi23mXC7CeOlKle0lQ46VZc/I4h3Vr4e64Lbp3UfH2e0kPuyGi1dVb9PR48lMaDqbbqTbG+itPuJ0aZB3jBSktrPFC9aeBGOV69cU1S8JuOZfVziTS/t2fdd1h8Mu7eLzknEqIy+h61pvUso+uS8zRJDEOFUFKIESnNvjMFZKC8vrBLnDJOKSFRxxXjq32/mJylD+6o16fVWjEfUkP8At/Lv7A4v23WbfcgPQ2ZlINWjOLk0WYomRH0PKaKVKybK2nNGpGpI/wAcdF0y6ddSUnGpoltOPD2z74azuRasNPtnsRlFGqy6WurIhvKpbTvV3JwbUWUukatCnMtIVkc8sW5pNPAB36OvSHFjf8Wrl1u2u+4Vx5Cc1rhOL9ohPNTSjxUBxB4jvwBb16NZN928neohXBQ5PaQexIaJ8QeOlQ/EYAgCuilsUVN6z6HeCM9XVhLkbr4e3qy/ewBO2Y1ibPrdVukQreocbtOHsst5+JPNaz8ycAVR2x7Vn9r092iUGSINtUtQcjNvZpcnP8RvVo9pKEjPSMu/M8eUi3t/Ezvgg3t74GMptP8AAEzFUuu1HgxISoxu5p3tNKH2FDl8sbVUq0Hh8EeVC2vFlc+3P2j3UKPCnVClz2h6MjzWVPVfJRbCY406tRAyGvVoHDiSMaOr1vCpqcNpzWy9/l+L9jzpCcpSpz80ab5JDVa7Fpb70rqy00xCE7nq5Y1MuZqbTrj6lKLSkjdBYcyB9ngePFULZ1Ulnz++d+/xevfGPmdLKWPkZbag3JaVNqE6+aPJqlgX3Ca9J1SnOIkLZOvfMO7xJUlDrK/ccy/LLHWQgorC2SITeTKlyy7MtioR7Rbq9UnXdF6v6aqMTqkdFNLo1pYQDqdK1o0KWOA/IyKMMsjXNXTH5g+uaelmAlhAIdnALUOCUoZSTkkJAChmrM8QPhiHUn41dy+rDZfPuZ2tHwqeO73ZiodiXk8WahDjGOUEOsOOqS2c08QQDxxKUGW9v064eJRWCZ1v6P1VDLV4RXKNVkp0olj9WsD6jqQtBH2VcsbHh8ltceFUwq6dOfr/ANmiirWpa8F+Pa611StSxpQ8AXCBzzzAAyTzyT88Y5UeCO7ihawfhPVN9x82Ubfto2z+O3TZdOcq1tNqKupvNqbca3i9ay08E8M1KJIWCM/DGo58s5Qrs2TbaqE5T34yJq0I1yKRPb3cuPnw1oPMceGtpXzwAPqrsU2q7N1v1LZBX3pNMJLjtszShfmd3vPVLP8AVX5nAA5q3S32009blMnU+BT6kwdD+9iPIeSrzbccyB+WABHeW0S9LzmCVctVeqCkHNlpRCWW8/5NpGltPyGAGCNIdjyGpDRydZWlxB8FJOY/hgDp/btYYrVAp1YjkFmoxmZTeXEZPIC/8cAbU2JHmQ34khOuPJbU08jxQsaVD5g4A5o35aM60LvqtuTQd7Tn1NoWffaPaacHktshWAGDACwAsALACwAeOh9Zj1W2jruFbf6DbzCl7wjgZMhJabT/AFCtXywBdvAAL6YdwNU/ZSKZn6+szWWUp79DPr1n5FCR88AVKs68fRP6FLTqgLVq1pHabUeZ+0MTrS70bPgqOpdN8bzR+P8AMJe96xF3sN1B3ic2XvbR+WXDFznK2OV06ZYkuOSI1C+a1SJRjVOmN6vdcbWoJWPFJOrPFfO9nB4lEu6PSqVaOqnNn1nahTD+uhPI8dKkr/jpx6upR9GeS6DU7SQ0Vi5KNXq9TmJzj8a3m1p6040kF4BR9Y4EnMEpHLFb1O6nOD8JZklsnxktelWHgLz/ABP8gh1X/iBTYrdGrsuoqlbyRQqTLiR6g0W05BFQjOocJYzBKkFKQc0nUMcHQ/8APm3UpxjjCnJScHn+ySx5vR/PZnQy/l8P5dzDUqZaNOtanuyZMS6KXGQ9MopmrkUyT2la5ENakB5p4h3iWipC8zwORxnRrXFSvJJSozeIz06Zr0jLs47fWw168HjUVH1X3EEp9rbRdptfn1KlUh6py5TxclOsICI7alckbxZS2gAcACrljrLa3jRpqnH4YrBDnLU8kmmdFvbbEjdYFDS9lxLbEqOpwfu6xn8sbzEcbR2/7YNmc0UWvsvzojGQVSawlxD6Ej+SeUN4keGepPgMAWZ2b9IrZzfG7jNS/RNZXw9FzyG1KV4NOew55AHV5YAKGABptF6Puzi+A7IlwfR1Xc4iqwcmnSrxcT7Dn7wz88AVsuboibUaVUlNURMeu09XFqUh1EZYHg428oZH7pIwA89KDbrQ7uo9Jt605pk0t8deqroSps60kpZYWlYSc0EFah93ADL0O68xTtqy4Dx0+l4D0dnPvcbUl8D+q0rABk6Ytpy6vs6iViIguKoMreyUgZkR307tav3V6M/LAFJ8ALABU6NVlSrn2rUlxLZMCiOJqU533U7g5tJ+K3dIy8M/DAFrOk1X49H2NV3eH1tRS3AjJ+st5Y1fg2lR+WAKG0auViiVFqpUea9Ans8W5MdZbWPLMdx7xgDojsdm3nUNnVHqF4OodrUxrfqKWw0rcr4s7wDhrKMirIDnywBV7pd7SRX7xatSC7qplu5iTlyXOX+s/wBUnsfHVgAHVGiVimJjKqMJ+GmY0mREU82pAdZWM0uNlQGpJB5jAGqw+/HeQ+w4pp9pQW06glKkqTxCkkcQQcAWi2LdLVbe4oO0RwrRwbjXCB2h3AS0jn/SDj4jvwBamLKjS47cmK6h+M8kLZebUFoWk8lJUMwQcACHbP0brav1D1VpmikXUePXEj1Mg+ElCe/+cHa8c8AUsu6zbosyuLpNehuQJzXFB91ae5xpwcFJPiMAe6XtBvulKBptxVKJlyDUp5I/AKywBMKX0l9tVPI03GuSke7KZYe/NSNX54AmdM2g3ftG6tW7pWyr0VvI9Majt7pGt3IvPqGas16dKAe4Z42013Oh6Jbc1H8l/kg+0LaBOYnOUikO7gMdmVJR7ZX3oSe4J7yO/CczzqfUpKXhw2xywfpq9US7vkzHw7z3m8Vq/HPGvJR+NPOcvISdn20CXOlopFXXvHnP80lHgoke4vxzHI42wmdB0zqcpy0T57M1NrlvtNOMVthOkvncy8u9eWaF/EgEHHlVGrrdsliou+zByy0686hlpJW64oJbQniVKJyAA8ScaigOiuxTZ03YOz6n0VSR6ScHWqq4PelOgahn3hAAQPhgCd4AWAGW8rqp1qWtUriqJyi01hTyk961ckNjzWshI+OAObFy3BUbiuCoV2pL1zqi+uQ+e4FZz0j7KRwA8MANuAJTY+0297Il9YtyqOxEqOb0Q9uO599lWaT8efngCz2zjpi21Vd3BvSL6Emns+kGNTkNR+0ni41/aHngCwVOqdOqcJqdTpLUyE+NTMlhaXG1DyUnMHAG1gBnuiz7YuqnGnXDTWKlEPJDycyk+KFjJSD5pIOAK17SOhmtO8n2DO1D2vQ09XH4MyOXwDn9bAFbLite4rbqK6bXqe/TZqObL6CnMeKTyUPNJywA14Avh0Xdm/0R2dtVCW1orNw6ZsrP2kMZfozXyQdZ81HABjwBQfpMbRxee0eQzEc10ahaoEHL2VLSfXuj77gyB+qBgBvtm8aK7SGYdRdSy8wgNKDozQtKeAPIjl3HFxb3cHDEuxy1902qqjlTWU3nblHqq7RaREb3VOR1pwcE8N2yn+BPyGPat/GPw7/keW/Rak3mfl/FkTbrd01uqspZkOb0rG7bazS2jzIHcPPEFVqtSXJcO1t6FN5Sx78ks2mSW0UViOoguuvBSfghJzP9oYndQl5Me5T9Dg3Vb7JfmSO3YjlDQiLTKUpqgyKN6Ql3aVuOsrd6rvlb1tZVDW2l/wBQWFI1eeePmN3PxvNOeaqq6VS2Txqxs/jT0+bUnj7DuYLHC2xz+9jLb8MJoioDyKZNp1YjP1XRCeajTGXZUcmU3CYKnm17iOnQN8hGk6gkjGN1U/m6lrjOnJQ8ybi1F+VyezWqW/lbzs2hFbdt9/8A4CG6auxVq5JlxG1sQM93T4zi1OKajt9lpGayo+yOPHnjrbKg6VJRlvLu/V9yHOWX7F6NgKdnC9mMGhW5Oi1dptrVWGiO2uQ7xeLzDnbAKuyNQ5AYlGBEtpnRDtKuh2faDgt+pqzV1M5qguHw08VM/u5j7OAKrXzszvWx53VbjpjkVKjkzLHbju/0bqeyfhz8RgBut28LptqR1igVWVTHT7ZjOqbCvvJHZV8xgA1bLL86Ru0qpyqNSLrMdMOMp9+a+wwEp7m0KWloqzWo8Pme7AA+2lW3tcj3MxAv5c56ZIc3cSXLdU/HXmcs2XMy3kM+ITy8MZQjqePUwq1FCLk+w31a3G+us0u34z65sM/pk0nSkqIGXa4AZYnVbffTTTyuWVFvevQ6lZrTLhDtMqN10CnJNYZj1SKSE6yc1JV3a+HH45fPG+U6tKPnSkiFTo21xP8AlOVOQ9UmJJm0B6tS28qtOQepgoG5baZO8S2tDoWkpyTvtWnPhwz4Y4fqvUpVrnDfkj6fdtj/APp5+Z1VjZRoUsR7jPLuG237npdJuhiVEt9h9RrrMNSCr1makKbWni4lKl69R7RzPfxMvptqo/zM6s8P98emPYzqz7BSNmwrBq7IsHaSKYxV2hJgwa82fRdRYcT7spKVRnOehQKAofPFsaQdX1dlSuCtsyLjiM01EVLTMVung9SaZi5oLTWjUWwperNPME4yqzcaTUV5+xjWsKkaqc/gx+/tGCxIcev3qqTIbHV46TJSweXZIS2CO/IkE4xtqWlJehbdKoqrX34W5p3RftfnVV7q8t2JEaWUsMsqKOCTkCojIknGcps8u+pVZzeG0vYk1pVh+76LUaFWfXvNNbyPKI7XgCftJVlx7xjOLzsywsq7uqcqdTd42Y+dHi9NnmzudLuG7WpvpeU3uaRuo2ttMcn1rqVqUkErUNGY5AHxxpOcD0jpf7HSMy9PT5GKf8FHABKsW+qBe9vor1CU4qnrcWylTyN2rU2cldnjgAB2v0tKzUdpr9C9DekqFUJ/VKMIvZloRq3aVnM6FhWWs55ZeOQwAQuknStnQ2d1Ct3VTW5U2Mjc0l5PqpXWXODSEOp7WnPtKBzGQPDAFCMALAF2OiFtAardhLtiQ5/lK3V6W0nmqG8oqbV56FlSPIZYAPeAAf0k9hK78piK9QG0/SqnN6N1wT1uODnuiTwC05koJ+B7sgKQy4kqHJdiy2lx5LCi28w6koWhaeBSpJyIIOAMWAFgBYAdbYteuXRXItEokVUuoy1aWmk9w71rPJKUjiVHlgDoVsk2aU7Z5ZsWgxlB6V+vqUwDLfSVgalfdAASkeA8cATTAFQukFU49/bQ36al5XoS1m1QW3Gz7c9whUgjx3eSUHzGJtpa+JlvgqupdQ8DCjvJ/kAyu2PV6ZqdbT1uIP2rY4gfaRzH8MY1rOcPdGVp1SlV2fll7mG2rrm0V3T+ugrPrY5/vI8DjG3uXT+Rsvunxrr0l6hJWiiXNShyfjK5K5ONr/8ASrFw9FaPqjlk6trU9H+DBlclszaJICXDvIrme4fHvZdxHcRimuLd037HV2V9GvHbaS5RPLf2RUqtWc7IZqIauSO11mY285objDehIYei7tUntNHeb4DR3eeOPuuvTo3CTjmi3hYXxbcqWdPO2nnuXELdOPubFrwpVJpEec/dHo6XSpq021UgH3IRjqOUswwGFGUXHE6C0SkDn34wvaiq1HFUtcZx/mR2Us/V1eby4W+rf0PYLC544Jwq1rl2lX/Gst6bJRRWEs1e6BlkyjWgKb3KHQX47ziXNJZWo6DnlmBjP+HLKmo+Kku8U++E9915ZLK2klueXU3wWuoVBpFBpUek0eK3Cp0ROhiO0MkgfxJPeTxOOoIg4YAjF/bOLUvqirpdwQ0vDI9WlpAEhhZ99pzmD5cj3jAHPraRYlUsS8J1uVA61xVBUeSBkl5hfFt0eGY5juOYwBMdnPSW2kWZuoi5PpujN8PR88lSkp8Gn/1iPIHNPlgC1GzfpHbOL33UVMr0PWl8PRk8hBUrwad/VueQzCvLABTwBy3p1LqVVqLVPpkZ2bOkr0R4zCStxaueSUpzJ4DAG1R6nWrWuSLUo4XDq9JkJdQh1JSpLjSs9K0HI+SgcAdDdnt+2vtKs1NSh7t5qS3uKtTHMlllxScnGHUnmk5nI5ZKGAANtH6Gb7s16fYc9puO4dXoieVDd59zT6QrMeAWPmcAROg9DTaXMmJRV5cClwwfWPBxUhzL7CEAAn4qGALS7N9mtq7N7bNNpIyT+uqNRfI3jy0jitxXABKRyHID5nAFSOk5tkjX3cbNIoru8tuiqUGnh7MmSrgt4fYA7KPme/AEf6P2zY33tEhxJDeujU7KdVifZLTZGlr/AEq8k/DPwwBdLbBtAj2DYFRruaeuJR1elsn35ToybGXeE+2fIHAFHtkVjTdo20mFTJJW8w66qbWpJzJ3CFa3iVeLijoB8VYA6A1u07ZrlI9D1emR5tMCQhEV1sFCAkZJ0fUIHIp5YAoDtztyyrb2jVCiWip4wIWlElLy94ESebjbastRSjMJ7WZ1Z8cAQDABP2QbfLt2cyUxm1GpW2tecmkPK4Jz9pcdXHdq/I9478AXb2fbSrSv2jCp2/MDoTkJURfZkMKPuut8x5EcD3HAGa+bAtW+KMqk3FCTKY4lh0dl5lZGWtlzmlX5HvzwBSfbH0ebq2eOrnsBVWtgn1dTbT2ms+SZKBnoPdq9k+R4YAE+ADdssU2bQjaeaXnQv468/wCBGJFPg7Do/wDQXzYH642+3WZyH/1yZDu8z8dZxoZytwmqks85Zo48NI4W8mQqu04MZ73rLWjLx1jHq5N9tnxI45ygubVVNC0X9XNT7W7+OZ/wzxvqcHUdZ/oP5o2uiXs0+kl8KuSczrpNuaXW9Q7K5qv1I/0f6zyOnxxHOQLu4AWAFgCpPTK2l9ZqESwqe56qFpmVkpPN5SfUNH7iDrPxHhgCsWAFgBYAWAJNZG0q9rJmdZtyqOwwTm7Gz1x3P6RlWaD8cs8AWe2b9Ma3qnuoF7RfQ8w5J9JRwpyIo+K0cXGv7Q8xgCwtMqtNqsFqfTZTU2E8NTUmOtLjah5KTmMAbWAGm5LUtu5qeqn1+msVKGf2chAVpJ70K9pCvNJBwACJ3Q0tlF4U2p0morRb7clDtRo8obxRbQdWhp7mQojSQscu/AFjEgAZAZAchgAY9InaR9B9nEx6M7orNVzg0vI9pK3B6x0f0TeZz+tlgCoVqWjTYtOFUrCEKdWneBL36tpHcVA8Mz54t7a1jGOqZzPUOoznPw6XHty2OdStq3q5T1OQkMpcIPV5UcADUO5WngR443VLenUjtj7CJQvq9CeJZx3TBMtKkqKVcwcjiiOxQQ7euy36TbkZDq85YSreMtI7ZOo5Zq4Dl4nFtQuqcKa9Tmrzp9atXbXw+rNW2roiz74bqFVcYihDD6KU5JG8jRpRaV1Vx0ZEFKXSCSRz45ZDHPddnUrUnpy91lLlxz5kvdo6DptrCgtP4+5IrbtygLfi02vVFmrVJ1+VUJtOhz0lD6ChKI8dKi4iMX1vFTmQVnpHmBjn7u7qpOdKLhBKMVJw49Xw5aUtvmWMILu8v5kPuejv2jKdYptXd0zm1x5cVbT0GahvNJU1LYVwyVw9lakqxb2dwruOZwXleU8qUc+sX+qTRpnHRwzb2ZUSl1hVVi1BgPNhlCkK5LQdR4oUOWLiCyWXSbeFXUpLOw3WtTLvacfrttPOxH6WvhIYdLLvidBGWeQHaGMdJCpWVSpFyitoh32Z9MioRQ1Tr+imayMk+mYiQl4ebzPBK/MoyPkcYkQspSq1Y1/W8tcF+HX6LJTpfaIS6nj7rrSxmk+SgDgAGbTOhzRp++qNiSvRso5q9ESSVxlHnk07xW38DqHwwASOj/srVs8sZEOchIr1RX1mrqSQrJfJtkKGYIbT+ZOAK87cLlqO0W/nXqfPTEty3HTCpTyz2XZKVeueQOR1LGkHvAGJdvbSl5s4RWX1/Cn5GtTa3XsDO4LlutqcaRJebiqzSlb0cadSV+9qPEDLwyxur3FXOh7fIjWdjbOHiRTl7McEM0sMM21Hmek3FOKmSyOO93Q19Xb4+06U5c/PyxE6ncKjQ0xeW3u+yz3+w3WFGdav40o6ElhIe6nX36EpqS4y46xuFMRHmTHLadRcKGHI6AQlOoICVJUPZzBzzxxtG1VfyprOcvOc9t0/XnnPODo5T0k5sgVHZ+9UoFz0qJcsJ+ns1+8XHo7KpdIdlnS2kqkEokLyIVueB56fPqoQUVhbJEJvJrbRboWbeZtQUm3qnbVTS5VLYqVGQ5EdU4ypKlBMcrUY7ys8lpAGfHLjjOJJtaalL1249fYD92VaqPQafEdDjLshGt2EpS1OoyWUpBzOagv2gFgq88ZSZLva03GMXtnt3/b99x0o9v3HZdWjVd+OZUBSNM0x81qbSsDVqTzzQe/lwxkk4kmhbVbSam1mPfHY2Kxs1ZrUlVUtucw5FlHeKaUTklSuKtJSFd/cRwwcM8GdfpSqvXRksMlWziwRHqzFtRJQkXBWzoeca4iNGQCXXSO5KE5nM+0rIY9+H5meIWNN75qSLX1fZ7s5qNv0+zKrT4r0BhjdUyE4Ql9LbCQkrYUCHAUjLUpPzxpOcK17T+h7XKZvajYz5q8EZqNKfITLQPBtfBDv5H44A3ujJtjpdmtytn96aqMpMlTsKTLSppLbjgAcYf1ZbviNSSeHE592ADpTLH2M2zV5N9Q49OgSnwtxyql8blIc9tTWpe6b158SgDAFT+kjtlb2gXO3CpDhNsUfUmGeI6w8eDkgg93uoz7uPflgAO4AWAJVsy2g1SwrwhXFT+3uTu5kbPIPxl/rGj8cswe4gHAHRK1Lpol1UCJXaLIEmnTUa2ljmD7yFj3VpPBQ8cAO+ABztR2EWLtDQX6jHMKtBOlqsRckvcOQdHsupH2uPgRgCs929D7adSXVqohjV+IPYLTiY7+X2m3ilP4LOAIWno/7ZS9uvonN1Z5ZkICf6xVp/PAE+s3ocbQam6hy5JEegw+BWgKEqTl4BLZ3Y+a8AWi2bbJrM2e04xaBE/SXQBLqT2S5L+X115DJOfupAGAJlgAW7f8Aa/F2eWkvqriVXLU0qZpLHejhkqSofVbz4eKsh44AopS7orVNkKeZkqXvVFbzbpK0rUeZVn3nx543Uq8qfBFubOnWXmW/r3J/Qr+pNQ0tST1KV4LPq1HyX3fPFtRvYy52ZzV30ipT3j5o/iZq5ZVIqubqU9Ulq4h9odk/eTyPyxlWs4T9mYWvVKtLb4o+jIJnXLQq+nPIkZ5c2nm//fzGKvz0J/vc6H+TeUv3lMktEiPX9cxccaQmlUqPvnYrz4YDquSY6XiUhLkh0hCT/uxVdf6toinunLZbZx6yx6LlknpXTvCWOXy/8IlsqW04h6jqlVVVfioBpkOdH3FZpYZO8kL9JamkORkxkLyCiM+HBOOVhBrFTFPwn8Ti806mdl/L3alqxx78lvntvn8V9pssTLOoFMXU4ch80VAQKpQWslNSt4n1XWYE1YfiOr4HftFxPekjGqVO4rz0SS8T6s+8fXTOKxNL+2Wl9mj1OMVnt6f9Fiejzs8XZ1gMOTkH0/XCKhVluZlwKcGbTSiePq0Hjn7xOO5jFJYRXmfbxtUTs6sd2oR9Kq3OV1WkNL4jekZqdUnvS0nj8ch349BSmmbZ9qNOrorbNyznJuvW4l95brLnHPStlRLZT5ZfDAHQi0ay9XLVo9ZfZ6u9UoUeW4x9RTzYWUjPuGeAKsdN2Cwm57amoA6w/DfadI56WXQUZ/61WAK2iNIPstLPwScAZm6XVHBm3EfWB3pbUf8ADABPtPa1t+tunej6dJqK4acty3LiKl6B4IU6hakp8s8sAH3ovbEjatK+l1fj6LjqaMokdwdqJFV4g8nHeavAcPHABI2hbHrBv2ORX6ckzAMmqmx6qUj/AEgHaA8FgjywBQm3r1uCxbpkT7SqTsbdOrbSo5FL7CVnSH2/YUCO7u7sAWFtfptx+rpbui3V9YHtSaa4ClXnuXsin/WHAD1UOmzYzbJMChVKS9l2UPFhlGfmoLdP9nAAO2o9I+/r9YcpqlIpFBc4OU2IT60eD7p7S/hwT5YAFOAL8dGjZr9CtnbD8xnd1yu6ZtQ1DtIQR6hk/cQcyPrE4Ar50s9pf0lvkW5Cc1Um2yplek8HJqv1yv8AR5bseYPjgA09ErZv9HLFNxzWtNVuPS8jP2kQk/qE/v5lz4EeGACJtcv+PYlhVO4FkGU2jc05pX7SW7waGXeAe0ryBwBzilSZEqU7KkuF2Q+tTrzquKlLWdSlE+JJwBdro+bE6DC2VJTc9LZnS7m0zZjElsL0M5foyBnxSQg6+HEFWABN0jej/ZtiUlFx0OpLitypAYZob/rSpSuJ3LvtBKEjM68/jgAIWtdlw2rWWaxQJrkCezydbPBSe9C0nsrSe8KGWALnbFuk1b17BijV7d0e6DklCSco0pX8ypXsrP8AJqPwJwAan2GXmVsvIS6y6ChxtYCkqSrgQQeBBwBzx28RLKg7TqvAs+N1WmRF7l9tKtTXWk/r9yPdQlXZ0+IOXDLAHzZTczMOU7R5SwhmYrXGWeQeyy0n74/PG2nIvOjXai/DfEuPmSG+tnfpl41GmqS1UMsn2l8Eu5cAc+5WX44ynDJO6j0zxXrh8X5g8VYt3Je3Pot/X4gAp/rez+eNWhlF/p1fONLCBYWzx2kvip1TSqcBlHYT2g1nwKieRVlyy5Y2whgvOm9M8J65/F29hl2m1tVXq8S3qYDIU04EqQ3x3kpw6Etp8SM8vicY1JEHrN2py0LiPPzLubIdn8ew7CptAQB1tKd/U3R78t3i6c+8D2E+QGNRSEzwAsAR+/rxp9m2hU7knkbmnslaG+RcdPZaaHmtZAwBzartaqNcrM2sVJ3fT57y5ElzxW4czl4DwGANHACwAsALACwAsASSzNot6WXN61bdVegkkF1gHUw5l/KMqzQr5jPAFndm3THoNQ3UG+YnomWck+lIoU5EUfFbfacb+WofDAFh6VV6XV4LVQpctmdBfGpqTHWlxtQ8lJzGANvACwBSPbRd6dpG2JUNhzeW9bmqNHAPZcLavXuDx3jg0/dAxJtKWufsQOpXPhUm1y9kMl50mq1WmJjwFIySrW6yTpK8vZAPLh4HFrd0pTjiJzfTLinSqZn/APDDbsVVuWq6/N7Do1yHWz3K5JR8TkMY0I+FSyzZe1PpNwlHjgFbi1LWpauaiSfnijZ1yWD4MD0M9Ys+BT7fpNDrFIceiMMyJbdbpbg6yVBluTNkFDnqH4zepLSTrSSUnTzxx9C/lUqzq05pSbS0T+HlxgtvNGT3fD53J0qaSSa+1fieLQtGlTbTiogNQbibkltdVjOKDUmI66pzeOl9Gl6IzHYbRqUoOIUo8se39/OFw9TlSxnS+VJLGFjiblJvC8rS7nlOmtPZ/v8AAH1VeVdd2pYprSmIzqkRadHcdU9uo7Q0pzWvieAKleZPDHS2Ns6VNRe8nu3jGW/Y1Qg61RRj3CValvW7blQdiMVLf1N5tKX47ikA5e1mlA4j8cWUUkdRZ2tKhLClmbX72NOs096n0GJaFHyVUKmVl5zkA1nqedV4A+z8MeP0NNem4UlQp/FL8u7Gx2ztndCCWK7UFOzVAFSQpScs+8IbBIH3jjHTFEd2NpR2qSzL9+hlZo1UtwfSvZxXH2lMgqWllzMlKfaHgsDvQtOPHD0NFz0uLh4lF6kFzZl0yI7u6p1/xdwvgkVqGklB83mBmU/FvP7uNZSBB24bYadTtme+tOe3UapcgVDo7kNYcISU5vvDTnkWmz8QojHsYt7IxnNRWXsiqcCTbFaiU+lurcp7tPUkpiLOkLUPazJ4En5HFrCVKolF7aexzlaFxQlKosTU+4zX7Ta16XfqElj9EXklp1HaSEjgNXgfjiPe0569T4J3SK9LwlCL83ckVOtOFGsFtybTus1KpOdZZb9hwtjJKND3AIGS8we0FlWnLUOHG1b6UrvyyxCCx7Z+Xfj2xjOcc9CqeIb8sfrQs6FfF2OUeOmZDo1ssPVCfDjpQ3U1PtdlMWOkKUhT2pGWtKRnzPHjiw6bRljxJtNy7rdY9fXf0ecGurLsgvXBT7tm05FHrdEfuayKvBizpz8+XEplegqbzWGZTmtlMgs+0Nae/nwxaGkC963YzctySZ0anqRQX4gNPLgBix40NspYaKAMgUhGlRC9eo8DyxsRcUIqMcYynHLfb99vUgNuVRLt2oqsuA5NAcLvV4ydRSfcITxzCMYxe5Hta2a+tx1eyHqVtCu6m12RKeYcbhPr9XAlIUgBA4DSeBScueWMtbySp9Tr06jbXlfZjm0qyrtzVEfVQa257QB3YWfPLShfyyOMtn7ElfR7n4X4dT9/eG7ohUG0qZT63VF1SNKud5am32SrS9HgtHNKtLmStLxGsq5ZacaTnprEn3AXtt2sTrz2kvVumyXY8CmK6tQnGlKbWlps/rklORCnFZqz55ZDuwMS3ewOqXvJ2XxKzfU4PPSAqTFeeSG3EwQOwt9fAKKgCvUfdyzwB4qlu7GNttDMptcepqQNCKlEO6nRz3BWYCx91xOXlgCq22jo+1nZw5GktT2qpSKg/wBXgZdiXvCMwhTHHVwHtIz+WYwAKHmnWXVtOoU262SlxtY0qSocCCDxBGAPGAFgBYAI+xrbbcWzWrEsZzaBKUDUaUo5BXdvGj7jgHfyPI92QF5bC2j2jfVJTUrdnJkJH+cRVdmQwr6rrfNPx5HuJwBJ8ALACwAsALAAz2vbeLS2dQnGXXE1C41oziUdpXazPsrfUM90j48T3DAFR479T2h1ip3VdjvXH5R3LKAdKWgOIS2kewlA4JHxzzOLGytlNNy4KPq3UJUmow2fIw1zZzOjanqYrrbA47o8HR/gr5fhjytYSXw7o9tetQltU8r/AA/6IgtC21lC0lK08FJVwI+IxXl0nklFlXHVI9Ti07eF2HIWG9yrjp1d6PDLE2zryUlHsyq6pZU5U3PiSXI+bUG2uoQXD+tDq0p+6U5n8wMSupLZFf0FvXJdsExtqhUKBaQo+4RWlFoz6y7EKZL8Ka9HU20ZFNXoXJYitO6wW1dlerPHzC7uas7jxM+HvpjnZSinl4qfVlJrG/McHawilHHP79BhqTl/Ux5NdtludU7Sp0Mw2JdRb6y1JhkJElZYeBWIrriCcsskjvxOoq0qLwq2iFectTUdmpfV3W2tL7zW9a3jnSSjZUqjbVdpVKbl0yNTkxH3K5XVLd3i5slAQhllje+sSyNIO6BIAz8sWnTemStnvNyikoxXGFzvjZv3NVWrq7F0sWxpBtti2HW/tNjR1TpkiBUoCFogymjrbTrOatbKuyrMgciD54ArSz0TdoMS/aXR6gymVb0mQOs1qKc2kx0dtzWk5LbWUjJOYy1HgcAXbjsMx2G2GEBtlpIQ02nklKRkAPgMAfHosV4gvModI5a0hX8cAekMMoy0NpTlyyAGAPeAMT0mOxlvnUN6vZ1qCc8vjgDLgBjvqrJo9lV6qqOnqVPlPg+aGVEfngDmRgBYAWAEQQcjz78AFTo47NDe+0SMJbWuiUfTOqeYzSrQr1TJ/pF8x9UHAFwdt20ZqwtntQq6FgVN4dUpKD3ynQdKsvBsArPwwBSXY/YcvaHtFgUh4rcircMysSCST1ds6nSVeLhIQD4qwB0VYZaYZQyygNstJCG20jIJSkZAAeAGAKm9M9+9JVUpkb0bIbtGnt7xNQSNTDst3gorKc9OhPZSF5e9lzwAKNgWzg33tFgwH29dIg/p1WPullojJs/0q8k/DPwwB0LACQEgZAcgMAUP6UO0j6X7RHYEN3XRre1QouRzSt7P9Id+axpHkkYADuADrZ3RUue6NnEO6YVQbi1aaVPRKZJSUoXG/Zq3ozKVLyKhmnLIjlgB9pu3HbNs3pcyzbypMiRUVR1x7eqMji4h49hs77tIktpJzBzz7s/AepZeEB24NmtzwQqWP8pJV231tZqcCjxVqSe0ePeM8ZumyzuOk1aayvMvYiBCkqyPAjmO/GBVk4t3arVae0iNUWvSDCOCXCrS8B97iFfPGxVC5tesThtPzL8STf8AC/b2jPqkvXl7GSP46sZ+Kix/1yl6S/Ajdw7V6pOaXGprXo9lfBTurU8R5K4BPyxhKoV1z1mc1iHlX4hG6ImzY168HbvnN6qbb5/RdQzDk5wdn/VJOv4lONZTF0sALACwBT/pj7Suv1uLYsB3OJS8pVV0n2pS0+rbP9E2rP4q8sAVswAsALACwAsALACwAsALAEhs3aDeNmzxNtuqPQF5gutJOplzLucaVmhfzGALPbNumRRJ+6gXzD9Fyjkn0rFCnIqjyzca7Tjfy1D4YAnO3HbDSKBsqfq9v1FmZLrQMGjSYriXBrcT6x0KST+qRmfvZYApU/Zdxw4zNQZSXCpAcUGSd62Tx4jn+GJjs6kVqRWQ6nQnJwf48M3qNtEqcQhmpo620OBX7Lw+fJXzxspX8o/FuaLno0J70/K/wJpGqNv3FDWwhaZDax6yMvsrGX2efDxGLGM6dVY5KGdGtbSzw/XsRWvbOA225Jpj/q0ArUw+csgOJyX/AL8Qa/T8bxLi061l6ai+1foNezqkN1K6YrRqMCnyGiHonpRBXFedQoaWFjIp7f2uB5Y5rq1d06Demc09no+JL1+w6WjHMgsV1+jOSqjQYKUMU8QXajW6BSDLiOFyJp1wiy+kN6VrIc3iGgrdpOYOOVto1Eo1Zby1qMJz0y2l9fK32W2HLGpolyxx7cIFt0W7TqLRKDV6TOfcNWZdTKC0lrJxATvNyeypbPrd3mRxUlXdjqLO7nWq1KdSK8jWO+3bPvtn5NEWcNKTXckGxbZredzSJ1wW7HblegVN72I4vdKkb8LCm2Vq7GsJGfaI7sWsXhmVrX8Kop+hKV2zQvpY7V5KXYdYgdqoU6SN240sI4OONq4pyTxBHZPMY3rD3Omo07erU8aL3XP6jVZVZFar9wVgDU4hDbUJs9zI1ED94pGePIvLNdhX8WrUn9i+QJZsuRLlvSZKiuQ8srcUeeZxoOYqTcm2+WTrY3Il+mZcZOZhrY1up90LSoBJ+JzIxtpclz0KUvEa+rg80E2R6RqdEqsQqdkTVoiyQMwAFlKEIKe0j+Bx4sHlt9H1ypzW7lszWuiirsiqRpNMnay9rLbDic1pTwB1e6QeWfA4zUnTeUQOs9KpxWlvKl957TXrWuNIarbAgzjwTNb4DP73/wBWfxxM8alV+PZ+pyn0S4tt6T1Q9P3/AIPppFeelO2/HqjcyEy0JgL2ZR2eLbSlDVlr+OnLjwGK3qd39Hjpbcov05J/TqUKz8XRomskgkVimU+jTqkKcxElCM0iPTkduO0ZOeZSrikqU4gugBWQSBmFHjjlI0JzqRhqco5eZd3j9Ft8+Gi81JLI7VKpWZswVQ25lufSa66nCYrVXrEqW+wWjMzcS1ELORSpI5uc8/y6iMVFYXCIbH3apc3pD0IH6ezW6RV6fHrNFqlRbPpWEjUreQ3JLQIeGpB0lxJzHPPnjfSpuTMfpcKDUpLUs8bf5BJcy3pPUKSmW7LmSXtRU4N2Qh3SGm3AnsrKTmc+7GqNVT+F53LSvV8RRim22++3PZkhuK4mbHYYoNCYb63uw5KlODPMnvI71HLPjwAxub07Isrq6VmlSprfuzFbN+fSJ8UG44zUhqZ2GXUp09vuBHcT3KHfjyM87MxtOo+O/CqpPJGmaVb9F2gMQLkLzlvxpjZnFgAuqi5hXAcOaTx/LGtrDKW7oeFUcPQuVfuySw9rFvx6/bM1qHVOr7umV2DwQtvTo3EhKMiUAdkg9pPLxGPCOVAfsldlbQYNI2iw5ESmsyELnbhO838YK4qYV2QtC8sswcx8eGALC9IvbvbD2zaJQ7JqLMr6QI3b6ox09Xgt8FNqRwU2pw5I0kezngDb6HuzI0qgyb5qLZTMrCSxTEq4aYaVZqc/0q08PJPngDctQ/8AC5twlXWv1tl2KrqlCHNt+fzLw7jkRr+TeACFtI2GbP7+bW5VIQjVYjJurxMm5A8NZy0uDyWD5ZYAqZtO6Mu0Cy97MhtGv0JGZ67DQS62nxeY7Sk+ZTmnzwAIMALACwBv0SvVqhVBuo0aa9T5zXsSI6y2v4ZjmD3g4AP9k9M+6ae0iNdlLarLach12ORGkfFSci0s/AJwAW6P0utjs5CTKkzKWs80SYylZfNjfDADwvpPbDkpKvpKlWXuiLMz/wBjgCL13plbMITZ9FxZ9We93S0mO381OkKH9TAAZvvpc7RbgbciURLdtwV8NUYlyUR/TqA0/uJB88ABJa5c2UpbinJMp9WalqJccWs95PEknHqWTxtLdjkqPcVuOMSTrhOPglAz5hP108fHkcb8VKWHxkhqVC5TW0kiXUPaRGf0s1VHV3OXWUcWz95PNPyxPo9QT2lsUt10SS3p7r07j/U6FQ66wHHUpc1D1cxkjV/WHA/PEqpRhVX+SuoXdW3eF9zNKg2TTaNKM0vKkOoB3a3AEpbGXE9/HLvxro2cabzySLvqk68dGML8z3QXVVm9qdWurdbt2jTmImQTvFOyZGopLTP7UoLe8Kfqpxyf8T36lCVKMsScG122WM5fbPwp+p0vQ7F0o6pLdvf/AAYmLT62itSJNxQKtcc0pks1pmU44mJFZVqlTJTwA3YWkpaS2QVknIDFNK+0+GlSnCjHbS4rzN/DGK745zxtyWyp875Y9VmTbdCrFIv5dYXNcVBTGi06A2pcN92LGEVTSZCijdM8lONLb1AHkc88QreFavTnaaNK15cpPzJSlqzp3y+yaeNjZJqLU89gJtvPMvJeZWWnUHU2tBKSkjkUkcRljtSAG3Zz0sr+trdQ6/8A8ZKSjs+vVpmIT9l/jr/0gPxGALTbO9tmz2/Gkpo1QDVSIzXSZWTUoeOSSSFgeKCcATzAHh8PFlYZUlLxSd2pY1JCsuBIBGYz88AV32k7Q+k/ZeuS5R6TUqQ3mTU6dGkOoCfF1svFxrLvzGXngATr6Ym19Wen0ajPllGPD8XDgDXX0utsysspcJH3YiP8c8AQy+NrV931JjP3DUC4YSVJjNsJDCEhwgq4N5Zk6RxOAOiECtU2fNnw4jweepjiWJoTybdWgObsn6wQtJI7s8ADrpNVf0bsWuAg5LlhmIjz3zyAr+xngDn/AIAWALV9HHo2BIi3pe0Xt9l6j0V0cu9L8lJ7+9CD8T4YALm0no97PL7DkmVE9G1pY4VWEAhwnxdR7DvzGfngCmbdxXVsnvyrQrWrxUunyVxH32k/o8ncKyIcYXqScjmOOeXccAZtre2m49pjlKVVWWojdMZKBHjlW7W+s+seyVmRqASMszll54Adtgm2yHsxqM1UujCoRqnu0yZTStMppDeeQb1dhQzOZTwz8cAXPsPapYt8xd9btUbkPJGb0Ffq5Tf32VdrLzGY88ASp5ll9pbLyEutOApcbWApKgeYIPAjADBa2z6zrUlVGTbtKZprlVWhc0MZhKi2Dp0p9lAGo8E5DAEe29X3KsrZpU6pCSs1F8dTgrQkqDTr4I3qiOCQ2kFQJ78h34A53kknM8SeZwBMtkVgP33ftMt9IIiuL31SdT7kVrtOnPuJHZT5kYA6ORY0eLGaix2w1HYQltlpPBKUIGSUgeAAwBUHpY7V5D98U+26S6ksW0oSJJIC0qnOJ5EHMHdNnL4k+GCNlKo4SUlyiE2/tap8jS1WGupvcusN5qaPxHFSfzxvVQ6O261CW1TZ+vYkFVte2LlYElaEOKWPVz4ygFf1hmFfvYycUydWtKNws/igdXBstrlP1PQP8oxhxyQMngPNHf8Au41SplDc9HqQ3j5l+I/7KLa3bEmrTGvWO5xo7bifdH6w5HxPZ/HGVOJN6NaYTnL5fqRW7oUKoXn6Lt2GN646iI2yz+1krVp7I5DtHTwxrnyVXUtHjNQWEvzL+7LLDh2LY1Mt1jIvR29c55P7WU52nl/1uA8gMYkAlmAFgCM7SL3g2RZdTuSZkoQ2/wBHZP7V9fZab/eWRn5ccAc3KrU5tVqUqpz3S9NmurkSXVc1OOK1KP4nAGrgBYAWAFgBYAWAHGiW5X67K6pRabJqUn+SitLdV89AOWACjQeihtkqqUrfp8elNq96dISk/wBRrfLHzGAJpC6ENzLA69c0JjxDLDr394tYAcf/ANBt3df88U73w6h2fx6x/hgBsn9CK62wTAuSDIPuh5p1n+7vsAQqt9GHbVQgHW6WiqMsq1pMB5DwzHeGl6Fnl9TBPB41lYG5m9J9OlmnXVTn6ZNTwUVtLbP7zSwFD5YtqPUP7zm7rojW9N59mOc+hW5cDHWMkOFXszGCAr5kc/goYlTo06qz+KK+ld17Z449n+/yIVVrDrVNX1mnqMppHaStrNLyf3ef9XFbVspw3juXtv1alV8s/K368Go9eNekUx2lSFbwu5ILpHrcgeKOHPPlyzxrldz0aWSIdMoqoqkfu7Eq2a3tSaRGk2/cEKKG0rekxJEqM25+lBopEaXrbcXuFrCeKe0kjwJxyXWOnVKrVWlKXZNKT4z8Ud0tS+5ouqFRLZk3t2rSIcBi4Kw8/IrU9CJKaRK6rTqe8hlvSyafNShaErQ1kNCHG18xl3YpbugpydKmkqcdtS1TmsvfXHKeG+7UkboSxu+fu+4Cl13FKuGtyKk+t8pcURHakPqkqaaHsNBxeRIT8MdnZWkaFNQWPfCxl+uCFUnqeS7vRitdq19jkGZK9S7Vt5Vpa1cMm1jJony3LaVfPEowKXX/AHZJua+K3cWtQ9JSnVt8SCGCdLaPgGwBgep4Chsv2JbVmKGi8oVPS5Dldn0Mte6mPxstQkNJXkjgfZClAq7uYxlGWCZYXngTz27jJWLBtWq1GQ/GqPo2UlxSZ0JwJSpt0HJaVNOFC21BXMHGzSmW07G3rvXCeMmKRWLXsqkPwaI+JtXke08CF5K5BS1DsgJz4JGGVE9lXo2lNxpvVN/v9oa9llETIqMivTDlGgAlDiuW9IzKj9xPHGNNdyN0e31SdWXEfzHhFIplZXJvG516KWeECKSUjcIOlBVl2iVdyRzxljO7JSoQq5uK3wdl7Gq3X9lM53qLtLEVpXZRKLYbHHvKkK1j4nHmYmtXNlN6dOF64NGsxa1YFQRIo8orpU06kpX2kkpSRocy59lZyI7sQ7ywp1V5vvIV9aO2lmPwM+R6lSb6q8Ck1eqMWpT48ZwMyHUuvRzJzJQleROhJBCdZ5AYj2ViqGp5y5Mr6lTUFmFbF0Opo1tXzYsO72afHWKBd7NRXFh9RjIU6ESJjCVpU0kA6QsJP8cTzWDq4rvm3LVl1GrJjRobLCIrMCP2Y8WIwkFqOhsjWAOXBXEnPIcMZXU3TpYj8Utv38iDTiqtXL4jv/giTUK45LiLrahFyIzIChuhwSGSMgE89AHDPGujS0RWOxd0qNXaslmKf5EqvW2HroSxcdvkSkvtpS6wCArs+GfeOShiRKOd0Wt/aO4xVpb5Ro2VYdWi1RqrVlvqMKAd+d6Rmoo5cO4A8STjGMDTYdNnGeup5Yx3JneXRx2wVeau4YVLakxpqEOsxkSG0vob0AJDiHS3kvLmBnljGTyyuvq6q1XJcDfYtS25bG6sqR9H6iKS6r/KFOfYdVEeA70uICkoWByWk/HMcMYkQs1HmbK9vdmKjvI3q2uLsZeTdQp75HMcyPiM0q7/AAwBUna/sPunZvUSZKTOoDy8oNYbT2D4IeTx3bnkeB7icATSR0r65I2XSrT9GNQqwqOiBEqUL1bKIuWhfquaF7saRpOXHPhlgCwfR2qezr/g9ptFtGpNTHYbW8qbZ9XJ6y5xdccaV2sivgDxGWQBwAVMALAAn2m9GzZ9fG9mIY9CV1eZ9IwkgJWrxeZ4Ic8zwV54AqVtL2C7QbBWt+fD69RgezV4ebjOXdvB7TR+8MvAnAA5wAsALACwAT9hOxZ/adWZ7L0hyBSKcxqkTm0hR37nBlsBXA55FR8h54A87TOj3tCsMuSZEX0nREcqtCBW2kfzyPba+fDzwAMsAEyxaNEp1H9Mysg+8kub1X7NkeHxyzxc2VJQhrfP+Dleq3MqlTwo8L8WRq8LoYrrjDUaOpKGFK0OKPaXqy90cuWIV1cqpwuC26bYO3TcnyY6ZYVfmoDim0xGzyL50qP7ozP44U7GpL2Pa/V6NPb4n7GzLo912qgyo8j9GJ9Ytk5oB+2hQ/PLGUqVWhunsa6dzb3flkvN7/4Y1z7muCqgRn5KloWQncoAQlRPLMJyz+eI9W6nJeZ7EuhYUabzGO4YLRoM635FPolKrfUKlOjZ1i36hGkSQuStKkuqdZS22mMw2js9YS6SU8c8uGOAv7mNwpVZ09UIy8s4uK27YeXqk3voa52LunDTsn9hHqp/wmMSlXTSYLFKgMQWmxRYzrL+iltjsl6G4VOuML9sqcQc88/PFhR+hNeBUk5yc352mvP7SWykuMJ+xrev4ltt+BDLrvM12FAgsUyLSIcLeuqjQgpLTkl8jevaVFWnNKEpCQchlwxc2XT/AAJSk5SnKWFmXKS4X4vc0TqavY+Wps6vm7V6bdosqopHBT7aMmQftPK0tj5qxYGsJULogbYpDep1qnwz9R6UCf8AyUuj88AaNW6Lm2ujASo9MRNLR1JXT5KFOJI4gpSotuZ/AYAerL6TG1WwpqaLeEV6qxWMkuRKklbE9pPLsvKGo/6QH4jAFnNnW3DZ5fqEN0ioBmpkZrpMvJmSPHSknJz4oJwBPsACbaR0adnN6F2W3H9B1lfH0hBSEpUrxeY4IX5kZK88AVL2r7C7x2brZdqZYmUqU7uYdQjr9teWrSppWTiVZDwI88AS6yrTi0WjITIZQ5PkAOSlLSFZHuQM/qg/jiRCOEdlYWSo0915nyH7oqRJSdkrFTlrU7LrU6ZPffcOpxxRc3OtajxJO554jnGkY6atW6vYFHpgORnVLeKHimOyrP8AtODAFNACTkOJPdgC2nRz6NfUTFvK9owMzg9SaM6P1Xel+Qk+/wB6Ue7zPHkBZ/ADDflzs2tZlZuF0jKmxHHmwfedAyaT+84QMAczpD70h9yQ8ouPPKU46s8ypRzJPxOAPjDDz7yGGG1OvOqCG2kAqUpSuACQOJJOADBbfRQ2v1qM3Jdhx6Q05xSmoPaHMvNttLi0/BQBwB8rXRo222mRVYEXri4p1pk0d8qfby95KfVPZ/cBwBItn/S5va3XU0y84prkRk7tx4+pqDWngdRICXCPBYB+1gC0FhbWLEvqNvLeqbb0gDN2nu+qlN/eaVxy+0nMeeAJY60080pp5CXGlgpW2sZpIPMEHgRgAJ7SOihYFz7yZQh9G6srM5xk6oi1fbj8An4tkfA4A2OjnsOmbN4tWl1pTL9cnu7ht5glSEw2uKdJISfWL7Shl3DAE/2lXqxZlmVGvOJ3j7CN3Ajcy9Kd7DDQA4nUsjPLuzwCWSlNO2ZSqlKeq11S3FzpripEhlsjWXHDqUXHOPEk8QMbVS9TobXoneo/sQ//APBpZ2jR6PP3t67q/vZfljPw0WX+k0P7fxY1SbBqdHUqZaVQdYdHFUF45oX5Z+yf3h88eaMcEWXTZ0vNQk0/RmGj7VWkvdSuGKqFKbOhx9AOkKHPW37SflngqnqY0Os76aq0skFy3XCgWy/VIcht9To3UNbagoF1fL+qO0cZSlsTru8jCi5xefT5jn0P9mxrFzyb2qLZXCox3VPK+S5zg7SvPdIOfxUD3YjHFFx8ALACwBTXpg7S/S9zR7LgPZ0+h+tqGk8FzVjgk/0LZy+KjgCu2AFgBYAWAFgCS2Ns6vC+Kn6PtynrlrT+vf8AZYZHi66eyn4cz3DAFqdnXQ9tCjhuZeD5r1QGSuqN6moSD4cMnHfnkPs4APNJo1Io8NEKlQmIERHsR4zaWkD91AAwBuYAWAFgBYAWAGuv2vblxQjCrtNj1KKf2cltLmXmknik+YwABb36JUdpxyqbN6oukTOKjSZSlORl/ZS4dS0/BYUPhjOFSUeNjTWoQqLElkCtRrdftaqmjXvSXqXPR+1Cc0LH105ZpUn7SCRizpdQX1ihuehvmm8+z/UZLNanVm7X7qNPcqEOlPsuORY+Sni46opipaaIVvVAo1lPIhJzIxy/XrxOLhqUJVc4b4wucvtttn1Z0nT7bwoJc6fzJfUKRS5N8QHZtGEuotvekK0+1HfZcDHe5UKWoOJz3jiFqVHWUqTq4Y52lXnG2koz0wxpgm01n0hU27JpallPBPcVq3W/f/tEVrdQn0a3KwzMuBio1ivzElceBITIj9XSle/cebSNyhTi1N7vshY0nli0t6Ua1aDjTcadKPMlh52wk+XjfPZ57mmT0p75bIlZ9vSLkuqk0GPnvanKajZj3QtQClfupzOOgIxebpBXFHszYtUmYR3C5DDdGpyB3B4bsgfdYSs/LAAh6OfRr62Il53rG/Rey9SKK6n9b3pfkJPud6UHnzPDgQLXdYjhhTwWncNhWpYOYGj2uXhlgDmDcNTVVa/Uqmr2p0p6Sf8ASuFf+OACb/8Aov7Ul2VBuaJDTJcltl5yjA6ZrbR/Vq0KyCipPHSDqHhngBlrtwUem2LFodGf3j8jNE3gUrTlxd1pPEFSuHwxtcljYva91ThbKnTec8/5NvaWVm0aEYn/ACfkjPLlnuRu8/lnhPg29W/oQx8P/WwMcajnQq16nzZGzmiU9xsuVN5bCIzXvZkKIHHwb543P4TpbilKVpCPM3jH7+RqtbLaDDYbFcrIYlveyhKm205+A3nFXx4Y88NGpdIpRX8yeG/l/k2VUjaRadLmw7cq70ugT0FMyntqOlbZ55s5kce9TZzw0NbkS76LUSenzR9uSJN1F2tKRSorYjy6i8nrbqiNOlAyHHgchlmrPEepTdStrfpsVdlb4SpLuyd25blw0JYah1+JJh58IjoJTx+rkrNJPliVGLR1Vra1aO0akXH0HKoRaL6XMSDUfQ1ffQHMmDkl3PlraPq1nh97Hr/E31YU9emMtFR+nf7OP8kAuir3rRa7FRUqimY5EcbmR0dlTCt2vUguM5AHin2VDGqee5QdRlXjLRUlku5sZ2w0XaTbolsaYtaigJq1Mz4trPvoz4lpfun5HGBWDBevSLg2Hc6qJeFuzorLma6fU4im5DEhnP206iyQRyUniQfLI4AzULpCbBapMExuqxoFSKdG9mxlR3Qk8074o05fv4Am8qv7PrioE5D9RptWoimFqnpDzT7W5SNSisJKuAAz8sAUKo1DtS5byrcenMvQ6Gd67SkFep1psOAN6irn2TxB/HGcI5LHptrGtNxl6DVWqXV7Jr7C4NRW1LSkPxJsZSmXEjMjmOIPDuOPJRwar20dCWnOQ47MemLWIG6p19xTUooySKvGATJSOWbrXBDnxGR+OMSGWitO9bWu2mJqVu1JmoxTlqLR7aCfdcbOS0K8lDAD3gDytCFoUhaQpChkpJ4gg8wRgAH7TuijY9072db+VuVlWajuE5w3FfbYGWj4t5fA4AqhtB2R33YUot3BTlIiFWlmpM+siOfddHI/ZVkfLAENwB7YYekPtsMILjzqghptIzUpSjkEgeJOAOimxTZwxYFgwKMUj0k6OtVZ0e9KcA1DPvDYyQPhgCdkAggjMHgQcAc/OkZULOlbUKixatOYgxIH6NMdjDSiRLSTvnAgdgZKOjsjjln34A3bYdg1a1WYp7aQz1aU0D2hkMvlmOIxfWzVSlj7DjL6MqNw5e+UZo1Htq3mt/pbjkf9YfOa/kT/AOnGUaVOlvwYTua9y8bv2Qw1baXHbUW6Wxv/AOfezSn5JHH8cRqvUV9Xcsbfobf9R49kSGFNRWLZMmS2G0yWHN6ju4ZgkeXDPEqE/Ep5fdFbVpeBX0x3w0Q7Z1a6ZstNYqkGLKt6O5uH0z5wprTzyk5pabeJzLgHayHDxxw3Vr3RHw4SkqrWfLDW0vVr0/aO+o087vj7gkViu0X0hEs6YuLTLYQtxMuJIalJqUDQEqTHVLW5LQhqSSlIdbVoKSTkMc7b21TQ7iOqdbs046J++lKLbju9LWckmUlnTwjxdD8qgJfuSqUxmbXVRk0+m3FFXuW5smdEKHNLCNbUtuO2oo3qdGZyzGMrKCuGqNOTVPVqdNrLioy235g5PfTv33PJvT5nz6k82HdFOAzFj3FtBj9YlupDkW318G2geIMr6y/5vkO/PkO4IBZiLEiRI7caIyiPGaGlphpIQhKRyCUpyAGAM2AFgCP3lYNoXlTjAuOmNTmsiGnFDJ5on3mnRktB+BwBSvbfsBrezWYmrU11ydbDrn6PPHB6M5n2W39PAH6qxwPkeGANzZt0q9oFq7qHWVfSSjoyG7lLIlIT9iR2ifgsK+WALT7O9umzu/ENt0uoCNVFe1SZmTMnPwQCdLn7hOAK+7Wrxj39tqFPQ+hVCtIKZjNFQyflg+tUke96wAcO5HnjOC3LPpVBTrb8Lc2Tn/vxIOvLFbH6MqjbL7Ypyxpcap7KnB9t1O8V+a8RD56Vz6bVUVIum2aM2dRjxHZG7TxOqS6EDh57jAEn6OnRsRSEx7vvWLnV+DtKpLo4Ru9Lryf5X6qT7Pf2vZAsXVKnTqTTpFSqUhEWDEQXZMl06UIQniSTgD5SKnHqtLiVOMlaY01pD7AcToXu3BqSSnmMweRwAA+mdd/o+x6dbTK8n63J3r6f/h4mSjn8XVI/DAFM8AXJ6KmxSNRqKzfNdj6q3Uka6S04P82iq5OAHk48OOfcnLxOALFYA+DjxHLAAV6RmwylXlb0u4KTGSzdlOaU8lxoBPXG2xmpl3L2laR2Fc8+HLAFHYsyXDktyojy48lk6mn2lFC0qHelSciDgA8bOOl7elCLcK62vpDTRw6zwbnIH3/Zd/fGf2sAWksHa3YV9x9dvVNDsoDU7TnfVSm/vNK4kDxTmPPAExwBXfbNdLVfvQUdheun2ufWZeyqpPIzUfPcMqCR4FZ8MbaaL7olsm3UfbZAF2iX9NhzF0ekublbYHW5Sfb1HjoQe7Iczj2c+xt6p1KUZeHDb1YOPSlS3u+629vue83itX45405KDxZ5zl5CHYG0KbImtUisOb7fdmLLV7YX3IWe8HuPPG6Ey96b1OTloqb54Z72u2+1umK4ynJzUGJeXfmPVqPnwy/DCou5l1u2WFUXyYO6TTahVqlEpMBsvTJzyGIzI951xWlP5nGk5w6RbObJg2TZlLtuHkoQmv0h4DLevr7Trn7yycvLhgCS4AWAIltUvyLYti1O4ntJejt6ILKv2kpzsso+GriryBwBzgnzpc+dInTHC9LluLfkPK9pbjitSlH4k4AwYAWAFgBYANuwvo3Ve+1M1yvbym2mDmhXsvzMu5nP2UeLn4eQF0rctigW1SWaRQoTVPpzH6thoZDM81KPNSj3qJzOAHTACwAsALACwAsALACwAsAMF52La950ZdIuKCiZFVnu1Hg40s++04O0hXw+fDAFLNrmxe9NlEp6bSpsl+1p3qRUo61NrAJ4MTA3kAfA+yryPDGqpRhPGpKWOMrJ6pNcDHTNq4cDLFVpcZS2pDC4ctvesNxW2Gwy2ksxy244hkalJSHBxUc888UlbomMunOW6eVs3Jt5e8spN8N4fCJCuPUju0K42LiuydU42rqi1aYpWhKHC0n2S5p4lR8VEqy4EnFh0u0dvQjB/F39M+3/AFt7GutPVLIWuhxaHpTaJKr7yNUegRSW1H/tMrNtH/l7zFgai1t0WDSborlGm1rKVT6GpcmNTFDNpyWvIIeeB9oNJB0p8TxwAG+kT0kUW+JNoWc+F10gt1KqIOYh9xbaPe94n3PvcgJ+s/RHo6qUonfwLcJUo8zIcjZknzLq8AV46LmxL6VVdN311jO3aW7+hsLHZlykceIPNto8VeJ4eOACr0n9tSLdgfQmiygzXaqgCpTU5/oURzgfZzO8cHhxCePenAElomyfYreGzek0eI3ErNNgR0sx6vEUEyUuc3F7xHbSpSyVKQvhnzGAB7X9gNw21THqfFQbrtcZ7toJHX2Ec9KmhkHgDyU32vs42Rn2Zc2XUYKHhVVmAG+qbKaLMU+6txcqOr/MnkvFSFp90tLSjiD9bHvlJMVYQerOfvY52lcX0nuOZUFNluNTWdEFg8SN8e24r7RCcvIYyjLLJVldfSKrl2itvtBVW6pLq9WkTZBKnXlnSn6qc8koA8hwxpbyc1cVnVm5PlhOKHLZsqHSi8WqnUzoU4rUrchwZvLAGZyab8O/GybcYbLL9C+qz+iWqi3iUvwz+/vM1QtO36jHjtbuOY+7KUzqaA652SNJRp0agnlpKSeOZVwzxxdK+q02+c54lsvt5/P7N8FQ6af/AEQ+fY1Voktqo0xxFUairQ+C2OPZX2Tp5qHZ5jF3a9WhN4ktD9zVGDpyUlvgkbd52LIqSK4qI99IdIaRGIP6z2U9rPd+Wo92LrXHku/9QtnLxWn4gbah0RaRcVCiVGRWnol1yGQ5PfRokQlOrGehCOydCPYSUr4gZ41N5KCvWdSbk+WDdrYft42UXGzcttMJq4hntOU9Rc3rR9pp6MdDqkqy4hIPiDnjw1FgFIsjbxs7chT2VQqkxwkRXE6ZtLnZcDpVkdJ7u5afPkBSfaBYNwWLcsigVtrS+12mH057p9knsutk80qy+R4HjgCN55cuGAJzsgUfpM+O4xF/ktGNlLkueh/1n/x/Q2drUd5+46c0ynW68wlDaBzKi4oAfnj2pybOtRbqxS5a/wAj7VbAtaFa2qaktPwGCp2a0clrc55EHgrNZyGMnBYJlbptGFHzcxXIM7due4bbqSKnQag9TpzfJ5hRSSPqqHJSfEEZY0HLFm9mPTJZcLVO2gRQ0rgkVuGg6Pi+wMyPMt/1cAWWoleo1dpzVSo81mfAeGbciOsLQfLMciO8HjgDfwBhmQ4k2M5FmMNyYrw0vMPJC21pPcpKswRgCvW07of27Vt7ULJfFFnnNRpr2pUJZ+yeK2c/mPIYAifR26Pdz0zaQ9VrypiobFu5LhJcyU3Ilrz3a21pJStLQzVmOStOALb4AGvSA2mJsLZ/KmRnNNbqOcKkDvDqx2nv9EjNXxyHfgCj9vWPOq7PXZL3Vo7hzQojU454qA4cPM4m0LJzWXsipveqxovSlqkblVsaqUlhc2lzFuhsZupRm25pHMjSe1jZVspU1mLNNv1WnWeipHH4oh78mQ+vU+4p1f1lkqP54r3JvkuowUeFgllmWhTqvEXMluOZNu7vcoyAOQB4nn34n2lrGossp+p9RnRlpjjdckhuyptx4jVu0wJM+boitsI/ZoWdIB8Crljff3MaVNr2+5EDpVnKtV8SXGfvZ8TAttpmZY1R65WWrfVIqTtRpe6YUy6hsIntaZBIdaTuU5OcFZjgMscF4tZtXUNNN1cR0zy8rPkfl4e/HHudphfA98en4mW4b1qlBq1Tp9YttjqtVYpzsany3Xju2IscJiJfU0psvgIIUtCuGseWMbTp0K9OE6dV5g5ptJbtvzYznTvw/QTquLaa5wFnYJY1u3heqryjxsrdt1LTUBgNliK/WCgKfktRSpxLSUDSdOftZHFt0u3q06f83ebb93jsnLbODTVkm9i0LzzLDK33lpaZaSVuuLISlKUjMqUTwAAxZGoqLtf6XFZlTn6Rs/UIVOaJQqtqSFPvEcCWUrzDaPAkaj5YAANSvG7apIVJqNanS31HMuPSHVn81YAfrR207TrUkJcpVflFlJzMOSsyY6vItu6gM/FORwBbvYf0iqLtEApFQaTS7qbSVGICSzISn2lxyeOY5lB4jzGeQBWrNHptZpUqlVNhMmnzWlMyWF8lIWMj/wDY92AOc21ewJVh3zUrceJcYYVvID6v2sZ3tNK+OXZV9oHAETbUtK0lskOAgoKeefdl54AlD+z65G20SGtDzigFqQleTiVHjl2suI8jia7Cpgqodao6sbr3N6JeO0CkN9UkNrd0+wZTKnFAeSxlmPiTjS1Uj2Z0Fv1+WnacZL3OjLbaG0JbQAlCAEpSOQA5DGgiEDXslpE7ak9f9aKZ0qOyzGocRSfVxg0M1PKz9pwuLVp+rz58gJnVqtTKPTZFTqkluHT4iC5IkunShCR3k4Ap7d+1Orbb9ptFsul7yJZrs5sdW5LkNtHW7Ify8G0qKEch8cAXLQhDbaUIAShACUpHIAcgMAUO6VN3en9rc6K2vVEobaKc0O7WjtvH47xZT8sAMGwvZyq/NokClOoKqVGPXKuru6s0RmjP+cUQj54A6IIQhtCUNpCEJASlI4AAcgBgCmHSn2y1Ks3U/Z9GmLZoVHO6nblZSJMsfrNZTzQ0eyE/WzPhgDH0SL6uxnaJHtdMt2TQZ7L6n4biitDKmmy4l1vP2DqGk5c8/hgC6uAOa1y2XcSboq7ECjTXI7c2SmPu4zxBbS6oJI7PLLAGmjZ/fjg1N23VFp8UwpB/9GAN+Ds22qtSm34VtVpmS0dbTzcSS2tJHelQSCDgA029t329WFQlOXtb0qoUnixFqFSacjPofUlW7Cnin1ozGZChqI97AEY2bVJ6pUSTOluF6dJnPvzXle0t13JZUfM54kU+DreiteD/APqYJbqafauSpokfresuk5+aswfwONEuTm7yLVWWecsaseEY2qWl5VSiJY/XF5vd5fW1DL88EbKKetY5yGjaaUCzp2vmVNBP3t4P8M8SKnB13Vv/AF5fZ+ZI+hxs06/Wpd9z2s4tM1RKVqHtSlp9a4P6NtWXxV5YjnGlvsALACwBSvpebSvT14tWnBc1Uy3c+s6TwXOWO3/qk9j46sAADACwAsALAB36N2wL6bTBctxNKFqw15MsHNPXnkHijP8AkkH2yOZ7I78gLssMssMtsMNpaZaSENNIASlKUjIJSBwAA5DAHvACwAsALAEcrW0awaGooq9xU+E4ObTsloOf1M9X5YAYf/0gdjO83f0rhavHNeX9bTlgCQUTaHYldUEUe4KfOcVyaZktKc/qZ6vywBIcALACwAsAatUpdPqtPkU6ox0S4MtBakxnRqQtCuYIwBRDpAbD5Wzitpl0/W/atRWeoPq4qZXzMZ1XiBxQfeHmDgAS4Auh0N3LVj2FIjRahHduKZKckVGCFZSG20eraBQciU6UlWYzHawA1dIvpJopaZNn2VKzqnFqqVhk8I/cplhQ/a9ylD2e7tcgKrUCnO1i4qdTsytyoy2Y+Z4kl5wJ4/1sAdE9pdmyLssp61YjoiR57kZmW93oiNvIW7oHeooRpT5nADFtJvq2djmzllMCO2hbTfUrfpQ99xI5q7ylGepxXf8AE4ApFVLa2iXBTJW0CbAlz6fNkOmVWNOtO9B7ZVpzKUAnIHLT3DlgBtta8botSoio29Un6dLHNTKuysD3XEHNKx5KBGAOilh1K5HrEplTvDcxqy5FEmo7tO6bbBGsagonSpKMtfdnngCtVnsWtt52yXguux1ejBT9NFWyrdPNNsPobbdB71KCiohYI45YAhd7WkdiW0NunGaarS6lED+sI3bqWlOKSnUMykrQW+45EeGMoywTun3ngTz9V8nmBZ1qVWtsXDSpSXIyV75+EninecxmOaO1xKSMbVFN5LynY0alRVYPbnH74G4VpVWumqVhrN2JR2FMQEp46lqzGafNZBxKtPicv7Ucb/FV5481DPlcsfYuWN0KiTqPRZ8xdTejVVtpUgsR3Mt1vUlvtD6y0qIzHLuxpq9Lpzg3VScv2/zK2PVZOrGNNfy28Z9fkOdsXAwzSoSnoaKKN0mLDqZ7TLjwWTvnsz2VAqUsKKTxHDLHL3/Sa2PE3nBvOO/yXt27F9Rvabn4aa1pCqNt0yRTHYrUFU2bHSlqBIZGW81t57zW2AhYGjeLJUvI6hwzGItG7nGepy0xfKfbfjfj0XHZ+pvlBYPESftb2aNiXQ62+zT0HNxlClFkFJCTvIr4KfaOWenFradUpVnpWzNM6LiE6zemrVGNEe8KIiUkcFzqcd058Sy4Sgn4KTiyNQcrM22bJLsfDtLq0ZmqupDZjzAIsogHgj1mWvieSVHAGr0grGs65tnlQmXC4mEqjsrlwqsE6lsrA9nLhrS6cklHecsuOWAKL2laU245qmmlBmKzkZMkjPTnyAHeo4yjHJNsrKVeWFslywrW1YVJt+Z1yK++6+pstK3hTpIUQTwAH1fHG6MMHS2nTYUZak3k2pVviVdcSsPZFmFGKGU9++Kjx+CUn8ce43Ns7bVXVR8RX4kQ2r1tx56NbsPNxxRS7JQjiSo/qm8h+OXwxhUfYqutXGWqUft/wa1C2RSHm0vVmT1bVx6qyApwfeUeyD8M8eKma7fojazUePZD85sjtdTelDkpCvr60n8inLGXhImvotH/AHDdEh7RNmkxVatCrO9XTxkJb5FI/l451IWnz7vLGuVPBVXfSZ0lmPmiHXZj0wLcq+6p97Mii1A5JFSa1KhLPiocVs5/MeYxgVJYWHNhzYrUuG+3JivJ1MyGVBxtafFKk5gjAGbACwAjgCi+2O8lbUtrC2IrhXbVE1RoiknsqbbV654eby+AP1dON9tR8SWOxDv7rwabl37DPedyqokZmJACUSnR2OHBtpPDgOXHkMWl3ceGsR5Od6ZY+PJyn8K/Fm/aVSm1Ghty54G8UpY15ZBSE+9ly8Rjbazc4ZkR+o0I0qzjDgEL5R1hwo9jUdPwz4YoHydpHjc3Ileq8OKqLElLYYUdSkt8CSeHPn3Y2RrTisJ4RpqWlKctUkmx4oll3TU6DNummtuOopshtPqgtb6l5a1uICQTkz2Ss92oYqbrqVGFZUaj3mnzx9v/AC3x8iZCi9OV2JTQrsrdxSpa4dFo8WpS9IrFUdLkXr5KwsxS4XAwy5KKDq0aCvI8cVdzY0rdLVOo4R+GO0tH+7GMtQ984N0ZuXZfqOF91eqM2vJVUI85jrclyOuh3C11wsSSnW4/TpqtLyQnUDkRlx5qxH6ZQg660OD0xT10npyuynDj/wCdjOrJ6d/x/wAFr+j/AG41QNkNtxUo0uSoqZ8g96nJfrsz8ErA+WOtIRA+mFfkih2PEtyE5u5NxOKTJUk5HqjGRcT/AKRS0jzGYwBSvACwAsAbdIq1Ro9Ui1SmvqjT4TqXoz6OBStBzBwB0osC62Ltsuj3GyAkVKMh1xsckO+y6j91wKGAK99Ny2WjDty5205PIccpshfilQ3zX4FLn44AqilSkqCknJSTmCO44AKdn3X6YjGJIWEVNtPtfygHvgeI7xi8tbnxFh/Ecj1Hp/gy1L+m/wAPY1598VOkSlw6lASXU8UPNLKUOJ+sArP+ONc72VN4kjdR6TTrx1U5be64Og+Kc6g0a5XKTQqTJq1WlIh06GguSJDhySlI/Mk8gBxJ5YAont2281XaPUupQ9cK1Ii84cLPJTyhwD7+XvfVTyT8eOAJv0LLR65dVXul5GbNKjiJFUf5eV7RHmltBH72ALXXVX41vW1VK7K/UUyK7KWPHdIKgn94jLAHMmoz5NQqEmfKVrky3VvvrPetxRUo/MnAFzuh7btuU+wpFTizY8uu1V3XUm2lpU5GaazSyy4n2k8yvj9bywAfcAV82m9EO16+4/U7UlGiVV0lxcZ3U7DcWrifFxsk94zH2cAZOjJsMrdiS61WbnjoarDp6jAShaXE9WGS3HUqTnwdVpAzyPZ88AH/AAAsALACwBSnpd7SPT96N2rCd1Uy3cxI08lzlj1n+qTkjyOrAA72W3MzTag5TZa9EWeRu3DyS8OAz8lDh+GNlORcdHu1TlofEvzJdfWz9NdX16EpLNTSNK0r4IdA5ZnuUPHGc4ZLXqPTPG80dp/mDd2w7ube3JpbxV3FOSk/1gcsatDOffTq6eNLJ1Ymzl6mSkVSraett/5tFSdQQT7yyOBV4AY2QgXXTulum9c+eyMV+SplyXBTbLoiesTH5CELSnkX1nShBPggElXh8seVJEbrV2m/DXbkvBYdn06zrSpluU8eop7IQpzkXHT2nXT5rWSrGooR/wAALAEK2w7Qo9hWDUa8ojroT1emNH35boIbGXeE8Vq8gcAc5ZMmRKkuyZDinZD61OPOrOalLWc1KJ7yScAY8ALACwBONjuzOdtDvWLRWtTdPb/SKtLH7KMg9rI/WX7KfM+AOAOh9IpNOo9Li0umsJiwITaWYzCBklKEDIDAG5gBYAWAAbtZ6VFp2g69SrfQmv15vNLmhWUNhXg46PbUPqo+ZGAKtXrtx2nXgtYqtaeahrP/ACfDJjRwPDQjir98nAEDwAsAIEg5jgRyOACJY233ahZy0IgVdyZARzp0/OSxl4J1HWj9xQwBanZP0nrMvZxml1L/ACFcLnZRGeVnHeV/MvHLie5Csj4Z4AM2AFgBYAZbxtKjXdbc636w1vYU5soV9ZCuaHEeCkKyUMAc5L7s2q2bddQtyqD9JguaQ6Bkl1s9pt1PktBB/LADNFlyokhEmK8uPIbObbzSihaT5KTkRgDESTzwAROj3SDVdstrx9OpLMrra/IRUKfzPzRgC/1w1+k2/RZlaqz4jU6A2XpLx7kjuA7yTwA7zgDnlta2nVXaJd0itzNTUNGbNLg55hiOD2U+GtXNZ7z5ZYAsvsM6ROy9VuUq0Jjf0akQmERmkyVBUR4+8rf8AlTiiVHeAcTzOAJvWejvsrrNy0+6GaeIkqPIbmOIhkJiytJ1jeNZFGRORJRln354Ai3S22lC3bJTbEJ3TVbjzQ7pPFEJH60/6Q9jzGrAAq6FP/SPWP8Awhf/AMyzgDb6Y9NlVHajbcGC0Xp02nNx2Gk81uLlOpQkfEnABPqewXZhbmyds10LgTaHT1uT7hp69zLU4oFboz5OpUtWlCFg9wGWBlCco8PBUSh3eujU2VFiRwXXl62pCjxT3dpPI5DEuhdeHFpLcq7vpqr1FKT2XYerObZnUOsSKo+d0+6gy3lHiUN9s5nz5Yk2q1Qk5d+Sv6k3TrU1TW6Twj6zKiVlyVWag1lQKSjdwYfJKld3Dx5flj1SVTM5fBHhCUJUEqUH/Oqcs+waysUCbW6Q0KO/GUlpxtHajvoKknQUKGWeeXLEG7sqN1S1SjhxJlGvVt66p6taku/KHNqu9ZhRvSFFTT0ksuLU4NEd1bGnQsuLOTeSdXqyMlHiTnjnK3SK9Lz5k47/ADWfb7t+3oXFO/o1HpTWoUqgt1+nMPml7iOHnFu1dvSlb0caw0W0qA/WKHErJIAz8cRYXToTa15eF5fR7Zz8vYkuGpcEUrdhVOAlEiI61UILyVOMPMrTmpKM9XYORJTl2tOeLS36nCe0sxkucmmVFr3NJy9rvcoDluu1iW5Q3FoWqnOOqW1qbOackqzyyPHIYsjUE7ZSywi00LR7br7hePfmMgP7OJFPg67o0V4GfdkNqtz31Gu15hL7rT6n93HhkZtFJVk2Ag8CCO/GtyeSprXdzGu1l5zsuwVZ1RTS6Q5OnlJMZrW/o4JU5lyT95XAY3ZOlqVfDhql2RC9mtKXPky7rqA1y5Lq0xSfd+uof3RjXTXcqOlUdbdeXLe37/Aw35tGlQ5jlKoywhxnsyZmWZC+9CM+HDvOE5mHUeqOMtFPtyyCtXjdLT++TVZOvPPtOFSf6pzT+WNWplOr6snnU/vCnYV8en23IsxKUVJhOo6eCXUcioDuI7xjfCeTo+ndQ8ZYl8a/EgG0i3GqNXdcZOiHOTvmkDklWeS0jyB4j441TjhlJ1W1VKpt8Mtx/sm7NrmziMxV6G86KTJSHnYK/XxVA/yrPNBI94ZHzx5pZHnY1YwU8eVll9mPSuse6d1AuDK3ayvJPrlZw3FH6j5y0fBzL4nGJEDghaFoStCgpChmlQ4gg8iDgAOdKDad9DrBXTYLuiuXCFxIuk9ptjL9Ie+SToHmrPuwBTizbqiUXesyI2pt9QK5CPbGXIZHgQMTbS5VPlclV1Lp8q+HF7rt2CAU0G4YP7OZHPePbQT+CknFr5KsfVHN5rW0+8X+/vMVdizWrddh0dnNwNhltAORDfJWnPmcseVotU8QMrWpF11Kq9s5+0D7zLrLim3UFtxPBSFDIj4jHPtYO2Uk1lcHqMyHn22S4loOLSjeuHJCdRy1KPHgO/GMnhZ5PSwzlnxKfQ6fHmvegpNAajq9OwZHWmERStT8iVGXH0utPzNSQkvo05AJBx8+V/KpVk4rxFVb8klperGIxkns4w/2vPcstGF6Y7/v1IJTdqQjS6lT7opan2ZUh18Td2hqew85HMZLzjWSI7y0Mq4BaB2iVA5nF7W6LqjGdCeHFJY5g1q1YT+KKb9HxsR1X5UkRK+Lgi1SpNRaW7JXQKY2mNSkylrWvQEgOOZKUrQXVgrKU8Byxa9OtZU4apqPizeZY/Be+Ftk01JZ44R0Q2eOIcsG2nGzmhVKhFJ8uroxYGsrL0340gXDa8og9WXEkNIPdrQ4lSvyWnAFZsALACwAsAX16KKJSdidH3+elT0ssZ/yfWF/+rPADF0zlIGymEkkalVePpHwYfzwBWymbOqRIpcZ5953rDqAtamlJKO1xyHA8uXPFvTsIOKb5OZr9ZqRqNJLCfc9M7PYLMhD0CrLbkNKzQrsKIUPgRgrBJ+WW55LrM2sTgmn8yWqgtvtt9cabkuoGRWUDLPvIBzyzxP0Z53KbxXF+RuK+ZYi3+kps5mxpaa3IVblVp7Zcl02dlqISM/0dxOaX8/dCe0fDHMtH0SrSlTlpls0VV247c6ztHq5ZYLkK14i/wBAp2fFZH7d/LgVnuHJI4DvJGsFuAL99GG0fo7sipanEaJdZKqnI4ccn8tz/wCSlGAI90xLu9E7NmaG0vTJuCSltQB49XjZOuf292PngCkuAN6jV2s0SoN1GjzXqfOa/VyI61NrHlmnLh4jAFidm/TJrELdQL7h+ko4yT6WiBLclI8XGey25+7p+eALOWff1oXjT+vW3U2ag1kN4hBydbz7nWlZLQfiMASDAEbvml3vOpifofWmKNUmiVZyoyZLLwy4IUT2m+PvJB+GAKt7QdqXSqsh5TVwvCLHUrJqosRIzkZf3Xg2Uj4KyPlgCDOdJ3bgsj/jKpGX1YsP/wD04A1V9I3bW5qCrqkDVz0tx0/hpbGWAGahWHcNzLXVJT24ZkrU6uZIzU46pRzUsJ5qzPecZxhksrTpdSss/DEkp2NQd3kKo7vPHdJ0/hqzxn4RZf6FH+5/cb7S73teMEvtpr9LaHBxslMltI8jmSB88e7r3N6dxbrf+ZBfeYhtgt7RmYkrX9XJv+OrDxUY/wCuUvSRHq/tZqcxpUels9QbVwL5Vrey8jwCcYOoQbnrU5bQWn8wx9DfZuZU+bf9RbJRFKodI197yx+kPDP6qToB81eGNZSFs8ALACwBSHpZ7S/pLfAtyC7qpFuZtK0nsuTVfrlf6P8AVjzCvHAAKwAsALACwBfjo07M0WXs8jyJTWmuV0Im1AkdpCFJzYYP3EKzI+sTgAt4AWAFgCo/SO6SEmXIlWbZcotwG82atV2Tkp5XJbLChybHJSh7XIcOYFZMALACwAsALACwAsAWi6OXSTktyIlm3tK3kdzJmk1p5XaQrkliQs80nklZ5cjw5AWxwAsALAFcumNs4RUrajXtCa/TqMRHqBSOK4bquyT/AETqvwUcAU5wAsAbVMqtSpU5mfTJTsKdHOpmSwtTbiD5KTkcATS+NuO0O9rdg0GvzUvRIa94tbaA0uQoDJBf05JVo45ZAc8zmcAFDoqbIrNuynV2q3M3GqQUOpRaYV+uaHBTkgpSQtBPBKFfewBtbS+hvVYW9qFhy/SMcZq9ESylEhI55NPcEOfBWk+ZwAdNiloPbP8AZXDi12SpEltpc+qF9wqRG1J1qbGZISlpCQDlwzzPfgCudOs64ukTtOrNxKkKp1rRHBHalrTqUhhH6lhpHAFxSe2vuSTn3gECw+y7YDZuzmqO1WiyZsibIjGI8qU42pJQVpXmEobRkc2xgDcq2zYVbbLS71nJQuDRKVuIDZOajNW84dZT4NtL4eZ8sAB3pg7QJEhynbNqLrelSlNyaoyzmpaio/osfSOJKldvL7uAGLZ90M61UYrc686kaQlwBQpkQJdkgH+UcVm2g+QCsAEZ3oa7MTDWwxUKuy4sAF0PtHPL6yd1keOGTzAK9rfR2ve17ZbRQlJrNvQlKdlLYQpEtI563me1qSnM5lBPwGWN8q+YKHCIkLRRqurnLf4AsrcgNwoFEoo66xBQmXMcZGtK1e1mrLu78Sq0sJQhuluyvtYZlKrV8rl5Vk369cMqHKj1hvOZR6tH0qhLV6sLAyUnvyIxsrV3FqfMJLgj2lnGcXSflqU5cketWr3NHqrMWjSnGFuqySyolTQHtEqQcxkNOZ4YpKnT6dw9Morc6GpdeDBzb2RLKdX95X5aqtMTT3Y6m46OqoHVg4E6XJLrys/WkJ4nmrl3ZYqb3pkqMdEI60s5f5RXt+Rvt7uNRKXGpbEdpVNcvraLCpsRrcJrE1thtACc22SoAqOkAEobGZOWLW2o+HTUXu0YzlllgKr0ebzsF2RJtRSrntx07x2m9luoM5e82OCHjlzyyJ8MSozwWHT+oOg8PeLI7Gl0eqOhSUpXMgrObLyNEmO4OBCkLyWgjG5NM6elWpVvNHDx96IDtcuHUtmhMK4IyfmZfWP6tHyHHGuo+xTdbueKa+bJfYwSizaYWee4Ur9/Uo/xxsjwWvT9reOPQBL63HHnFu8XFqKlk89RPHEY4uTy9zHgeEo2ab/6ZQd1y9Zvfubs554zp8lj0rP0iOPf8iXbYi0mJSXCkKcS85kk8inJJIPlnjOqWnXPhh82bls7UKTUFNRJ7XUJasm0FOamVHkAO9PwP449jUN1p1eE/LLyv8DNeNj2xIgyqk4n0c8whTjj7IGk5fWb5Ek8OGWEoIyvun0XFzfla9P0I9s129bQbBU2xAmdeoyfapEzNxjL+aOepo/dOXiDjQckbF2bQjtN2mpr1ZKYEBpCG4FPcc1JQhvilrXkkEqcJUo5DEi1jFzWrgg9RnONF6FlmzXbGpFT1PNDqctXHeNjsKP2kcvmMWtayjPjZnO2vValLZ+aJBZtHuO2pO/SVtgHsy2Tmg/H/crFZOlUovP4nQUrmhdRxz7P9/kSSh7SG16Waw3oPLrTQ4fvI7vliXR6h/f95V3XRGt6X3MerjatudRXajLCJDLaM2pDRGvV7qQseJ7jiTcKnKGp7kCydenVUI7N9n+gwbN7cuwSGbkg2wzcdJ3i4bsSTulodVpBWhKVHVrCTwISccL1e7oYdGVV0Z4zlZ2/6O6owlzjKCDJlPLuujspt5IpVuqE6U23CcTUqey/rCW3o5WtLzTLuT3qk6cuOSc8sUEILwJvxPPV8q8y0TaxupY2bXl82/zJWfMttl96IldlUgxbCk0eo1SnV2rTJomRpkFa5EhThUS9LlPuAFJU1paS18yMWtjRlK6VSEJ0oRjhqWEvaMUvfMnI0Ta0YeGwXY6Yil+ei/drNwbIqWzqzl0XVTZSM+I3RzaPwLSk4AzdI3ZhIv3Z+4zTka65SV9dpqO9zIZOsD76eX2gMAUCdacacW06gtutkpcQoZKSocCCDxBGAPOAFgB2tS16xdNwwaDR2S/PnuBtpPcke8tR7koTmpR8MAdJbPtqFbFr0y34XGNTI6I6Fd6ikdpZ81qzUcAV46XkqZX5tJtSmFClUxCqlOCjl6x71bDfhq0JWrj3EY30beVTOOxEur2FDGruVwpFerdsS+qymV9XJ9ZEc4fvNnuPw4HG2lXnReHx6Ea5tKV3HVFrPr+pJ6jQqLdMP0jSXUszfeVyzV9V5I5H7X8cTalGFdao8/vkqqN3VtJaKm8f3wQZ9FXp0hyJIW8w6jmjWofMZHiMVU9cHh5R0VPw6q1Rw0Efa7RW3qWxV0J9fFUGnVeLa+Wf3VfxxlUR13W7fMFPuvyBlSKPUKvOTCgN72QoKUE5gDJIzOZPAY1JZOdoUJVZaY8jpbdm1OqXpSrYkMrjSahMaiqCxpKUuLAUrjzyTmceNGNSnKDxJYZ0siRWIkVmLHToYjoS00gcghA0pHyAwMCkHS5u703tSVSmV6otvx0RBly37nrXj8e0lJ+7gAMQYE6oS24cGO5KlvHS1HZQpxxR8EpTmTgAt2z0Udr9abS8/CYozK+INQe0Ly/omg6sHyUBgCWK6Et7hrNNwU0ufV0vgf1tH+GAIrVOj1t1sWUKxSo7j7kXtJnUR8rdSBx9gbt4jx7OAJns76YdwUtxNLv+Cag02d2uox0hqYjLgd6ydKF5eWk/HAFmrN2g2decDrtt1Rme2Bm60k6Xm/JxpWS0fMYAfZUSLMjORpbKJEZ4aXWHUhaFJPcpKswRgACbR+iDZtd3k203fo9Ulceq5FyCs/c9tr905fZwBWOn7Np8e/pltVUtOehnCKmuOveNnR7iV8PaPDxHHwxlGOWT+nWvjVMP4Vuye3ld8a2YLaGW0uTXRlFjckJQnhqUB7o5AY3Slg6O/vVbx2+J8IG//CheO+3nWkFOf6rdN6Phyz/PGrxGUH+r188/gTuzdo0atvJgzGxFqKv1ZT+rc8k58Uq8sbIzyXVj1RVXpltL8GR/apabEbTXILe7Q6vRNbTwSFq9lwDu1cj54xqR7kHrFko/zI9+f1IXbFu1K5Lhp9BpqNc6pPojsjuBUeKlfZSO0fLGooDpPZ1rU61bYptvU4ZRKawllKuRWocVuK81qJUfM4AecALAEC227RW7C2fT6yhQ9JOjqlJbPvSnQdJy7w2AVn4YA51uuuuurddUVuuEqWtRzJUeJJPicAecALACwAQdg1jJvPafSKW+jXT2F9eqI7txH7RSfJatKPngDolgBYAWAAL0qtr7lqW4m16O9u69XGzv3UHJceFxSpQPcp05pT5ZnwwBSbACwAsALACwAsALACwAsAXj6LO1p28bSXQqs9vK/QEpQXFe2/EPBp0+KkZaF/I8zgA4YAWANGu0aFW6LOo85GuHUGHI0hP2HUlJ/jgDmXcdEl0Gv1GizBlKpsl2K795pZTn8DlngBuwAsALAG5SKzVqNPaqFJmPQJzJzakx1qbWPmnLAFjtmnTIqcTdU+/YnXmBkkVeGkJfHm6zwQv4p0/A4Af+krt4tyfs7i0e0Ko1ONyZiY8ye01EbyK0LSclIU4rJOSh7OeACL0YafAh7FaAqJlnL38iUse88p9aVZ+YCAn5YArfJ2ydICJtUkU9E+S3WJE/qrVAfQFRu25pbaS0oZBGRGS08SOOffgC5Fw3Kxa9oS6/XVoypkXfTC1mlK3Up9lsKzPbc7KQfHAAO6M1oP3NVKvtguZsP1erSnU0gK4paQDpccRn4fqkeASfHAGr0gOk7UberEi07KLaZ8TsVOrrSHN073ssIV2dSfeUrPjwy4YAAUbb3tijzhMRdc9TueehxYca/wBUsFvL5YAtT0e+kCNobTtErbbca6Ibe9za7LUpkZAuISc9K0k9pPzHeAAFOkpYv/B1f8e47ebEel19LjnVwn1SJCSN+3p+ovUlYHxy5Y2Uqrg8o0XFvGrHTLgj8u174hwLfuWu271W0HUdbZfio3jTe+B0OPpTqLefBQzGXHEuF0nKOpJRRW1enOFOeht1Jev5GvMqcmnUuVVZTkWU+pRbpD8dIzIc5cR4eHlibOo4Rcnhv6pVU6EatRU46kuZp+xHa6s0O2mKPn/lCo/pNRV35Hkk/P8AgcQ638uno+tLdlnaL6RXdX6kNohQ6Gto+kr/AJ1xOozj0KLpaVlw6xLzQn8Gw5ivLsuHW6tEo9HnVaYrTFp7Dkl9X2GklZ/IYA5nVO46pULim19b626jNkuy3HkKIUFurKzkfngZQm4vK2Zoy5kmZKclSnC7IeVqccVzJOAnNyeXu2FbZJXm36W5R1q/SYii4yk+80s5nL7qv44302dL0W5zDw+6/IYL82f1GNPeqNLZVIgvqLi22xmtpSuKhp5lOfIjGE4ELqPTJRk5wWYv8CFx6bUZD4YYjOuvE5aEoUTjXgqI0pSeEnkLuzuyXqI0udPGVSkp0BoZHdN88sx7yu/G+EcHU9LsHRWqXxP8CFbT7gaqldTHjq1xaeC0FjkpwnNwj+HyxrqMqOr3KqVMLiJt7KLe65VF1V9OceB+p8C+eX9Ucfwx7TRt6Na6p63xH8x32rVt1wxrdh5uPPEOyUI4k5/qm8h4nj+GMqj7ErrNw3ilHl8/4NGibIZjzaXavK6pq/6s0AtwfeV7IP448VI02/RJNZm8ew8u7H7fLeTcuShf1joUPwyH8cZeGiW+h0vVjRLg3jZiN4lYqlFTz59geY9pv8xjdTuJ0vdHL9W/hlfF/wD3L/KHmjXZRayjdJUGn1jJUR7Lj8O5WLKldQqfP0OJuen1aG/K9V+9htrmzunS9TtOPUpH8nzaJ+HNPyxprWMZfDsyVa9ZnDafmX4kMpltVyoXEza0XjOlSEsboL9Vr+uojMZITmSe4Yor2uranKVTaMeTqKDjWxKPfgkVpV+v2BdD1JnwXJDS3t3IppbO83yc0sSoodTml5BObStPHlinvrWlf0FUjJJ42lnbHeMsP4X9ZEuEnTlgn9m0236Yx1NxqOi+IHr5cuWFrqEV3LWrOOX0NyG0JPNlzeAc2888UPUK1Wo9Sz9GlskvgkuOdOYt/wC5afSRIppL/kB68rkm3FcEqpzTHW+s6C9EZEdtwI4BzQAk5q55q4+OOusLSNvSUI5x7vLXsQpyyxkxMMAr9Hba5/we3jpqCz9HKvpYqg4ndEH1UgD+bKjq+yT5YAvxHkMSY7ciO4l6O8kOMvNkKQtChmlSVDgQRyOABBte6NFp34+7V4LnoS5HOLktpOpl9Xi+1w7X20nPxzwBW2vdFXbLS5CkR6U1VWc8kyIT7RB/ddLSx/VwBsWx0TdrtXkIFQhs0OLn235byFKA+y0yXFE/HL44AtRsj2IWns2hKMDOdWpCdMyrvABxSeehtIzDaM+4cT3k4Ak97XlRrOtuZX6u5ojRU9hoe286f1bLY71rPAfjywBz5rm0y66ldtTuGU7lKqL5dfiq4tJA7KGwDxAbQAkd/DG+lXnT4IlzZ066833j3CvK3K4yIdYYSytXDJ3tNZ/ZXzR/744sYXdOptNFDV6ZXoPVSeflz93cbK9R5FqPtVaivqEZxWhbau0BnxAP1knLGmtSdF64PYl2lzG7Tp1Vuv39jJbZdpQLhiPV+5KVUp7tRVrhN05pC0Nx2ypsElx1r2loUAOPLPvxxPXOtVfGxTnTjjnU+/otnwsfedHYWUKdNRw2b+0lxCLMn6vf3SEfe3iT/AY6yfB1vVX/AOPL7PzGvZRb3VKWurPJ/SJ/ZZ8Qyk/+tWPKaI3RrXTDW+ZfkSNS7auNt2NrZmmMopWkHJ1pSTlmk8Fp48lDGWzJ78G4TjtLA407bttB2Yyo8apOqum1n+ywJiyJjOnmgSciVZDlrB+WNM44OZ6jYeBLbeLBfZFiXVth2gTTH9X1uQ5OrFSWCpuOh5wqJ81E5hCM+PwBIwK0u/s52UWZYFMREoUJIlFOUqpugKlPnvK3O4fZTkB4YAmBIAJPADmcAardWpTju5bmMLe/k0uIKvwzzwBt4AHO1XYVZW0OG4qXHTAruX6PWo6QHgRyDo4B1Hkrj4EYApDddsXtsuvJUF916m1WId5DqERamw60T2XWXE5EpVl/gcAGPZv0yK7Tt1AviJ6WiDJPpSMEtykjxW3wbd+Wk/HABsufpB2Ixs1qd2W9VWJ8lloNxIeel4Snuy0lxlWSwAe0eHIHLAFbNmqYy6O9MMtMyq1B1UmpL1anAtROQX358ST5nG+nwdZ0eEFS2acnyNd97PqtV6g7VYUlL7ikpSIbnYKUpHJCuR+eWPJwyaOo9MnVlri8+wMJ1PmwJBjzGFx3k823AUn88acHO1KcoPElhnukpkqqcQRs+sF5sM5c9WoZY9R7RzrWOchq2jqaTZ1R3uXa3aUff3icssSJ8HX9Ua8CWf3uTToabNOMy/6gz9aDRNQ+Uh4f7MH72IxxharACwAsAUW6VW0r6V3+qjwXddGtzXFbyPZclZ/pDnyICB93zwAFcALACwAsAWy6ElrpRT7huhxHbedbpsZfglsb57L4lbf4YAtDgBYAwT50WBBkTpbgaixGlvyHTyS22nUpR+AGAObG0a9Z16XpVLjlkjrrxMdo/smE9llv91AHzwBGsALACwAsALACwAsALACwBPdht7Ls7adRaqXNEJ14Q6j4GNJOhZP3Dkv5YA6LYAWAFgCi/S5tpNI2tvTmkaWa3FZmcOW8Tmw5882sz8cABTACwAsAE/o8bNfp1tEiMSm9VFpWU6qfVUhCvVsn+lXkD9nPAFttpXR52eX0lyQ/E9F1pQ7NVggIWT/Ot+w78xn54AqhtL6N+0SyN7LEf01REcfSUFJVoT4vM8Vt/HinzwA+9HvpEfQBCrduBpcm2H3S60812nYji/aIT77auZTzB4jwwBbmkL2e3kun3XTOoVh+Fn1GqNhC3WSpJSpOr20HJR7KsAV26ZW0veyIdgQHOwxpnVkpPNZH6Oyfgk7wjzTgA37HUog7EraVCSFFFIbfSkd7q294r/zCcAc85suTMmPy5Sy5JkOKdfcVzUtZ1KJ8yTgDDgAi9HiRMZ2z2sYhUFrlFtzT3tLbUHAfLRngCx/TKENFgUSW80h5cestFDK88lpLLpWg5ZKyVpGeRwA4bLulBs+uxEejVVpNu1RaUsNxHyFQ3c8kBDTuQAz5BKwPDjgD7tT6OmzydEk3HT3EWtMp4VOeebRqgHdDWpbsXgkcBzby+eMozaZrqU1JNPusFJ6xU5FTqD0yQQVuHuz0gDgAM+QxlVqObyzG3oRpQUI8IvB0ULR9A7Jos11GmXXnlz3M+e7/AFbI+GhGofexrNxi6W13eg9lTtNZXpl199EJIHPcp9a8fhkgJP3sAUXwAcOj70eJt8Smq/cLS41osqzQnihc5ST7DZ4ENgjtr+Q48QBaS6tiGz64GI2mnJpNQgIS3T6nTQmO+ylAyQngNDiAOGlYIywM6dSUJao7NFa7wuimWbelRtSqyFSXaapCfSTDelC9baXBqazJQoBeRyJGeNyqnR2/W4tfzFh+qNJzaVZraNYnlefuoac1H8UjGWtEx9Vt19b8GQy6dqkicwuHRm1RGF9lySs+uUO8JA4Iz+OeNcqhU3nWHNaaey9e5AmWnHnUNNpK3HFBKEjmVKOQGNZSJZeEHqlQ4VqWslDxAbhtF2Wse84eKvxPZGJK2R2tGEbajv8AVW4xbO6Yue/Ku2oJ1zJzixEz9xAORKf7o8hjGC7kPpdLW3Xl8UnsN977SpMWY7TKIpKFMnQ/NyCjrHNLYPDh44xlU9CP1DqrjLRT7d/0IdHvy72Xg6Ko8vI56HDrQf3VZjGGtlVHqNdP4mFSyrwYuWC62+2lE1kZSmOaFoVw1JB7jyIxujLJ0thfK4jv8S5BffdvpoVwOMscIjw38XySo8U/ukZY1TWGc51G18KrhfC90e6Tf1bgMllxQlt6SGi77SDlwOrmQPA4k0r6cVjk5y46RSqPK8vyJDs1NLZiTayutQ4lcU8Yz0apAutOQnkeu9Qhtx59bquxk2UkePHHKdZdSc1DRKUMasx51523ylHHO+cl5bpRWzS7fYTaY7Lh3bS46FpYg2+/GlMR6m6oMKfW2HUQ4U2S3vYiiy5q3EhzsqHlijpxjO3m+ZVVJNxW+M41ShF4nusaoLdEjiS9iD3ZBt+0qdWaQ2qdMrNaLX/KUMRVRY7b2/16yt3fOOKQE62+yRnxOeLuxqVbqcKnkjTp5+GWdTxj0WEvR78GiolBNb5YxXJsyvu3KZDqtYo0iNTZ7Lb8eZp1taXRqSFqTmG1ZH2V5HHQEYi+AFgAz7FeknX7AS3R6qhdXtcHsxtXr42fMx1K4FP82rh4EYAt/ZO1awb1jpct+rsyHiM1wVndSkeSmV5K+YzHngCW4A+EgDM8AOZwAONoXSA2bWUy6iVUkVGqo4IpUBQee1eCyOw156j8jgCn1/7b7jvm7I1XrDQFLp6yqn0RtZ3TX2ycu254qI/AY2UZ6ZJ8mi5pOpTcU8ZM4XZ92oyVkicR35NyB8+S/wA8W+aNf5/ic1i6s/8Ah96/6I9Udm1XZfAhLRJYUfaUd2pP3gf8MRJ9PmntuWVHrdNrzeV/eSGq09h5qh2o48clrZ69JSM9zHQdKnT3JGauBVwxq6xcfR7fC3klt7+hq6PTda4lV4j+o9mt3JAb/wCQ6hCcUtTbdLpMiQwpmMwEtMLkIbS+gqWElIWEoK9JJz544JW1Gf8A+SEv904xeW93py09vTLxnsddrkuz+waLvmC57kg2vBXqjMOb2oPI4jMe1x+wnP5nHcS3eC2van0irGjHhc/v2JzMiPeinYlNUmM7ud1FWfZb4aRy8BjYXM4PRphs8bA1tSwrrpt0xZL6AzGjr1OyEuApWnvSMuJ1eYxqjB5Oesum1qdZN7Jdx52uOpXTKdT2xvJkmTqZaTxUQBp4fErAxlVJXXJrw0u+S3exfZrE2f2LCpCUJ9JvJEisPjmuUsdoZ/Vb9hPkPPGg5gxbZNsFE2aW8JspPW6tM1IpVNByLq0+0tZ91tGY1H5YApDfe2PaHe0pbtaqzvVFE7umx1FmKgeAaSe1l4rzPngCFpUpKgpJ0qHEEc8AE/Zx0ido1lSGmxOXWKMng5S5y1OJ0/zThzW0fDLh5HAF29nO0W3b/ttqu0Rw7sndyormW9YeAzU24B38cweRGAIr0h9lse+7Ck9XaBr9ISuXSXAO0opGbjHwdSMvvZYA5/d+AHe27efrk1Udte6Q2grcey1Adw4cOZxvt6DqPBDvbxUIanuO7ljXVTHxJp6w4tHsOx3NDn4HScbp2NRcbmi365SznLg/36D5StpdcpikxrkhLWgcOsaN278wckr/ACxpblH4kdXZfxBn4sTXquSasyrVuyFoSWag0ObSxk6j5HJafiMZbMv4zo3Me0l+I10jZvSaVX0VSO6tbTQUWoznHS4eAVr7wBnzGPFTwyNR6VCnV1rj0NW74tQu27aLYlI7UqY+gvnmElfJSsu5tvUtXljCqyD1u43VNdt2Xete3abbdvU+g0xGiDTmUsMjvISOKlfaUc1HzxqOfHTACwAw339KPohVk2q2hy4Vx1opocWGwHVdnVqPDUkHUnPhnzwBzeuO3Lit+qOU+vwX4FQT2ltSUlKjn7wJ9oH6wORwA14AWAFgBYAv10W6Smn7FaIrLJc5UiW5+++pKf7CBgAs4AWAA70rLpXQtkU2OyvRIrbzdOT46F5uO/i22U/PAFDsALACwAsALACwAsALACwAsALAHSzZjXVV7Z5blXWdTsynx1vH+dDYS5/bBwBJ8ALAFWenBS0mPalVA7SVS4qz5ENrT/BWAKpYAWAFgC/vRu2a/QjZ3GMtrRW61pnVLMdpGoepZP8ARoPEfWJwAVsALAAl2mdGnZ5eu9mMseg64vj6QhJAQtXi8xwQvzIyV54ArNcezHbPsYqqq3THnkwmzwrVNJUwpPhJb90eTidPmcAC6vVyp16szKzVXjIqM91T8l48M1rOfADgB3ADkMAXR6I99Ra5s4Tbzjg9J26tTKmj7SozqitlfwBKkfLzwAAtv+wuu2Xcc6r02G5JtKa6p+PKaTqEbWdSmXsvYCT7KjwI7888AB5ttbi0ttpK3FnJKUjMknkABgC3HRV2GVWhyVXxc8VUSa40WqNAdGl1tDgycfcSeKCpPZSDxyJz7sARXpl7QI1TuGnWfBdDjdFCpFRKeI608AEN/FtvifvYAY+ibs0FzXwbins66Rbml1Godlyar9Snz3eW8Pnl44AJ/TF2l+jaBGseA9lNq+Uip6eaYaFdhB/pXE/gnzwBU626HKr1w02iRBnJqUlqK18XVhOfyzzwB03pVNi0ulxKbEToiwWW47CPBtpIQkfgMAUz6Y93elNosWgNLzj0CKA4nPh1iVk6v/y92MAYujz0dZF6OtXLcza49qtKzjscUrnKSeIHeGQeCld/Id5AF1osWNEjNRYrSWIzCQ2yy2AlCEJGSUpSOAAGAMuAOa+1ir+l9plz1DPNL1Sk7s/YQ4UI/spGAIpgAgVjYPtQpVrw7mforjlMltB9QZ9Y8whXs79kdtGY48sh35HAHjZNQBLqrlWdGbUDg0PF5XI/ujj8cbKaLrottqnrfEfzHHa7cGQYoTCuPB+Zl/5aP/V+GPaj7EjrdzxTXzf+CXW6SxZMJbHtIga0ZfW0FX97GxcFra7W6x/aARSlKJUo5qPEnzxGOIZ8wBMdlKnRdzYR7BZe3v3dOY/tZYzp8lr0bPj/AGMe9syUa6Sr9pk8P3c0/wCOMqpM68vg+0bLe2U1SoMok1F30eyvihop1PEeaeAT88eKmR7bo05rM/KvxHuRseYQEuU6qONyUEKQp1Iy1DvBRkU49lRTJc+hL6st/cwor142sxHp1chsyaciWuSKyuMie+2ZBTv1sl8lkuKCBkXU5+eKS86LGUnOOU9OMJuMXjOM43x8itrUatDaa29eR12YW0xtX20oPV+r25EWZ78FSsw3DZUClhI4JAdcUNSUAAajliVYWroUVBvMu79X+/XcgVJ6nkvY9GjvsKjvNIdjuJ0LZWkKQpJ7ik8CMTDABm0bokWJcO9mW2o25VF9rQ0NcJavNn3P3CB5YAq3tB2M7QLDeV6cpyjAzybqkbN2Krw9YB2CfBYBwBB8AfUOLbWFtqKFpOaVJ4EHyOAJTTtq20ymthuFdNUZaTwS2JbxSPgkqIGACbK2T9IO6rAp91GsTa2xUG1PehXZj2/DJPq1pbcVu1hxPayHHLLgcABGXTahCnLgTIzkWa2rQ5GeSptxKvBSVZEYHjeCd1VuiWxRDTdxv6jPZUhxwZasyMs8+OSQrkBi2qKFGGnGZSRzdvKrd1decQgxho9hV2clLywITZ4oU7mFHzCRx/HEWlYzl7Fjc9Xo09vifsb1VqF6W0ERnZYfYcHqJBAc5cxmsagR5421J1qO2coj29G1uvMo4a5XA/7M1utMyrkfdkre36UVGc0lmW2zEHaUZbKtTjadYStLgQfZyBTzxxfXajqz8N4eVsnlNy/2vh7ZWM9+50lpTjTjtsjfgSL/AKVPmmgVelW+mWGHnKSpaGVNNloCPqElC81KayJyWo/WOeItSNpVivGhUq6crVu8vPm+Frv7L22Nq1rhpHzZVb/U6UuqOp/SKgcmc+5lJ4f11cfwx2lNF70a20w1vmX5Dvb9xmr1+tMNKBhQNy0xl3q7e8V8yOGMlLLJVtdeLVml8Mcf5yNl0bSmqHUn6cIBffaCSlwuaUHUnVyyJ78Yyngj3nVVRm4actGnsUTKvjbnby6pk4hl5UstZerSmI2p5CQPDWkfHGlvJzVxcSrS1SL9Y8NBzy6QN7yLu2pViUXCqDT3VU6nI90MxlFGY++vUv54AHOAFgBYAMfRYvuTbe1CHTFOEUu4v0GS17u+PGOvL6wc7PwUcAXwwBzf2y261bu1G5aSynRHZmrcjo7ktP8ArkAeQS4BgCN0WszKRORLjHiODjZ9lae9Jxto1XB5RHubaNaGmQUTVJdUo6ajQHEl5PtRXQFaj3tq5EK8D34u/Ec4aofccl4EaVXRWW3qvzGGPtKYXnHqtOIyOlwIyUM+/Ntf+/ESPUFxNFjPojW9OX7+aNim25R6jTKpdReegpacBhx6alPWWGEnSZS2c0lbZJzOkjLI9ruPK9R6rNXSp0opJ+uyb/tz2f68HS2FCVOktUnrXfuOibjuu3Yina2lmqRWShL5aWlE2PvhqY6y17u8T48uROeJdr1WFWWnffj0eOcPvgvqPValP+p5l+IXeiLY70tdV2l1YBcuoOORKXnx0oB9e4PDM5Np8gfHEplJVqOcnJ8ssxgaxYAWAFgBluuy7Wuymqp1xU1moxTnpDqe2gn3m1jJaD5pIwBWHaZ0NqlF31QsKX15gZq9Dy1BL48mnuCF+QVl8TgCuNXotXos92nVaG9AnMnJ2NIQptY+SsuHngDSwAsAdGthraG9kFopSMgaawr5qTqP5nAE5wAsAVa6cU9Qi2nTxnpWuZIUO7NAaQP75wBVHACwAsALACwAsALACwAsALACwB0H6NalK2I2uSc/Uvj8JToGACZgBYArt02WgbAobvDNFWCPPtRnT/6cAU1wAsAFjo17NfprtEjuTGd5Q6Jpm1HUOytST6hk/fWMyPqg4Av3gBYAWAFgD4tCVoKFgKSoZKSeIIPccAAfav0ULSuYPVK1t3b9cVmosoT+gvK+02n9UT4o4fZOAKxMf8JWxe+mpDjC6XVo+YCXBrjSmCclDMdl1pWXceB8CMAWqsPpWbNLkiIZrr30dqZTk+xLzVGUe/Q+Bpy++E4AlSL32EUtZqbFWt2M9zMlhcQO8fNvt4AFO1bpf0WNCepmz8Km1BwFHpp5BQw13amm1gKcV4agE/HAFTSqo1Wp5qLkyoz3uJOa3XXnVePNSlKOAOhOzq1aPsp2VtR5ziWk0+OuoVyV9Z8p1vHz05aE+IAwBQ7aDedQvS8Knck7g5PdKmmuYaZT2Wmh9xAAwAU+iBaHpnacqsPI1RbfjKfBPLrD/qmh+BWofDAF2Js2NBhSJkpe7jRW1vPuHklDadSj8gMAVL2T7E5+0+7p20m82VM27PmOzIkBeYXM1LJQPJhI4Z+9lkOHHAFt2WWWGUMsoS0y0kIbbQAlKUpGQSAOAAGABrQNs8C6tq7tnW1olUukxHpFXqo7SVupUhpLTBHDSlTnaX3nlw4kAg1uopplGn1FfsQozshXwaQV/wCGAOXj7zj7zjzh1OOKK1nxKjmcAHzot7E/pTV03fXWM7epbv6Gw4OzLlI48jzbaPFXieHjgC6SlpQkqWQlKRmpR4AAd5wBTSssxdrm3dUDZ2hmhQYjbhm1+K3lvw17clxCSlKwpZCEeOeZ8iZsp1ZQeYvDIHtY2NbTLRqEmpV+KZ8F1eo1uJm5HOfLXkAWvgoDywbPKtRzlqlyx82WV1qdb4p61fpNP7JQe9lRzSflmU4303sdT0e410tPeP5EJvWw6jSprsqGyp+lOKK0LQNRaz46Fgcsu441yhgp7/p0qcm4rMPyIrGhy5TwZjMreeVwDaElR/AYwK2MHJ4Sywx7OrNdocVyVNA9JSgAW+e6b56c/EnniRCODq+l2LorMvjf4ChsRblu56qKyeptEyjQ8+KXJHtLX5hPd8sOWewiriu58xp7L5mK/doCqIv0fTwldSUAp1xXaS0Dy4d6jjyc8GHUupeD5Y/F+RCoG1K6472p95ExontNOoSPwKAkjGvxGVFPrFeL3eoLFAqya5RWZyopZbkggsOZKBAOXzSTyzGN6eTprat41PVjGSDsUCLPu+TMt6cu30QJLMFiXDS4pRmOhatfYUjctJDSitefADgDim6l1DwHhR1PDfONlj73usI5i8p05VXo2S2+0J1odJ/aFaSI0baDSnatSHuEWrpRuJKkD3slBKHezkQFBKuOZON1C7p1dotNrlehXyg0WLsXahY98RN/blTblOAZvQ1erkt/fZVkr5jh54kmBJ3mWX2VsvtpdZcBS42sBSVJPMEHgRgAIbR+iZYVyB2Zb3/FuqqzOTCdUNZ+0xw0f6Mj4HAFWdoexXaDYbqlVqnFdPzyRVYubsVXhmsDNBPgsA4Ax7HNnz1+bQKbQcj1LV1ipuD3IrXFzj3FXBA8yMAdGWGGY7DbDCA2w0kNtNpGSUpSMgAPADAFIelXfrNx7S00umIQti2wYxfQkFbkrMKezUBqKWyAgDuIPjj1HksY34It/wAIdCW03IlQlmotDLRoSdKjz0rVxAz8sW/0+HLXmOZ/0asnpjJaH++BoeuW7LjkGPS0KYaGWaGDkQD3uOcP8MR3cVarxHYmxsbe2Wam79/8IeruYMtNForylvSlLS7McZQXFpabRk67pHHlqV8sedXr+HS3xq9/Xt97NHQ6WqrKS2j+3+A/y6zFbhU2iOTIcCHDfeVTkOzFS2XYbADrQdWwvsokq7CkuDkTpSCOPz6nbycpVUpSlJLV5dLUns8ZXMedvtbOvcuxqXbtDqNvTWoVBc3e8ZbfkNqKJLCA62lSEMb9reIHtLUFJBzVyyyxvsOkwuIuVXs2l2ezec4eH6LGeDGrWcXsa07ajSFW0+mAhUWpaNwzFI4I1dnWlQ4ZJHLHY+JsXNTq8PBenaXGDU2MKO+qye4pZP5rwpGroPM/sGDaiki8ZPm20f7AxhU5IXV/67+wmvRNebb21UtKjkXY8tCPjuFK/gnGBWF8sAcw7xgSafdtagyQUyIs6S06Dz1IdUDgBowAsALAEm2YRpMnaPa7EX9euqw9GXk+k5/IDAHS3AFFtvEWnVbpF1uPIdSI2cVLmZ06lIhtDdg+JPDG+2gpTSfBEvq0qdJyjz+9xnmWJaLTanXtcZoe0ve5AfNWeLSdlSXt9pztPq1y3hYk/l+hkoFDolMkqfp1V1IWMnWFONKQrw5ZHMeOMqFGEHmMvyMbu6q1Y4nD7cMbbwttup1unMUpsvVmpr0CK0UjegD2s1EJCu7jzxXdYqUqMfEk8epZ9CnUlmHMVx+hNlUltTUSix4H6AFdZ9ElKlPswNBC3pHrHdWbyms1xVArRrzGWQx868d5dRy83Grs5ei2XbO01s9O51mnt+/38iF3zVaxUV021A8y5ObyTUWYzam2Q82pYZSFOpS7khpfaT7APIZ54vui2MXN1Ip+b4cvfDxl7bc9+SHd3ChDMuFyNluXftG2a1TfUmY/TipWbjHtxX8vrIOba/jzHli/qUpQ5IlC5hVWYPJZjZp0wLYrG6gXmx6DqKuz19vNcJZ8TzW188x541m8sFDmw50VuXCfbkxXhqZkMqC21p8UqTmCMAZsALACwAsARy9Nntn3pT+o3JTGpzYHqniNLzXm06nJaPkcAVd2l9Du4KXvahZEg1iCO16MfKUTEDwQrstu/wBk+RwBXR1l1l1bLqSh1tRQ4hXAhSTkQfhgDolsFkpk7HbScTyEBtv5tEtn804An2AFgCq/Tihr3dozfcSZrJ+J3Kh/DAFVMALACwAsALACwAsALACwAsALAHRjYVSnKVshtWI4nS51Bt9ST3GQS/8A/tMATvACwBW3puy0ptG24nvOz3HR8GmdJ/2uAKfYAQBJyHE+GAOg3R72aixdncSNJb0Vmp5Tqrn7SXHE9hr/AESMhl454AJuAFgBYAWAFgBYAYL1sW2L0orlHuGEmXFVxbVydaXlkHGl80KH/wCeGAKJ7aNile2a1kJcKptAlqPo2qBOQPfuncuCXUj5K5jvAAG+AFgA/wDRE2aKrt4OXdOazpdv/wCa6uTk5Y7GXjuk9vyOnAE66ZO0nqlLiWHAd9fP0zKvpPKOhXqWj99adR+6PHAFRsAXf6IFo+htmKqw8jTKuCSqQCefV2fVND8QtQ+OADTVqVBq1OkU2oNb+DLQWpLBJAW2r2kKyy7KhwI7xgDOhDEdlKEJS0w0nJCU5JSlKRwAHIADAFSOkZ0k/SokWdZUkimcWqtWGjkX+5TLCh+y+sr3uQ7PMDd6D9IzlXVWFD2ERYjavvFbix/ZTgA3bfKt6K2PXVJB0qXCVGSfOUoMf/tMAUl2O7LantGu9mkR9TNOZyeq04D9Sxn3d2tfsoHjx5A4A6GUOi0yh0iJSKWwmNT4LSWYzCOSUp/iTzJ7zgCufSv22+j4zuz+35H6dJR/l+Sg8WmVDMRgfrODivwTw7+AGbobLsOHbkxLNTYXeNSeJmQlnQ8hhrg0hsKy3g4lZKM+eR5YAsktCFoU2tIUhQ0qSRmCDzBGAA7evRotSpT1Vy03PovcAzVqYTqhO580uxuAAV36Mvgcep4NtGtKnLVHkE1zxrjstei8aY5BZz0Iq8UKk09092TiRrbJ+q4kHG5VDpbfrVOXx+V/gMDl/wBlx0FxNQbOfMNNrKj/AGR+ePdaJL6lbr6xCLs2pPT2HINHQqNHcGl2Sv8AWqHeEgeyD+OMJVCoverua009l69yZ7M2EN2fB0/tVOOL+O8Kf4JxnT4LbpMcUI++fzAzWpb0yrTJTxzceeWpWfx5fLGhnJV5uU236mW3aK7WaxGp7fDeq9Yv6rY4rV8hglkztaDq1FH1DNd1YYty2VmKA25pEWntjuVlkD+6njiRJ4R1l9XVCjt8kMFp0qgyqKFwq8umqYjOR6qwyA3KkOujeure1KzUy2MwlOkg6DxBXjjb+tVhVxOnrzLMc8LGyx/ufffv6I5emotbMe1uRITdYmzKW3KYnOvKq6GJK3t1NSttl7f6kILTLTcxQc3OvirIKAHCClKbhGM2nFLTmOMx3axvu24rGrHGcGzjOwzVS0KV1p2u2tLlUQty5JiVPS5Hi7phYKnkFHrm0ku7toIBPZyI1KxYWnVK0MQqYk9Mdk/Nl9vRvbMuOc8I1Toxe62CBa/Sb2kWVIRS9oFNNapza1NCqNZIkZIUpGYXwad9g5aglRHHPF7bXlOsswf2dyPOm48ljLE2p2LfMXfW7VG5DoGb0Ffq5Lf32VdrLzGY88SjAlLrTTrSmnUJcaWClaFDNJB5gg88ARy2tm9k2xWKjV6DSWadNqgQmYWAUoIQSckN+wjMq46QM+GAGzbPtCbsPZ9Ua0lQ9IrHVaS2felvAhvh36OKz5DAFMWnotpUdE6agyKzPUVvEn1ilK7SgVHMgJz4+JxcR028Mv4mcvU131ZpPFOP7/E07/ahS6HArCWt1IeKeYyUULQVZK8cssYXyUoKfc29IlKFWVLOYoi1BuSZResGIhClyEpSVOAnLT4DMYg0bh0847lvd2Ua+NWdh9pf0iZhyLoqEJ2pUiqtPwJq2XNDqGs0ZrBSF7pOoZJKk6TkpOKa+uIV6vh68VotSWeM77ds7dlutmTbeiqUPKvKS2U019FZfXKQwxTYrSHzGcKXCNy2mOy26+3uJTMrjz0KbWVHh4UkG/HWmbc28Z+bbbSeYyh9qksEx/Dx+/1BE13460hHhXtH44Ae7Vu2fbkpx2M2h1t/SH2l+8E8slDiDxxlGWCZZ3sqDyt8ivKux67WlVFhtTSXG20lteRIUkZHiOYwk8sX1wq1TUttjZ2a3T9FL8odwni1T5bbkgDmWT2HgPPdqVjEhnSph9mQw2+wsOMupC2nE8QpKhmCD5jAFP8ApcbI5tPr67+pbBcpVS0pq4QM9xKA0BxXgh0AcfrfEYArhgBYAWALI9EDZXKn19V+1FkpptN1tUnUP10pQ0LcT4paSSM/rHyOALdz50WBBkTpbgaixG1vyHTyS22kqUo/ADAHPW/KJcVxV+pXWE7xyryHJioY4OtJcVm2jj7WlGQ4Ymuxmo55KqHWKLm4vbfnsatuXw7FPo2uhSmR6vfLGa0fZcSeKh+eNtveY8syNe9KUv5lHn0/Q93NYrRZNTomSmCN4uODmNPPU0fDyx7cWX1ocGNj1V58Orz6/qYbRsdir0d+oLq4pVSQSulNvJcQh4MZFxTbgBK1J48G81DLiMcpf9SdKooaNcPrYxtnjK7fbhPJ09OllZzhk5p9TTBpz111KTDmVGbEMgzlxGnP0qOncNoZfILebrWneMEEqzVmlGWeKOrR1zVCClGEZYxqfwvd5XOz4lwtt5EhS21PnBFtn1LW85Ir0lI3jxUiOAMgB75SO4e6MfR+mW+lZ+xHG9cusvw182TCY3DciuCalC4oSVOhwZpyAzJ44tJpY34KGm5KXl+ICM9yM5NeXFb3MZSyWW8yck58OJxzU2s7cHfUlJRWrdkssPaltAsN1Mq36g6zCWrtwngXIbpHMFtXZz4805K88eYMtSzjuWm2adLey7h3MC6EfR2rK7O+UdUFZ8nebef2+H2seHod2H2X2UPsOJdZcAU24ghSVJPIgjgRgD3gBYAWABh0iNpX0F2dyn4ru7rdUzg0rI9pK1j1jw/okZnP62WAOfZJJzPE+OAL29EqsiobG4UfVqXS5UmIoeGa9+n+y9gAzYAWAAr0trXcrWyZ6ayjW/Q5LU7hz3RzZd+QDuo/DAFFsALACwAsALACwAsALACwAsAPVlWzJui7aTb8YHeVKU2wSPdQo+sX+4jNWAOmkSKxEisxWE6GGEJaaQO5CBpSPkBgDLgBYAp902q6l+6reoiFZ9RhuSnU+CpTmkZ/Jj88AVtwAY+i9s1+mG0JqoTG9VFt7RMlZjsrez/R2vmtOo+SfPAF8MALACwALdofSGsqw7xh23WUPrL7G/ly44Dgjazk2HG/aOoAk6eIGXA54An9vXNQLjpyKlQqgxUYK+T8dYWM/BXek+R44Ac8ALACwAyXnaFFu+2p1v1hrewpqCkn3m1+46g9ykK4jAHOK9bTqVpXVUrcqQ/Sqc8WiscAtPNDifJaCFD44AZMATTZ1tfvqwJOqgTiIS1a5FMf9ZFcPeS37qiB7SSD54AZbzuyq3bc9RuKqKzmVF0uqSM9KE8kNozzOlCQEjADfSabKqlUh0yInVKnPNx2E+K3VBCfzOAOm9t0OLQbfptFiDKPTYzUVrzDSAnP55Z4AcHHENoU44oIQgFS1KOQAHMk4Ap90iuki7XFybQs2TooYzaqdVaPGX3FtpXcz4n3/u8wK34Au10NaOImyyTPI7dTqTywfsNIQ0P7SVYAc+lQ1UqlYFPtmksqk1S4qtGhxo6eatIW8SfBKS2CT3DjgCX7Idl9K2dWixRoul2e5k9VZwGRfkEcT46EeygeHmTgBp287X4mzi01Ox1IcuOohTVHjK45K959Y+o3n8zkMAUAnTpk+a/OmvKkS5LinZD7h1LW4s5qUo95JOAMbL7zDyHmVqaebIU24glKkqHIgjiCMAHXZp0tr1tzdQbnSbipSeG9cVpnNp8neTnwXx+1gC2Oz3aZaN/0lVStyUXkskJlx3EFt5las8kuJPDjlzBIwBJZMePIYWxJbQ9HdGl1pwBSFJPMKSeBGAKNt2LZ+1LbbXqDae7t+joZfXTXGE7xlx2MUpLmjMaW3VEkBHIZcMAQ/aJsWv8AsF5RrdPK6dnk3VoubsVWfLt5AoJ8FgHAEi2S11l6lLpClASoilONJ71NLOZy+6rnjfTZ1HRbhOGjuvyGW/Nnk5qY/VKS0X4rxLj0dHFbajxUQPeT8OWMZwIfUemSUnOG6fb0HrZPbpiU9yrPoykTexHB5hlJ4n95Q/LGVOJM6Na6Y63zL8hnuKpfSS/YtPaOqBAXp4ciW+06r5lOnGdKOuokc/8AxLf7SxxFYXzGvaTIZVXGmmkJS820C64kZKUpZzGZHPIZY29Ra149jnehxapNvhvYfGrs2k0qI5W30IckORBGZlKAS7GG+3pfU2jSFOLVzUsHP3sUFf8Ahmm4LbENWWvsxjfhemOC0pdYhKpoT83H/wANqzPQptVVQfrDrtfXK6480hQW40GV6+004r161uBstgjIuLTx7JxT9Q8Tx9KglS06fnn3XwpLOe6in6osqWNOc7m/eAmTIi6NGaVu50suVioJ0qc6jTihkqDCOO6juKUCc1cWzkrTnjRYaYS8R/Vj5V/unl8vvJY9PiW2TKr6fvYb3bBabeYn0WUbalsTREiOqlKkuSA6dMSQ0qKkrSXVZ8uzlxHLEql1icX5v5nl1bLTpx8SeX2+/wBTCVBfImljdLW87ZnLo94oRckGK4phU5hSUyhuyUlSXBk2+OHDUAT9bHRU56oqXqiK1gs5YW1exL6i723amh98DU7Ac9XKb+80rjl5jMeeMzwrB0mr7qdzX+KfRmTNo1mr0PJHaQuari8SBxOjSEeWR8cbqUJfElnBFuatPGiUtOogsS7barrYiVdhLD31XuKM/sucCn54s43VOrtPYoKnTq9u9VJ5Xt+hmvS3KlV2IxgOILUdJKY3LVn3pV7PIZDGV5byqJaexr6Xe06Levl9wex6FVXquzSUxl+kH1htqOrJClKVyA1ZDj3Yoriaoxcp7KPJ1dKSqfDvkMN0Upmn0BEJv9GmxIGmNPdSYb7bJcbjlmSllx1CnQ6Q0c1ISNSlkHPPHGWVd1Kup7xlPdfEm8OWY5S2xv3eyiscFjUjhfYa1CtG9tpN7IsOpyIpVCR1moXJHZDijGS2VsEqG7C0qVI4cASVZqzyxfdLtqKXi0tUVLPlfZ8Pb12xz22I9acuGDa7rZVa91VS31zGZ7lMeMdyVHz3alJ9oDUAc0nsqHiMW5oGFXtH44A+YAWAFgC4PRR21RqlSWLBrsgIq0FOmiPOH/OIyeO4z+u0OQ70/DAFjZUWNLjuxpTSH4zyS28y4kLQtCuBSpJ4EHAFcdovQ1olSfdn2VUBSHnCVGmStTkXM/ybgzcbHkQr5YAE7nRF2yokbpMWE43n/nCZaNHxyVpX/ZwASdnnQxYjyWpt9VJEtKCFeiYGoNq8nX1BKyPJKR8cAWap9Pg02ExBgMIiwoyA3HjtJCEIQngEpSOAGAK5dK/a0UUmRYduqU/Kc0quSQz2hHYPFEckclOEZq8E8O/GSi2YSqRTw3yVjot8Vmm6WlK63FH7F05kD7K+YxJo3k4e6IF10ulV3+GXsS9mbal3o3LzeiblwSrsvD7ix7QH/sYnqdKvs+SllSubJ5Xw/h93YjceJcEetOWdDkZtz3UsILnBIS4Qdefu9n2sVN5cO1hPPwpF7bUqd1oq48xPJ6rdo7n0fkseiaZM/Q3Uz25CdK2G0OoccDJcYcWVlAU6EpcbCiDnlnjiqXjVl4sXrnHfyuPdtYWcSSxnEcuMsZL56VtwhivyQ9UqrFt6C40oTVokzHGVMv69OtLDipDY1qyZJXpcWtSQrIqJ5W3QbPU9W+fhWcrHGrZ7c+iSeNkQ7+5VKDb4W/6EqiRWYkVqKwMmWUhCB5DH0KMVFYR87qVHOTk+WRPaNW+rQUUxlXrpXaey7mgeX7x/hiBf1sLT6lx0W11T8R8R4+YO4kV6XJajsDU68oIQnzOKmMcvCOmqTUIuT4QZ4NGhRqS1Sy2l6OhOS0rGYUo+0r5nHRQopQ09jhqtzKVR1OGRaubNmHdT1Jc3S+fVnDmj91XMfPEGt09cwLe1621tU39z5ZW1jabsynCNBlLTESc3KRMzdiLHeUpz7Of1myMVk6bi8M6GlWjUWYvKLSbM+lVYV1bmDWlfRysryTokq/RHFfzcjgBn4OZfE4wNgakLStKVoIUhQzSocQQeRBwB6wBQLpI7SvpttFkpiu66JRNUGm5eyrSfXPD+kWOB+qBgAU4AtB0JLoS3Ubhtd1QHWG26jFHm0d09+IWj8MAWzwAsAatVpkOq0yXTJyN7DnMrjyG/rNupKFD8DgDmvf8AZtRs276nbk8HewHiltw8A6ye006PJaCDgCPYAWAFgBYAWAFgBYAWAFgC0nQ02arXImX/AD2sm2gqDRdXes8JDw+A9WD5q8MAWvwAsALAHOfbldwuvanX6q05vIgkGLCUOW4jDcoKfJWnV88AQVCFrWEIBUtRySkcSSeQAwB0P2EbN0WFs8g015sJq8v9Mq6u/rDoHq8/5pOSPln34AIeAFgBquq5KbbNuVGv1JeiFTWFPveJ08kJ+0tWSR5nAHNi7rmqN0XLUbgqSs5lSfU+4OYSD7KE/ZQnJI8hgDJaV7XTaNUTU7dqLtPlJy1bs9hYHuuNnNC0+ShgC3+xTpRUe8X49AudDdKuNzJEd5PCLKX4JzzLbh+qTke492ADzgBYAWAKkdNi0m2KtQbqYRkZrbkCYod62e2yT5lK1D5YArHgBYA2qVS51WqcSmQGi/NmuojxmRzU44rSkficATZdv3/sdvem1es0QJk09/exFSEl2G+QCOw62QCcuIyOYPdgC12zXpR7PruDcSqOi3ayR2o8xY6utX81IOlPyXpPxwAFukV0jnLoVItO0nlN24klE+oI4Kmke4jvDH9/4cwK9YAWAOh/R8pHovY3a0fLJTsTrSvjKWp/+DmAJ49T4T0yPMdZSuVE1iM6oZlvegBenw1AZYAbbwu2i2lbk24Ky9uYMJGpX1lq5IbQO9a1cAMAc7do+0CtX5dcu4asrJbx0RYwOaGI6T6tpHkM+J7zmcAGahdECp1vZvTa2zU+pXRNb60afKT+j7lziygqSNaF6MiTkeeWWAApeez28bLn9SuSmOwVkkNPEamXcu9p1OaFfI4AYGWXXnkMsoLjzqghttIzKlKOQAHiTgDopsU2dNWFs+p9GKAKk6OtVZwe9KdA1jPvDYAQPIYAjfSe2lfQ7Z67Chvbut3Bqhw9J7SGsv0h0fdQdIPioYArv0Qv+mRj/uEr+AwBeR9hmQ0tl9tLrLg0uNLAUlQPMEHgRgDl31qRCqapERZYeZdUWlo4FOR7sDKE3F5WzQTrZ2o7+OfTUZbaWSlDtSYQVMhS89O9A9gqyPL8Mbo1PU6K160ntU29x8u66otOtlyfCfQ65KG6grbIUCpQ4q4fVHHGUpbE+9vFCjqi854IJsxgapMyoL/ZpDKFea+KvyGJfTYbuR8t69W2jD13HkUmnU6XLuSuqTv1uFTLZ7QbHJAA95eQ+WJHhRi3UmQfpE6kY0KPGN/f1+SFc9T63Y7s0I3YlhGlBOZ0qc4fkMLipqo59RY0NF3o505/IjtrWb1qCuqzZC4KEjXDeQdKk6DnvST3DLhiFQslODc+C0vequnUUKfml3/T5jpRtpSN87Cr7K6nFdQiI5U46UolmG2ondhJ7PbSVIKuC9KlDPjjlbrou+aDxhtpP4c+vr744ylsX9O4285JrYbkVOVNXAqUPrc9YeTLpnqJBYeUTJTKaWl1DKWEqybUtI0qCdKsszipvWqcY64yxHbEt1lfDpezeruk91nK7EiG/f7jzR4NKpFvmnLloMCRvC4+WUrYUzMWjqsuaSlzcrS1+qSQUaj7QIVj24qTq1dePMsbZ3zHOqMN1lZ+J84XHASSX7/Ei960uk0l2FXrcVLp0ufIWulJZSppBaaOgPMnUXUFzsupAJGS9I9nFt0q6rSbhUw9C3ed8+j7bbr12y+TTWguV3NSDW7ltV51irwFqaW+5v3V+2p8KKXcnxmlagpJB4njjoLDqkMeVqS599ym6h0nxnndS/AeixZ12J1NkNziOOnJt8fFPJeLXFGv8/xKTXc2fO8PvX/Q1OU+7bUSp6G8JlLRxWg8UgfaQeKfik40OFWhut4kyNa2vNpLTU/ff9TDSK1GRcDVcuukCXRKwFsIWtKlBtDakpU5H4pClNcsjz49+Oe6pOpcqSpT01Y4ePyT9mX9lQjQio4zH97k9Q9BaptVuyY4FyNG7TEhERpEaLlpj6nZKnFO7xOlRbkNHVwKccw4yc4W8ePWW6cu+0cYxvvGW2+Sw7OQRbUkPbI9hNSvqrKK72u4pXGL/F3W8D1RJz/k0FTyh8sdlTpxhFRisJEFvIJ9mPR0vvaJRnrjalsU+G+6oMSJ28K5KgTvVp0BRyCuGZ5nPwxmeAhV7R+OAJFYNg3FfVwJoNAbQuaWnH1KdVobQhoZkrVkcsyQkeZGANe7LJuu0qgafcVMep0njo3qewsDvbcGaFjzSTgBkwBkjyH477b7DimX2VBbTqCUrSpJzCkqHEEHkcAWg2T9MLq7DNJ2hNLeCAEN16OnUvIf9oZHP7yOP2e/AFk7bve0LmjpkUCsRKig9zDqSsfeb9tJ8iMAPmAGS4r2tC22FP16sRKchPc+6lKz91GetR8gMAVw2s9MBt2M9SdnrawpwFDlekJ0FIPfGZVxz+0vl9XvwABbZvNyl730jHW+mc4XnZuZLy1n2lKK/b4+eJ1rdeHs1syo6j0/6Q8xluuxIJFvWncrRk05xLUjmpbPA5/zjRyxMdClW3jz++xVwvLm1eme69/8M1bcsaVSqv6QmyGurxQpTakk8eGWas8tIAOMLeycJam9kbr3qsa1PRBPMjfpXX5K6rcNPaYRJmqbhwnqgWURxTla25L2T+Ta9W60EHjpKsgeY5Hrd3CrX0vOhb+XOdSxpW265z88HR9LtnRoJfW/Xkcp4hNQeu1dMX0RGkrZcYkIXLeVT3GwqI3GBU+7BU523EoWpGRUDmQMsU1LU5aaerxHHO3lWtPzOXCqY2WVq49XksHjG/H+P8Ef2b0TdRnKs6nJb+bcbPubHtK+Z4Y+j9Po4Wp9zi+t3WZeGuFyTJ99qOw4+8rS00krcV4BPE4sZPCyUcIuTwuWBWtVR2qVJ+a5zdV2E/VQPZT8hjm6tTXJs7u2oKlTUF2Jbs1ompxyrvJ7LebUbP6x9pXyHDE/p9H67Kbrd1hKku+7CASACSckjiSe4DFsc2NlJuSj1VRREfzeTn6lfZXw7wO8fDGilcQnwS7iyq0fiW3qbNSpcGpRjHmtB1vu+sk+KT3HGdSnGawzVQrzpS1ReGCa5rdkUSduVHeR3O1He+snwPmO/FFcUHTljsdjY3irwzw1yS3Zvt62h2Eptmnzuu0hPtUibm6xl/N8dTX7hy8QcRyaGy8Ol3QaxswqLNIYkU27pqBDEZfaQ0l4ZOvtvJ4HSnMJzAVqI4YAqdgBYAmGyO9VWXtEotwFREWO+G5wHfGe9W98ckq1DzGAOkLTjbraXG1BbawFIWniCDxBBwB6wAsAA3pPbFXL1oSLhobGu5qQ2QWUjtSoo7RaHitBzUjx4jvGAKPqSpJKVDJQ4EHngD5gBYAWAFgBYAWAFgCabJtmFZ2iXWzRoILUNvJ2qT8s0x2M+J8NauSE958s8AdD6BQqXQKLDotLZEenQGksRmh3JT4nvJ5k95wA4YAWABzt+2gJsnZpU57Tmipzk9QpY97fvgjWP6NGpfywBzywAbeins0+lV/CtTmddGtzTJXqHZclk/o7fnpILh+A8cAXmwAsALAFU+mXtKzXDsCnu8E6Z1b0nv5x2T8P1hH3cAVYwAsAfULUhQUklKknNKhwII7xgDohsEvaXeWy6j1acveVFtKok5w81ux1aNZ81pAUfM4AIWAFgAEdMqGh7ZRHfI7caqR1JPhqbdQf44ApHgBYAsp0ONmvX63Lvqe1nEpecWlah7UpafWOD+jbVl8VeWALaVSlUyqwXYFTiMzYTwydjSEJcbUPNKsxgCu20vocUWfvZ9iyvRco5qNKlFS4qjzybc7TjfwOofDAFXrvsS7bPqPULjpj1Pf47tTgzbcA723E5oWPunADDgD022txxLaBqWshKUjvJ4DAHUG3qaml0Cm0xPswYrMYf6JsI/wwBvOONtoU44oIbQCpa1HIADmScAUR6R+2ly/rk9GUp4/RSkLKYeXKS97KpKvLub8uPecADazJluw7rpUy447sqhx5CHZ8ZgJK3G0HPRkopBBIGoZ8sAdFLI2iWZelPEu26kzMSlILscdl9rycZOS0+HLLwwA8Vii0itU9ynVaGzPgvDJyNIQlxB+Ss+PngAS0nos2DRtocC7aWt1mJBWqQmiOetZEgfqlocV2wlCu1pOfEDjgAzKUlCSpZ0pAzUo8ABgDnlt72kKvzaHNqDDmqjwv0KkJ7tw0T6z/AEq81/DId2AJJ0RFhO2WKPrwpaR/UB/wwBerAHLapthFTltp4hLziR48FkYAvpsF2UQrT2Ys02rRG359bAmVph9CVpzcSNDC0qzBDaMgR9bPAAc6TmxLZ1aNvi5aK85SZcmSllmip9ZHeWvisthR1NaUAk5Zp5DIYADFpXnS6TSlxJDDm9BU6FoyIcUeQP1eWLG1u4wjhlH1HptStU1JrHHyI9Xa/OrMrfSVZIT+pYHsIHl5+JxErV5VHllla2kKEcR+/wBQmpobU6g0uC/+oaSy48j6+lHs/NRxdeDqhFPjY5T6W4VpzXLzj7yNXfXnKjLbt2k/q9aWnSjkpXIIGXuJ78QrqtrfhxLXptoqcXXqc8/9/NjxOm0qzKTHZZYD0lzh9VThHtrWricvDEic428Uu5BpUql9Ubbwl+Hsa+6pl2Ul6fBaMKqsBSdaOycyn2VKTlqSscMapU4XMM48yN8alWyqqLeqD/f2GtQNrUyMpxFZiomMqbCfVIQ0d6yUqiqWlICCI6wtYGXFSjnjirroUZf03pee+Xs/i9/NsvkjsIXHqPYmUNmdGrUKMxUE02aVxlUqMqRuYToO4602+UeuL2RBz1BWfH2cQ/DquLpybjrjvrljMlzpa7Y+zGNuTZlc84fY24lWpyavWqPWfWR6W6Fy4jaFyGJDMJO6jRkIUl3IrdcVvFLKVa1AhWY46Z0J+HCpT5mtnsmnLeUu3CSxjKwuMM9Ullp9iCU6z01Km+kIs5EerSOsSINFS09qLMcFZKXT3EIUEEagSnIqCsX1TqDpVNLTcFhOeVy/b7s8c5SwRvB1L59jFcM68Ke0/b9dC0bl8svKUApWpjLW2HR2V6cxnxPdi0o9S8el5ZaotJ/Z2K+PTadOrrSw/wACfwp9DrND9DUWUqTFjnswZKWWX0w2snFaULUthxwLX+sUEK4ntaQccdUpVaNXxKixJ91lrU9vmlhcbrjbLLlNNYRkfYsZW0dmLWy8iiuzGa1clReHWFJQUlTMUBsHJhZdGZStY0kZezi06HSqzpqb+GC0pL57t++2OE+fUjXVWEXjvJhU6TVjV6/qFDu62KzBnWtQ4jrq4SXQgDLtvPpcz3aiEJSNByIy8Tli8NRMazctyWZY1kxLKpPpCE9Tk6ylsq0hDTJQrhyK94onxwBRBXtH44Auh0O7Ip1LsiTc5cafqlbc0K3akrUxHZJCG1ZZ6VKVmsjw04AOVct+h16nuU6tQWahBd9uPIQFp+Iz5HwI44ArntI6GlNkh2fYc3qT/FXoiaorZPk0/wAVo+C9XxGAKy3bY12WhUDAuOmPU6Rx0FxPq3AO9twZoWPNJwAxYA9NuuNLDjSihafZWk5EfMYAmuzyJfF7XZTLUhVmchM53J1W/eUhplI1OulOrLsoB+PLAEr2l9GXaVajj86O0bipIzUZ0QFT4T4vMcXB5lOoeeAIFYtCZqdYV1tOpiIneONH3lZ5JB8s+eJllRU5b8Iq+q3TpU/L8Ujdr70y6qi3FpUE7mCVNJe9lOWY58koHDgMbK7deWIrZGi0jG0hqqS3l2/fJuRdmlQYbD7dTDM0cU7tKtIPhrzB/LGyPTpLfVhmmfXISeNGY/vsR+bNuidM9CzJDzrgc3SmQCviDz0tgqXlz5HEC5uJxT1vgtbW2obTppbhXnUyeikptuMw7AbltF2Bv/09hMNDBTLdhDdpfS4onSEe2StXZTjg6daPieM2paXh48r1Z8qlvpx78eVbsvGttPBCawq6ZUxm1ZUpqc1M6vJ9KBrTJdipQS0HlqCXSEJJ7LnEHvyyx0vSrSlVnrgnF7rTnZP6zXb7UV19c+DTbe/+fQnLDDUdhthlOlppIQ2nwCeAx3SWFg+fTk5PL5ZDdpFb3UZuktK7b+Tkj7g9lPzPHFd1CthaS86Ja5l4j7cEBgwn5s1mIwM3X1BCfn3/ACxVQi5PC7nRVaihFyfCDXT4LECCxDY/VMJCQfHxPzPHHSQgorCODrVXUm5PljPfMmezQXEQ2luF/sPOIGehv3s/jyxHvZSUNu5O6VCDreZ8cfMEza1oWFoUUqTxSpPAgjwxQ5OxazyGC0KlLqNAYky+L2akFz64ScgrHQWtRyp5ZxXUqMadZqPBobRYzbtu75XtsOoKD97skY1X8c0/kyR0WbVfHqgWYpDrjfYoVakI1swX3EdyktqI/hjbGjN8JmiV1SjzJL7TWkwpcVWmSw4yrwcSU/xxhKDXJshVjP4WmYcYmYsAXg6KW1FN0WSLcnPaq3bqUsjUe07C5Mr89H6s/LxwAc8ALACwBXbb50YmbmckXPZiER6+vNydTDkhmWe9aDyQ6e/PgryPEgU/qlKqVJnvU6pxXYU+MrQ/GfSUOIUO4pPHAGrgBYAWAFgBYAIGyrYpeO0WoJTTmTFoyFZTKy8k7hA7wjlvF/ZT88sAXq2dbObasG3W6LQ2dKPblSl5F6Q73uOq/gOQHLAEpwAsALAFD+k9tSTet9Gn093eUGga40RST2XXyfXvDxBKdKT4DPvwAH2WXX3UMtILjrightCRmVKUcgAPEnAHRXYrs7asHZ/T6IpI9IuDrVVcHvSnQCsZ94QAEDyGAJ3gBYA16i/IjwJL8aOZclppa2IqSEl1aUkpbClZJBUeGZwBzW2gm7XLwqkq7Ir0OuzH1yJbL6C2QVnhpB9wDgnLhlgCO4AWAFgDoB0Z7WlW7sgpDUxBblVAuVFxs8CBIObef+iCTgAp4AWAAB00KkhjZnToOfrJtUbIH2WWnFH8yMAUrwBvUKi1GuVmFR6a0Xp895EeM2O9bhyGfgPE4A6TWHZ9Os60aZbkAepp7IQtzLIuOntOunzWsk4Af8ALADfXKBRK7TnKbWYLNQgu+3HkIDifjkeR8COOAK27S+hrGd3tQsCXuF8VehZqiUHyZf4keQXn97AFcpVCuCxrrhJuWkPRpEGQ1IXCfGgPIacCiEOdpKkqyy1JzGALy7NukBs8vwNx4cz0fWV8DSZpDbpV/NK9h3905+QwAKuljts6qw7s9t9/9JfT/wAYZLZ9hs8RFBHescXPLh3nAFS8ASy69lV/2rT4lSrdGfjU+a0h5qUBrbSHBmEOKTnu18fZXkcAR+lViq0ie1UKVLegzmTm1JjrU24n4KTkcAWQ2V9L+vplRaNecBVXDy0MMVGCgJllSyEpC2eCHSSfd0nyOALbjlgAKdKraV9FLAVR4TmmsXJrit5HtNxQP0hz5hQQPveWAKL4AM3RI/6aIH/dJf8AssAXtwBRno87NfpjtakTpjeui29IVNl5jsre3h6u181p1HyScAXmwBQrpN7SvpntDeiw3ddFoOqFCy9lbgP6Q8PvLGkH6qRgAQ4A9NNOOK0tpK1eCRmfywBNanf8xVH6omIuHOWA2pziEhvLLNGfEE4sZ37cMJYZR0uiqNXU3mPJl2b0Uanay+NKEZtxieX84v5DhjLp9L67NfW7niku+7/wiN3RWFVisuPp4sp9VGT9gcv6x44iXNXxJ5LOwtvBpJd+WThCUWnZpKuE10cfN90cB+4P4Ysl/Io+/wDkoW3eXX+1fkv1NG0qbRoVsrrktgSnclrVqSFlKUK06Ug8Mz3nGu1pwjT1vc39Rr1Z1/Bi9KNyCimVuM9PtxbtHq7QKCuOosK7Xur3ZAKVZc8a6trQu4fCtvVBXNxZTSm9UGNFm3pRKJHVCqlLdcPWkypUmO8UuvKYCt004CRpCVqKgptSSDx45DHK9R6dVqyzCSW2nDWyzy1+jTXbY6qjVikEWNOgVduM9SbiejyZc9ph7cJBadlvsB54sxFDVpbdUVrcPA6QEgnI452dOVJtVKSajBvflRTwsy9WtkvdtvBLTzw+4z1qfJkSBRZSqQqtwmWesxpSi7EWzHayV63s6HiSuQ/qIPsjmnLEu3pqK8SPieHJvDW0st+nePEI8rn1ya5Pttkjt52JbVOgzKpTqg4llLiBHjlpS2j1hJdabS9mFfqgeJB4jI5HFh0/qdapJQnFZxu877bN4+f6o11aUUso1mHpNPjCTVkOvunTPmOrUXS65kBEZdVxKMs9R1+GOhsbyglojthvbjOPT27lNe2lWcs+qx/xT+J/PsZIteemwp7e9qEWFLi/pbLT+nrqEPanFOZJCHdzwyGWeQ54mvTU3afH3+v3EZKdDyxcd5fYttu+2oNuybpN0m0rIp9DvGPLeVFRopEuKlDi3ISVFLe+QpaNBQBknxTliHOnp+0tKVZTyu8efmVYS2468G20lbi1aUISMySTkABjA2hEqNsbZdjtTaqOiXRVOadM+MreRXM+O7cKdTaiM/YcHywAZ9nPTNYXuoN+wN0eCfTEBOafvOx+Y8y2T93AFkreue37jpyKlQqgxUYK+T0dYWAfBQ5pPkeOAMlaoVFrkBdPrEFioQXfbjyEJcR8clZ5HzwBXXaT0NqTM3s+xJno+RxV6JmKUuOfJt7tOI+CtXxGAKyXfYd3WfUDAuOmPU97M7tSxm05l3tupzQsfA4AtJ0ONm/o235d7zmsplXzjUzUOKYjau2sf0rifwT54ANO0q94VkWVVLjlZEw2v0Zk/tZC+yy381kZ+WZwBz8otwV9irzLgkRnpqJ61uVB7SclKcXrUvVllnqxLtpypvVjKK2/o0660akp9hyqW01W7LdLibkn9q7kcifBCeGfxxIqdR/tRBo9D3/mSz8jZs6n3C9UBXKnIV1ZTSineLz1hQ4HSOCUjnjO0hUctcuDV1KtQUPCprzZ+4y0N1PpmoXO3uIst17/AIvS57jjEdRYIEhaVNKQrWlGWRJy59+WOV63WVao4buH11FJvf4eez+/jsdH02i6VGKfOP8A6P8AGuK1natXH3pjJVML65Ed5hUZ3dx21GO8xJ7GlxYcXktSVKJKTozGrFFO0rqnTST8uMNPKy35k4+iwtspc+bGxYKccs0LWbkz5E25p2rrVTWdwFqU4puOnglOteaiMkhIzPIY+h9GslQpJL9Pm/te5xXXbzxKmhcL8/8AofZcpmJFdlPnSyykrWfIf78WspKKyylp03OSiuWBSq1F6o1B+a97bytWXgO4fIY5upU1yz6nd0KKpwUV2Jrs1omSXKu8nic2ov8A61f4fjiy6fR+u/sKLrd1xSXzf+CdLWhCFLWdKEjNSjyAHM4s8nPpZPjTrbraXWVhbaxmhxJzBHkRgnkSi08Pka5tp29Me3z8JG85qUjNGfxCSAcaJ2tOXKJdLqFeCwpbfeObLLTDSGWUBtpsaUITwAAxvSxsRJScnl8shO0usNhlmktqzcUQ9IHgB7APxzzxWdRq7aS/6Hbbuo+OEetn9tReppq0tsOvOk9WSriEJSctWXiSMe2NusamedYvpavDjslyTjicWZQGKRHYktFmS2l5o823BqH548lFPkyhNxeYvDB5eFkJhNKqFNzMVPF+PzLf2ge9P8MVF3Z6fNHg6bpvVfEeifxdn6/9kLxXF4SLZ/fFYsi64Nx0o+viK9awTkh5lXBxpfkofgePdgDonY96UO87ah3BRXd5Dlp4oPttOD22nB3LQef48sAP2AFgBYAiN/bKbGvuLubipqH30DJie36uU39x1PHL7JzHlgCuN49Cu4I7i3rRrDM9jmmJP9Q8B4bxAU2v5hOABZVOj1tlprikPWtLd0+/F0SUn4FlS8AaLOxLa48vQi0qnn9qOtA/FWQwBMLc6Je1+rKQZkSPRmFc3Jr6SrL+jY3qvxywAb7B6H1jURxuXc0ly4piOPVyNxDB820krX+8rLywAd4UKHBitRITDcaIwnQzHZSENoSO5KU5ADAGfACwAsAAbpQ7akWnQl2pRX/+MlWaIfcQe1Eir4FXDk44OCPAZnwwBSXAB36JWzT6R3uq5ZzWqk25pcb1Dg5NV+pH+j/WHz0+OALuYAWAFgBYAYLvsS0rwpxgXHTGagxkQ2pacnW8+9p0ZLQfunAFbb86FkxDjkqyKsl1o8U02o9lY8kPoBSry1JHxwAHKlsD2w06QWH7VnOKBy1xkCQg/BbJWnABS2LdFKvzKtHrN/ReoUiMoOIpCyC/JUk8EuhOe7b+sD2jyy78AXBSlKUhKRkkcABywB9wAsAUy6Zt4IqV7062mF6mqHHLkgDukS8lEH4NJR+OAK84As90NdmvWZ8y/ag16qHqh0bUObyh690fdQdA+J8MAW1wAsALACwAsANNyWnblz01VNr9OYqUJf7J9OrSfrIV7SFeaSDgCs+0nobyWVuVLZ7N3gT2xR5i8nARxyYkcAfILy+9gCt1yUS4qPV34dwxZEOqaip9EsKDiir381e1n9bvwBPejjs/i3ntMhMT1N+jaWPSEthZGb26I0NBPNWpeWr7IOAL/Px2JDK2JDaXmHQUuNOAKSpJ5hQPAjAAH2l9EezLh3s61Vi3aorM9XSnVBcV5t82v3OH2cAQ3YD0cbooG0t2q3jBS3GoKQ5TVpUHGZElzMNuNkcw0AVcQCFacAWrddbaaW66oIabBUtauACRxJJ8hgCgl/1uvbadsamKGgvIku9RojSswluI1n61fPSD2nV/HAFrdmnR42e2XAZ1wGqxWgM5FVmtpcOvv3TatSW0juy4+JOACU1AhNKC2o7bak8EqShII+GQwBnwBCtlGzeJYluvU9BbdnzZT82oSWwQFrdWdCRnx0tt6Uj5nvwAx9IraV9BtnUpyI7u63Vs4NKy9pKlj1rw/okcQfrZYApJs/2c3VftdFJt+NvnR25MlzssMI+u6vjl5Dme4YAt5s+6Jmzq3mWn6+g3JVRkVqkZoipV4IYB7Q/pCflgAxUyhUWlshimQI0FkcA3HaQ0n8EAYAyTqVS6gyWJ8NiWyebT7aHE/goEYAFd7dGmya1BlJt9S7YmyElKjC4xF5/Xik6B8W9JxsjVlFYT2Zpnb05tSaWUVWquymtbPb0ZiXelDMXiunT05qiylJ9nS5kMiOZSrIjG2006/MRup+J4LUFlv8hjvKdLrtc9HU5CpLcMEJS32tS/fXw/DG+7m6s9Md8ETptKNvR1z2cvX8BxsSUtlybbVSb0qOpSWV+YycR8xxxtspYzTkRurQ1KNen9/wCRGJi6rbVXlxIkhbBBy1p4ake0g/gcQpaqM2k8FrTVO6pxlJZGdxa3HFOLOpayVKPiTzxoJqWFgldo2vPlRV1ePOXTZEdWcKSglJCkcVK1JyUnLxGJNOwVam9WNPvx9pWXnVPAqKKWfX/ArNuKiUgz01OG7IMsBpyoMrOe51a3GCg8NMnRoUvMKCScUXUbOrVx4cklHtjvwpZ/28pcZLmlUS57m7d1Zp9Sq9KpcFxh2mBbLkoQg6zHXJf0747tWkZ56slaQcjp7sYdKtZQzKaepvHmw3pXG/8A379zblSnFdsok1xQ5drRHagw8mbB1hvRKTrkNa8x2F+y4PJYxKu+lQluvL+/3wWt/YeAtcXmPvyMcV+jVaLPTFqZp4IccUjdtgkOZlXZ4e7kFFvL54jK7urdKGNUXt+37lBO1o1Jan8S/f24M06gRHJjkmXBmTUq0ssiMj1TYZSElKcylWXHvGLWHVbSpvNtPC29Cs+hXdNaaenG+/qSroo7NPpNfhuGa1qpFuEPDV7LkxX6hPnoyLh+A8cCzLj1KuWouqJtepS4iqjPYLqKTIUgqeZz0nJtftjMHhgCum3not0hqlTbqsZrqjsRCpE6hji0ttAzWuN3oUkcdHI92XIgVmti7rmtaopqVv1J+mzE83GVZBQ+qtPsrT5KBGALKbOOmaFFuDf0DT3emICeHxdj8T8S2f3cAWTty6bcuWnJqNBqLFShK/asLCsj4LHNKvJQBwBsVijUmtU92nVaGzPgvDJ2NIQHEH5Kz4+eAMlNp0GmU+NToDKY0GG2liNHRwShtA0pSPgBgCrvSVuv6WX5CsWK5qpFv/plZKTwXKWOw2fuIVl8VHwxJtaPiS9iB1G68GnlfE9kDCNdaXbm9BxY36M0FIU6OGkoHHJPLSOWLSNzmpoS2Odn0/Fv40n5n+/vIBeDEaPck5uOkJbCwdI5AlIKh+JxVXcUqjwdJ02cpUIt8mRis3DVm4dAjuerc0RmmUDTqzOQ1q55eONVe9cafmfkijOnYU1U14zJsmdJp9wwpMekqpsWX1NqQ3TLlSp52P1N9woWUdXKkuha5GlPZK06+I5ZcvXq0pp1NUlqa1U9k9SWe/GMeuHjktYprb8Rs2pTmpD0JThYfmyEmQ48hTD7qG8yhtHWo2hLrZCc0a2wtIyBOJPRabipcqK27pe/llw/XDw2YV2bVv7Qaa421EntiEpACEOI4s5DgOHNOO0oX0eJbHH3nR5puUPN+f8A2a20W4GlMM0yK6laHMnpC0HMZe4nMfjjXf19tKN3RbNpupJcbL/JCqXT36jPZhMjNx5WnPwHefkOOK6nBzlhdy9r1lTg5PhBshxGIcRqKwMmWEhCPgO/546SEVFYXY4OpUc5OT5ZFtotb6rTk05pWT8zi55ND/6jwxBv62I6e7LfotrrnrfEfz/6IDSq7VaWvVCkKbHe3zQfik8MVdOtKHDOir2tOr8SySqLtRkhIEqChxXettRR+R1YnR6k+6KifQY/Vk0Y5+06e62UQoqIxP7VR3ih8BwGMZ9Rk+Fgyo9Cgn5nn8CHPvuvuqeeWXHVnNa1HMk4r28l3GKisLgLtmPIdtmAU+4gtq+KVHF/aPNNHF9TjivI0dob1RZorbkRxTSA6BJUglJyI7PEd2eNV+5KGxJ6NGDq4ks7bEcs+8prE5qFPeU9DeOgLcOam1HkdR45Z88Q7W7aeJbpln1HpsZQcoLEl+ISlJSoKQsZpUCFJPeDzGLrByqYGLkpJpVZkRB+qSdTJP8AJq4p/wB2OcuKWibR3VlceLSUu/f5mjGiSZToZjNqedOZCEDM8BmeHwxqjFvgkTmorLeEEDY3tir+zO4C80FSaLKUE1alE5awOG8bz9l1Hce/kceGSL6WheFu3dQ2K3QJaZkF8cx7aFd7bieaFp7wcAPWAFgBYAWAFgBYAWAFgBYAWAFgAU7ctu9F2c0tUWMpubdclH6FT88w2DyekZckDuTzV8MyAKHVmsVOtVWVVapIXLqE1wuyZDhzUpSv/fAd2AMESLJlymYsZsvSZC0tMNI4qWtZ0pSB4knAHRvZDs/jWHYVNoCAOtpRv6m6P2kt0AunPvA9lPkBgCZ4AWAFgBYAWAFgBYAWAFgBYAYr3u+l2hatRuKpqyjQGivRnkXHOTbSftLWQkYA5tXFXqjcFdn1uor3k6ovrkPq7tThzyHgByA8MAerZt6o3HcFPoVNRrnVJ9EdkdwKz7R+ykcSfDAHSazbWp1qWvTLdpw/RKawllKuRWrmtw+a1kqPmcAPWAFgBYAWAFgBYAWAGK7rGtO76aadcdNZqEf3C4MnGye9twZLQfNJwBWTaF0Qrho0g1nZzUHJYZVvGqe64GZjRHH1L40JXl3Z6T8cAaNldKbaHZk/0BtDpz1Rajq0PLfSWKkyPPVpS7+9kT9bAFnLF2n2RfMPrNu1NuSsDN6Gr1clr77Ku0Pjy88ASrAAK6WW0v6NWMLcgvaavceplek9puEP1yvLXwbHkT4YAh3QmtGMY9eu55AVI3iaZDWfcSEh5/L72pv8MAWJvm76bZ1qVK5KlmqLTmt4W0+04skJbbT5rWoJwBVan9Ni9EVVTtQoUB+lKVwisl1p5CPJ5Slgn4owBZDZbtbtbaRSnptD37bsQoTOiSGylbSnASkahm2sHSctKvjlgCbYAortmuSq7XtszVBt/wDSIkd30VRkj2Dkr18kn6pUCoq+okYAt/s12c0GwLXj0OktglIC50wgByS/l2nF/wDpHcOGAPW0DaVaNhUj0lcUwMJXmI0VHbkPqHutN9/mTwHecAVoufpsXO++tFtUOLCig9h2cVyHSPEhBaQn4cfjgDUoHTUvuNIT6cpECoxc+2I+8jO5eSip1P8AZwBZLZhtjsvaLBU5RZBaqDCQZdKkZJkNeeWZC0Z+8nh45HAD5etmUG8rdlUCtsB6HJTwV77Tg9h1o+6tJ5H/AAwBz4u2267s1v6VSZWSpNNczadyyQ/HWM0LHktB4+B4d2M6dRwllGm4oKrBxfDHpi6LJlS2qvISqNUmk96Vk8svc7KuHLPFqrmi3re0jnZWN3GLpreD/ffg1aUmm3Vdsqa61qiRmk7plfv5dkFQ8O/LGFPTXqt9kbq7naWygvibN5U2zqpU3KI7T9DyVlptxLYRmpPPIo7SeXfwxs10Zy0YI/hXVKn4qltzz+p4vWexRqAzRoXYL6d2B3hke0T5qPD8ceXc1Tp6F3MumUnXrOrLt+f/AEeqbDi25Zr0ia0lx6SnW4y4MwpauDTZHlzPzx7TiqVHL5Z5WqSubpKDwl3/ADYPqYs+lYiuR37Z/tjFOdbR+JfNBj2qj/ijK8n2v72N9Tg6zrP9B/NDJs8sinyKEubVYweXOP6MDmFIbTyWgjIpKj3+GMYQytyH0zp8JUtU1nVwMc27ZNGrM+JTXE1CK2sNofnJDznq+BAVw7IOeKu46bSm+6+WxT3MlCo1DdL1Lz7H9nkewbEgUEaVTeMiqPp5OSnfbOfgnIIT5DE4hlVduuznbXUdpU6vSaHKlolPpTSn6YFSm22W+ywkFsamyAMzqA7WZwBba1jVqTs3p6rveC6lCpiVVp5Z1cW2s3StXJRAHaPecAVW6KGzCLc13TbqqURLtBo2pEVh5IU25KeHZSUnMKDTatR8ynABT2l9ESz69vZ1pOC3qmrtdVyK4Kz9z2mv3OH2cAVtrFsbXNj1dElXW6K/npZqcRRVFfHhrHq1j7Cx8RgAzbN+maRu4N/Qc/d9MwE8fi9H/iWz+7gA33Jths+Bs4qV7Umox6pDitfowZXnrkr7LLK0+0klZGYIzAwBSEVW8aLNlVipxuuCrOdbnPq4qU46SslSxxSc1HgeGJ9N1KG+NmUtdULx4UsSj+/tJJRblt2qvh5nQzUSnQUugJdI55BXvDFhRuKc3lbSKa6sa9JYe8PbgidyWJV2nn5zDnXm1lTrvuujPiSU8j8sQLiymnlblzZdWpNKD8r/AAHHY/QhKqsiqLeQw1AbUnfl6KncqdToC32ZIVrjqBLayB2c8ch1+50wVPGXJ8Ylvj0ceJd164Ojto75Hqq+klTXbit2opo0hFPkVFTLSCESUiQtL2tYU+2tSyheYJLYGhAzz4Q6OjSqNaPiLWo7/V2WOyaxt/u+Jszln4ltsKy6LaFft6u3zeyJMwMTY0J2NTyiOmKy6lKEyNCQBoRwSlI4ADDqNxcUK1O1tsRzFyzLfU12+b5yeU4xknKRGpezGpTJFalWkv05QabMbiRZjfByQX+LaW2yEla059rSPPliyh1mEFCNx/Lqzi216Y5y+y9DU6Oc6d0QyRHfjvrYkNqZfaOlxpxJSpJHMKSeIOLiMlJZW6ZpwSWw6pRKdOdcnqLbzidDD2WaEg+1n3jPxxOsqkIPzclT1a3q1IJQ3S5QTjKjCKZW8SYyUlwvA5p0gZk5jF1qWM9jlPDlq048wGK7VnarVX5q+AcOTafqoHBI/DHO1quuTZ3NpbqjTURvxqJAsALACwBPNmVXAXIpTivb9cx8RwWPw44tOnVeYnPdct+Ki+T/AME4nwmZ0J6G9+rfQUK8vA/I8cWU4alj1KCjVdOSkuUBOdEfgzXYr3ZeYWUq+I7xjm5xcXj0O8pVFUipLhjo/e9zvcDOUgcsmwlH5gZ43yvKj7kOPS7dfVGmRLlSnd5JdW85y1rJUcvicaJSb5JsKcYLEVhBB2b0TcxXKq8n1kj1cfPubHtH94/wxa9Po4Wr1Ob63dZl4a4XPzHy4LfoU+O5InoDSm0lSpaOysBI7+5XzxJr0ISWZfeQLO8rU2lDfPYhOz7adddgVz0lbsooaWcpMJ7tMSGxyDqPHwUOI7jjn2dsi6OyjpE2RfzbUMuikXEQAulSVDtq/wDh3eAdHlwV5YAKuAFgBYAWAFgBYAWAFgDw++ywyt59xLTLYKnHFkJSlI5kk8AMAVx2xdLWk0pt+jWCtFRqnFDlaI1RWf6EH9crz9j72AKj1SqVGq1CRUalJclz5Sy5IkvKKlrUe8k4A1cAWB6IWzX07d7t3Tm86bbxAiauS5yx2f8AVJ7XxKcAXSwAsALAEdp1/wBrVG76naMSZvK7SGkPTY4SckoXlyX7JKdadQzzGeAJFgBYAWAFgBYAWAPD77LDLj7ziWmWklbrqyEpSlIzKlE8AAOZwBRrpJ7b/p5Wk0WiOn6K0tZLa+XW5A7JfI+oBwb+Z7+AAUwBajoabNc1Tb/qDXAaoNE1eP8A1h4f7MH72ALV4AWAFgCom1DpTXXSNq0tu1n2nrepP6C7CeQFsyXW1eud1DJYOrspKVchn34ALGzTpQbPrw3UKe79H60vIdVmKG4WrwakcEnyCtJwAYwQRmORwAsALACwAsAUp6X9/RK5fDFuQQ2pm3kFEuQEjWqU5xW3r56WhkMs/azwACqdUqhTZjU6nSXYcxg6mZLC1NuJPilSciMAWI2Z9MSvUzc0++I/peEMk+lGAlEtA8Vo4Nu5fun44AEe1/aHIv6/KjX1akw1HcUxlXNuK1wbGXcVcVq8ycAWS6FFbjPWVW6LqHWoU8SSjv3UlpKUn+syrABk2n2MxfNjVS2XXurqnNjcSMswh5pYcaUR3jWkZ+WAKA3xssviyqsmm12mONqdXu4kloFxiQTy3LgGSifq+14jAF69iWzlqwdn1Poy0j0k6OtVZwe9KdA1DPvDYAQPhgBg6S+0r6F7O32Ijmit17XBgZHJSEEeveH3EHIH6xGABT0KrIadl1q85KNRjZU2nkjktYDj6h56dCfmcAWir1bp9Cok6s1Fe7g09hcmQvv0Np1HLxJy4DAHOPaRtBrd+XXLr9UWc3Tphxs+xHjg+raR8BzPeczgCL4AWAHW17nrNsV6HXaNIMaowVhxlY5HxQoe8lQ4KHeMAdHdn94wbys6l3LDGlqoMha2s8926k6HW/3HEkYAAnTXs9p2j0S7mUZSIrxp0xY5qadBcaz+4tCv62AB30Y9ilMv2ZVKrcbCnbdgtmK22lSmy5LdGeaVpIPqkdr4lOAJPeHRXvC0Zy63YEj03CGe8pT+SJe7PNIPZQ78tKvI420arpyyiPdW0a0NMgfxKtQlVVxVQimk16MlTcliWktOp+sOOWZ4d4zxbUrilJ6uJHM3NjcU46Pihn9/vgjNJbXdN3OT305wYxC9J+on9Uj5nifniLSXjVdT4RZXD+iW2hfE/wBtmW9Jkut1+PQaeN4W16dI5F5XPPyQP8ceX1XVLSuxu6BYPGV8U+PkSWlbJKTGS05LlPPS0ELJayQ2FA58AQScRlTO/o9FhHltyJJddFXW6SaeFBAdeaU6o/USvNeXnlyxlJZJ95Q8aGn3RqXpWmretpfVsm3lpEWAge7wyzH3E4SeEa7+uqFHbnhAyoGz+4qvD660ltlhz9Up9RSVj6yRkTl540KDZzdDplarHUtl7l8bk2jtU7aVa1jxQhyZWhIkz8+bMVlhxTeX2nHUfgDjErzc2g7ULRsCJElXI+6wzOcU1HLTS3c1IGo56c8uGAK17Zukm7f0QWRYkKQmNVXERpEp0BL8nWoBLDTYJ0pWrmSczyyAzwBYuw7WpmzPZpHp2RWilRVyqm6ygrW6/p3j6kpT2lEngkc8shgCsFv9MG/Kbcs+TVIzdUoUuSt1umuereitqVwbZeSPdTwyWD8sAFq7uktszq2yur1CnuNSqotnq7Vv1BtO8373BJW0rUhxDftEpJHDxwBUKzLMuC87hj0GhMb+fI1K4nS2hCRmpbivdSPHAGa67LvOyqgafcFPfpr2oKRr/VO6DwU2tObbmXkcEGsjxRdpTyQGau1vUHgZDYAV+8jkflizpdQ7TKC56IuaTx7f9jlJtW17gZMukvJYe5lTPs5/ba4FPyyxulbUqu8Nn++xEhf3Fu9NRZXv/hjLLN6Q3UWypwSlVLSxEyIWpWtekBKjkpOo8O1iBdV528HrflxnPsWlrRt7iSqQXmT/ABH226s/Fp8i15tNTTKxTipEisoiI3zMBSldbU64EFwKAVkhziNJyy5HHI3lBSmq8Za6cuI6tnL6uFnHzXrv6nQQltpxhrubF9ITJNNta0o7tT34EkiC8pfWWxy38OKlMUL7Oe8RxPvcca+m+XVXuGoY28y+H5Sl5sez+w9q/wBsdyWoXs7obFyIpLzsV+46Yil/QB5h5MtupLASjNTmfAKOYPn8MVLV5WdLxEmqU9fjJrS4d+Db5FnHdce5ssUR+Pclq7MqPNVDi2qn03d9UjrKMpOnW72x9VKtA+95Y1SuU6Na9qR1Ov8Ay6UX6dtvx+w9Ud1Bdt2DTa5tS+m9Uc006KzHiyXepT0N6Zbkb2W0PL7xw1fPHSdC6L9Ch8Um3FZWfKn3wiNXra2Qil0mqVWV1SmRHpsopUvcR0KcXpQM1HSnM5AYuq1eFJaptRXvsaIxb4PiJ1QjMvQ0uuNsudl9jMgHI8in4jG+NR4wnszVKjFyUmt0auMTYLACwA7U21K5UoolQ2N4ySUhWtI4jnwJGN9O2nNZS2IdbqFKlLTJ4Z8qNrV2nRzJmRi2wCElepJ4nlyJwnbTgstbCjf0ar0xeWaVPmvwZrMtg5OsKC0/Lu+eNUJuLyuxIq0lUi4vhhsgTWJ0JmYx+qfSFp8vEfI8MdJCaksrucHWpOnNxfKIRtLowCmas0Pa9TJ+PuK/Dhit6jS+uX/Q7nmm/mv8kCxVnQm9RKU7VKmxCb/aHtq+qgcVH5DG2jT1ywaLquqVNyfYNTDDTDLbDKdLTSQhtPglPAY6OKwsHByk5PL5ZDdpFb3MRulNH1kjJyRl3Nj2R+8cV3UK2Fp9S86Ja5l4j4XHzBzioOnM8GLIlS2Y8bPfurCW8vHx+WMoxcnhGFSooRcnwg/Wttw2wbPkIj1Apuy32uA35Vv20DuD3FxP74UMSK1pOHuiDa9UpVdvhl6MNVm9KzZRcCENzpa6BNVwLNQTk1n5Po1N5eatOIpYhYplYpNVYEimTWJ0c8nYzqHU/igkYA3MALACwBHbj2i2LbSFKrtdhQCnm048ne/JpObh+QwAF716ZtnU9LjFqU9+tSuSZT/6NFB8cjm6r4aU/HAFcNoW2raFfiyit1Epp+eaKXF9TFHhmgcVkeKyTgCC4AWANinQJlRnxoEJovzJbqGI7Kea3HFaUpHxJwB0g2XWJEsaxqZbjGSnYzeqa8n9rJc7Tq/hq4DyywBK8ALAEZ2k3vCsiy6nckvJXU2v0ZknLeyF9lpv95ZGflxwBV3og1aoVTa/X6hOeL0ufTpEiW6rmtxcplRP4qwBcjACwAsALACwBBb223bM7OaX6WrTK5iOVOiESJJPhoRnp/fIGAKj7Zekfc20ALpUFCqPbGfGElWb0jLkZCxlmO/QOHxwAHsAO9o2vUrpuanW/TU6plReSyjvCQfbcV9lCQVHyGAOlFrW5Tbat6n0GmI0Qaaylhkd50jipX2lHNR88AOmAFgAZdITaT9BdncuTFd0Vqp5wqSB7QcWO26P6JGas/HLAHPkkk5niTzOAFgAn7NekPtEsXdxWJXpWioyHoucVLQlP8yv22vl2fLAFr9mvSQ2dXvuonWfQ1bXw9GzlBOpXgy9wQ58OCvLABVwAsAQ7a3tAjWHYdSuBzSZTaNzTmVftJTvBpOXeAe0r7IOAOcUuVJmSnpcpwvSZC1Ovuq4qUtZ1KUfMk4AxYAWAFgCXbLtpNb2eXWzXqZ61GW6nQlHJEhhXFSFHuPDNJ7jgC+mzjatZ20CliZQpYMlKQZdNdyTJYPgtHeM+Sk5g4Alj8aPIQEPtIeQFBYS4kKGpJzScj3g8RgDISACScgOZwBz36QO0k33tEmS4zuui07OFSR7pabPadH9KvNXwy8MAWl6JUNuPsWpzqPalypbzn3g8Wv7rQwBj6XFUkwtjkpphWkT5saK9l/J5l0j5loYAopgBYAWAFgC6fQumyHtmdSjOHNqLVXUseQWy0sj+scASfpSxm39iNeK8s2VRXWye5QlNj+BIwAKOj50j7Ety3INn12CaKiPnlVm83WXnHFZqW+ANaFEnnxHwGALTU2p06qQmp1NlNTIT41MyWFpcbUPEKTmDgCN37sqsW+om5uKmofeSMmZ7fq5TX3HU8cvI5jywBV/aXsauHZBS5NZpc+PVbZedCMpGTMxp1zst8Bwd/d/qjEmhdSp8EC86fCu03nKBtsjDb1yyn3jqkCOtaCeealpCj+Bxrp8nT9CjHxflHYeNqlTuSDIhqhOux6dozLzJKc3s+S1DyyyGPajZN6xVqwa05Ufb1JJYcyuTreZlVZwOOvElhWkJUWuQKsuZJ/LGcM4J/Tp1J0lKfL4+RFpQReW0ARD26PSAdeXJek9r+uvh8MYfEytn/5V1j6kP3+JNaxc1DohZanvhgup9UhKSeynhyHIY2NpFvXu6dHClsamyK+J959KGBcdR7Ds5yWGWM8w00mG6lppP3UD5njiKcMEjput52jbjmfs1BxOX3mT/wDTgCE9DzZr6VuORe09vODRTuKcFDguY4ntKH9E2fxUPDAFjbo217PLWu6Pa1eqPUp8hkP79ac47eokIS64M9ClZZjMZZczgBp2hbBNme0SOajuUQ6nITrardOKQXM+SlgereB8Tx88AUcu+1PQd5z7YgTE1lyHJ6m3JjoUN87npKUo7R1BfZyGfHlgC7nR72NMbPLX385CV3PVUpXU3ee6TzTGQfBHvEc1eQGAB/03asG7btqk6u1JmPSinyjthH/7fAFRMAZosuVEeD8Z1bLo9lxByOMoycd0YVKcZrEllEjt+7I7Vdcq9bMl2YlnTBkxShC2nUkZK0qBQQUaknMEcc8jiH1SFW4jhNe+e6+z7/8AKMrSlTorCWEEhL9tVhiqPPPon0RyEvRHYkbp5hmEsOqzjqAWAXE6gRoTllknM5DlHGtRcUlpqauWspuW3xccbfWee+FksPK8+gtljtaF8rNUjKord+0p6HQJrBy3QQhIYU0sErGkNBOZ4k5YdbjT+i+R+J9FqJzT7+ufvMaLerfbUjCwiTcNPrt3bQo6ZCrYiig0/c62n5dTCtLZW4k6lrbPEnz5cMZyat507e0ePGl4jzuow77dkx8WZT7bfaYKPYm3aBa1cTHo+oXG0jr63nGzU1NIOZ0hS97ksEhSSMzjO46n0udenmf9J7YT0Z+7B5GlVUX7g4taza5ctxNUCntBM9alB0PndhoI/WKc1cRo7+/HR3vUKVvR8Wb8vtvn0x8yNCm5PCLObOLZhWm5SmbP6pVqQ6XlXVdLbrbrxWy2spjpbBzab3gGXP8Axx8z6teSulN3GqE1jw6eGlu1vnu8FpRp6fh3XdgQ2W7MZe0i6pr0lxyNRWnFOT5qMtRW6olDTZUCCtROfkPljtutdZj06hFLeo1svl3fsQaNHxJexEVWpVJlbqlPoUZ+qIpqnypbTZUrcMLKd6pKc8uAxbfTYQpwnVahrxy+77Gnw3lpb4GPLEwwFgAi7MZ6VwZUAnttL3yB9lYyP4Efni36dPZxOZ67RxJT9diTV+mek6PJhDgtxObRP108U/mMTK9PXBoqrOv4VVS9AMPx32HlsvILbrZ0rQrgQRjnWsbHcxkpLK3QRtmUl9ylSWF5lph0Fo/fHaH5Z/PFv06T0tehzHXYJVE+7Q/XRGRJt6oNqHJlTg+LfbH8MSrmOab+RX2E9NaL9/zAvjnTuQl7OaJ1WnqqTyfXS+DPk0D/AOo4ubCjiOr1OW61dap+GuI8/MlcqSzFjOyXzpZZSVrPkMTpSUVllPTg5yUVywKVapPVKoPzXvbeVnl4J5JT8hjnKtRzllnd29FUoKK7GpjWbiebNaJmp2rvJ9nNqLn4++r/AAxadPo/X+457rd1/wDiXzZPypKQVKOlIGaie4Dni1OcArcNQjz6vJkx20tMrVk2lI09kcNR8zzOOcrzUptrg7uzounSUW8s1oVQnwXg9CkuxXhycZWptX4pIONJJJTB2x7VYCUojXZVEoTySqU44PwWVYA3F7edsS06TdtQyPg4AfxABwAx1TaLf1VBFSuOpy0ngUuy3lJ/DVlgCPEknMnMnmcALACwAsALAFi+h5s09LXJIvWezqgUX1NO1DguatPFQ/omz+Kh4YAuRgBYAWAKadMHaX6YudizIDucCh+sqGk9lc1xPLz3KDl8ScAa3Qt/6T6l/wCEO/8AzDGALqYAWAI5tIU4jZ5c623FNOIpM5aHW1FC0qTHWQUqGRBBHPAHPhnaptMYbDbV11ZCBySJr/8A9eANKp3zelUSU1KvVGYlXtIflPOJPyUojADHgBYAWALY9DTZruYky/57frJGqFRgocm0n17w+8oaB8FeOALRYAWAFgCgnSU2lfTbaJIbiO66JQ9UGnZHNK1JPr3h99YyB+qBgAT4AWAFgBYALmzTpMbQ7L3cSQ/6doqch1CaolaE/wAy/wAVo+BzT5YAtfs12+7PL9DceDM6hWFcDSZpDbxP80c9Lv7pz8hgCtvS42lfSG9k2vCczpduFTb2R4LnK/Wn/RD1fkdWAANgBYAWACHsR2Sz9pF3NwO0zRYel6sTR7jWfBtJ5bxzLJPzPdgC6d2bDdmdz0WPSp1GaYRCZTHgSonqZDDaBklKXB7QA7l5jAFab26Mm0ywp/p+x5j9VjxjrZehFTVRZHm2j2/3Cc/q4AfNnHTDrNOcTStoUJUxDZ3a6pGQG5SCOB3zHZSrLv06T5HAE4277fbZGylSrQqzU6bceqEytlWTjDOX6QpaDkttWg6BmAc1Z4ApXgC7nQ4rbc3ZW7TtXrqVPebUj7DwS8k/MqVgCS9Ja1pFxbIKy1FSVyqfoqLSBxJ6sc3P/KK8Ac/sALACwAsAdBejjZMi0tlNLizEbuoVDVUZjZGRSqRloSfNLSUA+eAI90vq81T9kblPKvXViZHjoT36WldYUfh6oD54Ao3gAzdFk31K2lRIFAqb8Kkt5y64hPaYVHbyzSptWaNTiiEA5ZjPMcsAXtwBSvpebSvTt4t2lBd1Uu3v8508lzljt/6pPY+OrAD5aPRdrblj2/d9v1URrpkRhLkU2YP0Z1t7NbbYWkakEtFIOYPHwx6ng3UK8qU9UeUaM5yTT5voK6qcqjVVwZdRmaVMvjkSw9xaeT8DjeppnV23UaVdYez9GNF71xFv22vq+Tch0dWhITw08OYHghP+GPZvCMuoXHgUtuXsv37EV2MhvVVlftMmR56e3n+eWNdIrehfX+z/ACNG1FbirudS57CGGQ193Tnw+ZOManJD6y34/wBiH63Fx9lG1Kh3LLbdn0Zhby0hvSHiFsrZUnjknUjeg+fljyccGnqFi6EvWL4Cr0ib1trajaNpxrLmpqM+XVgwIHsSUOOtFKQ40e0Bmfa5eeMSAWE2f2ZDsiyKdbsBAcMBj1qh2d9IPadWT9twnnyGAKGbYqZtBZvipVO9aa9AqNTfU6kq7TJRyQhl0ZoWlCAEjI92ANax9re0CyUuNW/V3Y8V5KguGv1rGahlrS2vMJUM89ScjgA+9FHYsslvaPcbRU64SaBHdGZ4+1MVn3nk3/W+qcAHqm39Aqm0Go2jTsn/AELES/VpSTmG5DywlqOPtaApS/DgOeeAKv8ATVq3WL/o9MBzEGmhxQ8FyHl5/wBltOABdsp2T3HtGuFNNpqCzBaIVUqmpJLUdv8ALUs+6jv+GZwBeWkbGNnNNstFnmjsy6R7b/WUhbrrxHF9TnBQc805ZchkMAc/byboTV2Vdq30qRRWpbzdOC1bw7hCylB1HicwM8AfbWtO6bomPwbcgPVGU0wqQ+xH9rcoIzOWYz4kZDmTywBKLf2w37aNNFBS0wTT1OCF6Qja5MFa/bDRVkpHM8CMUd7/AA7bXFTxJak38WHhSx6m+FxKKwTWyL8tyt3hs/txlDjVJpy3JUwzNOcmtPJWd6sgkH1uWg+eKPqXTK1G3uazw5ywlp7U1jb7uTfTqxcort/kGt2Vi+qdf06fU5MqJcLEpa96SpKkZK7Oj+by9nuyx0djb2tS1jCCjKk4/v7SNOUlLPcIz9OZvCgS7uqdHYRdN6SmKVbMVguNjeNZCRPORz7u13cPPHPRqu0qq3hN+Dbxc6jeOHxD9CTjWtT5lwaTtJmbItqCqPS0P141amliM0j1bhXMBbBCE6gsoWg5D+GNyrx6tY+JPFLRPL9PLv8AZlGOnwp45yiVbNbkpci86LZ1vodplBtyHJmTTOSGH5FS3Jbcdkoz4bouHJOfDLyGVX1iznG2ncVcTq1ZRS07pQzlKPzwbqM1qUVwjJT69b1ubNbubs9PWmWt3TBXsvX1KqzOy4psD9m0hXYH/wCTjVtq1xe0XcbN5lo7QhH1933Cmowen/6zUruzmyrUs6jU26rdnPIUwXqpdtMyU5ElucS04ke02gcO1w8OONtt1e5uric6FWK3xGnLiUV3Xu/YxlRjGKUl9oP6/sSrMe2W7st+W1XbcWwZDj7fqnmUpz16215ZhBGRKfwxf2v8RU5Vvo9ZOlWzjHKfpuvU0TtnjUt0QSj1aTSqg3Nj+2j2kHkpJ5pPxx01Ko4SyivuLeNaDiwvUauU+rxQ/EXx/aMn20HzH+OL+lWjUWxxdzaToyxL7z1UKJSKgQqbFbeWOSyMlf1hkcezoxnyjGjdVKfwtozxIcSGwGIrSWWRxCEDIZ+OM4wUVhbGupVlN5k8sY76rDUGiOx8/wBJmjdNo79J9tXwy4Yi3tXTDHdlj0m2dSqn9WO4NqBS1VSrR4Q9lxXrD4IHFR/DFPRp65JHUXdx4VNy9A0tttttpbbTpbQAlCR3AcAMdGlg4Rtt5fJCNpVb0ttUhlXaXk7K+HuJ/wAfwxW9QrfURf8ARLXd1X8l/kHuKk6Q2adBfnzmIjAzcfUEp8vE/IccZQg5PC7mutVVOLk+EGuDCYgw2YbAyaYSEJ8/E/M8cdJCCisLscHVqupJyfLI5tCrfUqWILSspE3MK8mh7X9bliHfVtMcd2WnR7XXU1viP5guxSnWDtbdvyK1PDCM0MI7Uh76qf8Aee7G+3oOpLHYh3t4qEM9+yJ9Vdn9DlsgRUmE8hISlaOKTl9dJ5/EYtaljCXGzOdt+sVYPzeZA9rtBm0aUI8rSdY1NLQcwpOeWfiPniprUHTeGdLa3cK8cxG3GkkiwAsALACwBt0ilTqvVIlLp7RfnTnUR4zKeanHFaUj8TgDpJs6sqBZVmUy24WRTCayfe/lX1dp1w/eWTl4DhgCSYAWAIjtVv2JYli1O4nikvso3cBlX7SU5waR8M+Kvsg4A5wz50ufOkTpjpelynFvSHle0txxWpSj5knABy6GP/SxL/8AB5H+3YwBdrACwBG9pX/R1dX/AIPP/wDll4A5oYAWAFgBYAfbGtCo3hdtMtynj9IqDwbLmWYbbHaccPkhAKsAdJqBQ6dQaJBo1Ob3UGnsojx0fZbGWZ8SeZPjgBwwAsALAAn2mdGzZ5e+9loj+hK2vj6RhJAC1eLzPBDnx4K88AVQ2ldHzaHYhckyYnpKio5VaECtsJ8XUe21+8MvPAAzwAsALACwB9QtaFBaCUrSc0qHAgjvGAE44txanHFFa1kqWtRzJJ5knAHzACwA6WvbNYuevwqFR2DIqM9wNMo7h4qUe5KRmVHuGAOiGy3ZvR9n1pRqDTwHHR62oTcslSJCh23D5dyR3AYAl+AFgCAbRth+z6/m1Lq8DcVMjsVaJk1JHhqVkQ4PJYOAKAXZSI1Fuir0eLIMuPTpj8VqUU6C4llwoC9OZyz0+OAGrABs6KW0Zm1doJpM90NUq40pirWo5JRKSc46j8Soo/ewBeZSUqSUqGYPAg9+AKVbeujXWbaqMm4LSiOTrZfUXXIjA1vQiTmU6B2lMj3VDkOB8SAAsAIAk5AZk8hgCxvR66NlVqtTi3VecNUOixlJfg0x9Ol2WscUKcQeKWRz4+18MAXGwBRfpV7Smbtv0Umnuh2j24Fxm1pOaXJSiOsLHiAUhA+7n34ACmAL3dFvZr9EdnrdTmN6azcWiZJ1DJSGMv0dr+qrWfNXlgCY7YNoMewrBqNfUQZgTuKY0fflu5hsZd4TxWryBwBQSyaBMvO/aVR3FqdfrE1IlPHirStWt9wnxCNSjgDpWwy0wyhlpIQ00kIbQOQSkZAD5YAov0sbu9O7V5MBpeqJQGUQW8uW9/WvH4616T93AAil1SozGWGZUhx9uMClhLitWkHmBnhk2TrSkkm84JDs2r7VJuFKJCtEWancOqPJKs80KP73DGcHhk/pVyqdXfiWwTLnsemXBJZkSXHGHmU7vU3l2k55jPPw442yhk6C86dCu03s0Mu0ClTKjDoNDZ9dUnFklZ5BLbYS44o9wzOPJrsROpUZTjTpref/AFuzWatGyLZWwurVVxNTTktC23FMqSe5SA1mtPkSceaUuTT9AtaP9WWWGqz9uFx0anJeVIN30RscdS09fSlPPQ9kA6QPddGo/Wx44ehquOlRcNdF5XoFq3b32XbVqG7EiuxqvGWn9LpExADzfd22V8Rl3LTw8DjUURXa2NhdpXltrrDNAjuM7PLckBuepbinEyJKPbjMrPa0FfPickjn2hgA17fNr0HZpaKItM3YuGe2WKNFSBpYQkaS+UcghscEjvPDlngCCdCqE+9RbruCSpTsmoTmmXJCzmpamkF1ZKjzJMjM4Ah197N7i2udIi4IkD9Ho9LWxFqFUUnNthDTKQUp5anFL1aU/wCGALH06JY+yu16ZRYLfV2X5DUODHTkqTNmPkJzPLWtR4qVySPADAHjbbd30U2X1+roXoldXMaEe/fyfUtkfdK9XywBzlwBePoo7NPovYYr05rRWLj0yDqHabhj/N0eWrMuH4jwwA4dJO29mqrBqdxXNTW3KlFa3dNltHcylSXOyy3vE8VJz4kKzAAJwBQ1C1trC0EpWk5pUOBBHIg4NAnr222/plDcodSltzob7JivPvMNLlbhfBSQ+pOrPLvPHFFH+HbSFXxYJxknnCb05+Rv+kSxhk8ibVrV/wAoXLDyhKtult0iyaA9kXUuvp0vSjl2SR3kHlijn0Ov5aMvN41RzqzXGFxE3quufRbElQ4zDta3NqUpSZdWi0Bql0eOrit2qvOLaS4c+eQKj+OK1pzr1bFeWDrOcn6U0k8G7sp98Y+0g9wUzZHZdRNIuxipXLdK8nq5NjSNw2w6+nWpDfEa1drM6uf5Yu7Wt1C8h4lBwo0OIJrOUvX0I81CDw92Zp9ZpliOWm7CWi4tnj0pdcpsY6GpqJKU7opkZZ6iyo5pzSMyMu7GFK3nfeMpfyrtR8OT5jjny/PueuShjvHk16oWruvFin2XdU+RHvh9aq7S5QLZjAKC17zju1gJB06RyTlmcbKObS3c7mjBO2Xkkt9Xbbuvf5nkvNLyv4hg2w3mzUbk9DUB1TFtUGOKTAabUQhxtv8AWqVl7QWtPfzAGJ/QOnunR8Sqs1qr1v2zx9yNdxU3wuEa9qbLGqjbwue5K4xbVvuuFmHIfQp56StPtbppORIGXPGd91p063gUabrVUstLZL5s8p0MrLeEfLq2ez7Xp8W56BWWq1bz7m5aq8LU2pt3+TebPFBPnjb0zrXi1HSnGVGvHfS+69U+5hcWqcd8SizRg7Sq0ynTKaal5e+ewr5lPD8sdPDqE1zuUVXolKXwtxMsnafUlIIjRGmVH31Er/LgMZS6jLskjXDoUF8Um/wInOqEyfJVJlul55XNSv4DwGIE5uTy+S5pUo046YrCJfsvYbVPmvEdttpKU/vq4/3cWHTV5n8il69J6Ir1YQnHEttrcV7KElSvgBni2bOaSy8APqU56fOemPHNx5RUfLwHyHDHNVJ6nl9zvqNJU4KK4RrYwNoQtmtE0tuVd4dpebUXPw99X+H44ten0fr/AHHN9but1SXzf+CcLWhtCnHFaUIBUtR7gOJOLNsoEm9u4F7iq66tVXph4IUdLKT7rafZGOdr1dcsndWdv4NNR+/5mtTqdKqExqJFTredOQ8B4k+QxhTg5PC5NlatGnFylwgx0OixaPT0RGOJ9p53vWvvP+7HQUaKpxwjibu6lWnqf2ew4Y3EYF+0t3VX0N/yUdA/ElX+OKXqD8/2HWdDj/Jz6sieIBcCwAsALACwBZXob7NOvVmXfc9vOLTNUSkhQ9qStPrXB/Rtq0/FXlgC32AFgBYApX0vNpRr14t2nBczplvE9Z08nJyx2/8AVJ7Hx1YAAGADv0M1pTtZkg81UiSE/HfMH+AwBdzACwAxX7/zGuL/AMMmf/LrwBzJwAsALACwBbzob7NOpUiXfdQZyk1HOJSNQ4pjIPrXR/SODSPJPngCy+AFgBYAWAFgD4QCCDxB5jAAa2mdFzZ/d+9m0xH0drS81dZiIHV3Ffzsfsp4nvRpPxwBVLaPsN2g2C4tyrQesUoHJurxM3Yx8NRyCmz5LAwAP8ALACwAsALACAJIA4k8hgC8nRn2JiyaD6frTAF01ZsZoUO1EjK7SWfJauBc+Q7uIBvwAsALAGvUJjcKBJmO8G4zS3ln7LaSo/wwBy7ny3Jk6RMd/WSXFvL+8tWo/wAcAYMAIEg5jgRyOALj9HzpK06tQotrXnLTFrrIDMKqPHS3MSOCUuLPBL3dx9v44AsZgCH3Dsf2Y3E+qTV7bgyJK+K5Ab3TqvvONaFH5nAHu3Nk2za230yKLbkKJJR7EndBx5Pwcc1rH44AluAK2dIXpLwKbCk2pZMtMmrPBTNRq7JzbjJPBSGVjgp08iocE/e5AU/OACX0fdmyr72iQ4khvXRqblNqxPslps9lr/SryTl4ZnuwB0HSkJAAGQHIYApF0s9pQuW+RbsF3VSbc1Mry9lc1X65Xnu8g2PMHxwA6dC+0ev3rUrmeRmxRY25jq7usS808Pg0lf44AtzcVai0Kg1GtSzlGpsZ2U791pBXl88sAcyKvVJdVqsyqTFa5c59yTIX4uOqK1H8TgCSbMtmFy7QrhRSaM1paRkqfPWPUxmj76/En3UjiT8zgC8tA2GbNqTZabSXR2J8BXblvSUBT7z2WReLgyUlXhpI0jgMACnaHs8p1iPQ2olcCabN3nU41RQp51kM6M0JeQpBWn1gy1jMeJxsVRotrfrFSnHS8SBFY1cdrlSrdbfbG+ZbbZixxx0NdtekfeUnjjODzuWnTrh1pTqPlLCXtuCWfNkzpr0ySsrffUVuKPif92NBzFSo5ycnyyZ7IZkpu4nYqFHq7zClOp7s28ilX55fPGynyW3RJtVcdmhyt+1OsXzWZDMh6FEp7zm6kxXCy4h1fLQ4nlo4nHqhlm2l0+NWvPPwJk42UdJ2NYMJdrzKSmo2/FceMKfECWZaypROp5JOh0qPvZg5eONRSVElJqO6A5ft8Vu97pmXFWF5yZSsm2R7DLSfYZb+ykfjz5nAwLo9E+kmBsYprxGSqjIkyz/rS0D+DQwBKr3vOyNlltSqtMQiOJT7r7cJjLfzJjx1LIz4qUT7SjyHyGAADsMrlxbWtubt4XAc4dvRnHoMJOZYjF71TLSB45FSyrmSnPADh02bu0x6BaTK/wBYpdTmJB7k5ssZ/MufhgAJbDNnC792hwKU6gmlRv0yrLH/AGZojNGfi4ohHzz7sAdEG0IQhKEJCUJGlKRwAA5AYApb0vNpXp28GrSguaqZbxPWtJ4LnLHb/wBUnsfHVgAAYAWAFgB9+m9yqptJpbsxTtOoj/WqbFUBpbcKtXxIz5Z8sziF/p1HXOenE6ixJmfiPZegZo83Z7c11m+o9Vo0dypMhq4rduIKAQopSl1cZQ9okJ7JH/2xx06d3bUPorhVeh+SdL8FImrRJ6tvkwTbSlWJ9K5CbJS6KIkABTpJSpzjrLWvthvw1ccdX0j6V4C+k48T29Pftn5EStp1eXgn1gbPbeh7N3rvuyl1CczUZCGoK6aFdYhx29Wqbwy4axlxz4DzxQ9U6rWleK3oThFwWXq4k/7PuJFKktGpkFuKx0NR6nXLZfcq9oQHmWDV3UBhW8fSFaN2ohSignSogYvLTqWXGlWShcSTelb7L39yPOn3W8SdVS36jtF2aWou09M2dbMZyDVaIhaQ+klQIkIQSNQXlxy/34pKN1Dp97W+keWNZ6oz7fLPsb5R1wWOxo7PrNr0eoV63bvcl0q2KXETWbkpaSAp9LIC2UcM8tWfce7x5buq9QpShTrW+mdactFOXpnkxpU3upcG3QLh2W3tW2rTkWcxQGKirq9Lq8JxRksung0Xc+Dmo8D/AOzjTdWt9Z03cKu6rhvKMls13x6GUZQm9OMA3m2VcTEiuIbhuSWbdeLNUktJzQ1ksthR8iUnHR0+oUZKnuk6qzFeu2SO6b39hixNNZIrGrLdNraQ8rTHlDcuKPIEnsqPzxLs6uie/DK3qts6tLbmO4WSAQQoZg8CMXxxoLrisOpQ31u09tUqEeKQji4jyUnmcvEYpK9lKL8u6Ots+rQmsTemX4DdR7UrFRlpa6u4yzn619xJSEp7+eWZ8saaVtOb4wSrm/p0o5ym+yC7FjMxYzUZhOlllIQ2PIYv4xSWEcVObnJyfLIptFrfVqemmNK9fL4u5dzQ/wDqOIN/WxHT3Zc9FtdU/EfEfz/6Bq2hbi0oQCpajklI4kk8gMUyR1DeAtWfbCKND1vDOoPj1yvqD+TH+OL61tvDW/xM47qV948sL4Fx+o+PyGWEBbyghJUlAz71LOSQPMnEpySK+EHLgy49MQRX29vLomfY0IHyQMUF6/5rOz6VHFvH99xgxFLE+oQtaglAKlqOSUjiST3DAN4JpE2aTXabvXnwxOVxTHIzSB4LI5HFjHp7cecMoqnXIKeEsx9f0IxVaJU6W7u5rBbz9lfNCvuqHA4hVKMocltQuqdVZi8mrFY38lpjeIZ3q0o3rhyQnUctSjxyA78azedJ9mVEtyh2JR6VbslmbS4zAS3NjqStD6z2nXdScxmtZJOAJRgBYAhW2HaFHsKwajXlEGaE9XpjR9+W6CG+HeE8Vq8gcAc5ZMh+TIdkyFl195anHXVHNSlqOalE+JJwBjwAcuhz/wBLq/8AwuT/AH2sAXhwAsAMl8oLllXA2n2l02YkfNheAOY+AFgBYAkezuy596XlS7bh5hU50B90DPdMJ7Tzh+6gE/HAHSSj0mBR6VDpVPaDMGCyiPGaHuttp0pH4DAG5gBYAxmTHEhMYuoEhaStDOoaylOQKgnnkCRxwBkwAsALACwB5cbQ4hTbiQttYKVoUMwQeYIwADtpfROsa5t7Ot7K3KurNRDKdUNxX2mOGj4t5fA4AqhtF2S3vs/lpauGFu4zyiiLUGVbyO8Rx7K+YOXuqAPlgCHYAWAFgCyXRS2Jel5rd+XBHzpUNf8AkSM4OD8hB/XkHmhojs+Kvu4AuDgBYAWAFgCE7bKt6J2TXXNCtKhTnmUK+1IG5T+bmAOcWAFgBYAWACjs/wCkftOsxluGxNTVaU3wRAqILyUDwbczS6keWrLywAXqd04Ym5HpK1HA/wB5jywUn5LbBH44A+VLpwxdzlTLUWXjyVJlgJHyQ2SfxwAINoHSM2m3qy5DlThTKU5mF0+ngsoWk9zi81OLHkVZeWABhgBYAvx0admn0K2dsPzGt3XK5pm1DUMlIQR6hk/cQcyPrE4Afttu0Vuwtn1QrCFpFTdHVaS2felOg6Tl3hsArPwwBzrdddedW66ouOuEqcWo5lSjxJJ8ScAXz6LFo/R/ZHT5DiNMuuLXUns+ehzss/LdISr54AbOl7d3obZf6IaXplXBJRGyHPcM+udPwzSlJ+9gCqOyrZVcW0W4kUulo3UNrJVSqSk5tR2j3nlms+6jv+GZAF+7A2f25Ytus0OhMbthHaffVkXn3T7TrquGaj+A5DhgCSYAqB01a479MLfpbLpT1aAuQsJPfIeKf/2GAAlYl1Jt+sqXIzMGSN3J08SnI5pWB36T+WMoSwWHTbzwJ7/C+SV1LZlS62+alQKi0iNIOtTeW8QCeekpOY4+6RjY6eeC0q9JhWeulJYZuRWKBYMB0Nvdfr0vJDbQ9tSvdToGehGrnnzx7tE2wjSso/3VGYrnlqtey0wNedXqpWZLg5lbnakL+WegY8lsjC7n9Ht9P158/wCf0InZFiqr+8mS3DHpbByW4PaWocSEk8AAOZxhGGSt6f07xvNLaCJERscQ71AjUfZMrN8pz/pAcvnlljPyk/8A8D4fx3/MNVsbdRs5tKJT5dL9KW5DZ3dNlw1pS8knNTaXgrsKSsn9Yn+qcYShgg3/AE7wlrg8wZW7aJtEuW/bidrdcf1LOaYsVP6mO1nmG2k+HieZ5nGBVFteh9aPojZm5WnUZSbgkqeBP/Z4+bTQ/rBZ+eAKybfbu+lW1evVBC9cSO91GH4bqL6rMeSlBS/ngC1fRb2a/RHZ83U5rWitXFpmSMx2kR8v0dr+qdZ81eWAJltf2gx7CsKpV9RHXEp3FMaPvy3QQ0Mu8J9tXkDgDnJKkyJUl2TIcU7IfWpx51ZzUpazmpRPiScAY8AE3Zv0edot9tNzYcVNOoznFNTnZttrHi0gArc+IGXngA50ToSWm02k1u4J0x3LtiIhqMjPy1h84AcpfQs2ZrZKY1Uq7LvctTsdwf1dyj+OABre3QzvKmMuSrXqLNdZRxENwdVk5eCcyppR/eTgACTaXMpVVVArMR+JIjOBEuK4ktvJyPEZLHA5cseSzjbkBvuK+01FqlV3Ztcz1MmQWo1HjWY43pdIUrQndp7bT2efEkfMcscNadM8NzpXtJTjJym6udvt7onSqZ3g/sG3aRTpnXLY2O0TN2THUh6rPZHJ+pS+0txXilpKic/D4Yk9Iqx01eo1dk9o+0I8L7TGquKaJFEo9g1O8qxQWIzsGk2bSBHXdUB3qzrTsfPfvOlA9cpas0gHP2TwxXTr3dO2hVbUp3FTPhyWU0+EvTH+UbUouTXGlckBpl3Uizb7qCVVJd42xVohhVR860OvRpCQchvSTvGvj4jhi+rWFS7tY+X6PWhLVH0TXy7MjqooS/uTHSiVDYfZ1TFy0WdUbhq0fNdHpD0fcIaeUMkF9zIBejP3fwxFuKXU7uHg1IwpU38Uk85Xsvf3MounF5W7CFBQ1TbbrNjTEh26a9Q6jcVwvDmmU8AW2ch3pSTw8vPHP1G6laF1HahSqwpQ/wCK5ZJWycXy02QL/gipj8C2bTTu4l3S4r1dr9TeKz1SDpzQyWQclKy45c8/I4vv9enGVWvvKhGSpwivrS9ckfwFtHvyQm9dm8y35VM9Gy0V+m1plT9KnQ0KzdS2cnE7rtKSpPeP/vi56d1eNeMta8KdN4kn29NzTUo6eN8mxa1+9XbRBq+oto7LUrmpIHcscyB446m2vsbS+85q/wCkanrp8+n6E+jSY8loPRnUvNHktB1D8sWsZJ7o5ycHF4lszLmTjIxNCsVqBSYqn5jmnh6tke2s+CR/jjVVrRgsskW1rOtLEQPVWpyanUHpr57bpzy7kjuSPIDHP1KjnLLO2t6CpQUVwidWFavV0Jq81Hr1jOI2fdSf2h8z3Ys7K2x539hz/V+oav5UeO/6E0WtCEKcWoIQgalqPIAcycWOSiSyD43EqvXlTmWsxT472plH1tPEuH45cPAYqvH8Wsv7UzpPof0e1m38bW/6BD5nFsc0BW5Ht9Xqg54yHMvkrLHOXDzN/M7uyjpoxX+1GlEiSZchEeM2XXnDkhCeZxrjFyeFybqlSMFqlsgpWrZ0ajoEiRpeqJHFfNLfkjz88XdtaKnu/iOS6h1KVbyraH5/MkmJhVkS2lTtzRG4g9qU6Mx9lvifzIxA6hPEMepc9EpZquX9q/MGOKU6sldi7SL6siSZ1t1B6KzqG/jntxXD4ONK7BJHfz8MD3BaTZp0vrUre6gXgyKBUldnrqc1wVnzPFbX72Y+1geB+iS4syM3KiPIkRnhqafaUFoWk96VJzBGAKTdLLaX9Jb5FuwXdVItzUyvT7K5p/Xq893kGx5g+OAAXgBYAN/Q8c07YAnL9ZTZSfzQr/DAF5MALADReH/NKt/9wlf7FWAOYeAFgBYAuN0O9mvou3ZN7T28ptaBYp2ocUQ21dpX+lcT+CR44AsbgBYA+KUlKSpRySOJJ5AYA597adrVSurahJr9HmvRYtMPVKG+wtTa0stE+tSpJBBdUSv4EDuwAQtmfTFr1M3UC+Ixq8IZJFTjhKJaR4rR2W3f7J+OALRWbtAs+86f1626mzPaAG9bScnmie51pWS0fMYAkOAFgBYAWAKI9KPaX9L9oLlMhO66Jb2qHHAPZXIz/SHf6w0A+CfPAAawAsAEfYbsjm7R7tREUFNUGCUvVmWOGTefBpB/lHcsh4DM92AOgdNp0GmwI9PgMJjQojaWY0dsZJQ2gZJSB5DAGzgBYAWAFgAJ9L2r9R2PvRQrSqpzo0bLxCSXz/scAUYwAsALACwAsALACwAsALABU6OGzUXxtFjCW3rotGynVPMdlehXqmT/AEi+Y+qDgC/+AKLdKraV9K9oCqNCd1Ue29cVvSey5KJ/SHPkQED7vngAV2nb8m4rnpVCjfrqnKajJPhvFhJV+6OOAOmsCDGgQI8GKjdxYjSGGEfVQ2kJSPkBgCsm2a0Li2wbam7WpKtzRLWjNt1SpqBLTDsn1rmX1nFI0JSjy45DPAFg7Hse3rKt6PQqFHDERjitZ4uPOH2nXVe8pX/2HDAEN2w7a4NmPQrdpO7m3jWHWmIcQ8URw8sIDz+XHv7Ke/4YAKKc8gCcyOZwBQ3pR1UVHbTWUJOaKe1GiJ/dZC1f2nDgAk3JcvRw2Tzja0S1E3TVYvZqcuQlp8oX3pU68FDWO9LaQB8cAaFybPdmm0qw6heuypldGrdJSV1ShIzbCwlOtSN0klKVFIJbU32VZZZZ8h6pNcAHsaZRotxsTKw4UNNZqaXlqTvfdK+/Ic8ZQ53JvT6lONVSqdvzJdtHtt+qtKuSJUGpEFloeqzGlKB/JqGYUSo8ueNk453LTqlq6i8aMk4pfvB9qzq4eyOCIXBEhLaZKk+DilFf4qGRwfwntZ6bGOnvyC7Gk5wKNrKcf2WVZEzjHbD4jlX1QlKhl8HMbo/CdHZ5dlLVxvj9/MVv2RbjdqMO3DpYk1BYU0+pe7W3rHqkJJ4cR2iDgoLG4tun0lRTq7OX7QYIu36dYVkfRyo0xK249PXEtyqweyN621pZTKZUeyeSitCjn4Y1yjgrL6wdB+sWBnYBs4Xfu0WJFlNl2jwD16sKPEFtB7LR/pV5J+GfhjErzoOEhIAAyA4AYApF0s9pf0lvgW5Be10i3NTS9Psrmq/XK/0f6v4hXjgAFYAs/wBGno6RKnGj3veMYPQnPWUakOjsujukPp70fUR38zwyzAtklCUJCUDSlIySkcAAO4YAhV37admNovKj1uvx2piPbhs6pD4PgptkLKD97LAEepXSk2LVCSGPTaoilcErlR3mkf19JSPngAn06pU6pw25tOktTIbwzakMLS42oeSkkg4Ag21/YzbW0ijKZloTFrjCT6Nq6E+sbV3Ic+u0TzSflkcAUGuCg160bllUiooVCq9Me0qKCQQpPFLjaxkclDJSVDux5KKaw90CaUfbzdsZTT9UQ1V6hCiSItJqL4CZEdcgBO9LgGbukDgFeJ44524/hi3ltDMIylFyiuHjtjsSY3Mu+5imXfRaXskYtyiyjIrVwSFS7ofKVJWhLR9VH1K9oH2swfHxxlTsKlXqDrVVinSWKa+fLPHNKnhcvkg1D9HGtQBUv+TjJa673ep1jecvs54vLjX4ctHx4ePn2NEcZ34DdtLhUmXdKbHpduMU25UToqrVqlLbS02uC4kK1SDnmop4q1Zd348V0epUjQ+lTqudHTLxIz3epf2/oTqqWdOMPsZWKVcuz/aAraBVZwvGirWuBUKnAcbVI3jo3CUOMk8FhQA0g4wlXo39p9Epx+j1PiUZJ4wt9n6e40ypz1PdGexoFeuS8KdtMpMtMupv1J6PdFGdWhrqUE+rSO0dSkhjy5j44w6lVpW9vKyqLTBQTpyW+qXP36jKmnKWtfaerAt627drVz3h6VjU+B12VRrKny+1HS+5qJdAHNCPZB5ZZ486pdVrinSt9EpS0xnVS5xtt83z9wpRUW5fYhmu2y7rveoumbEoNJVRDorN3MPBqHLU6lK2syOBWEHM5Dv45csTLHqFCygtLrT8T4aTWZRxz9hrnTc32WO5Bro2eXbZkVmsMzGZtGkq0M1mlP72OV/UWRkUn4jHQ9N65TrzcI6qdVfVksMiXFoseZKSI8bvuZSdJqL2R8/8cXn0qp6sgf6dQ/sQ2OvvPuFx5anHDzWslR/E40N55JkYpbLYlVjWr6QeFQmJ/QWVdhB/arHd90d+J1nbanqfBT9V6h4a0R+N/gE3F0coDu/bq361UmEv1CD+lOp99Q9weQ7/ADxUXtznyrjudN0jp+n+ZPnt7Dbs9a3lzMq/km3F/wBnL/HGmwX8wldZli3fu0FbPLj4ccXpx4FolNnVqqONxEa3HVqWpXupBPtKPcMc3Gm6ktju6laFCnmXCClbtswaJH0teslLHrpJHE+SfBOLy3t1TXucje306732j2Q6OPNNlCVqCS6rQ2DzUrwGN7ZEUW/sPePTEF+0af1iu9WB7ENsI/eV2lfxGKTqE8zx6HW9FpaaOf7mRUAk5DiTyGIJbh5tG2mKVbTUCS0lxyQN7OQsBQK1+6QfqjhiTGOEdrY2ip0tL78jFcOyimy9T9Ic6k+ePV1ZqZPw95H54xlTIV10aEt4eV/gMdv3ttW2WyltU6Y/CjO6gYy/XQnCR7SUnNGrvzGRxpawc/XtalJ4ksEAddcecW66ordcJUtajmSo8SSfE48I55wAsAGzogf9MTX/AIfK/gnAF58ALADZdDYctqrNnkuFISfm0rAHL/ACwBKtl9izL5vemW5HzDclzVNeH7KM32nl/JPAeeWAOkNOp8OmwI1PgtBiHEaQxGZT7KG206UpHwAwBsYAWAAp0qdpf0UsBVGhO6KzceuK1pPabij/ADhzyzCtA+95YAovgBYA3aPW6xRag3UaRNegTmeLcmOtTax805cPEYAshs06ZM+NuqffsTrjPBIrENIS8PN5nglfxRl8DgCztrXlbF104VG3qkxUoh9pTKu0gnucQcloPkoDADzgAadIHaULE2dzJcZ0IrVRzhUke8HXB23R/RIzV8cvHAHPckkkk5k8zgBYAdrUtes3TcEKg0Zgv1Cc4G2k9wHNS1nuSgcVHwwB0S2ZbO6NYFpRaBTBqUj1k6XlkuRIUO26r8MkjuGQwBK8ALACwAsALAFXenBVtMC1qQD+tdky1p/o0obQf/MVgCp2AFgBYAWAFgBYA3KRR6nWanGpdKjOTKhLWG48ZoalrUfD/E92ALRwehXEdstlMusrjXir1rriQHISSRwY08FnT9cHn3ZYAAu0LY7f1hPkV6nK6lnk1VI+bsRfh6wDsk+CwD5YAO3RS2n7LLft1VuzpXoq4pshT0qVM0ojvn2WkNvckhKPdXlxJy54AMO3faW1Y2zmZU4zo9Kzx1SjaTn651P60eTaM1/HId+AOeilqWoqUdSlHNSjxJJ8cAHrodWj6V2jyK86jVGoEYrQT/2iTm03/Y3hwBdjAGnTaPTaYh9EBhLHWnnJUkp5uPunNbizzUo+J+GABPt86QFN2fQV0ikqRLu+SjNln2m4iVcnn/PvQjv5nhzAqxsYTUbq2426/UnlzpsioidLfdOtazHBkKUo/wCjwB0LwBzX2lVY1faNc9SB1JkVKSpB59gOqCP7IGANO/Ldr9vXdVKXX0rFUakOKfdX+21qKg8k96XM9QOAD70R6ZModAvG9qtnGtsQ90FucEPGPqcdUnPmEDs5+JywBubKKBY2zrY5MvfaBT0y27qcaaZp6m0PLMNavVIbQ4UjNQ1PHj7IHeMAQzbjsrt+jUSi3Vs9lvOWtdjqG26TmtQDy062d2Fdsg6SNKuKT+QyU2ljsyLW/UzQ25NlXvCdgAEhKJSFIKAo5lK8+IGrtJUMbIS7Muen3sNHhVfhMn/BdbJc616a/wAn+1lqazy/pM8vyxl4aJH+kUedfl+z8xxMyk1qRFtKhAKo8bJypPo9gtNnMNJPva1+0rvx7zsjfrhWaoUvgXxfJdvtHW56DRrkhJ6xNVGZgurRvEFIbCwdKgoK4cOXPHslkk3dtTuI7vCi/sIVtJrtJXT6fQKa8JLcLIuvBWsDQjQlOrvOWZOMKj7FR1W4hpjSg86S23Rn2a/QzZ2xIltaK3XdM6fmO0hBHqGf3EHMj6xONRRkg22bRWrB2fT6ylQ9JOjqtKbPvSnQdJy7w2AVn4YA51POuvOrddUVuuEqcWo5lSjxJJ8zgCdbEdn/ANO9otNojwJpyCZdUI/7MxxWn98kI+eAOijLLTDSGWUBtltIQ22kZJSlIyAA7gBgCr/Sd6QdQp82RYtpSTHfaGmt1Ro5OJKh/mzKh7JAPbUOPd44AqgtSlqKlEqUripR4kk4A+YAm+y3a5dezusomUl9TlOcWDUKS4r1D6e/hx0ry5LHEeY4YA6CWhdVJuu2oFw0le8g1BoON5+0k8loX4KQoFJ88AV96Z2z5mRRqffMRsCVCWmDUyB7bDp9StX3HOz+95YAqNgD6EqPIZ5cTgCabPbyt+jxKvRLlpq6hQa2htL645QmUw4yrUhxlSvzGeKbqvT6taUKlGWmrTzjPwvPZm6lUSynwwzWfcTNxyKpdlqQUyavblLaotq0SS82uYpCeLkp4akk8FaRkfEd+OOv7R26hb15Yp1ajnUmk9PtFfv0JtOerzLlLCGO25FBl1uo33ULcNtx7SbVIrdPC1hmVWdREVKGV5aFJJ1ZdyiMTruNWNONrCr4rrvEJbZjT+tv3/Q1wazqaxj8xlrVUj7QNmNcu+fAZp1z0GQw09UoY3KJrEpendupHArTn/DE23ouwvadvGTlRqJvS99Lj3XsYSfiQcuGiP0LanFctdq0bqoLNcpERCxSlNfo8qO6oEgpWj2s1HjmM/jifc9Far/SKFR06kvizumjXGt5dMllD7UaXVbl2FW03a7S5jVDky/pBTo41uh5xWpp9Tae0oaCePn8cQaVaFv1Sr4/ldSMdEnxhcrPzNjTlSWntyRW0KjtApkn6GQIxbVX34qvR06PqBWhwKadCHR2RmnMqy5DFpf0rSovpMn/AElLzRftutjVTcl5fUKV6UCxb4vqXbMGCmBWaVk9X7qj6W4gaZbzlKXHGSdQcySPnmeGOY6ddXVlaqtKWqnPaFN7yy35d/luSakIzlhcrlgovPZdW7aaZntSI9ZocsKXEqtPXvW1IRlqK0jtN5ahnnw88dV0/rVK5bi06dRcxls/+yLUouO/KFbu0FyEy1DnshyK0NLbjQCVpHmngFY6ehfadpcHPXvR1UblB4k/Uc7rvqIKclikPbx+UntujMFtHeOPJR/LG+5vVpxDuROn9KlrzVWFH8f+gc4qDpiZbMGdVWlO/wAmxl/WUP8Adiw6cvM/kUfXZfy0vVhHeQXGloB0laVJCvDMZZ4uGcxF4Zp0ejQaTDEaIjIc3HD7S1eKjjXSpKmsI33NzOtLVIxV64IFGi72QdTqv1Mce0s/4DxOMa1eNNbmdpZzryxHjuyMWdNnV24ZFUmHNMRvSw2PYQXOGSf3QeOIVpN1ajk+xa9SpQt6Cpx+s9/fBOVrS2hTi/YQCpXwAzOLNsoEsvADahLXNnyJS/afcUv+sc8czOWpt+p39Gnogo+iJTsyt30nXRLeTnDp2Tq8+SnP2afxGfyx7TW5c9JtfEqan8Mf2g0YkHXCwBjkR48llTEhtLzK+C2nAFJPyOBjKKksPdA9ufZQw4FyaCrdOczBcPZP9Gs8vgcapU/Qorvoye9L7gZS4kmJIXHktKZfbOS21jIg40nOzg4vD2ZhwMQ0dEVak7ZogHJcKWlXw0Z/xGAL14AWAG64/wDm9VP+6P8A+zVgDl7gBYAuh0QdmvoS0nrwnNaalX+zD1c0QUHs/wCtWNXwCcAWDwAsAeHXWmWluuqCGmwVOLUcglI4kk+AwBzs23bRXb92gz6wlZNMZPVKQg90VonSrLxcJKz8cAQLACwAsALADnbtz3DbdRRUqDUH6bORyejrKSR9VQ5KT5HhgCy+zTplg7qn3/DyPBPpqCj834/8S3/VwAK+kdtSav6+1Kpr29t6ko6rS1DMBzPi8/kcj21cB9kDAApwB9QhS1BKAVKUckpHEknwwBejo1bFU2Lb3pqsMgXXVmwXkq5xY57SY48FHgpzz4d2ADVgBYAWAPLbjbiAttQWhXFKknMEeRwB6wAsAUo6ZtX63tOhU8HsU2mtJI+284tw/wBkpwAA8ALACwAsALAG9Q6HVq7Vo1JpMZcyozFhuPHbGalKP8ABxJPADAF7NhWwak7OKb12Xom3VLRlMnZZpZSebEfPknP2lc1fDIYALOAMUqLGlR3I0ppD8d0aXWXUhaFJPcpJzBGAAJtL6IdoV3ezrRdFvVNXa6rkVwVn7nFTX7nD7OAKsbQqLfNr1Fuz7pkOK9EArhRN/v2G0PgHUzxISFhI4ZD4YAieALz9Ei0fQmytupuo0y7gfXMJ79yj1TI+GSSofewAbMABTpAdISDYcNdEoS25V3yE8uC0QkKH6x0cis+4g/E8OYFIKlUZ9Tnv1CoPrlTZSy7IkOnUta1cSVE4ANfQ5pPXNrDk0jNNNpz72fgpxSGR+ThwBc646mmlW/U6oohKYER+SSeQ3LZX/hgCsuxPouUeu2p9Ib8bk9bqpD8CI04WVNxzxC3PtO56su4ZeJwBj/8A0i6fOgBO0GxIdwT6W0hb81pLSkNqc5IUiQlelXLUEKI8sbpW8l9nPsRKd5CWP9zePfHf5GrT9olzbeLrp9iwKemgWJHUmVWIkY5qVFjkEIccAQkBStKUoSnLM58csaSWGaffVmVmhX01No8eq2xZHqFRShDiXVx2NbyUJX2E7sjQk+WAIfsyuAbYLup9VYo4o9hWJkaTT+yd7UVI0tEhICAI7fFKU8iRx48AGW6ttFhV2rVG1dsdmP0pthx70VOU2ovJZzO7OacnEKUPebUpBPlgAA23slvG86dWq7alLW7RqY4ckOuJDhSe0G0E6Q6ttvIry/xAwBis69KdQKLUWRHX6UfGpiRwKSQMkJPIjTmT54zjLBbWN/GjTksed9x6p5U7sfqC3DrUXFqKjx475BzxkvhJdPewl8/8oz9HHZr9ONokZMpvXRKNpnVPMZpXoV6pk/0i+Y+qDjUc8X/wBVbpgWrtMrNThVCJTXJloUtg7tUTN1aHnOLzrzQ7SRkAAciABz44AqrgC1XQgojWV01tQzeHVoTR7wk6nXPxOj8MAWLvy5BbNl1q4MgpVMhvSG0nkXEoO7T815DAHNCbMlTZj8yW4XpUlxTz7quKluLOpSj5knAGHACwAsAW56ElyPv0O4rddUS3BfZmRge4SUqQ4B5Zsg/PABp2xUdusbLLpgLGeqmyHUd/bYRvkf2kDAHN3AFvuiFssYjW1OvGrxkOuVxKokBl5IUOpJV61RSrhk8tOXwT54AdtpXREs+vbydaTot6pnj1XIrgrV9z2mv3OH2cAVbvDZ/tB2cVhoVeK/TX0qzhVKOo7pZHey+jv8uBHeMY1IRmtMllP1PU8DtbG1xDFGlW7dtIbuChz5K5stWtTMzrLnEvb5Ptq+9+OKC86Fmoq1vN0qsY6V3jj0x2N8K+2JLKNe9NpFLqFux7TtWk+g7ZZd6y80tzfSJL+WQW855dw/3DGzp3SJ06zr15+JWaxxhJeyPKlZNaYrCHbY5AiUOn1naVVGwuNQGyxR2l8nqk8MkDz0BWZ+OfdiL/ABBUlWnCyhzVeZe0Fz95nbrGZvsPFRrD9VsdnaPbDC7bu1upJpNSRS9TbM5TqNSVIaTwKsyM08f4YiUrdUrp2dd+NQcNcde7jj39DNyzHWtnnBt0aFtmt+oTr7ua3ptYqiKc6xTprrra3IalA6XVMJ1L0pBPDIZccabip06vCNrRqRpw1ptYeJe2eD2KqR8zWTb2ZCsUzZjMrVosRLnuuqy95cMFxSXXW4KdQ3a2SUrWXCSTl9bvyxq6z4dS9jTuHKjQhHyPhOXrnhY/wZUcqGY7t8mtsxr0VirXTtBiU8W9aVNhbuVRWl7xmTNcTklkbwcivjkAMuzjZ1m2k6dG0lLxa85bS7xiu+3t/kxoy3c+Ioju0WlW/Lsum3k7TEUKv3E8PR1GgcGFRmhk7JWgjMFxZ7Onuy54sek16sbmVspeJSpLzSlzl8Rz7Lk11knHVw2Qq4rAuqg1B2nzYSlyo8ZubKTH9duWXcsi7oz3eROR1YubXqlCvBTi9nJxWdstenqaZ0pRI7ieayf7LGexUXv6JH944temrlnOdel8C+ZPMWhzww3PdsOitbtOT1QUOwx3J+0vwHl34iXN0qfvIsbDp0q7zxD1/QFU+oS58pcqU4XXl81H+AHcMUc5uTyzr6VKNOOmOyCbs8gdWt8PEZLlrLn7o7Kf4HF1YQxTz6nKdZraq2P7UbN7T+p25KIOS38mEfv8/wCyDjO8nppv3NXS6WuuvbcEQBKsgMyeQxQHaB8sygCh0BiIoZSXPXSz/OL7v3RwxJisI7ewtvBpJd+4+YyJhG59/wBv0+urpMtam1NhOuSBqbSs+4rLiMvHGOtZK+r1KlCpol95IGH2JDKHmHEusucUOIIUk/AjGROjJNZW6MmBkMd1WlTbhiaHxupiB+jywO0nyV9ZPljGUckK8soV477S7MB1WpM2lVB2DNb3b7JyPgR3KSe8EcsR2sHHVqMqctMuUPmzbaBVLBuyNclNYakvsJW2ph/PQptwaVDNJBBy5HHhqLobNekvs7vTdxH3/QVaXkOoTlAIWo9zL/BC/gcleWAC3gDUq3/JUz+gc/uHAHLfAEx2SbP5N+X5TbebzTFcVvqi8n9nFa4uq+J9lPmRgDo7Eix4kVmJGbDMaOhLTDSeCUoQNKUgeAAwBlwAsAArpZ7S/o1Y4tyC7pq9xhTS9J7TcJP65X+k/VjxBV4YApDgBYAWAFgBYAWAFgBYAWALL9FDYl6Slt3/AHBH/wAnxV/5BjODg8+g5GSQfcbPBHirj3cQLeYAWAFgAE9JrbKq2KUmzqA9ndFbRu3FtntxIzvZ1cOTjvJHeBx8MAGmh05FMosCmo9iFGajp+DSAj/DAG7gBYA55dIirmqbZrof1ZpZkiIjyEVtLJ/NBwAOcALACwAsAOduW3WrkrMai0WIubUpitDLCPzJPJKUjiSeAGAL37D9htG2b0gPPBE255aB1+o5ewDx3DGfFLY7zzUeJ7gACjgBYAWAPilJSkqUdKUjNRPIAYA5rbUbsVdm0Gu1/UVNTJS+qk/9nb9WwP8AVoTgCLYAtVse6WtDhUynW3d8AU5iE03Fi1SEkqZDbaQhO+Z4rTwHEoz+AwBK9t3SeoVvUdFPsqYxVa7UGdaJzKg6xEbXyWcswp36qO7mrwIFMJkyVNlPS5by5EqQsuPvuEqWtajmpSlHiSTgDDgC1XQepP8Azqq6h/2WI2f9Y4v/ANOALRToUSdEdhzGkvxX0lDzK+KVpPNKh3g9+AM+WWAOecyJLjx5UeQw9OiqaQsobGguPlzW4p4klSs9IzUjMAcBjG26zTqRxPbPvy/Vv9SvrdMlGSlT7fgsYSS9hyotdVbcyRcsWrSKH1hSabTnqZlkpLSfWuKaOaHWgrlmD5ccsTbhxcvbgtekWUI2uuu5LW9vX5j1ZV50uz7PvnZ9Vi69ULmjrXSamjtMuqfY0N7wk6kayc9R4DvxFawZ3Ns6U9PP6Bdu63L82ebCqNRdmbDkuahSZVaq1PKXHc8t6642jipwLXknsg5IGRx4RwXs33tA28s0vZ3MpkVFQjyRIqdwpayU1Fa4LKmyPVq1EZ6CNRyTkMAHidV7PtXZHeNGtROmHaEJ6nuPDLJU5xjNQKx7TgW6neH6xy7sAVh2GbAqvtHndemlyn2pGVlIngdt5Y/Yx9WYJ+srkn48MARzafb7Vi3pW7Ro9WdnU1gobfUoaNRUlLhbWkEpKmyctQy44ZNkaskmk9mSewrvvnZRTvTNIlx1RZu7VVKNLbzQ4fc0rT2wsJPcR88TKlo4w1FRQ6mqlZ00vt+RZTZp0ntn147mHOd+j9bXkOqTFAMuK/mZHBJ48grSfLEMswwDIjMcjgAM7a9heymr0Sp3NUW/o/MhMuSZFVgpSnVoGfrWOCHSeXconvwBDOhDMaVQrphBXrWpUd7T36XG1JB/8vABf27UyRUtkF1RY4Jd6it4JHMhgh4j8EYA5z4AWAFgBYAtd0IKJITFuiuKGUd5caEyfFbYW45+AcR+OAD/ALTqg1T9nNzzHTklqlzDx8SwoJHzJwBz62aWNNve9aZbkXMCW5nKeH7KOjtPOfJAOXichgDpDS6bCpdNi02A0GIUJpDEZlPJLbadKQPgBgDFGr1FlVSVSo85h2pwdPXIKHEl5rWkKSVt56hmkgjAH2tUSkVymvUyrw2p0CQNL0Z9IWg/I8iO4jiMAUd6Q+wo7OqmzUqQVvWtUllEcrOpcZ/2twtXeCkZoVz4HPlmQA5gAlW1tNto2hHs28aCZ1EiOKfiSae4Y8pDys81qBOhw9ojM92OdvOj1vpDubeppqSWGpLKx+aJMKy06ZLYIGzi/aLW7niW7bFKFNpVEgTpdvQpCg47Iqpb7LzyuRWElekZ/wCGVB1fplSjQdavPXOpOKm1woZ4Xtwb6NVN4XCX4g72cVnaI/tWpymJMx6svTUipNuqXxb1/pAfSeASE58xwx0PV7ezVhLKiqaj5eOe2CPSlPxBp2gymKVtJuBy25CosZE19DDkZZRkkntpSUEdnPMfDEvpcHVsqfjLL0rOfwMKrxN4JLKpW0E7JreiuUMt2b1ldQly4WpbzwUvILkoBJTkjPQcssssVkK9p9PqS8T/AMjTpSlwvaP+e5taloW3lCLXKLSJV7x9olUqcB7Z1QITS6FGYeSVLLCPUxgzz177iR8B8OetripG2dnCM1d1ZPW2vV7yz6YJEorVrfwocrTh3E1bFTucVeFRrzuVxqt1CRUE6mo9K3hSy0rP2UqHj3cPPEa+qUXXjQ0SqW9FOmlHl1MbszgnpznEnv8AYAXa9Otedf8AVJNspbFLWUZLYToZW8EDfLbT3JUvM47voVOvC0gq+dfvzjtn7CBXac9uCMU2ZUojxfp7jjbqBqUW8/ZHPUOWXxxcxquDyngi1aMaixJZRKf+EupmnqaLCBO5JlD2QO86OWr8sTv9Rlp9/UqP9Dp685en0/7Ic8+686p11RW4s5rWriSfPEBvJdRiksLgTLS3XkNIGa3FBKR5k5DBLIlLCyHKHFREiMRUeywhLY/dGWOmhHCx6Hz+pU1ycvVkE2oT834cBJ9hJecHmrsp/IHFX1Ge6idD0KltKf2Gvswt4VOudcfRnEp2Thz5Kd/Zp+XtfLFfTjlnbdItfEqanxH8+wZ8SDrRvuCss0ajyai5x3KfVJ+s4eCE/jjxvBoua6pU3P0K9SJD0iQ4+8rW86orcWe9SjmTiKcLKTk8vljpbt1Vigv7yE76kn1sZfFtfxHcfMcceqWCRa3lSi/Lx6dg02zc9PuCD1mL2HUcJMZXtNq/xSe44kRlk6+0u4145XPdDxjIlEJ2pW8idRfSbSf0un8VEe8wT2gfunj+ONdSJT9YtddPWuY/kBzGg5QWACts16SG0SyN1EMn01REcPRs5RVpT4MvcVt+Q4p8sAWmsnpCbPb9pj0ONK9GVt1lxPoqcUtrUooP6pz2HPkc/LAFA8uOWALtdEjZr9HbJVc05rTVbj0uM5jtIgp/VD/SHNZ8RpwAecALACwBFr62ZWTfMLqtx01uUpKSliWOxJaz/k3U9oceOXLxGAKr7SuiDdtE3s+0HfT9NT2upnJE5A8Angh393I/ZwAApUSVEkORpbK48lo6XWXUlC0qHcpKsiDgDFgBYAWAFgBYAWACXsI2QTNo92JYeSpu3qeUu1iUOHZz7LCD9d3L5DM4A6AwIMOBCYgwmUx4cVtLMdhsZIQ2gaUpSPAAYAz4AWAIVtc2nUrZ1aL9al5PTF+ppcHPIvyCOA8dCeaz3DzywBR2x5FVvfbPQ5VXeMqdVavHemunvCXQtQy7kpQnIDuGAOi+AFgDytaUIK1nJCQSo+QwBzAuWqKqtx1WqK5zpb8k/wClcK/8cANuAFgBYAdbYtiuXPW4tEocVUuoy1aWmk93ipR5JSkcSTywBfTYtsSoOzaj9nTMuKWgekqoR89yznxS0D81cz3AAErACwAsALAA76QF3/RbZPXZza9EuU11CGRz3sr1eY80oKlfLAHPDACwAsALACwAsAXf6HVIEPZMublkup1F97PxS2EMj82zgA6YAD+1npKWxs9r7VCMF2sVHd72aiO4lAj6v1aVkhXaUOOXcMvHAFJKbdNZpydyzIUqMnVpYUSUgq4Zp70nkeGItazp1N2t/UzjUaJHOqFlV5uA5LnSKa3T2g0qnbre6hnmotuJ95Z5k4nbFtOpb1lHMnBRWMYz9xvXBdb8eixKxR2RFdqi1s9ZyC1ssRfVtMgnMAkdo49cu5vubxxpqpT2c9s+iWyRLtnG1naTTqXS5VLlBTi6h1N2HITqiyGNGta1IGWgt5e02Rjz4kafDd1Ti38erGfVf9DqekLQKBa1zroDLy9o9wz3TPrCm0hnQSoIcjkEnQy32W0Hv7RzxgypqwUZNJ5SJ/sbsimVbo2iNcM0waVWZbtUrMpStKlR2ZIKgp1R7OsRhmrwx4ayQbO9q1IqjVx1KhRk0zZpZEIsQkJRoMl1CS6tzj7KUNtgJTzOvNXHgAKiUJqXdl5TK1UfWb19yfNJ46nHVlYT81H8MS7Ojrn7IreqXXhUtvilsbF6zX6zXo9DhnUlpelXgXle0T9wf4433k3UmoIh9LpKhRdaXf8AL/skFUi2jEiQqPUwgJKNMdwjJQy5qKxxTqJ+GJdSNKKUJFbQnczlKrT+3/4PNB2u7R9lTsdqJN9OWu52WqdPJXu8vcbcHab4csuz9nFbdW3h/Ivun9Q8dYe00b+3bpJwb+sqn0Khxn6eJLm+rrL2R/VZbppC08FoKu2TkOQ4YiFkNnRJvRmgbThTJTm7iXCwYYJ5dYSdbH4kKQPNWALyOttutqbcSFtrBStCuIIPAgjAHPfbrsjqOzu7n2kNKVbs5anaNM5p0E57hSv5RrkfEZHvwANsALADra9r1u6K7EodEjKlVGYvQ02nkPFaz7qEjionkMAdFdmVhwLEsqnW3EIcMZGqXIyy30hztOufAq5eAyGABZ0wb6bo+z9q2mHMp9wugOJB4iJHUFuH95ehPnxwBqdD/Zr6GtZ+8p7Wmo131cHUOKIKDzH9MsZ/AJwAab6u+nWfaVTuOefUU9kuJbzyLjh4NtDzWshOAOcku8bkkXVIuoTnY9dkyFy1TWFqbWlxZz7JBzAHIDw4YAu50atqdXv+yn3K3kusUh8RZEpI0h9Kkam3CBwC+YVl4Z9+AN/pKUuNUNi9xh8DOK21KZUfdcaeQeHmRmPngCiVn2vUrquam29TU5y6k+llB5hAPFbivsoSCo+QwBaq/OhpbkyAh2zZy6bUmWkoVHllTsd9aU5airitpSyMzlmPIYArVc9kbQNnVbZNWhSKTNZXrhT2z6tSk8lMvozSfhnn44wqU4zi4yWYvsep4Hqf0gNpkunOQzOZYcfRu5E+PHbalOJ5dp1Iz+YyxQ0/4WsoT1aW8cJtuK+w3u6mMWzSzJF53nAoic9w4vez3R7kZvtOq+OXAeZxO6x1FWdtKr3Wy+b4MKNPXLAZ6peES5rsRTbLqNXty6o7iKLGpmjOC7BbWUqeLZ4NbpnUvtDPHHULCVtQ13MadWg1rcvrKXpnvl7bEyU9UsRymRa8LQtGrKumuwNNJtm0WGaXTX47aSahUW8k5rzy1lR4KV4ZHxxZ2F/cUvBpS89au3OSb+CD9P0+w1VKcXl8KI3rvW8W7cq9Tu2G9JZvamJp9Ino3aAOoqyT6pOXYzPHgOeYxIXTrd1oQt2k7apqkt/re/qY+JLGZfWIFaVn1+6q03SKLGL8pfFxR4NtIHtOOq91Kf8A3xxe31/StafiVHhfn7I0QpuTwiy1o2tD2eNvU2n0wzmn6PLnVa7nEhTLy2m80xWMioJQDxIVz88fN7+9lftTnLS1VjGNLusv4n7llTh4fHpyA3Z3s0g3JRatXK3V00GjQS3GYqDqdTapjqhpQocOyAe1lyzGO36t1iVvUhSpQ8WpLdpf2og0qOpNt4Qw3vY9bs6sejaoEK3iA9ElsnWw+yr2XG1d4OJ3Tuo07unrh8mnyn6MwqU3B4Zq2s7AYr0R6c4G47S9ZUQSNQHZzy+1i2tnFTWrggX8ZyoyUN2wxMutPNpcZWlxtfsrQcwfmMdCnk4eUXHZ7MD1zzTUbhluozUC5umQOPBHYTl8csc9cz1VGzuOn0dFGMe/6hms6gih0CPDIykr9bLP86vmP3RwxlFYR9CsbbwaSj37/Me8ZEwE21m4es1BujMq9TC7cjLveUOX7ifzONFRnMdautUvDXEefmD/ABrKMWAHe1a+/Q60xNQTus9ElHcpo+0P8R549i8EqzuXRqKXbv8AIsCFJUApJzSoZpPiDyOJR3J5fYbkMOR3Bm28hTax5LGR/jgeSjqWPUrdKYVHkusK9plakH4pOX+GIh8/nHDx6GLAxFgBA5YA2Ke9EZnx3pjBlRG3ULkRgvdlxsKzUjXkdOocM8sAX82X7fNmt5x49Pp0gUmpoSltuiy9LS+AyCWD7DgGXAJOfkMAE/ACwAsALACwBDNoOyGw78jKRX6ahUzTpaqbGTUtvwydHtAfVVmPLAFVNpfRMvi2t9Ptw/SOkI7WhpOma2n7TPHeZeLeZ8hgAGOtOsuradQW3WyUrbUCFJI5gg8QcAecALACwA82faVau244Vv0ZnfT5y9CPqoTzW4s9yEJ4k4A6I7Ntn1GsK04lv0sZhoa5cojJciQoesdV8e4dwyGAJTgBYA0q1WabRaTLq1UfTFp8FtT0l9fJKEjM/E+A7zgDnptk2qVPaNdztVf1M0yPmzSIJP6pjPme7W57Sz8uQGAJL0UKSJ+2emPFOpNOjyZZ8vVFoH+s6MAXzwAsARnaZVxRtnlyVPPJUWmylt/f3Sgj+0RgDmlgBYAWAHm0bRr921+NQqFGMqoSjklI4JQke044rklCe84AvrsZ2M0LZrQtyxpl12WkGqVQjis8923nxS0k8h38z5AEXACwAsALACwBU/ps3drmUG0WV8GUrqcxI+svNpjP4AOfjgCrmAFgBYAWAFgBYAtj0eOkXYNItSl2XXkqor0ELQ1UV9uK6XHFOErUBm0c1940+eACxtl2zUWxLJ9Lw32ZtTqaSigNIUHEOry4vZpJzabzzJHPgO/AFBJlSn1SoSqjUH1yZ0txT0mQ4c1LcWc1KPxOAH1GzG8XO11NKM+5TrYP8cZ+GyyXSLh9vxRjkbNryZGfUN4P5pxtZ/AHPDQzyXSrhfVMUGs163WnKdMhJchuq1Lgz2SW9Y95OrLI/DHmWjGnXq0PLJeX0kiR0W5jVoM9Cpcan1XcmNSYpG4jNMr4ulsjMbxQ4ccZqWSfQu/EjLdRnjEVwku/2mlKqb9r0OkN0httuTUo/W5c9SEuLUSrINpKswAnLHmcI0zrO3pw0cyWW/8AA/za1d102jQqKKi7DpdQdeVNgJOUXKLx6xo7k8cykHTq488GsmU7f6QoS+GUs59Nu5JKzeVv2p0c02PS3y5XK1LLk+QhPqXmFOa1OtOjMEaWm2iD2vLGDWCtubaVJ74afDXDITRKnS6HZi5MZ9D0xfFaR7W/XwSkg8ckDFtRqRp0crn/ACcjdUKle60yTUf8f9mPZ5StKJFemHirUlpxfhzdcP8AD8cY2FPmb/fqZ9Zr8UY/v0RlkVOxLiWHJ6jGkN9kKcJbJQDy1DNJH54ylUoVfi2ZhCheW20N0/tNa5qxSqzJplCguao2+QHX08gPYSlOfPIHGFxVjUcYLjJtsbapQjOtPnD2/EdJ9PseBJj0mVCCFSU+reyPjpGbueeeeN84UItRa5IlGtd1IupGWdPb/oh9y0OTbVYZdiOrSjMPQpA4LQpBz5j3kHvxW3Vv4cvZl50698eGfrLku9sG21U/aHb6I8xxLF1wGwmpw/Z3mXDrLQ70L7wPZPDllnGLAINx21QblpD1IrsJuoU5/wDWR3RmMxyUk80qHcQcxgCul29CamPyFP2rXlwm1HMQp7e+SnyS8gpVl8Un44Aa6J0IaiZCTXLmZRHHtNwmFLWfgt0oCf6pwBYHZ1smsnZ9CWxb0LQ+8AJVQeO8kvZdy15DIfZSAPLADxdt20G0qBKrtckiLT4qc1KPtKV7rbafeWo8AMAUgadr23rbYz1kKZiSl8WwcxDpkc6ikHxyPPvWrAF8oUOLChsQ4jYZixm0ssNJ9lDbY0pSPIAYAb7otS3rqo7tHr8JE+nPZFTLmYyUOSkqTkpKh3EHAFdbq6EsF6aXrYuBUOKtXGJOa32gH6rqCgnLuBT88AG7ZTsypGzq02qDT3DIcKy/OmrGlT76sgVaRnpAAASM+AGAB30vb1jUfZt9HkOf5QuJ5LaWxzEeOpLrq/6wQn54AivQ12abiHMv6oNeslaoVG1dzST694feUNAPkrxwBaDAGnVaRSqvAdp9UiMzoL40uxpCEuNqHmlWYwBXTaZ0OKRN3tQsOV6Nk8VeiJSlLjqPPJp3tLb+CtQ+GAK1Vy2r92e11LdSjS6HVGjmxIQSjVl3tPNnSsfdONdWjCpHTNKUX2Z6pNcEmhbdri306o1NhubcDlMVS6dV0hLLrG8Vmt1YSnJxZTwz4ZZfHHP1P4Zo4jCDcaXia5R5T9vZEhXL784JoLFqt32DYVGtpTX0TQDKuacHUBTM1R/SC8lRB7CSoI/3ZYpv9ShaXVxUrZ8fimscx7Y+fc3eG5Ril8Pcc7fupqsbUZ9Po7QhNsUV2m7PZLzWbSVRuO9aCxpVvdJOoe6MsRrqydKxjOo9WaqlXSe+/Z49PzM4TzPb02IVSo907Vb8IpDH0ZmiEI90VCMpaWnFpBQtx1tvd8XVdnd5/wADi6rSodLtf5j8aOrNNPleybzx6mhaqsttvUaLSvWXaEa8LXlPyZkaTDl0+KiOorjNyASgvlCsskkZ8QM+OJd906N26FeKjFqUZPPLXpkxhU0ZiTe5LBrlxWDa1vbPXItYt+GN9VJDEhCVKqDvtuPNr0qSlAJ058fLliktOqUre6rVrzVTqy2imn8C7Jr1N06TlFKG6HqRGtqnmFOqC2qvSNl9H6rIdOS2ZdXk8ERU55hSW/yzGIcZ1p6owzTqXtTK9Y01zL7TNpL3UF+JGTsTt+dTqbSXZy6btGqkN2rpg7s9SLaiVpjnIZNFKB48PDFl/wDtHVhOVRR12cJKGc+b5+5r+jJ7cTYKopuyhU+PVmkPRqZUC43GkKGbDqmzpWBn2SUnHa0L+Km4Ql5o8r5+xV3FlCqvOh32X2/6SrnX306otPycOfJTx/Vj5e1jZTWWXnR7XXU1PiP59gyYkHWjdcNZao1Gk1FziWU+qT9ZxXBCfxx43gj3VdUqbn6Fe5D7sh5x95Wt11RW4o96lHMnEU4WUm3l8sx4HgsALAFhrZdW7blLcX7aorJP9QYlR4O7tHmlH/ihzx6SCvd1ISi5aolPLrT3984iy5OFvF/Ol/yY1Y8IwssAPlMsm6KkkLjU9zdHk67k0n8V5Z4yUWTKXT61TiO33D41siudQ7bsVvyLiifyTjLw2TF0St/t+8TmyS6W+007GcUOI0uFJz8s0jDwmJdErez+0JFkbdNsuz4NxbgiO3BQG8gUyFbx1tA/k5SdZ5dzmY+GMXFkKtY1afxReCymzjbjs9v5tLdJn9XqhHbpMzJqSPHSMylweaCcYkQn+AFgBYAWAFgCAbRth+z6/m1rq8AMVQjJFXiZNSR4alZEODyWDgCqW0zotX/aIen0tP0hojeat/FSestoHHN2PxPAcygqHwwAGMAfUNrcWlDaStaiEpSniSTyAGAL29G/Yqiwrd9K1ZkfSurNgys+cZg9pMYefe558O7ABlwAsALAFLelNtt+k9WVZ1Bfzt+mOfpz7Z7MqUjuz722jy8Vce4YAr9gCy/QipO8uW5auU/5tDZipV/3h0rP+wwBbzACwAJOlRV/R2xasIByXPcjREfvvJWof1GzgCg+AFgB7s2zLhvCvR6HQYplTpB49yG0Z9p11XuoTnxP+OAL87H9jtvbNqF1WGBJrElINUqqh23VD3U/UbSfZT8zxwBP8ALACwAsALACwBzi203d9LNp9frCVaoypJjwz3biP6lsj7wRq+eAITgBYAWAJXB2c1qRZUq8H34sKlMlSIoku6Hpa0KCVJjo97LP8sVdTq1ONyrdKUpvnC2j/wAjaqT06uxFMWhqFgBYA9qeeWhDalqU21nu0EkhOZzOkd2ZwB9Z78AWVxLPoYsAYpMaNKZLMppD7KubbiQpP4HAxlBSWHuiCXJsogyAqRRF9Vf59UWc2lfdVzR+YxqlT9CkuujRlvT2fp2IcxX6nRGjQ6zTGZrMZRU1FmpOpoq56FDjpP4YwzjYqo3M6S8OpFSS7PsSq07qjT5cVMktKn1B3qCYKEaWY0FKSopSOXrFZZ4zjIs7O9U5LONUnpx2Uf8AsbaQtdw3Iy5KhtMW/bhLj0dtlTkdLaXNSkuJTqX63SeQPwyzxU9WudFPTH457R3w/s+X2fMq61Z1Z4wlGHZHm96RabNKNQjqLdTekFuOI6AiO/p7UhRZORYS0XEtJ0+0pKuGIfTq9w56H8CW+eV/bv8AWzjL9E0R6sY4z3NGr1W5qdQWqFUKeYRejNvNLyKFGIo9kqT3az3nLHQUuqRq03GDTSenK9uxT/6VGNfxXn1x/kh+NZYDtKoFZp0Riput6GFlBZdSoHioak8uPdjfKhOCUuxEp3dKrJ009+5Mq8lFx2g1Vmh+lxRvFAdxTweT/wCoYsa/82lqXK/bKO0btbl038Mv2v0Irb8KbcFZZZlPOPMo9Y+tairJA5jj9bliBQg6s8Mt7yrG2pNxST7EjvK5X6PcEB+hu9Rq9PydE+P2HUHLst6hzGnmDiR1CSzhckLolOelybeHx+pYDZl0qZ8iitu3xSl7pOaDWqekKz0c1vRfaA8VN5/dGIioTcdWNizle0lU8NvEgyUTa3syrbQcptz053PLsLfQy5x8W3ShY/DGklG9N2hWHBZL0u46Yw2OOpctgf8AqwALb56XGzahNONUIuXHURmEJjgtRgr7T7g5fcSrAFUdpe1m8dodTEuuycozJPU6azmmMwD9VOZzV4qVmcAWk6I2zT6P2Y5dU9rTVLiAVH1DtIgo/V/61Xb8xpwAWNo16wbKsyqXJMyIhNEx2j+1fV2WW/3lkA+XHAGaw63Krtk0GtSygyqjAjSpG7BSjeOtJUvSDmQMzwwBt1e57boy226vVYdNW8CplMt9tgrCeBKd4pOeWfdgCAXv0kdlVrwnVoq7VZqCQdzApqg+VK8FOpzaQPEk/I4AqLNql37b9qsREg5Sqm6mPHZRmpqHDQSpWn7LaNS1HvPxwBfygUOnUGiQaNTW91Ap7KI8dv7CBlx8SeZPjgCufS12w1SjTqXaVtVB2FUWFJqNTkxllDiP+zs6h48VqH3cAMuzPpk1CNuaff0TrjI7PpmIkJeHm6xwQvzKMvgcAWdtW8rXuumpqVvVJmoxDzU0rtIP1XEHJaD5KAOAKj9L7aT6cu9m0ILgVTbf4yyOS5zg7X+qQdPxKsAV978AOlTp1yW+85TalHl0t15CVOxH0uMFaFDNJKDlqBxi4JvLW6GSf2rtv9FUukx6lQI1WqtvJW3b9WdcW2qOhfDS4lOe8Ce7l/jjmr3+HPFnNwqShCr8cUk8/L0JULnC3WWglbNLhpqbsptqWnKTURupFbuesISUCbOW0dDQzAKWm3HBwy/xz5zrFrPwJV7haN1Tpx/tjnd/NpEmjPzYj82eLdhW/ZlpXeKSU1m6kNpg1CroAU2upVFRbbgxs89QbUrNfiefgPbupVvLij4n8uhnUo99EN3OXz7CCUIvG8iBq2XWVbshNGuK/PRNzvISJMaKwt2PHUsZhuQ8lQHfx5Yvf9aubheJRt9dFcNtJv3SI/gxWzlhm25VItpVW39n94xkxLfoMtdVmyoep8VNShriulPDse6ef5Y1KjK6hUu7d6qtWOhKW3h/3L5mWdLUZcL8TBA2v7Vr2uJ23KXMDCK/JW0wlLTZcix3T20ody1hKGxmTnjOr0GwsqPjTWfCjvu8Sa9uM5PFcTm8LuMe2e4Ic24otr0PjQLWaFMp6E8d46ng+7w5qWsZZ9+WJ38O2ko0nWqf1a71P/C+4wryy9K4ROrRoCaHQmIWX6QfWyleLquY/d5Y6mKwdfY23g01Hv3+Y84yJYJNrFwdaqaKQyrNiD2n8u99Q/8AQnh+ONFRnL9autU9C4j+ZAcaykFgBYAyR2XH322GxqcdUEIHmo5DA9jHLwix8KKmJCjxE+zHbQ0P3E5f4Ylnf04aYpeiM4yz48u/AzK4VeT1qqzJI4h99xwfvLJxFZwNaWqbfq2ONsWjVLhkFEVO7jIPr5a/YR5eavIY9jHJvtLKdd7ceoXbesegURKVMsiRLHOW8ApWf2RyT8sb1BI6m16fSo8LL9WSDM4yJwsALACzwBHK9YlFqiussj0fUknW3Njdg6xyKkjIHj38DjCUEyuuumUqv+2Xqh0tbpFbTdnUtqlXg2bjovJmUtX6ToH8nIPt5d6XBn5jGiUcHLXVpOi8SLK7PtsFhX5HCqBUkmZlm7TH8mpaPHNontAfWTmPPHhGJpgBYAWAFgALdKbaX9ErAVSYL27rVxaorGk5KbjAfpDvl2SED73lgCiuALO9E/Yl119raDcEf9Ejq/4vxXBwcdScjKIPuoPBH2uPcMwLbYAWAFgAAdKTbb9FqQq0KE/lcVUb/TH2z2okVfmOTjo4J8Bx8MAUrwAsAXL6FNI6vYNZqik5Kn1HdpPiiO0nL+06rAFiMALAFb+m1VtzaFvUkKyMye5IKfERmtP8X8AU8wBILGsa4b1uGPQqFH30t7i44eDbLY9p11XupT/9hxwBfnZJsjt3ZvQOoU8dYqMjJVTqi05OPrHd36W0+6nP88zgCdYAWAFgDRpVbplV60qnvpkNw31xHnEcUb5vLeICuR0E5HLkcxzGAN7ACwBCdtN2/RPZhX6wleiSmMqPDPfv5HqWyPuler5YA5xYAWAFgDJGbbckNtuOBltaglbpBIQkniogcTlz4Y8k2ltuCxnoxqn2RASi34e02g0IvKotUhPqQtlL51rbmQ061HI/Hzyx888ZzuZfzJWdWpjVGS5x3jIsceXjWkNVRr0K/bJg0F80r6T1yoMs0Gk0+PuTS20OFDxfXzyUgcu/+EqlaysbmVVeJ4NODc5SefEeNsGDlrjjbL/AHl0bPoqLl9A2S5Nud6Ikt1J1uMsBMlClJWlAAPYGXMnHQWfVH4Pi3Omin8Pm7fqR50t8R3IfUKdPp012DPjuRZjCtL0d5JQtJ8Ck5EYtqVWNSOqDTi+6NTWDXxsPDIz34ANUjafZ7K9IkOPZd7TSiPxVpxI8RHYS6vQXdv7DJD2k2fKUEdcMdR/l21JH9Yahh4iModVoS74+ZJGXmX2kvMOJdaV7LiCFJPwI4YzLBSTWVuj3gejHddqQLhg7p3JqY2P0WV3pPgrxSe8YxlHJDvbKNeOHz2f77ANqEKbS57sSSktSo6slDzHIg+fMHEY4ypTlTlpezQ+2rewoMd5o01mYt1xL2/cUsL1tkON6uJSoIdQlQzGftDPtYrb7p3jtPU47Y+/Z/en+Xoewq6SdU6oUy4qyp9uow9wh0SaWVxUtyabmVKdW9mnS82w0lTiiSoKcCOIKjijq0p29PDjLOMS82VP0x6OTwlxiOfQkJqT/AHsP7j9SRKkx7npLclM1ptuY6h1tt+U3ClB9RXH7LundpL7rbAJUVDMjugKMHFOhNrS3jZtR1Rxzxz5YuXGNjbv9ZELvG0rOYpk2pIdciyW0trSuNpciPy5ZU8lhlAyAaQ3ycQsgADNOZxddPvriU4wxlPPPxKMdsv3b7NfaR6lOOMmOE5Jh25HgXdTno1NfATFmLSdGRGtCV6e0hWXFOfdjq7LqtvVzSck8fv8AbObvemVoVPGpcv8Af4nmTW7WolBkQqS8JLj4XpQCV9pwaSpSsgAAMT5VqVODUd8kKFrcV6ynUWEv8Hu0WY1DtR2sPjNx9JdPmlJ0to+Zx7apU6Wt9zzqMpV7hUlwtv1ZBo7U2u1oIz1SZrua1eGfFR+AGKyKdSfuzoJyjQpf7YonF8VFmkUNiiQzpU8gI8wynnn98/44s7yoqcNC/aOf6VRdas6su35/9DVatiN1CAuZUStpDwyiJTwVl/KHPu8BjRbWWpZl9hMv+reHPTDfHP6EVqsJMKoyYaV7wR3FN68ss9Jy5Yg1IaZNehb0KmuClxlGrjA2k22N7PXr9v6nULSrqGrrFUdT7kRrIuce4q4IHmRgDozHjsRo7UeOgNMMoS200kZJShIySkDwAwBTzpibSvStxx7JgO5wKNk/UdPJUxaeyk/0TavxUfDAFl9jv/RRaH/hEP8A2CcAV66cX/K1pf0Ez++1gCsOALe9DfZr1Gjy77ntZSqnqiUnUPZjIV61wf0jidPwT54AstgAE7YOizRL0qEu4KLPXTLilHeSA+VPRXl5AcRxW3wHu5j7OAKm33svvixpnV7jpjkZtStLM1PrIzv3Hk9k/A8fLADRbtz3DbdSRU6DUHqdOb5PMKKSR9VQ5KT5EZYA0JcqRMlPSpLhdkyFqdedVxUtazqUonxJOALCdFXYn6fqSL3r8fOiU9z/ACVHcHCTKQf1hHe2yfxV8DgC1122Ral3U00646azUIx9jeDtoPi24MloPmk4AoDtrs6hWdtIqtu0N152BC3WXWCFLSp1pLpRqAGYTryGAIlS6xVaVIVJpkt6FIUhTSnWFqbUW1jJSSU5cDjVWoQqrE0pL3PVJrgmdnbUBQ6dQaOuCnqVOrjdZnSEklb+gBISUHh2BxHHFP1Do3jTqVNXmnScEvT/AOm6nWwkvfJKrq2JXLc12Ta/bkyHUrarMhc1usGShKGUPK1qS8lR1gt55ZZYq7L+I6NtQjSrKUK1NadOHvj07bm6du5SyuGS2ZPtqHPl3wFIqdJsSlMUCiyV9pE+q6SCoH3kNhzL8xipp0q04q1+CdzUdSS/sh+rwbW18XaKwQ2uVKMqzoe1S0Y/0XryZq6TV48PhHcU60VF1lKgQnMcwP8ADPFxbUn9IlY3D8alp1xb5WHwzTJ+XxI7PJEdl9ANSrhqL41Rqfk5meOp4+wPl7WOzpol9IttdTU+I/mGPG86wbbjrTVFo0ioue02MmUH3nVewPxx5J4I91cKlTcv3kr2+86+8t51Wt1xRW4o8ypRzJxFOFlJt5Z4wPBYAWAJzsrt1U2sGqOp/RafxQT7z59kfu8/wxspouej2uuprfEfzDBjedUM141YUu2p0rPJwtlpn+kd7I/DPPGMnhEO+reHSkwOWha8i4aoIySW4rXblv8A1UeA+0rkMaIxycpZWbrzx27h0p9Ph06G3DhtBmMyMkIH8Se8nvOJKR2dKlGEdMdkjYwNhoVau0ekN7yoykR8+KUHitX3UDNRx43g0VrmnS+J4IpK2v2+2opjxZMgfX7LY/Mk4w8VFZPrlJcJs+xNr1vOrCZEaRHH18kuD8iDh4iPYdbpPlNEspdZpVVZ3tOlIkIHtBJ7SfvJOSh88Zp5LOjXhUWYvJu49Nxp1akwKtAcgzm94w5/WSruUk9xGPGsmqvRjUjplwA2uUiqWtXd0l5bT7JDsOY0ShRT7q0qHEH+BxGksHFXds6M9LDNs06Xt3UPdQbvaNwUxPZ64MkTkD73BDv72R+1jwjFqLF2oWRfMPrFuVNuS4Bm9CV6uS199lXaHxHDzwBKsAeXXW2m1OOqCG0AqWtRyAA4kk+AwBzt24bRnL92gz6uhZNLYPVKQjuEVonSrLxcJKz8cAOGwPY9K2jXWlElK27bppS7V5I4ah7sdB+u5l8hmfDAF/oUOLCiMw4jSWIsZCWmGGxpQhCBpSlIHIADAGbACwBBdsW1GmbOrQeq8jS9UXs2aTBJ4vSCOGffoR7Sz4cOZGAOelcrdTrtXl1eqPqk1Cc6p6S+rmpav4AcgO4YA0cALAHQDoyUf0ZsWt8EZOTA9Mc/0zyin+xpwAU8ALAFOOmxVg9e1CpQVn1KnqfUnwVJeI/gyMABjZ/s+uW+rhaolBY3j6u1IfVwZYaz4uuq7gPxPIccAX62WbK7b2d28imUpG8luZKqNSWAHZDvifBI91HIfHMkCaYAWAFgCsPSK6SfVC/ZtjStU8ks1WsMHPdHkpiOoe/3KWOXIceQBz2V2oLT2e0KglOl+LFSZfnJd9a+f9YtWAJXgBYAq502bu0Q6BaLK+Lyl1OagfVRm0xn8SXPwwBU/ACwAsAFGyKfbVtWA/f1dpjdbmyJvo2g02RxjhaEa3Hnk+9lyA/35jmuo1a1zdq0pSdOKjqnJc+yRKppRjqe5KLRvGPdsOtyqPT2LSvaiwnKlCqFHBYYkssZbxmSzxQvgeGrP/fV3/T3aypxqSde2qSUWp7uLfDi+V9hthU15x5ZL0I/Sbnp1YuNN034mZQZ0xLBoFxUyMG47b8ZRCn3EZEPFSh2ss+/FhXsp0aPgWumrGOdcJPLw+yfb2Nanl6pbejJ1ctT2pqbjTk1ZuZYDzmuqVu0GkNyVN++46ntOIX3qy4eOKOzo2OXHQ43S+GFZtr5Ls0bpuf/AOn2A3tSvWNeN4PVeIwtiIGmo0YPHU8pDCdIW6RnmtXM46/ovTnaW6pyeZZbeON/T2IdapqlkTuziqGmMSWHAuUpGp6IrskE8ckq5E5eOOlfT5acrn0KFdap+I4v4fUjLkaREeWzJbUy6n2kLGRxBlFp4ZbwmprMd0a6vaPxx4ZHzADpQblq9Dkb6A+Upz9Ywri2v7yf/Zx6pYJNtdzovMX+garUuqDcUHfMjdSWshKik5lBPePFJ7jiRGWTrrO9jXjlc90PeMiYQHavbiZVOTWmE/pEPJEjL3mSeBP3CfwxrqRKTrNrqj4i5jz8gSY0HLn0KI78sASj/hCq70CXHqLMepypQdSmozEqckN9YUFuFCswM9SdSSRmk8sVv+l01JODcEseVbJ44/79Tb4z77kqh0O3a1aUOn0hDTz0RtnfSx2H+vy1+sXIzSFJjx0JVqPaSQEcUknFXO5rUbhzqZSlnbtpjxj/AHSePR7vnY3KCccI356YBuWUzDcQ5XazDTNKlsPy2kySoO71+Du3w2tcdSinLeaNXu90elq8FOX9KnLTyovHGFPKytWM/DnHcyfxe7/fBp1rZ5b9aZbqVuzWmlyJIYeRloj9YkobMVhtsZqbKwHXFp46B2csxljdb9Vq0XorRbws++FnU2+/ZL15PJUYy3iN9LkNxKR6EuJvKmOqcagVROoxX0oWc929lkdKhwP447Ow6hSqw8OT39O6zvuuxzHUen1YVPGpc/v7zapVMtW299UevpdKkkIWpaFKCeeSAjmTifSp0qPmyV1xXuLrENOPv/EZ6PTH7srz1XmoKacheSWz72n2Wx8B7WI9Km689b+EnXNdWdFUofH+9/0JfS65HqFVlxIuRiwUoSXByLhJBCfspAxYU6ylJpcIpK9q6dOMpfFL8gXt02dWq7JbiI1rddWtSz7KQVHtKPcMUnhyqTePU611oUKKcuyRL6jY1Cg26846pZlRkFwygctS+5Ok8NOfzxYVLKEafuu5S0Oq1aldJY0t8D/0dNsNO2eVGoom0JyoMVEIMqoRO1JYaa+weypvNWZ4j58MVB1EYt8Fo69t5sRjZvUryodTYqQitBLEUK0u9ad4MtOtHJxGaueY5AnAxOf9Qny6jPkz5rpemS3VvyHlc1uOK1KUfiTgDozsZXr2TWgrl/kmIPwZSMAADpxoSJ1nr95TU9J+SmP9+AADs6sqfet5Uy24WaVTXcn3ss90wntOuH7qAfnwwB0kpNKg0mlxKXT2gxBgsojxmk8kttp0pH4DAAb2t9Jmm7P75iW6Kd6UYQzvayttzQ6yp3i0lvPslQR2lA+I4jABCsPapY19Rd/btTQ+8kanoLnq5TX32ldrLzGY88ASSoU6n1KG7CqEZqXDeGl2O+hLjah4KSrMHAHPvb9TbEpW0qoUuzIxjQIWTUxIcLjXWwSXg1qzKUozCcs+YPdgDFsU2T1HaPdzdOTqZo0TS9WJo/Zs58EJPLeOZZJ+Z7sAdB6VS6fSabFplOYTGgQ20sxo6BklCEDIAYA28Ac2trtW9LbULpng5ocqUlLZ+w24W0/2UjAERwAsAew48lBQFKCFc05nI/LHmEAmUDaRZkyzIVl3lRn/AEXT3FPQ59Kc3bwdXnmt1tw6Fk6ss/yxzd10i4hcyubaa1yWGprbHs1uiTGtFx0yW3sN1/X7S61TKXalqU5ynWxS1lcdh4hciRJc4F53TmNXHID/APAk9K6XUpVJV68tdee23CXojypU1YjHgIdp0JFDoUeDl6/LeSleLqva/Dl8sdLFYR2Flb+DTUe/f5jxjIlkbve037jhMtMy+rqjkrQ0oZtrURl2suII7sYTjkr+oWTrxSTxgD1btqtUV3RUIym08kPDtNq+CxwxoccHK3FpUpPzIa8eEYWAHi2rXqVfmhiKnSyk+vlKHYbHn4nwGPYxyS7SznXlhceodaPSYdJpzMCGnJlkczzUo81K8ziSlg7KhQjSjpjwjcx6bgS7V7g65UmqNGOpqEc3svefVwy/dHD45401H2OX6zc65+GuI/mT6zbeRQqGzFI/SnfWzFfzivd/dHDGyKwi7sLbwaeO/cfMZE0h1+X0mhI6jByXVXRmSeKWUnkojvUe4Y1zngqepdR8Hyx+P8gOy5cmXIXIkuqefcOa3FnMnGg5Sc3J5e7MOBiLAGeDOlwZKJMR5bEhHsuIORwM6dSUHmLwwyWLfKK80YkvS1VWk5kDgl1I5qSO4jvGJEJ5Os6d1HxvLL41+JLsZloRTaPbyarb63205zIGbzR7yj9oj8OPyxhNZRWdVtvEpZ+tHf8AUCOI5x5sU6pVCmzWp1Pkuw5jB1MyGFqbcSfFKk5EYAsPs06Ytfpm6p97xvS8JOSfSccBExI8Vp4Nu/2T8cATPb/0g7VmbLhDs6qNzJdyZxnd2Sl6PGABf3rZyWhSwoIAI4gkjlgCrFmWfWrvuWFb9Ha3s2avSCfYbQOK3XD3JQnicAdEtndhUWxbUh29SU+qYGqRIIyW++r9Y8vzVl8hkO7AEmwAsAaFertLoNGmVmqvpi06C2XpL6u5KfDxJPADvPDAHPLa9tQqu0W736zK1MwG82aVBJzDEcHh5a1c1nx8gMAQjACwAsAdNrDpIo9k0GlZaTCp8VhQ+0hpIV+eAH3ACwBSza5aFx7T+kbVqHQmtQhiPGkS157mMy2yjeOOKHIa1KyHMngMAWk2ZbMbb2eW8ikUVvU4vJc+e4BvpLoHtrPcB7qeQ/E4Al+AFgBYAqx0jekoWzKsyyZPb4s1itNHl3KYjKHf3LWPgPHAAV2BWl9Kdq9BgLRriR3+vTPDdRfW5K8lKCU/PAHRHACwAsAc8OkDd30p2sV2c2vXEiu9Qhkct1F9XmPJSwpXzwAO8ALAGzTYEufMbiRI7sp9zkwwguOEJGpWlI4nJIJxrq1Iwjqk0l78HqWQwSbKhXbbiaPs6uMyIcZ4yzZtV3cea3J0aVqbXkA5w7s8h445KHUJWtbxLyliTWPFhlxx2z6Et09SxB/YM7taptgWfNoMamzo98Vxgxa5Jno3SY0YqIU1GHvBwD2vzxMVvO/uI1ZSg7am8wUd9T9ZfL0MdXhxx9ZjbaO2Ov0SmpoNUjsXDa/smjz0haUp/mnMipHPhzAxIv8AoFKtPxYN0q390f8AK7mEK7Wz3RL74mWVbGz+PKs9mVTKjeqd8qKZSlmNCSCh1v1atJS6TkAvM8+WWKjptO5ubtxuHGcLfbOn4pdn9nsbqjjGHl21AqtRumLrkc1F1LMds6+37KlD2Uk9wz8cd5bKOtauCl6g6nhPQsthiCgoBQOoK4hQ4g46E4gxvRoz2ReZQ6U8taQrL8ceOKZlGpKPDaASr2j8ccufQj5gBYAdrYr0ih1lie3xQk6ZDf12j7Sf93nj2LwSbS5dGopff8iwLbjbrSHWlamnEhaFeKVDMH8MSjuU8rJ4lRmpcZ2K8M2n0KacHksZHA8nBSWHwyuM6KuJMfiufrGHFNq+KDliIcDUhpk16GHAwFgD0hxxB1IUUq4jMcOB4H8sHuCSW3dqINTmzamh2ZJqDa2Vzg6oOt74FDi8v2nZVmASDqAyIxXXdjrhGMMRUXnGNtt18v0b2NsKmHv3CJIuG1m4Uqr0ZyCwGG3m4riVpD7XV209SziOISp9x9zitS0K0ZZheOfha13JU6mt5az6PL8/mT8qiuEms/2knXHlYMcmu1Z62o8/dsUxTjcYQGltt1AbpKHR1dbIbU62JakbxClpOrtdvLGULamqzjvPeWd3DfbzZzh6OGlxtsNTx6fj+8jbV9nVCqLMZymvNU6py3OrMsheuHJfaTnLdaKjrajtOamwoFY7JJ0p44kUOrVabamnKCWf9yT+FP1k1vjbnCyzCVFPjkYavclUpdH9BGCIElAS2Xmlamy0tIWFIIz4uJUFZ58jnjr6XU41KWIfv1+05/8A0jFfXN6lz9v6DhswZPo2e7y1upRn91P/AP1if05eVld12XnivYy1CrUu1oopVJQHqm4Rqz4nWr3nT3nwTjKpVjRWmPxGFG3qXcvEqbU1+9v1Pm0KW5Et6NAW4VvyFJDqzzUGhmo/NWWPL6WKaj3Z70enrrOfZf5/6HvZbb/o+imoupylVHinxDA9kfvHj+GK6mj6p0e20U9b5l+Rt1/Z/btcbMhgCJKc4plR8tCj4qSOyr4jjj1wTNtz02lW3Wz9UCW4rZqdBmdWmo4K4svp4ocT4pP8RjQ44OXurSdGWJF/NgtYpNR2T203AmMynIVPjx5iGlhSmnUIAUhwDilQy5HHhGAj05P86s37lQ/jHwBI+h5s09FW5JvWoM5T616mm6uaISFcVD+lcT+CR44AN183fTbPtSpXHUVZR6eyVhHIuOHsttJ81rISMAc2rhrtRr9bnVqpOb2dUHlyJC/tLOeQ8AOQHhgDWgz50CW1MgyHIstk6mZDKi24hXilSciMAHS1OmBf1MoUum1llusSzHWim1NWTbzTxTkhTwA0OpSePIHzwAGqBQq7dlyRqTTW1TavVHtKMzxUtR1KWtXcBxUpR7sAdDNlWzWkbPbQjUKCA5I/W1GblkqRJUO0s+Q5JHcMASNys05FZZoxeBqT7DkpEYcVbhpSUKcV4J1OJSPE4A9VeeinUqbUF+xDYdfV8GkFR/hgDl5JfckSHX3Dm48tTiz5qOZwBjwAaNgHR8nX/MTWq2lyJaMdfFY7LkxaTxaaPcge+v5DjyAtpdexjZtdFFj0mpUVhDENoMQHow3D0dCfZS04jjkPqnMeWAKTbcdl8DZxeIocKqekmnWEyk60aHWUrUoJQ7l2Srs55jLh3DAEDgTX4MxmZHyDzCw42VAKGocuB4YGdOo4SUlygp29tZp8nSxWm+qPcust5qZJ8xxUn88b1UOktetRltU2fr2J2w+xIZS/HcS8yvihxBCkn5jGwu4yUllboyYHp5cbbdbU26kONq9pCgCk/EHhgeNJ7EXqWzO05qitMdUNZ746tKf6qtSfwxg6aK2r0mhPtp+RrQ9k9rMOBbxflZe44sJT89ASfzx54aMKfRaK5yyXRYkWJHTHitIYYR7LTY0pGNhaQgorC2RlwMiNXxd7Nv08oaUFVSQMozf1R/Kq8h3eJxhOWCu6hfKjHb43x+oMtn9ONVu6MX/WJZKpb5VxzKOIz+KyMaoLLOe6ZS8Sus9tw5YkHZGjXKszSKTJqLvFMdGaU/WWeCE/NWPG8Gm4rKlBzfYr3OmyZst6XJXvH31Fbiz3k4inC1JucnJ8swYGAsALACwBs06oSafOYmxlaX46wtB+Hd8DywRspVHCSkuUWHps9moU+NOZ/VSW0uJHhqHL5HhiWmd3SqKcVJcM2eB4EZg8CPLA2FeLjpvoyuzoI9lh5SUfczzT/ZIxFktzhLql4dSUfRjbjwjks2eWm1Xqk6qYkmnRU5vZEpKlr4ISCPx+WM4RyWfTLJVp+b4UO1w7Jp0fU/RXOuNc+rLyS8PgeCVfkcZOmSrnoso70916dyR7AdrtD2XViczX6Cta55S2/U2/87jtp/Z7peQKNXaORB+OQxqKSUXF4ezLoWhfVp3hTRULcqbNQj++Gzk42T3ONqyWg/eGBiP2AFgCk/Sh22/S2sm1KE/nblKd/SXkHsy5SOBVw5tt8k+J4+GAAJgBYAWAHizaUavd1EpQGfXp8aPl5OupSfyOAOnQAAyHADlgD7gBYAaaDa9Foap7lOjht+qSnJ1QfPFx591WZKleCc8kjkBgB2wAsALAFT+kb0lOsCVZlkyfUcWavWmj7fcpiOoe73LWOfIcOJAq5gC13QltHSxX7ueRxWUUyGvyTk8/+ZbwBaXACwBFtqN2JtLZ9Xa/q0uw4q+rf94c9WyP9YpOAOay1qWoqUdSlHNRPMk4A+YAWACjsq2Y7R6iwi77YqEakIiuONomuvFCxpHb7KUOdnjkdXPHM9b6zZ039HrxlPK4S+7uiVQoze62CPVDsyrcQu33clFRcrGW4r9urdRJ1DvdCEKQtQPl+GOdo/TaMsWtKr4L+pVxj7N9v3ySHofxNZ9UQzZxNN27QKqzcbv0jt1qmSY0qsVH1bkansHU3ISe1oc1Ac+PE8cXPV6f0W0g6P8AJquaajHhzfK90aaT1Sed1gg+0XZ/LtGptbt0TqFUUdYotWb4tyGFcRxHDWkHtD/DF10rqkbuHGmrHacfR/oaKtLQ/YiiQtaggcSeCU4tTVkySosqI8piS0pl1PtIWMjjKUWnhmEKkZrMXlDjRborFIIEd7Ux70dztIPy7vljbSuZw44I1zYUq3xLf17k6p20WiPsZywuK8PaQElxPyI/xxZw6hBrfZnP1ui1U/LiS+4F6vaPxxSnWHzACwAsAHXZ1MXLs+ApfFTOtj5Nq4f2csSIcHZ9LqaqEfbYkmMywATtEjhi8akByWsOf10BR/M4jT5OL6nHFxIjmMSALAG1CpVSnK0worsk/wA0hSv4Y9wbKdGc/hTY6iwrwIz9FPfgB+WePdDJP+nV/wC1jdPolXp/+fQno48XEKA/HljzBoqW9SHxJoltL2nzt3Ii1H9Fblxm47tSpbTbU7UwEpZWVZoCtLaN3kCnsqPfijrdGjtKG7Tb0zbcd+V9+/fdGUa/r+A+27J+kU+uVUPykwShqBDgBYU8/IkoRHU89klxKC8ho71ekAqXp1DPPEG7j9HjTp4jq3k32ST1YXGcZ8qzws4NkHqyx9rdQUzTbiZTQ/SMtxKiyWtcmOFScnnlrBRr1bopXyAbQhtOrM4g29LM6T8TRH32e2y745yv9zcng2Sez2yRKmWJdNLo0KbHqrUORU3HA7HUoGOww2wXVvPvJ1pStAT2khOpOae85Y6GH8RKNSUYqWIr7W28JJfk/ZlfX6bCqlrSf7/exHKbSnaXdzLVdO4DD6i48s6m1uIGsZODNKsyUnPPvxcWFxTqyjLO3P8A9InUITjRkorfGNh9q0M3PfMamNq1w4qEmQ4niAj23DmPHMJxNvJa6mPQfwz09zST+s8v5Il+0CvJoluKbjndyZQ6tFSn3U5dpQ+6nhjRN4R3nUrnwaW3L2QLLXvCqUCSlTKy5CJ9fDUewod+X1VeYxpjLBzdpfTovb4fQLl0QIlwWk8psawpjrcJfeFBOsfiOBxvkso6i7pqvQfyygM29c9w23UkVKg1B+mzUcno6ykkfVUOSk+RGWIxxROr02yTdpSrXhXslEdmkyFifVISPWOR5Cm94rcezrSls+ycj4DAF4rDuSyq3b8U2hNjyqTFabYZaYPFlCE6UIW2cloIA5KGAHWtUOj1ymvUysQ2Z9PfGTsZ9AWg+ByPeO492AK2bTOhtEe3tQsGZ1Zzir0NNUVNnyZfOak+QXn94YArJc9o3Na1SVTbhpz9NmDk28nIKH1kKGaVp80kjADQASchzPLAF4ejLsS+hVC+kVbYAuirNjJtQ7USMriGvJa+Bc+Q7jmAVL5vSiWZbE24ay5oiRE9lse264fYabHepZ4fnywADui7cVavm973vmsnOQ8mLDjNjMoZZKnFhlvP3UhCfieJ4nABS281Y0rY/dUoK0qXBXGSfOUQx/8AtMAc6cAHHo+9HebfElm4bhQqNaTK80I4pcnKSeKG+8NZ8FL+Q45kAXbhQokGIzDhsojxI6A2ww0kJQhCRkEpSOAAGAM5OWAObu2C7Tdu0mv1xK9cd+UpuGe7q7HqmcvihAOAIvTadNqVQjU6C0p+bMdQxGZTzW44rSlI+JOALM7QOiLRqRZHpqnVzqVQpUEPVgTO1Fecab1OqbUka2ypXsjJWfAYArfRbjrFFe3tPkKa+u1zbV95B4HHqlgkULqpSeYsJNA2s0yVpZq7XUnuW/RmpknzHtJ/PG1VDoLbrUJbVPK/wJzFlRZbIfivIfZVycbUFJ/EY2lzCaksrdGXAyFgBYAh117R6XSULjQFJm1Hlkk5tNn7ahzI8BjCVTBU3vVYUto+aX4AfqFQmVCW5LmOl6Q6c1rV/wC+AHhiOctVqynLVLdsn2xlhJmVR8jihpttJ++ok/3cbaRd9Cj5pP2CnjcdID3bFPU3TYEFJy37qnVjybGQ/NeNVUouuVMQjH1YKMaTmRYAWAFgBYAWADVsrlKetFtCjn1d5xsfDgsf3sSKfB13R55ofJsl+My1AttWYS3dzik/tmWlq+OnT/6cR6nJyPWY4r/NIiCQVKAAzJ4AYwKoPtnUAUOgsRFDKSv1ss/ziu790cMSYrCO3sbbwaSXfv8AMe8ZEwEm1ytMyqozTWkpJgj172Q1a1+5q55JHd440VGcv1u4UpqC+qRGhXBW6BUW6lRZz1PntexIjrKFfA5cwe8HhjWUhZPZn0ypDW6p9/w98j2fTUJOS/i8xwB8y3l93ADz0iOkfRBajVCsapImy64yTKqMZX+bxVdko7il5ziMjxSPMjAFQ8ALACwAsAE7o1Uk1PbTbiMs0RnHZa/Lq7K1p/tAYA6C4AWAFgBYAWAPilBKSpRySOJJwBUfpGdJQ1HrFn2RKIp/Fqq1lk/r+5TLCh+z+sse1yHDmBWXACwB0Z2IWj9E9l1ApK0aJRjiVNHfv5Prlg+adWn5YAnWAFgCtfTVu7q1uUW1WV5OVF9U2UB/IxhpQD5KcXn+7gCoGAFgB9se0Z123PCoMNYaclKO8fV7LTSBqccV91IOIXUb6NrQlVlvjt6vsjOnDU8BXtmu7GrfuFFKt+qV2nzNYY+lDbqOrOO56QpyMewtnV4p/wB+OWvLbqNel4lWFKcefDw8pe0uz+0lwlTi8Jv5jTtcrFJXVpNAuagx4d1w5bSX7kpmbTb8RXaU8qNyUtTZBHH54ldBt6ipqrQqOVCUXinLfEvTV6ZMK8lnElv6kurlz3Da1tJm29SqHdOz6UymMZ7URTbgaRwDM9LawdQ7yoZZ+BOWKm2s6VzW01Z1aN2nnDltn1hlfkbXNxWyTiQC6ts8euWQq049rwaXG3yX2nI6lFLKgrUotNqHYK+RIPInF9Zfw86Nz9IdWc3jG/f5vuaJ3GY6cEe2e0PrlTM95OceFxTnyU6fZHy547Oxo6pauyOe6xdaKehcy/IItRpVOqTO6nMJeT3E+0n7quYxbVKcZrc5mjcTpPMHggdb2by2dT1Kc6w3z6uvg4PgeSsVdbp7Xw7nQ2vW4vaps/XsRLcusOLaeQpt1PBSFjSR8jivawXkZKSyt0YFe0fjjw9PmAFgBYAOOzSOtizYergXVOOj4KXkP7uJFPg7HpMcUF75JRjMsgHbTFpVec7L3d2k/HdpxHqcnG9Wf/kS+z8hhptMnVKY3DhNF6Q57KE/xPgB44wSIVKlKpLTHdhYtrZdSYCEv1bKfM5lr9gg+GXv/Ph5Y3xpnTWnR4Q3n5pfgTVtDbTYbaSG2xyQgBKR8hjYXCWD1genxQCklChqQeaTxB+WAIvW9nFs1PUtDPUZJ/ax+Cc/Nv2fwyxg4IrbjpVGp20v2B9V7Cum33DLiFUhlAOUuISFpSRkdSR2k5g8e7GipRysPdFDcdMq0t1uvVG7Tdpi3EPMV6Op5LzRZMmGUx3AFaVOKUhICVuOFlHrDkoZd44Yoq3R8YdJ4w84lv8AL5JZe3H5kRV/Umbku1XIc2pW6tao7igqfSIcZt9pTJQwwltuE9wCUupzU6vtKIHjinVOupRhW5XEnJp58zy5r24itlk35jyjNW6zJgwn4dcpqX6BrdbqFUdOa5C2iVpbQ02RuVvPBac1DJKswk+rxhbW6nJSpSxV2xH0ztnL5UVjjlc/EeyljZ8GnszoQhUhdScbDUmqHeJQOSGM+wkZ58Dz/DHe0o4Re9IttFPU+ZfkDvaBcIrNwOqaVqhxfURvAge0v95X5YwnLLKLqVz4tXb4VsiNoSpSglIzUeAA8cYFeH5pv0NZobkHjCgEO/eDfEficsSeEdul4Vvv9WP+AbWVs6frLSZ9QUqPTT+rCf1juXhnyT541Rhk5+w6W6q1S2h+YQ02zZFJaTvIkRkdzkopUo/N0nG3SkXqtLekt1FfP/s3aZTKXFkoqtuvGlTk/q6hSnd0r4EIzbWPFKkkHHjgmYz6fb1Vsl80EOh9Jeo22+zB2hxeswXToj3JT28uPeJMbuV5t/JONMo4OcvbCVB+sX3Dtbt0W9clNRUqDUGKjBXyeYWFAHwUOaT5EZ4xIAPekvcFs0bZZUFVmFHqEmb+iUiNIQF/pLg4Op707pIK8x4Zd+AAj0U9iPpqe3fdfj50iC5/kaM4OEiS2f1xHe20eXir4YAuA++zHZcffWlplpJW66s6UpSkZlRJ4AAYAoV0h9sz20O5urU9ak2tSlKRTW+I3y+SpKx4q5Iz5J8ycAH3oZ0nquy+ZPI7dRqTqgfsMtobH9oKwBs9MSriHslTCCslVOoR2dPilsKfP5tjAAZ6PPR0k3i+1ct0MrYtVo6o0c5oXOUPDkQyO9XfyHeQBdSLFjRIzUWK0hiMwgNsstgJQhCRklKUjgABgBvoFzUe4GpUikvdZixZC4ipKf1a3Wsg5u1e+lKjp1DhmDgCMbc7u+imyyv1RC9EpccxIR799J9Ukj7uoq+WAOdGALHdDrZqKpcMm957WcOjeopufJUxxPbX/om1fioeGAJP0ytpQjwIdgwHfWy9M2saTyZSfUNH7yxrPwHjgCpWANqDSarUFFMCG/LUOYYbW5/dBwBtp+ktvSAspl0t88taVsk/JQGeGTZSrTg8xbRIIe1m6GEhL4Yl5e84jSr8UFP8MbPEZZ0+tVlzhmd3bDcCk5NRYrZ8dK1fxVh4rM31yr2SI9Vr0uWqpLcuavcnmy3k2j5hOWfzxi5NkGtf1qnxS2GTGJDFgAlbGHBvaq13lDKx8iof4420joOgvea+QT8bjowZbZ2VaqS97mTyPnmk401TnevL4H8wZ41HPCwAsALACwAsAGrZXFUzaLayMusPOOD4cED+7iRT4Ou6PDFD5tkvxmWoGNrDqV3apI/Zx2kq+OWf+OI9Tk5LrL/n/Yj7svt70lW+vPI1RKdk4c+SnT+rHy9r5YU45HSLXxKmp8R/MM2JB1o31+sM0ajyai7x3KfVp+s4eCE/M48bwaLmuqUHP0K9SZD0mQ5IeVreeUVuKPepRzJxFOFlJyeXyzHgYiwAsALACwAsALAFg+hbSesbRqpUiOzApqkg/bfdQB/ZSrAF0MALACwAsAeVrQhClrIShIzUo8AAOZJwBT7pFdJNyuKlWfZsjRRBm1U6q2e1K+s0ye5nxV7/AN3mBW/ACwBM9jtom7NpdAoqka47spLswf8Aw7HrXc/ilBGAOkGAFgBYA5/dJa7vpJtdrCm164lKKaZG45jKNmHMvi8V4AFuAFgCVbMbwj2nd8Wqy2S/AUl2NPaR7ZYkILayj7QBzGKvrFg7q3dOLxLZr5rdG2jPTLJOao7s9u+84kFiqR6JYdpwm0svvJKZEptKgp3QCNa3FrVlx49+WKWiru0tnJwdS6ryey4j6eySN70Sl6RRJKNVLiqN8zNpJtE1qzKwFQkpQ23JkMRWCGkuBntK1erzI08eOK24o0adrGy8bw7in5uWk5PfGftNqk3LXjMWb9x7QZGzioGQ1aNMlW9XE/o1Tp4chNyWj+zfZIcQHkjgoKTjRadKXUIYdaoqtPmMsS0v1T2ePtMp1vDfCwyvdyVKBU67Nn0+AilwpDqlx6e0SUNIPJIJx39pSlTpRjOWuSW79Sum8syUS56rR1ZRXM2FHNcdfFBP8QfMYn0biVPjgg3VjTr/ABc+oQaHfdHqOlt49SlH3HD2Cfsr/wB+Lajewnzszm7rpNWnuvNH99iSYmFWa8mnQJSgqTGaeUOAU4gKP4nGEqcZcpM2wrTh8La+QDVe0fjjmTvz5gBYA2qVTpFSqMeDHGb0hYQnyz5n4AccEjZRpOpJRXLLEw4jMOGxEZ/VR20tI+CRliWd5TgoRUVwjNw7+A7z5YGZX2qOSK9c8lcVBddnSVbhA7wVZJ/LEV7s4as3WrPHMmGW0rUh27Tw0jJya4M5UnvUfqp8EDuxIjHB1llZRoRx9bux9xkTTytaG0FbighCeKlqOQHxJwDeBpXeNqIc3aqrG1cj28x+I4Yx1IiO+o/3ocosyJLb3sR9uQ39dpQWPyzxkSITjLdPJmwMxYAjtwWJb9a1OOM9Wln/AK0xklWf2k+yr+OMXBMgXPTqVXth+qBzVbHuy23lTae444ygH9NhqUhxKe/UE9tPDn3YjVaCksSSkjnrjplWjut16oxqvYVCNEplRjtRoX6MzUZUcLLzseJ+qRpUsoTxJUrQBqVxPHECh06NOrry3u2lts5c+/tvwtkRYVU2lL4dshchzKRWaatMCQl2I43ujuFaVoSRpy+sggeWLnk7KE4VYeV5XsDqr7H56HCqkykPtHk0/wCrWP3vZP5Y1OmUVfocvqPK9x2s3ZkabMRUautDshk6o8ZvtISruUpR5kdwx7GmSbHpPhy1T3a4RuXhU2qpVYdoRnM1SnUqqa0n2Gkdst/eOWZx7J9jdfVfEmqC7vzfIc7wuBq2qDvIyEh45R4LPuggc8vBCRjKTwjffXKt6WVzwgGzZ0ubIVJlvKffXxU4s5nEY46pUlN5k8s2aJXanRpiZUB4tqHto9xY+qtPIjHqeDZb3E6UsxYbXkQrstPgnJuexqbB47t0cv6qxliRyjr3puaH/JfiB+1Lqu21qwiVbk+RT6jqDeTCuDhzyCFo4pWM+5QOIxxWl5x3Cne1xXJfV42yztTfRSLagDdSahBbcWwdZ1OLITr0OO5JQTlknnlj1xaJVzY1aPxLb1Ln2yu3VUCCm21x3KI00luAYakrZDaBkkIKSRwGPCIVq6WW239bs8t9/wD/AIhlNn5iICPxd/q/WGAKq4A6G9HikCl7GbXY05KejGWvzMlxT38FjAG5tG2WU+/qrb/ppzVQaM69Kk08Z5ynlBKWkqV3NpAVq7zywBNmmmI7CGmUJZYZSENtoAShKEjIAAcAAMAVT6RXSScmLkWVYsnUwrNiq1hg5l0ngY8ZSfd7lLHPkOHEgWI2YWoi09n9Ct8JCXYURAk5d76/WPH5uKVgCv8A02bv7NAtFlfPXU5qc/iyxn/5mAKwUakz6xVodKp7RenT3kR4zQ95xxWlP5nAHRGh023dk+y1th5wJp1vw1PTXwMi877TqwPrOuHsjzAwBz7vK6qldd0VK4qirOVUXlOqTnmEJ5IbT9lCAEjyGALHbAui7T5lNi3VfjBeTJSHqdQlZpTu1cUuycsidXMN+HteAAOlc2kbJtn6UUqoVSBRt2BopsdGa0J7vUR0qUkfFOAFRdoGybaK05S4FRgVwKB3lOkI7ak953EhKVEeYTgABdIHowwqVTpN22M0pESMC7VKJxXu2+ano5OZ0p5qQeQ4jwwBWHACwAsALAEx2VVARbpSwo5JmtLZ/eHbT/dxnTe5bdGqaa2P7kGjEg60jO0Shrq1tPBlOqTDPWWgOZ0jtp+aTjGayiu6pb+JReOVuAzEY40WAFgBYAWANmnQJNQnMQoydT8hYQgfHv8AgMEjOlTc5KK5ZYenQWafAjwWf1UZtLaT46Rz+Z44lo7ylTUIqK4SNn8vPA2Ffbon+lbknSm+2HnylkDjmlPYRl8gMRZPLOGu6niVpP1YaLPoIodBjwiP0hXrZR/nVcx+6OGJEVhHW2Nt4NNR79x6xkTATbWbh6zUW6Myr1EPtyMu95Q5fuJONFRnMdautUvDXEfzB/jWUYsALACwAsALACwAsAW36EFJCKHc9XKeMiTHiJV5MIUs/wC2GALOYAWAFgDw66002t11YbabBU4tRySlI4kknkBgCmvSK6R7lzqftO0X1N26klFQqCeCppHuI7wx/f8AhzArzgBYAWALPdCa0t7VK9djyOzFbRToaj9d31rxHmEpQPngC2uAFgBhvy52bWsys3A7l/k2I682D7zgTk0n95wgYA5nSH3pEhyQ+suPPKLjqzzUpRzJPxOAMeAH2x7SnXZdNPoMTgqW5k67lwbaTxccP3Ug4g9Svo2tCVWX1V977Izpw1PARKvsMgVludUNmdYTX40F1TUqmPerlNqBPsrIShwHT2eWfdnigofxLKi4wvYeE5LaS+F/5XuSZW2d4POAe0a05cm8IVuVf/Izr8hDMlc31G6ST2id5l3cvE4v7i+jG3lWp/zEllad8/cRow82HsHSA1s9rb1wSbXfl2Oi2C2x9J4j+mFIAO6aLzQKQpSiO7iRxJxxFWV3RVNV1G58bL8NrzLu8MnrS848uO5Etrl27UqVSTZ91y4FWh1JDcqJVGUoLq2ULzSsadOnVlzKM/A4tehWNjVqfSKCnCUMpxfGf37mmvUmlplhgZx2BDFgBYAn2zZ+svOPJW+o0xhOW7X2hrVyCSeXicsWnT3N/wDFHO9bjSilt52T3Fqc6AVXtH445Y+iHzAH1KSogAZqPAAd+ADDs5stdIZNTqCMqi+nJpo82Wz4/aV3+AxvhE6vpVh4S1y+J/gTfGwuCM7Q68KTbjwQrKXNzjsDv4+2r5J/jjCbwiu6nc+FSfrLYYNk1thqOuuyE+tdzahZ9yBwWv5ngMY049yF0W0wvFffgIuNpfDbcFfgUKmqnTDw9llke04vuSP8T3Y8bwR7q5jRhqkBK47srFefK5julgH1UVHBtHy7z5nEdyycfdXs6z83HoMueMSIZ4k6ZDeD8R5bDqeS21FJ/LAzhUlF5i8MnlvbW5zOlmtNdaa5dZbAS6PiOCVfljaqhdW3WpLapuvXuEym1KHUoTU2EveRnvYWQU8jkeB8DjamdFSqxqR1R4ZtY9NhD9ptw+jKD1RlWUuo5tjLmGh+sPz9nGFR7FV1a58OnpXMvy7kTtHZHPrdC+kNUq0K3KG4ssxJtRXo37g4ENp7wDzOObv+uxo1fBhCdWpy1Hsvc5iFBtZeyNW6bFvKwH409byOpyT+gVeA8HGHsuPZUOPLuUMSem9Yo3WVDKnHmLWGj3E6Lynj3Rt0za/WWGwifFamkftQd0v55Ap/LFwqhZ0uuVF8SUvwMVX2tVyWyWYLLdPCuBcSStz5KOQH4Y8dRmNfrVSSxFafzNPZlIH00jKeOpbyXkhR4krU2e/zx5Dk09Jl/wCQs98/kSTbMw8WKW+P1CVOoV99QSR+IGM6pYddi8RfbcF2NJzghgA7bOozsS0KeH+BVreyP1FrKh+XHEmHB2fS4uNCOfmQzZ1REVK55laWnOJDdWpjwLq1Eo/qjj+GNcFuVPS7fxKzqdk/xN/a5cOhlmhsK7TmT8zL6v7NB/vfhj2o+xu63c4Spr5v/BELO2i3rZshx+2qs9T96CHmkEKaXmMs1NL1IJHccsxjSc4R999595x99anXnVFbrizqUpSjmVEniSTgD42hS1hCBmpRySPM4A6f21TE0q3KVS08EwIjEYf6JtKP8MAOKlBIJJyA4knAFROkZ0lDVutWdZcjKl8WarV2zxkdymWD/Jdyle93dn2gBb0fbR+lG1mhQnEbyJEd9ITB3buL6wA+SlhKfngDodgDnVt3u76VbVa9UkL1xGnzDheG5i+qBHkopKvngAtdDfZp12rS78qDOcan5xKRqHOQseudH9Gg6R5qPhgB16Z20V1tuBYUJRSl4Jn1ZXEBSQco7WfeNQK1fu4ACuwKyo94bU6PS5iA5T2VKmzmzyU1GGvQfJa9KT8cAW66Rm1KRYFhlymL0V2rL6pTV5Z7rhm69keHYTy+0RgCg0mTIkyHJEl1b8h5RW684SpalK4lSlHMknAH2JLlQ5LUqI8uPJZUFsvtqKFoUOSkqGRBGAL/AHR82kP7QdnLUuqaXKvBcVAqhyGTqkpBS4U8vWNqGfnngCl22K0GrR2l1+hMI0RI8kuQ0+DD4DzQ/dSsDADzRuj3tJrdhx7ypEJM2LIU5u4CFZSy02dO9Q2oALBUDkAdXDlgAcyosmJIcjSmVx5DR0usupKFpUO5SVZEHAGLAGeDMehzGJbJydYWlxs+aTngZ05uMk1yixFLqUep06PUI5zakICx5H3k/unhiUmd3RqqpFSXDNrHptBHtBsJ2A+7VqY2V09w6n2U8Syo8zl9Q/ljROBy3U+muD1w+H8v+iBY1lKLACwB6aacdWlttJW4s5JQkZkk9wAwPUshi2e2Qqitekagn/KbyckNfyKDzH31d/hyxvhDB1fTOn+F5pfG/wAP+ya42FuRraBcAo9vPaFZTJmbEcd/Edtf7qfzxhN4RX9TufCpf7pbIgGy63vSFb6+8nOLTsl8eRePsD5e1jXTRR9HttdTU+I/mGTG86wbrhrLNGo8mouc2k+qSfecPBCfxx43gj3VdUqbl6fmV7kPuyH3H3la3XVFbij3qUcycRThZScnl8sx4HgsAZocOVMkIjxWlPPuHJDaBqJwMoQcnhbsINC2QSXAl2syerg/9WYyUv8AeX7I+WeNqpl7b9Eb3qPHsiYwbAtGGAE09Dyh78glw/gez+WNigi1p9NoR+rn5jmmhUNIyTTowHhuUf7se4RJVtT/ALV9xrSbQtaSCHqXH496Ebs/ijTjzSjXOxoy5iiMVjZFSXkldLkLiO9zbvrG/wAfaH54xdMra/RIP4Hj8Qq7ANplubNqH9D7vZcpS5ExyQzW8t7BdLoSkBS08WyAgDiMvHLGlxwUNxaVKL8y/Qs7DmxJsVuXDfbkxXhqZfZUFtrT4pUnMEY8IxmwBjkSGIzDkiQ4lmOykuOvLISlCEjNSlKPAADmcAUv6RHSNfux161rUfU1a6DpmTE5pXOUO7uIYHcPe7/DAAAwAsALACwB0K6O1o/RjZJQ4riNEuc36Rl589crtpB80t6E/LABJwAsAV46Z13ej7Hp1tMryfrcnevp7+rxMlH8XVI/DAFM8ALABY2cxtn1EtL0/clWlRanVpK4MBykPZSoTLaDvXXW0n2XNWRSpJzGWQxy3Vp3dav4VGEXCEdT1ryyfZJ+3qS6OlRy3uyWwLekUa3aW1SZrVX2cxKn6WrdcoqldfKGxmlEqPqC0hvLjoPLjlmMVNW6VatN1Iundyp6IQn8P/6Xw8+5tUcLbeOSFSNrVEqt81usXTQG65SKtpjssrUUPxYzR9V1dXJKsuKvE94xdR6FVpWtOnQqOnUhv7Sb5yafHTk21lMmNs2XaFZhrXbN2K+gMV9NWuO3qgjTIZ3CSpOogDeIOnSePLvJxT3nUbijL+fR/wDKa0U5x4efyZuhTi+H5e6BBtAvCVd11zq4+NCX1aYzA5NMIGlpA+CR+OOt6XYRtKEaS7c+77sh1Z6pZI7iwNYsALABjtGmpgW/FbyycdTvnvvOcfyGQx0NrT000cT1Gv4lZvstvuG67Lweo8xqJFaS64Ua3tfdq9kfljRdXbpvCJXTumKvFyl6kakbL7wQ4QmMh0fWQ6jL8yMVHhs7+XSK67fibMDZLcr6h1pTMNvvKla1f1UZ/wAceqmzZT6LWfOIk+tqwaJQlJfAMucOUl0Ds/cRyT8eeNkYJF3adMp0d+ZepJcZliYpMmPFjuSZLgajsp1uuK5ADAxnNRWXskBC4q1Lu25WktApaWtMaC0fdSpWWZ8zzOIzeWcddXDuq3twg3Q4bMKGxDYGTMdCW2x5JGWJJ2FOChFRXCM2BmAq+7lVXK24ptWcGNm1ET3ZDmv988cRpvLOL6jd+NU/2rgjeMSALACwBvUSlP1aqRqex7chYTn9VPNSvkOOPUsm63oupNRXcsLEiMQ4jMSOnSwwgNtjySMsSjuoQUUorhGbMDiTkBxJPcMDMAd6V81yvvykn9GR6qIP5tHI/vHjiNJ5ZxF/c+NVb7dgsVyzKvtGtawnLUUiRS4ERql1OMhQ1QZJUA8863mDpPPP/fjhrbqFPp9e48facpOcX/cuyTMpQ8RR08DrcosZcWbWapHXPsyxS3b9u0dpe7TMnZBUh5xY45Z8yOeWfliLZ/Ssxpwem4uc1Jy/tj2SMp6eX8MdkReIzYm0ylVeNSrdbti6aVDcqELqbilx5LLGW8acQQMlceBxZzlddOnBzqutQnJReeYt8NGpaaieFhoGVUtetUulUuqTWN1CrLa3ae5qSStLa9Cjpz1Dj4jHS0bynVnOEXmVN4f2kZwaWfU06dNfgTo81g5PR1pcR8Un/HEk9pVHCSkuUHQGi3jbn1o0kdoA9tl0fwUk/iMSdpI7P+XdUvZ/gwa1TZXc8Z8phoROY9xxCkoOX2krIyxpdNnP1uj1ovy+ZDlbeyecqQiRXSlmOjJXVUK1LX5KI4JHzxlGn6ki16NLOamy9CVX7cKKXS/RkPjVKgkMRWEc0IV2dWXd9VOM5vBZdSufDhoj8ctkb9KhQ7VtZKHiAiG0Xpax7zh4q/E9kY9WyN1GnG2o79llgMqtSkVOoyJ8g5vSFlavLwA8gOGI7Zx1aq6k3J8smFm7NHqqwioVRao0FfFlpP61wePH2U/xxnGnktLHpTqLVPaP4snyLQsintpQ5BipB5KkqzUfm4cbdKLtWNvDtH7TG9YNruvsTocdMZ9hxDzLjJ1NEoUFAKRnpUk5ccsseOCNVbpVCotvL7oPdsdI+3VzmaPejYt+pvf5vOzK6dI80untNHxS5y+scaJRwc1d2k6EsS+8DnSK6SK6+qRaNmyFIoaSW6lVGyUqlkcC20e5nxPv/d5+EUrlgC2PQmtHRCr12vJ4vLRTIavsoydf/Eqb/DAB02t3aLS2c1+uhWl+NFUiIc8v0h71TP8A5iwcAc4YkZ+ZKbjtDW++oJSPEqxlGLbwjCpNQi5PhFk9lW3ufYDaLLqVLFYoVLRq67TUbuSwl1WpW9bJ0unNWfMH443VLZxk0t8ES3v4zgpS8mp7ZD429sl2w26Ujqlfg5dpCuzJjqV5dl5lX4Yjk4CGyag2bZnSin23bsx6VDTTpEb9IKSUSuw84wlactYbS3lnlnnmO7AGx04KZNXDtSppBMFlyXGdPcHXQ2tGfxS0r8MAVQwAsAXN6FlEmxLBq1UfSUsVOflFz95MdGhSx++Sn5YAGW1m13NovShk25TSdClRWJ0hPENNMR0KkL/cGY+9wwBa2u3JZmzu2IblUfRSqHFLFPidlSgnhobSEoBUckpzPDkM8AR++9lmzfavQm5rm5eeebzp1xQChTg+r208HUDvSr8jgCh98WfVLPuuo23U8jLp7uguJ9lxBGptxOfctBChgBjUhaTkoFJ4HI8OB4j8RgCb7N7zRSZBpk9emnSVZocPJp095+yrv/HGynLBcdKv/DeiXwv8GGH+B5Y3nViwBEK9syt+prU9Hzp0lXElkZtk+bfDL5ZYwdNFXc9JpVN15X++xE39jtcC8mJsZxHcVa0H8NKv441+Eyrl0Op2aNiDscnKUDOqDTae9LKVLP4q0DHqpGdPoUvrSX2E4t+zaDQu3DZ1yu+W72nPl3J+QxsUUi5trCnR+Fb+o94yJhhmTI0KK7LlOBqOynU44e4f++WBhUmorL4QCrsuKVcdZMgJUGR6qFH5kJz4fvKPE4jSllnGXl069TPbsGO0qCih0KPBy9f+slK8XVe1/V5Y3xWEdXZW3g01Hv3+Y8YyJYJNrNwdaqbdHZVmxB7T+Xe8of8AoTw/HGiozl+tXOqfhriP5kBxrKQWAHK36BUK5UUQoae0eLjh9ltHepRx6lkkW1tKtLTEOFt2vS6BE3MNGp5Q9fKUPWOH/AeWJEY4OwtbOFGOI8+o74yJYsAfdKvDACII58MAfMAYpMWNKjrjymkvMODJbSxmk4GM4KSw90Q5Fav/AGUTPSln1J0UFxecinPZvR0qPc42eGR7ljJXniPOGDlOo9N8HzR+D8g67NulxZVwBuFdKPo5VDw36jrgrPk7zb+C+H2sYFSB7pCdIqXeb71tW04qPajSsnnxmlycpJ5q7wzn7Ke/me4AAEYAWAFgBYAkmze1V3XfdDt9IzRPltof8mUnW8fk2lRwB0tbbQ22lttIS2gBKEjkAOAAwB6wAsAUN6VN3fSDa3OjNL1RKG2inNeGtHbePx3qyn5YAD2AHK3KKut1uHSUSWIapjgbEmUvdsoz71q7sR7q48Gm6mHLSuFuzKEcvAYq6zBpsWJQNq9o9TZjtIi0676IkJO7QNKNRTm26APHj9nHIW0pVJOrYVtTbzKlU/H3X73Jkttpr7URqdsrrUe4Y1DsquJrDNfYWpQaU5FWiKgjV19o+wniPa5+GLKn1unKi6tzT8N0n3w9/wDY+5qdF5xF5yeajsJrAgSZFBrdLuOTASVzqfTX9chATzKUEdvLyx7S/iWnqSq06lFS4clt/wBB2z7NMg1PuauU6k1GkQ5SmKfVghNQYSB6wNK1JzOWoZHwOLuraUqlSNSSzOHD9MmhTaWPUbUNrcWEoSVLV7KRxJxJMG8Dkq16+iIuW5Ccbjtp1rWvs5JHfkcjjd9HnjONiKr6i5aVJZY140ksWADpAcQ5BjOIOaFNNlJ8tIx08HlI+f1VibXuyM3TZkqqVLrsV5tsrQlLqHc+aOAIyz7sQbmzdSWUy36f1SNGGiSb+QS8QT7YLACwBp1WsU2kxTKqD6WGvdz9pR8EJ5qOPG8GmtXhTWZPCA3ed9TLhc3DYMemNnNtj3lH6znifLuxolPJyd/1CVd44h++TJsvhiTd8dauIjIcf+YTpH5qwp8mXSIaq69ssNmJB2AwX3VFU21ZzyDpdcSGGj35u9kn+rnjGb2IPUa3h0ZPvx94BcRjihYAWAFgAq7I7f3MZ6tvJ7b+bMT7gPbV8zw+WN1NdzpeiW2E6j77IImNpfEQ2m3B6MoBiMqyl1HNpPiGh+sPz9n54wqPYqur3Ph0sLmX5dxi2KUaExLqV81loOUa1Wd8hpQzD85zsxmRnzOo5/HLHJ/xFcScY2tN4qV3j5RXxM5q3j9Z8IWz23b7qO0FxaXpVpqkNyKhUp6WlR0NRsipSg2dCSjNQAHLDqt3a07TiNfDUYrOcv577ntKM3P+0c7W9HUywnqTeqHk2Pc0xb1FrkfLrDUqL2C8Y5JXocSPA/niPe66l2qltj6TRjicHw4y3xq4yj2G0cS+FnunVLZ/acCbS7IqEi4rsuVHopqoLYMZmKzJUEqCUq7RWrh/7541aN3dSjO5iqVCi9eM5cmv8HqcY7R3bClULatWlbQbViVfTPkRmItJtWhjJQbS0M36hJB4cFZ6B35fhy9K8r1bStKn5U3KdSfrniEf8/vMmUYxks/YDKobK2a89VKudUaqXJVZDNmUhgIaQ4026ouyXgR2GENjPMf4jHTUutugoU+YUaadWTy8NraK9ZNkeVDOX3b2IzXLPvXZwI1YjzosymzFlgTYDvWIynUcVMuggdoZHuxd9M63SuZOMVKE476ZLDx6iEqlu9UX+htwtsp3YE2mZr71sOZA/uqBy/HF14paQ67/AHR+41anthqDqC3TYaIpP7Zw71Q+AyCfxzwdU11euSfwLH4i2a0uXWa89cFRWp/qp7LjnEqfUOH9QcfwwprO46TRlVqOrPfH5m5tbuHJLNCYVxOT8zL/AMtH/q/DHtR9jb1u6/8Axr5v/BDbJoiKzccWI6M4yc3ZA8W2+JHzPDGuKyyq6fb+LVUXx3Ctfl1fR6ko6qE9ek5txU5cEJSOK8vs8ABjdOWDpeo3ngQ2+J8ASlzJUt9T8p1T7y+KnFkqJ/HEc4+c3J5e7HW2bsqlBlpcjuFUXP18RR7C09/DuPgcZRlgk2l7OjLbj0C3dtOi3DaTrjPb9T1yCvvzCdX9pPA43yWUdRe0lXobemUAxppx51DTSdTjhCUJHMk8AMRjjUsvBv1q3qxRn91UYymc/ZXzQr7qxwOPWsG6vbVKTxJYOhOxS002rsvt+kEAPiKmRLy/l5PrnOPfkV6fljw0Ad6a927ii0K02V9ua6qoS0jnu2Bu2gfJS1qP7uAK52YiLT4c64pGlRiDdRWsxnvVDw+eX44n2iUU6j7cFP1NyqSjQj9bd/If4DTtOo+lU9qFcFXPWi6/8c9PHgOB7/PEqC0w5xOW5W1ZKpV+Fyo09tjGtc/6XQZNuVNNPrkePvp9RhqKEhScuPY55948OeNNakqk0ljONyXa3MqFFyknp1YinyN0KdXrNuymXvGloqa0S+tddSo5PLJJeQ4efrAVA4iVrdw35T7llbXqqtxw4zXZl43m7H2x7NykL61Rau2DqQQHoz6ePnodaV3H8wcRyaVPvLonbU6LPWmjxUXBTSr1EmMtDbmnu3jTqkkH7pI88AOGz/oiX/WKg05dSU0CkJOb43iHZa0/VbQgrSknxWeHgcAWevC6LS2R7Og6ltEeFTmRFo9OB7TzwHq2x3nM9paviTgAf9FeyZyKXU9o1eTrr92PLdacV7QiqXrKh4b5zj90JwB46UOynaVfSaa7bhYl0umIWo0jXun1Pr9p0KWQ2vsAADMEceeeAHHosbOr0su1ao3c6DENQlJdiUxS0rLQQnStw6CpILvDhn7uABNtItZraf0pHqBA7UKKGGqzJR7jUVtJk8frAndD7WALI3rsc2eXjTGoFYpLf6K0lmFLj+pkMIQNKUtuJ91IHBKs0+WAKt7S+iRelu7yda6zcdKGaiygBE1sebXJ39zj9nAEBtLaFOoavRNabcciMndjUMn45HApyORIH1TxGNkZ4Liw6q6flnvH8gqU+pQKlGEqA+iQwffQeXkocwfI43JnT0qsaizF5Rs49NgsALACwA3Vu4aRRI++qL4b+oyOLi/up5/PljxywR7i6hSWZP8AUDl33tPuF7Rl1entnNmKDz+0s96v4Yjynk5S+6hKu/SPoOOy23/SFaNReTnFp2ShnyLx9gfL2sZU1ub+j22upqfEfzDHjedYNlx1tqiUaTUV8VNDJlB951XBA/HifLHkngj3VwqVNyK+PvuvvuPuq1uuqK3FHvUo5k4inCyk28vk8YHh6aaW66hptJW44QlCRzJPADA9Sy8B7s+2WLfpCI2QMx3Jcx3xX9UeSeQxJjHB2tjaKhDHd8j5jImjLc120q3o4XLVvJDg9RER7avP7KfPGMpYId3ewoLfn0BXWdpVz1FSg0/1COeTUfsn5r9o40uozm6/Va0+HpXsRxdQnrVqXJdUrxK1E/xxhkr3Vk+7HCmXfclNUDGqDoSP2a1bxH9VeYxkpM30r2rT4kwi2rtSh1BxEOrpTDlK4IkJ/UqPnn7B/LG2NQvrPrEZ+Wflfr2/6J5jYXZ4fYZkMuMPoDjLqSh1tXJSTzGBjKKaw+ACXhbq6DWnYfFUdXrIrh95tXL5jkcRpRwcVfWvg1NPbsMmMSGLACwAsALAFjuhbaPXLsq90PI9VSY4ixlHlv5XMjzS0gg/ewBcXACwA1XVXotvW3U67KPqKZGdlLHju0FQT8VEZDAHMmoz5VRqEqoS17yVMdW++s+846oqUfmTgDXwBsu02otQ2prsV1uHIJSxJUhQbWU8whZGRy8sa1Vg5OKa1Lt3PcMIeyjarUKFU41JuCoqdst3NM+DIa642EaeAbQrMp7WXLh5HFB1zokK8HUpRxcLhp6fvZIoV2nh/COP/CxHqCNolUlrdjVKvRmYdFLSCrdx0LKdyVjggFoDPxOI/wDobp/RoRw4Um5T93jn33MvHzqfqaWwGhV1V7RLla1RKDRSt6r1RfYYS0ls62yrkSoH2fnjd/FFzS+jOi96tTaMe+c8mNtF6s9kQt+J9Irtm+jG9DEyU880CMg2ypwqBP3UnHRWFvPRCD+JRWfuIN3cxpJzfATKJb1Mo7ARFbzey9ZJUPWKPx7h5DHS0aEaa25OKurypXfm49Ox8uo5W3Uj/Mn88sLn+m/ke9P/AK8PmBjHOnciwBP7IvCK3FRS6i4Gt3wjPq9nT9RR7su44tLO7SWmRzvVemycvEhvnlf5J6ntAKT2knkRxGLU50bE7VrSI7RkpPhus/8A1Y53xEfcV1qh7/cYZG1y2Gx6lqS+fDQlH8VYeIjGXW6K4yyO1Xa/VHklFNiNxAf2rh3q/lySPwxi6pArdcm/gWPxIPPqU+oSDImvrkPH33Dn+HgMamU9SrKbzJ5ZrYGsnWx//nJI/wC6L/voxspclz0P+q/+P6BfxvOqIPte1/RpjL2etI1f1F5Y11OCm63/AEV/y/UD2NByosALAG9RKU/VqpGp7HtyFhOf1U+8r5Djj1LJuoUXUmoruWFhxGIcRmJHTpYjoDbafJPDEo7qnBRjpXCM3Dv4DvJwMwD3hW3bhuRxyOFOMgiPCbHElCTkMh4qPHEd+ZnEdRu/EqOX1V+RJ7N2pN0Jq26HUaYlNGo1UNSqYbz30lzk2pxCuGbHNI8h4Y5zqXQ3VdWpGT8WdPQs/V9fv7mqlXWF6BYrFxO3DQ2rRt66l3LOvWoOASVJCHKfSxkt9txHtJyHDtZZjPLHJ0LRW9V3Faj4MbeC2/vn2aJjnlaU86n9yGu5ZtkpgzLsqEAVW2rYdRbVm0RStLDzzSc35LuXtAkfMD4YlWdO51Rt4S0Vqy8WrPuk+Ir99zGen4nulshllM2tVLKhX7TqN9D7mNTahUH0e5mxJfCxm7uVpySlvjnl3jE2Eq9K5lazn9Io+G5T1LeK9M+5hiLjqSw87DPBrjtmbeHqhfk1yqSqa66mVNjDXmtxgpQUoVu8kpDmWkcu7EurbK86UoWsdCmlhP2e/r6GEZ6KuZbj5a1eve7r+TtJpzCZFOokxmB6BZUVSGYEjNvsNJGWnSolSvreQxBvbW2tLT6FN4nUi5a3w5Lfn97GyEpTnrXCMsW04tOu284FXkLe2a2jJXVXqYDk07KeQOrx+7j2tJGfd54xnfOpb0JU1i8rrRq7qK5f+QoeZ5+BbjPctGot37PqXclMt2Pb1cm1cUmnw4WYamtqHtaO4oXwKvI/KZZ3FS0u50Z1XVpxp625cx/++hhOKnBNLDyQG7bCrlt1KoxXU9ejUt8RpVSiJWuMl0pC92VlIyUAeIOL6x6nSuIRkvK5rKi+ceuPQjzpOJI7E2hUam09mkzmDGSgk9bR20qUo8S4nmPlni1hPBd9O6nTpxUJLHuS+rWra90MCWNKnHB2KhFI1Hw1dyvnjY4plpWs6Nws/iiHbO4kam31Uae2+JO6ZcabkAZBRQtJVw4+BxrhyVXS4KncyjnOEzxtkbe9J09w/qFMKSj7wXmr+IwqnnXU9cfTAPMaiiEMAH63W1QrOhJldkswtboPcNJVl+BxJXB29qtFus9og92UW/1yqLqz6c48DgznyL6hw/qjj+GNVOJRdGttU9b4j+YTpE+iSZa6LJdZdkqSFLhO5HUFcuCuBPw443bcHRSqU5S8N4z6HmLe99bMGBULamqmW60odbt6cVPMNpUctTCidbYz7kn8caZwwc/1LpiprXDjugZ7UtoEraffwrKmeoNvtx4caMtwKDKUjtds6BkXFLV3c8aZy0xb9CjSHCtW9TnXIUBkMMSG90gVJtZWluKznqkOMthRWklHMg5HPNWWWOftbypHM92udPrJ8LL/AHjsSalJPb94GS67YvN59ypyozkuIlGbcxpA07lKtKVFKc9JVwUR3Z4to9Zp135pJT4wRKNiqMcQXlPlu0qfT1UyuU8mc0+otTGG08WweypKufxxeUKco6Zx3T5Ke8uIVNdGfla3T9TZ+ji3LwdpQdV6Hjq646zqO7SlQ1acuWeZy+GM/AzW0/UW5q+m4tVUx/Mfl9x+2ebSLwpF+SZNpSkwqc8dUyItGuK623wC3WgU9pX1gQR4406PHq7bIleL9Et1q80v8/8AQbaH0zqAtp1Nat6YlyNwek00okMHjkF+sLKkBXdnniI4em+CxVRYWdm+xpXJ026MhhSLat6Q/II7D1QWhpsHx3bRcUofvDGJsA5RH7327bU6ZBr01b6HFFT4bGlmJCb7T26QOCcwNIPMqIzJwBb3a9fMHZnszkToSUMyGWkU+gxQBpDxTpaASeaWkp1keCcASKoXO3RLFduWopXIbg0/r0tLQTrXoa1r0glKcz8cAV0vnppNSKS7Es2kPxZ7ySkVGoFv1OfvIabLgUrw1Ky8jgCb9FHZ49RLPeu2qpUqu3QrrG9dzLgiZ5t5k8c3VEuE94KcADbpE7YtplA2rN+hnJtDp1Ka3MPeIIjzcyFvOlCs23UE5JHhl3E4AluzfpjW7UW0Q74i+iZoT/yjGCnIqyB3o7TjZP7w8xgCs9+3XVNoF/z60GFLk1aQG4MNsZqCODUdoAc1aQB5nAE3ufo97YLDp7Veio60wGUvTl01ZW5GOnNaHm+BUlHepIKcEzZSrSg8xeGRqmbXq2wkJnxmpoHvj1S/yzT+WNiqlvS65UXxJS/AfG9sdIKfWU6QlXglaFfx04y8UmLrsP7WY5G2SnhP6PTXVq7t44lI/IKw8Uxl12PaLI9Vdq1yywURd3AbPe0NS/66s/yGMXUZBrdZrS4xEh8iVIkvKekOKeeX7TiyVKPzONZVSk5PL3Z5bQtxxKEDUtZASkcyTyGB4lksBalCRQ6HHg5DfAbySod7qva/Dl8sSorCO4srfwaaj37/ADHfHpKBHtYuDrdURSGVeogcXsu99Q4/1Rw/HGiozlutXOqehcR/MgWNZSiwBONlFETMri6g6nNmnJCkZ/yq+CPwGZxsprcuei2+qpqfEfzDDjedUNtw1yNRKQ/UH+1u+DTf13D7Kf8Af5Y8bwR7q4VKDkwBVOpzanOdmzHN5IeOalfwA8AO7EVs4irVlUlqlyzVwNYsALACwAWNlt2uzGjRJq9T8dOqG4eamxzQfu93l8Mbqcux03R71yXhy5XAQcbS9IXtVowm28JyE5v09QVn37pfZUPkcjjXUWxUdZoaqWrvH8gNY0HJiwBlZiyX0uKZaW4lpOt0oBVpTyzOXIYGUYN8djFgYiwBfrov2l9HdkVMW4jRLrRVU3/HJ7IM/wDkpQfngAs4AWAAP0w7uNJ2bM0NlemTcElLagOH6PHydc/t7sfPAFJMAOVv2/WK7UBCpMF2oyUpU8uMwM1ltvis/hiPdXNOjDVUkorjL9TKMW+A6X3N2Z3A/FlVq7JLVvwkNNU6yYUUty4zqGwhbagoZJJI5kfA44jplO9oJxp0YurJvVWlLMWs5TJ1Vwly9vQYa/smtcXrZECE3MpMW5znNpFQUky46EOZcSOW9SOGfLE6167X+jXEpaZyo8Sj8L2/wa5UVqXueK/t1uKhXNMo1EpsCFbFMfchooioyClxplW7VvlEatS9PHjj21/hqjXoqpVlOVaaT16ns3vsJXLi8LgZ9szPoOqNQaE69T7buKJGriqElZSy08+kgpKBw4aOHhiZ/D8vGhqq4lWpSlT192l7mFwtPHD3Pezukpi0fry0+vmnMHwbScgPmeOO+sKWI57s4rrNxrq6O0fzN667nbocVOlIdmP57ls8gBzUryxtubnw17kfp9g68vSK5BvUbqr1QStEiWssue0ynsoy8NIxTzuZy5Z1FGwo094x39RpxoJg702069UQFx4qg0f2rnYT8irn8sb6dtOfCIdfqFGny9xxe2dXI00VpS08R+zQvtfnljc7CoiNHrNBvuvsGZuRU4alx98/HU2clNBS0ZHzHDEXVKO26LDRTnvhSDntW6JVftuLLrdsTU1WixW1vyGJKktSmW2xqWrM6W3AkDPPgfLGBtK+4AWAFgBYAluy6YmPd0dCuAktuM/Mp1D804zp8ln0ieK699g2YkHYDFe1Hcq9szIrQ1SEgPMJ7ytvjkPiMxjGayiF1Ch4tFpc8gDPPEY4kWAFgAqbI7f3UV6tvJ7b2bET7g9tXzPD5Y3U0dL0S2wnUffZBFxtL4iO0u4PRdAMZpWUuo5tIy5hr9or8Oz88YVHsVfVrrw6WFzL8u4Otn0HrNxNun2IiFPH4+yn8zjZYwzU+R876xV00Mf3bBDq9u0mrpymMjed0hPZcHz7/ni3q0Iz5Oat72pR+F7enYEiJsml1Nx+lS3WFtKWlmS0otuaeXNOXMc8c1XownmMkpR9zuaUnhPhk1sW+LZFtSrJvOM85b0qQJkWfE/ziHJ06CsJPBaSOY/jnii6l02t4yubZrxUsNPiS9CTTqrGmXA/Vev0i49p9mWzbjmu1aE/Dh05WRG8O8Qt98hQBzURxzHdiDQtalvZV69b+vVUnL22eEbHNSqRS+FBH2g1y3qP12u7QKHTplVbnOmz4SE6Zr0dtRDa5hSdJa5HtfhnjnelW1atppWlScYaF4r+qm+VH3+RIqyUd5rfsV3TeFwLuaRWYEs0adUHDvTTs4raQ4fZCWsuyP8A3xx9B+gUvBVOa8SMV9bzfmV/iPOVsS67HrrolIk7OKiwhDESoJqFfrsbeyN/1gAtOPnLPIA5jvJHiMVNjGhWqK8g95Q0wg8LGOUjdU1R8j+1hFauS3Y5fuakKTJtiwISKVaTHfLq0tGRfLZyX39488c67OtLFGptWupa6r/tpx7ZN+pcriPHzPGy6DJpu/ueNejNUtDcOz7ypjjZ3gkqaKloUw6D7bnAL4E5ZccZdaqKpig6DhcZUaUu2M+q9F2FFfW1Zj3K/wBamoqtblzY0REREx9a2YMdOSGwtXZbQkeHLHe29Lwqai3q0rl9/cgSeWShmydrVtU41tqkVGBBKdTr27OWjxcb4kDzUnESl1u0nU8ONWLn8yTSdalvHKI1b9ZepFajVJOayyvNxP1kK4LHzBxZp4MLau6VRT9A01ik0i76A3odzZd9bDlJ4lCvMfkoYkNakddXowuqXt2YLZ2zO74z5bbidaR7rzKklJ+RII+Yxp8NnN1Ok14vjPyH+09lksSm5ld0oZbIUmECFKWRy1kcAPLGUafqTrLo8s6qvHoPu0m4urU8UOGddTqWTZbTzS0o5fivkMZTl2JnVbrTHw4/HL9/iSC2qK1RaNGp6cipsZvq+s6ris/jwxnFYJ9pbqlTUQbV3Z/ekivuywESFSXt51xtYSEceGYOSk6RjS4PJz1x024lV1c5fJPL1kNxLNn9YXqUpgMBX13FZJz/AB442z4Lu/lpt5Z9MAv2a7P6pft3w7bpy9yqRqXIlKTqSyy2M1OKGY8gOPEkDEY4o368Lr2ZXbOtsVJiU7TlBt3cnfR1JXk4UZLAKdXDeJ8eBxEubGlW+Jb/AL/aM4VHHgcaTc8WpyVNN1JyhsMxitpolslcwlWRbJ0JGkLORJzKvyqa9nKmsuPiNv3+H35/TBvjUz3wbEelw971eNUPR7jLDBkyIaVlLe8b4l3QhW+KlpzGog5Kzzy4DZS6jXo+aOfM3s3zh9t9tvnxwaa1pSq7TSeDWiUaoUtiqoqLpdgVM7kVxg70bwFae1kSrI6VceXyxd9O6vSqZhJ6ZyXf9+5VdQsJrROmsqm+DSjNRKbS3KRRZTdRrNVVu1Os+yhrvzPdkM8WsUoR0QeqciBOUqtTxasXClT9e7HVlNNpNCq9MhHePQ4xVNkfWecBTp+X5Y3rTCEorstyJJzrVqdSWylLZeyIxRrFlTKa7PmO9SZDZWxqTmVADPURwyTliFSsnKOp7ItbnqsYTUIrU87/AL9Qw9FG+7AtBNWer4fhT6g42wmtrbKoTbIGaWVOJzLSlLOZKhpPDiMsQi5VOWNWNiPdKTaizeN8JpdLkpkUCgpLMdxpWpt6Qvi+6kjgocAhJ8sxzwMC1l9JbkbC63x7CrceWD8IZUMAUl2K7Onb92gU+iqSfRqD1qrOD3YrRGsZ9xWSEDzOALv7UNp9ubMLai1Cewp1tx5uJDgR9KVqA9rQDkMm2xn+A78AYaHd+yja5QlxGVxazHUM5FKloAkNHxLS+2kjuWn5HAFTukpsxsewLjgw7blP76c0qTIpbpDiYzerS2Uu+3kshWQVmeHPABQ6J+xLqzLW0K4GP0h5P/F6K4PYbVwMojxUODflx7xgA0bbauaRsluqak6VinusoV4KkDcJ/NzAHOTAGeJAmzHFNw47klxKVOKQyhSyEI4qUQnPgBzOAMGAFgBYAnGyu3uv1g1N5OcWnZFOfJTx9gfu+1+GNlOJcdHtddTW+I/mGHG86s1KrJlRqZKkRGFSZTbZLDCeJUvu4eXPHjNVaTjBuKyyu0rrJkuqk6usKUS9rGStROZzz78RTg55zvyYsDEWADRsqgiPagfy7ct5bhPknsD+6cSKa2Ot6NTxRz6smOMy2BNterKnqrHpSD6qGjeODxdc/wBycsaKjOX63XzNQ7R/MH+NZSCwAsALACwBv0GpLplYhzkHIsOpUfu8lD5pzx6mbrer4dRS9GWK4HiOR4j4YlHemtUoiJtNlxFjNMhlbeX3kkD88Ga6sNUHH1RXBQIOR5jgcRDgD5gA17NLe9FUESnU5TKjk6vxDX7NP4HP54kQjhHX9JtfDp5fxS/LsZbh2dUCr6nm0dQmH9syOyT9pvl+GWDgmZXPS6VXf4ZewMq9Y9coa97JY6zASeMljinT9rvR8xjS4NHOXXT6tLnePqi7OynpAbMrsiRKTCf9CVJptDLNHmkI4IGlKWHfYc4DgB2vLGJBCvgBYAo10uru9NbUlUppeqLb8dEQAct+5614/wBpKT93AARwAYrTgXxZOzSo1+m0OSJ1woZ6nXmCHOqw0LJXqaHrGyvSCFZZEZeGORvqlre3saU6kdNLOYP60vnw8ehLgpQhlLkn052yb0/ybcjTNZ9B0RFQr98QXENKakEag0gtp0uZjkD392KGnG5s/PRbp+JV0woy3yvV54JDcZ7PfC5BXaFQsmuTnpNxXFU6VdiZSXqNcMg9YZQhv9Sh/mcwRmTwGOpv6VzRilRpQnQ04lBbPfnH7yRoSi3u2peoQb79H0twXRdez6PW5mQcFwUuUv0XKVl2XX2kg6NXgocfE45/pmur/IoXLpx/snHzx9k+/wBhvqbbyjn3AbeV3VW7bgkVuplPWH8koabGTbTaBkhtA7kpGO26fY07WkqUOF97fqyDUqOTywp0NKE0WnhHsiO1l/UGOxo/AvkfP7p/zZf8n+ZCtpFLqDtRYmNNLdjFoN5oBVpUCTxy5Z54ruoU5as9sF90SvBQcW8PIz0exq7UCFLa6pHPN17h+CPaOI9KznL2RNuOq0affU/b9Se0ay6JTNK931mSP273Hj9lPIYtKVpCHuznrnqdWr30x9EP3E4lFcLADDcFowqzIRIWssvJTpWtHvDuz+GIle0VR5LGy6lOgsLdBo6Yu0j0XbkWyoLuU2tevqOk8Uw21dlJ/pXB+CT44oTsysmyu2aXdG0KiW/VFOIgVJ8sPLZIS4M0K06SQoZ6gO7ABF2ldFC+7Y3s2gD6R0dOavUJymNp+2xx15eLefwGAAi4242tTbiShxByWhQyII5gjAHnAGeBMehTWJbJydjuJcR8UnPAzpzcJKS5RYmm1CPUqfHnxjmzJQFp8s+aT5g8MS0zvKVVVIqS4Zs4GwG1/bO3HnXavRWtS15rlQk88+9bY/in8MaZw9DnupdLbeun9q/QGBSpJIIyI4EHGo503KNS5FVqkansfrJCwjPwHvKPwHHHqWTbQoupNRXcsNChx4UNmHHGliOgNtjyT/vxKO7pwUIqK4Rm+PAd5wMwC3vcBrlffkoOcVr1MQfzae/948cRpPLOJ6hc+NVb7cIlOzKBu6bJmqHakOaEH7Lf/wBzi26dDyt+pxXXKuZqHovzJFcc/qFDmyc8lJbKW/vr7Kf44l3E9MGytsqXiVox9wK45w7o9ssuuupaaQVuLOSEJ4kk+Ax6lk8lJJZfBKW7ZvC3n4lZgEpmRiHkORzqcZWPEZcflmMbbnpjnTcZrVGS3RAodXoylhPD7ZGW4LgrVfqr1UrMpcue8fWOueXJIAyCUjuAGWIVta06EFTprTFFlKbk8smGyayaLXhW6vWRLkQLejokqp1OAMp9S1ZDRn3JyJOKjrnUalDw6dPSpVXjVL4UbqFNPLfYNF8Nxq/Ng21Qw9En7QDHqVwvOgIejUqK0kJS4njpz0nge/PxxxnTW6EZVquJRtcxhjiVST7E2r5nhfW5+RDWG9nk6DctUsqluUOZYqUzKXcBeL6JS2lFKQ607qRqcKTo/wAOWLmTu4SpQuZqpG58soYxpz6Nenc0eTdx209xlvbaDdtY2aMOyLej0qPcMz9NrcMJaFQVFzyStodoEK4k8jlwxM6d0q3pXrSqObpR2hLfRq9zCpVk4cYyN/R8ixnb8dkKZTJn0+nS5lIjL4hyY0gbsZeIBJGJH8VTatUs4jKcVJ+kXyY2q8x82f3/ALSpm02mqFSlzZk6ahqdCdWtTS2lryeSpk9hKUoz7uzlj3qvS7KFlLyxjGMdmuc9t/3kUqs3McazsbdrF2XLPp0yBQ7SiVJ6NGqE93csKc1dplngc9Cs0+GI1v8AxAqVClGcZ1K8oJtRWXj1fzMnb5k+EhlqdB2h7MXG33g29R5ivUymViRBkHLPsqGRSrL4HF103rVG6yqbxJcxezX2G2lXrW3Hw/gOEbbLALf6VTXUud+6WlSf7QBxceKWkOux7xY31fbBNdbLdLiJik/t3TvFj4JyCR888eOoaK/XJP4Fg+bMKRIqtbkXBPUp7qx7DjnErkLHPP7CeP4YU1l5HSKLqVHVlvj8ybTLhIvKn0JhXAtuvTf9WS2n8tWNmd8FxO6/8iNJejb+7Y8XfebFtdW3sVUnrQWU6VhGWjLnmD44Slgxvb9W+MrOQV3ZelRuNxAdSI8No5tRUHMZ/WUfeONEpZOavb+dfnaK7FidjMCJsl2J1babVWx6ZrTQFKYXzLZOUVsd/rV+tVl7gB7sYkEGmybYdcm1SXOuWsTzTqHvnHJ1XeGpx94nW7uwSBwz7Sych54AIrGwXo21iR6Bod8uGv57tpXWozwcc5ZBG7Qlz4IVgAUXhbF77G7kcpEwtvw5yd4xLbTkiUx7CtDmW8bUAdKk58M+8EHEO7sYV/i5XH/zgzhUcTHSbsptU64iTJdhPPdiDCDhSltKEoPqlgsNoW4W/FIzA4EE4qa9jOnjCUkuXjnnlbtpZ93z7G+NRMc0RKbPV6QhFVOluOKjenGhkw9oUELVuxqQG+0AFkJ5cyrPHlvfV7WWzzt8PdZ9/X23+WMGuva068cTWVkj9IdZoUCruyWHKnAclFmNPSg7iStnUr3+PdqPA5Y6ex6lTxpn/UaUtP6lN1Hp1SpKLg8RjlZ/Q9OVWpSrTmVB86pdXfTEhtJ5BAOWlA8+OLB1ZOk5PmWxCp2kfpUKUOILL93+8ElfqVPsG3abBdZ6y++T1ltJAKsxm6vjnnkckjPELOlH0uVWNlSjFrLfP+Rjuy1aDU6Cq5rcAbQga5EdI0pKR7XZ9xSe8csYyimsoh3tnTqU/GpfaGiB0m7NuLZRWrZqra6LW/QcmFFC83Y8hYiqbQEOAZpUo9yx8zjUUBNOids7ZtvZ6mvPhKqpcmmSpaclaIqcww3mPHMrPxyPLAEE6WezzalX64zXIUL0lbFNjhuMxDJcfZKu0846zlqOojmjPsgZ4Aq9BnVCmzW5cF92HNjqzafZUptxCh4KTkQcAGzYns6uDbFfLt0Xi+7Po1PU36RlPc5TjaAGoqSMhlpALmXd5qzwBaO/dokK16nblr05Laq9cExiJDij2WIm8CXn1JHJKUAhA7z5A4Ah3S+qwhbH3YurJVTnRowHeQgl8/7HAFMLTtOv3XXY1DoURUuoSjkhCeSU+8txXJKE95OAL7bGdi9A2a0TdshMuvykj0nVSOKzz3TWfFLSTyHfzPkBWbpeM2pE2ix4FEpzEKa3FD9XejpDe9efVmjUlPZ1BABzyzOrjgAMxaHWZcCVUY0J56BBy65LQhRaa1EAa1jgOYxpncU4yUHJKUuFndnqi+TRxuPAwbOLhthFGj0pl/q84ZqebfyRvHVcylXI+AHPG+DR1XSrqjoUE8S9+7JzjYXIsANVdteiVxvKoRwp33ZKOy6n97v+Bx445ItxZ063xL7e4M7h2V1iBqepp9Ixhx0AZPpH3Pe/d/DGmVM5666PUhvDzL8SELQtCihaSlaeCkngQfMY1lO0HmwgkWfS9P8AJn8das8SYcHa9N/oR+Q/4yJwA77cUu76qVcw+U/JPZH5DEafJxPUXmvP5jFjEhCwAsALACwAsAWSg6+oxtft7lvV8dAxLR9Ap/CvkjYT7Q+OBmVrm5dcfy5bxWX44iHz+p8T+Y82Pb5rdfZjrGcVr10s/wA2nu/eOQxlFZZK6fbeNVS7Ldh64d3AdwxJO2FgBf488AQu6NmVLqQVJpmmBP56RwZWfMD2D5j8Ma5UyovOkwqbw8svwMtj9Inajs6meh61nWaaxkDBnqJdQj+YkdpWWXLPUnyxoaOXq0pU5aZbMsxaHSN2Z3NRJc9if1GbBjuSZNKmlLT+llGtW746XeXuk+YGBrKGV+sSq3W6hWJZzlVGQ7Ke7+08srP8cAaTJbDqC4NTYUNaRzI7xjx+wLE3y7tVRc8G7tnLsidbEyHGZprcAb5lDbaAksPx+0MwrPmPzx8+6arB0ZW95iNaMpOWrZ790yxq69WqHBjvi3KnWJdLt2k02JTrznxRPvhuG8uNTUx0K1tomISrRq1donmO7njLpt3ClGVapKU7eMtNHUszz309/wDB5UjnZfF3HKnbU7SkF+34y6XZNxwnVMIqLUSPMpb5bOjsPaUqSlWWYUr8TiNV6LcRxWfiXNGSzp1OM1n2MlWjx8L/AABttXuvavFkPWvc1calwpDbb4bgFjq7rROptWbSUqyJTnkrHSdDsbCS8ejTcZLK82cp9+SPXqVOGwX46UihSsCuszKUiAtQEuGNIR3qa90j4cji7saylHT3RyXV7Rwqa/qy/MlQOXLE4qBc8AR6tXtRaZqbSvrckfsWjmAftL5DESteQh7ssrbpdWrv8Mff9CCVi965UiUB3qsc/sWc0/ir2jirq3k5+yOhtul0aXbU/clmzXryqVJW+pSo5dAj6uPIdvLPu5Yn9PzpeeCn65p8RJc43/wS/FgUgKNot7VC9ryqVyTs0rmuepYzzDTKOy00PupA+fHHLH0Qetgikp2x2mSch19A/EEDAHRXAA/2jbDdnt+trcq0AR6oR2KvDyakg92o5FLg8lg4AqptK6LG0C097NpKPpHRk5q30RB6y2kfykfirl3oKvlgAMKSpKilQyUOBB54Ammzy9xRnjT6go+jH1ZhfPcrPvZfVPf+ONkJ4LfpnUPCemXwP8AxIWhxCXG1BbaxqQtJzBB5EHG86tPJ6wPSPXFY1BrubrzfV5p/62zwUfvjkr+OMXBMgXXTqdbd7S9UN1kWEu3p8uXJdRIcUN1EWjMZIPFRIPInljGEMGjp/TfAk29/QmWNhbER2l3B6LoCozSspdRzaR4hv9or8Oz88YVHhFX1a58Olhcy/bApiOcgGygQOoUWHFyyUhsFz76u0r8zjpKENMEjhLur4lWUvcjW06dogRYKTxfWXFj7LYyH5qxC6jPZItOhUszlP0WPvIBAgSp0pEWK2XXl+ykfxPgMVUIOTwuTo6tWNOOqWyQVLXtKJRWw6vJ6oKHbe7k/ZR/v78Xltaqn/wAjkb/qMq7wtoen6kgxLK0F20kMivpS2hKDuElwpAGaiTxPnlik6h8f2HW9Ez4O/qM9vXLXbcqbdTok1yDNb4B1s8weaVA5hST4EZYqbq0pXENFSKlEuYzcd0TNnbPWVC6ahMjh65LjjNwm6qhWgRo6ey4221lw1p7weeKaX8PU/wCTCLxRpSctP9z7Nv2N30h7+rJhSrVnVrZrR7NslbdQFQkMT70qTK05MF5WlllQVpUd0EalAeA8cVNe9jRvZ3NzmOlONKL745f29vn7G6MMwUY/ae643Wrkv1FMsJ6GhjZ223HolPlrbCpLrRyeW225wcVrRxz8B3nGNs6dva67pSzdtuclnyp8Za4EsyliP1T7tEjyGK1ZYpVLZom1aprRJnGm5tttbxRQ2FtZqRqVxK/IHPMYdJmnTr65upYw2Wrl453/ACPaq3jjabGy+Nr970Gu1ehxxR01hkqjTbjpkTdyHMh2+2r2VDkrhwPLEjpvQbavShVfi+G91CctkYVLiSeNs+ps161q7fmz6whaY67BgNmFVo7au1GnPODePvo55K4qKvDj34wtb2lY3dx4/llJ6ov1ilsl+h7KDnCOkjW2utwU1KBZNGXqoVpM9TQRydl85Lp89fD8cWP8O28tErmp/UrvV8o/VRruZb6VxE1rY2Py6pQGa/Wq1AtmmTVFFMcqK9KpJHMoT9TPvONt716NOq6VOE604/Fp+r/2YwoZWW8DNemza57QeZFSabeiSwpcKfFcDzDyEZFSkKTxyAIzzAxL6f1ehdp6MqS5T2aMalFxJLZW0G3KbQkU+QyuM9GQteY7aX1+1zHFJVy48PPFzGawXth1OlTp6Xs1+IyWNUpNQ2htTpBzelF9S/3m1cB8BwxjB+Yh9Pqud1qfLz+Q97Z0nTSVd3rh/cxlVJnXvqfb/giNhUmjVS66dHrskw6EHUuVWWEqVu46TmvPQCRq9nPuzzxqUWzm5TUee5afpKWPc99WnSKjZMuFOtKjMLfVBjupTq0py3qFZ7pSWmk5BOYI4888eGQwbbKg/bPRtseiUBZaplYZjCc+1w3iVx+srSSP5Z1RUfHLAFWELWhYWglK0nNKhwII7xgC0221cm4ujLZVfrOa69vYgbdV+sd3zTiVfEupQlZwB8T0OocuyKUEVY06+nIxkS4sghcdalHVu9A9YjdBQQVpzGfdgAGVJy+Nn9YlWxV0FlcVSUvQ3MlIKM94lTTg4hKs9SSk9/jiHcWFOq8teb1/fJsjUaJLRLtolRcQuMeo1B1eUiLLeyilTij2281I5k6Vgc08NOWedFcWNSmt/NFcNLzbdn/j37kiNRP5m7TKLT5V1l+PDRDg0dIUtDal7pyU4nNCt2rghSG+KwB7WLzo/iOlmcnJZ2z+9/b2LHplnGVbxMLy/n/0Di9a+a5X35SSerN+pipPc2jv/ePHE+Tyyvv7nxqrfbsTa2or1J2Z1B2UkhU8LMdk8zvkhpsAfbPEY2R2iXFpB07OTf1uPt2Rhh2Ratu01uddbuuS5yjZnSD9VKUdpZHeeWGlLkwh0+jQhqrvf0/fJMdnd/U2lyyiyao7SZCjqVTl6lR3svrR3SpCuHeghXnhiLMo0LO42h5ZBptHpN2y/U/QF6ITbtaTkEycyqnvBXsrQ6eLWrwXwH1samsFFcW8qU9LIdt/su3L6v8At61rSp0X6TVIeka1XY/stU/2Q49uzoXq4qBPH2QPax4aAvzpdlbGNmQUlG5pNJa3bDIy30qSvkM+9x1fEnu58hgCsew6t1jaJ0j41y1pe9kNpkzS2PYabbZU2y2gdyUFxOX+/ABQ6V9Gr13VKzLIoEcyahNekzFp5IbbbCG966r3UJ3isz/jgCd7N9m1lbG7Oky5UppMgN72uV5/s6tPuJ5lLYPBCBxJ8TgCbW1cbNctuJcG5XDhzmutMJfyCxHV2m1r7k6m8lZd2eAOde0K5n7w2gVmuJCnDU5izFRzVus9DCPk2EjHjeN2AotPW3FsCm2Zd9WqNlvUtb6q1R24qyqpB1etC0uAFKsuA45j8jjiGq0ruVzbwhcKeNEtXwY52J/l0aZeXH4jdc1k2HUdm/0gtmizaU+uaxDoLkp/fPVXeLLbgDIKgkpIJ4eGJFn1G6p3nhV5xmtLc8LCp91uYTpxcMxX/YObzseu2fOYp9a3KJj7IfLLLqXS2CSnS5p4JX2eWOh6f1Gldxc6edKeN1jPy9iPUpuPJs29tFuCkBLS19dhp4bh85kD7C/aH8MWSm0TrbqlWlt8UfcJ1v33b9a0ttPdWmH/AKq/klWf2Veyr+ONymmdFbdRpVuNpejJDjInnh55phlb7ytDLSStxZ7kpGZP4YGMpJLL4K+XJWXKzWpVRXwDyvVp8EJ4IH4DEWTycNdV/FqOXqFvZhLD9nxkZ5qjOONK/rax+S8b6fB1HSJ5oL2ySvGZZgS2n05US7JDuXq5iUvoPxGlX9pJxHqLc4/q9LTXb/u3InjArBYAWAFgBYAcbdpa6pW4cBAz3zoC/JA4rPySDj1LJvtaPiVFH1ZYjh3cB3DEo7w158pEOBJlrOSY7S3CfupJwZhVnpi5eiK3qJUoqPM8TiIfPw2bNre9FUBMh1OUyoZPOeIb/Zp/Dj88SIRwjr+lWvh0sv4pftEsxmWhHLgvmkUKqR4MwLVvUa3XG+O6BPZzT358eWMXPBAueowozUZf/B6p9SgVGMJMF9Ehg++g55eRHMHyOMkyXSqxqLMXlGzgbCOXza7Ndo69KR6QipLkRfecuJb+Cv44xnHJX9RtFWp/7lx+gCTwxGOMFgCff8CO0BdqQ7liQeuRZbXWDEYOqU21mdDimeZSsDMac8Uf/wC0doq8qMpaXF4y/hb9M/qb/o0tOSMUq6LqoJdZpdUmUzUSHmmHnGeI4HUlJHHFlXsqFfDnCM/mkzXGco8PAXNnlq35R6DLuWfRlXNQbrhKRWKc0+oVLq5USh8e+dfMacyQccn1W9tatVUYz8GrQl5ZY8mfQl0oSSy1lM3bG2h2Q7UpdP8AQdGte0IDKl1RmoIMqoTU+xukrVxK8/d4nGnqXSrpQU/Eq1riT8unywj7/I9hVj6JIA05xhcx9cZJRGK1FhCuJS3n2U/IY7qmmorPONyCz4zDlvDNlhx0eKElX8MbFFs1yqRXLSPiVyoj4UkrYfbOaTxSoH+OG8X6M9ajNeqZIo+0W5WmwhS2niPfcb7X5acS1f1EVk+jUG+6+0b6ldlfqKSiRKIaPNpvsJ+enn88aql1OfLJFDp9GnwtxozxHJpNrPsqm1KA3UZbq1grUnqyeyOye9XE8fLFlaWkZrUyh6j1OpSnoivtCEwwyw0hlhAbabGlDaeAAxbKONkc3KTk8vdg4vK53ZVU3FPfKY8QFBcQfbWfaPwGWQxTXlxmWI8I6rpdgo08zW8iHq9o/HEAuCb7DiBtetHM5f5TY/vYA6N4AWAFgDmbtGSlO0G5kpGSRVZwA/8A5heAI9gCT2lftUoCgwf0qnE9qKs+z4ltXun8sZxngsbLqM6O3MfT9Au0G56NXWdcB8FwDNyMvsup+Ke/4jhjepZOotrunWXlf2dx1x6ShYAXDvOQ7zgAC3vcHpuvvyUHOK16mIP5tPf+8eOI03lnE9QufGqt9uxp2zA6/XYcYjNCnApz7iO0r8hjZbw1TSKi9q+HRlL2DTjozhQbXPFn3BdzkKGnUmKlLSln2EZcVKUficU9xF1auF2OosakLa21S+tuTS37dg0WNu2BrfX+vkn2l+XknyxY0LeNNbclHeXs68svjsjbnVGJBQhUlenerDbSfeWtRyASPnjZOoo8milRlU+HsbWMzSCW/wB7eXRKH8mG0fggH/HFDfP+Yzs+kRxbr3z+ZHQCTkOeIhZBBpGzmO7SNVQWtqe9206f2Q7kqT3nxxa0unpw83xHOXHWmqnkw4L8RrXTbwsyaKpTJbsfdnhPiLKe/kseB8DwxWX/AEuM46asVOBbWXVIVX5Xpl6fvkl9v7X7YqVQYe2h0BuoTGZCZSK9BG5lhaMtIcQkoS4jsgZZj4Y5K66DXpwas6mmLWNEt4/Z6MuI3Cb86+0m9uxZcp64tsDEyPcFbXBW5S6TEOtynuujRk8lWWXV2cuXPtYpbucYql05p0qerzSfE0vT/k/8G+PepywQW9tCv2xZM5EYdWl1MtvyxOjBbiuagr1ozAXrz88dbd9Ktb1RzvGGUtL/AE9CHGrOH2k8qlVelUO2NodvyEWdWavPVSK47GO5hrUjiJSm/Z0gZlQyOKOhRUatWzqr6RThDXDO8v8Ajn8je5ZSkvK3yQG+tmN1Wv8A5Smluo0iUv1FciOB+O8peZGauYUrLPji96Z1mhc+SOY1FzBrDRoq0ZR37BMuSxKltLVZFQtx5D9stwYtMnJbWnVTlt/5xvG+7hyPfl8Mc3Z9Th076RCssVtcpL/fnjDJM6fiaccG8X7sr11OVnZtMprkO3k+gIFvPKbUtVPb0pW8Wl8N26sHiCFZDGjTQoUPDvVPVV/mOaz8fZZXdL7MmXmlLMMbbYGy+tnlnV26q1LjSodrUG3UsRa3UmmlraeqT57SWWEnspSeycsSem9WuKFCnFqVarVy4RbWVBerMatKMpPskDa46BXNm14oZ3rMl1DaZMGYgamX476SErAPHIjMfHHVdL6lG6peJFY3w0+zXKNUJSoVMrkxXnebVyQoAMcx5UUub5IOpB16cik8+7kcWUpZJF9fqvGO2GjJR2WqZTUGeypLcgdclK5hbDWRYY7OeneOEE6su7GVrd0nmOd87++Oy/z8jnL22qyllemF7Z5k/kuB1gXdOkxahGhzKhAhTojwqDDK0pExBWN4kpy3at02Txy1EcM8SnpqvLzx9/8A8I0VUt1hOLy0u+Ft/wD7P7AtbMr+sO5dm7GzHaU51aFmpNvVlZ3YU0yo7tWrjuHGs8klfZKeHjnElTx8mWlOspZXdYz7Z9zZhdGPZFQ5YrVxX2zLt9k70RithjeJ5hKnkurKgfsJBPdjWbiUUOu0vbFtMgGlsaNm+z4CS2pxG7blTstMfJB9ltpKM0g9w4+1lgCS3psxh3ZfFtbSGbxXT6fTksvMNDSlpcdB3x3TupvSHs+2VBWY8sARmJSbS2obbKvekhDE6yrQginmQ8Eriy5QS4txXHsqbZQ6Tn908sAQ+5NgGyu+aRKufZXcUaIlhtT0umyFq6u2EgqVq1evjcPrAjwyGAARbF6Vy3m1IYSJNMDnrGlA6NavquDikqCf/tjKM8E+06jOhst4+hK/pts4nKE6oUvRPTxILKV5n7wICv3hjZriWv0+0n5pR83yNaPeqrlvSjxd11elsP622VcStxKDoUvu4HkO7HmrLNcb/wCkXEFxBP8AEZ9qkmU5djrT2e6YabTHT3aVJ1Ej4qJxjU5InWJN18PhLYjFKckt1KKuKSJKXUFnLnq1cPzxgiupNqaxzkKG0Gg+mbrokJvg48hzrKx7rCFZlR/tZY3zWWdH1O28WvCPrz8jLH2kzdlF4uKswNhD7bYrECQN6y5pOpCAf1iCEn3Vd+Nc0kyq6pSpQqaYfaM+2fbXWtptUiuvsejqVBbAi0xLm8SHVD1rqlZI1KUeA4cE/PPArQl9CSkb27bhqxTwhwW4yT5yXdX8GMAWsr9Vt63oMu46w4zDjxGcpE5wDUGgcwjP2jmo8EjmcAUyvvajXtt+0Oj2tBDkG2H5zbMSDn2lAqyXJfy4FQbzIHJI+ZIFk+kDcrVn7G6t1PJlyQwik09CeGXWBuuz91kKI+GAKY7PLBRXmZ1dqlUFCtui6FTaoQVL3qj6tphIy1OH8uGKbqvVPAcaUIeLWqcR9u7fsbqVLVu9kgwQ69Tarak30fUk7RaNR299UaFXGNxU2mE834skDUdI8Qfj3Y5GpbTpV464/RKlR4jOm8wb9JRJilmP9yXZkHtKHQ6xf0WbY9QEBii7iXSKFX5GW+kKXqfjx1jUEjhz4knF3fzq0rVxuo6nUypTprhdpM0U0nLy9uzJNX6xSLeu7dNWI3SbkrkvNytXO51mEy4+rtLaI1NlAJJzB4YrbW3qV7fLuHOjTj8FJYk0vXvk2yklL4d33YNNs8y15d9SHLc3CooZZTLehp0RnZYT65xlI4aCfDHR/wAP068bVKtnOXjPKj2T9yLcNatiP/RKu+i2qk2xvWHRr0o4uJT3Ep55Hyx0f0WenV2Kz/UaXiODeGh1t/aRcFI0sPq69ETw3L5OtI+yvmPnnjUptHQWvValPZ+aP77jzem0WBVbdTDpm8belK/TELGRQhPHTmOB1HwxlKeUTL/qkalLTDl8g4xqKAI+x6rJRKm0lZ/XgPsfeRwWP6pz+WNtJl/0OthuHruFLG46Qiu0O2F1ujhcZOqoQs3GB3rSfbb+eWY88YTjkrOqWnjU9viiBFSSDkeBHMYjnHnzACwAsALABa2WWouDFVWpaNMiUnTFQeaWjzV+/wB3l8cb6ce50/R7PQvEly+PkT/GwvCG7U60INu9SQr19RVu8u/dI7Sz/AY11HsVPWK+ilp7y/IHNjW+a3X2WVpziMeulnu0JPs/vHhjVCOWUHT7bxqqXZbsPH5eWJJ2pgmzI8KG/MkHSxHQXHD5J/34GFSahFyfCK9VmqyKrVJFQkH1kherLwHupHkBwxFbycJXrOpNyfc90Wu1KjTUy4DpbWPbT7ix9Vae8YJ4MqFxOlLMQ/UmoN1KmRZ7Y0olNpc0+GfMfI8MSUzt6NXxIKXqjbHPHptK83NGRGuGpMI4IbkuBI8tRyxFlycJdx01ZL3Y2oICgSMx3jHhHLCXdR77uat02+9l81cqIqHGiJjQnkNPwlMpyUw60opGnPjkf4cccBYXFrbU5Wt8sS1N5ksqWe6ZYVFKT1QMO0qh1i65lCtZinQantEYa63dFVipQ02ynkhl9xOSOAV2yfLLnjPo9zTtY1K7lOFo3inF7t+6XPy/E8rRcsLmXcdVtXjQrik7R7k6vNiUimGJT4tvOl6I0823oaakJSQpDWZKjmCAcRU7evRVnRzGU6mW6ixJrO7Xq+3yM/MnrfZdiF7a6/CnW5bDdQagS7ymxxUKvV4aEJKWnM9ywotnSpWXtZ+Hni5/h21lCtV0OcbeL0xjL17vf8DRcSyl/cMFpWIzuUTqujWpfaZiK5Adxc8/LH0K1svrT+45HqHVnnRS+1/oTltKW0BDSQ2gckJGQHyGLNbHPN55ME6nQJzZbmR0Pp+2OPyPMYxnTjLlZNtKtOm8xbRCq3s19p2kO+fVXT/dX/vxW1un/wBhe2vXO1VfaiETIMuG8WJTSmXU80LGRxWyg4vDL+nVjNZi8owYxMydWNctLplGktz39BS9rabAKlKCk8cgPNOLOzuIwg9Xqc/1WxqVaqcF2NO47/lT21RYCDFir4OLJ9aseHD2R8Ma7i+cto7I32XSI03qn5pfgRVnvxALk8K9o/HAEx2M5f8ACzaGf/72if7ZOAOkOAFgBYA5p7Um0t7TLsQn2U1ieB//AFK8ARjACwBljLkofQuMpaXwfVqbzC8/LLjgexk08rkndv7WajG0s1hvrrI4dYRkl4fH3VY2KoXVt1qUdqnmX4hIo1w0estbynSUvEe21ycT95B443J5OhoXVOqvK8jJtKuD0Vb647SspdQzZb8Q3+0V+HD54xm9iF1W58Olhcy2/UCWI5yBN9mMDXNlziODKA0g/ac5/knFl06G7foUPXa2IqHq8/cEXFucya0KBFhIWlhGRdWXHVn2lrUcypRxhCCjwbataU+expXBccGixt4925C/1EYe0rzPgnzxqr3Eaa9zfZ2U68sLjuwd0+pTa5dsB2YvUovo0oHsoSk6skjw4YqYVJVKqb9Tpq1GFC2ko+gWueL440DN1u7646iscRv1Afu8P8Mc7cvNR/M7jp8cUIfIktgWrrKKxNR2E8YbZ7z/ACh8h3YmWNt9d/YVfV7/AB/Kj9v6BAz7yfiTi2ObBbe10+lJPVIqv8nsHgR+0X9b4eGKO8udbwvhR13S7DwY6pfG/wACLZHuxCLY3I/piIFuR+sRw6hTbq29aNTaxkpKiMs0kcxhOjq+JZx7GKrR7MI6Nplj3HTILG0OhSZ9UpjSY8es054NPPMo9lEgK4HL638Mcw+j3NvOTtKkYwm8uMllJ+qJfjRkvOtyZ0qQ7eNNivw7HaqWz2DqpkOixpWU6Kpaklc05EErUeGo+fiSaevFWk2pXDhdy8zm4+WX+z5G9ef6vlHACzDtPoWy+O0mRQLdakrZjSCFtyaw4guDf8AF6M8vjmMR/wDyfoVS+e1Wq47rmNPONvTP5GXl1qHZDBTJLt712BSqCybQvcOS4t1LpjZZh9SbBTrW2lYClg9jLxPPlifWgrKlKdV+PbYi6ep5lqfvjjuYLzvC8su5jp+0Km2zVJ8CXaTD14WmxIg0yt0ttSUHcpMcOymfqgcdZzxlV6VO5hGUazVvXalKE3674i/8Hiq6XjHmib+z+0H27Kr06bU2KpaVz0d2XVJxWEKh1RglaELSpRUVhR55cT+ejql+nc04xg4V6NRKK/ug/wDBlSp+V901+IA5MyZKUhUl9x8toDaC4or0oTySNWeQHhju4wjHhJFe2T+rbNosC1LTR65d63S/vI8AEbtENzJDOtOWoKUogg58s/DFDQ6u5163H0ait331Ln7CQ6Oy/uZtVOnXzaBm+l6amrU6K8uEau0C7HDjY4pKsgFBOvIpcHMZDIjGujWtbvT4ctE5LVpezw/32MnqjzujWgrplUbmim1JEHIOPZKZQCA4CFaUH2OwO0W//wAWEb64toqLWpPb1/H3ItSzo1Zanz++V3Pk2CiM8ZRcLSFMJgMSdB6tFQGwXSlz3lqQeyMs+1i7tr+jVez0yxw+y7/P2KeraVoLDWqOrVt9Z9vl7/I0Zds06euE+yE02m9TLiVnIuulOpWeXedIBUcS5W8ZYfwxwaad9OnqT889f2Lj/PASKbtJTafR1et2j0aXCrFZKut1XsrZW1J4OPa0HU2rdJDaUqHLiCcV2lnTztKsYKbXlZJNvVNk1DYpspgQWd/MlCHHitJ9pS3ISUpSPicseEYmtTufZ1sPsm3dn9fhmqIqzDnptDASvMODJ95xCstaVrVoSM89I8sABjaNYuz2VWaGnYzVnpc+7FOR10VhxRQyyR2w4pWTrSDn2kO58ATyGAD7J2fWvs02A3FSktMTnWac+9Un3UJXv5y2skLKVZ5BKindjuGXfgClNp2lX7srsah0KKqXUZJ7KBwSlI9pa1ckpT3k4AzXBbd02PcvUKxFXT6vDUl5CVZEEA9haFJzSpJy5jAyhNxeVyicuSrNvuIwZr4p1YaTp4kJPmAVdlaM+I7xjdtI6Rzt7yK1PTP9/eeqfQLHtB30lMqQly2+LCc0qIP2G0ZnV5k4JJCnbW1q9cpZf77DhTKru6dUb2qLe7L7eiAweaY6D6tPxdc4nGSfc30q2ISuJ9+F7dvvYNqDRqhdlwrStzIuqU/Nkc9KSeJ+JJyAxpSyzn7ahK5q/Pdsmk6Zs1tdz0d6PFQlt8H1FCXlA9+pTnZz8kjGzyouKk7S38unU/vJ1syv5NBbm1KwUsAv7s1Kjvo0odLerQDl2mlZKVpUg6fEHDSnwYzs6FzDVR2kv3wD3bRtuuTaPU0okNqptEhn9Fo6V6gHBwU46rJOteeYHDgOXfnpOcwTfoZ2j6Rv2fcTyM2KFF0sqP8A2iXmhOXwaS5+OAHnpr3dvqvQrTZX2IbSqjLSP5R47toHzSlKj+9gAfXHQLutzZCigTaOt6FIqKKu3XYTiXouhTARu3dGZCknvOQ+OOVtLq3uOoeLGeJKGjRJYlzyiXKMo08Y75Fsyhx7PtiqX/V5jKG6hT5VNoVNQ4FPyXnfVKKkDilCCnjn/uzdZqO7rQtKaflnGU5Y2ilv97PKK0R1MaLSmbIanQo9DuiJJotVaK93c0RRdSrWrMdYZ8E8uyD8RiXfQ6hTqurQcakH/wDje33Mxg6bWHs/Un9Sbuy0dmtVkzLqp1z2rICItCYfb66l9T2oKKCo6mVsgagM1DhigpO3u7yCjRnRrrebT04x+afHZkh5jB75QDrfpYqlXjwydLa1esVy7KeJy8z3Y+iUKeuaRTXlfwqbkGlKUoSEIGlKAEpSO4DgBjozhG8jRWLVotWzVIZ0Pn/rDXZX8+5XzxHq20J88k226hVo8Pb0ZA61YNYganIo67GHHU2PWAeaP92KutYzjxujorXq9KptLyy/D7yMFJBIIyI5jEItTapNSk0ypR58Y5PR1hafA+IPkRwwTNlGq6clJcosFSKrEq1OZqEQ5svjPLvSr3knzBxKTyd1QrRqwUo8M3Mem0hN5bOI1YWufTSmNUVcXEH9U6fE/VV541yhkp77pSq+aG0vwYLKtQKxSnS3UIjjB7lEdg/BY7J/HGlrBzda2qU35lgb8eGg26fSalUXQ1BjOSFnubST+J5D54JGynRnN4imwk2jstTGdROrulx1OSm4Ke0gHxcVyV8BwxujT9TobLo+nzVN/b9Qi42l8eXXWmWlvPLDbTaStxauSUjiScDyTwsvgAt5XGqvVt2WMxFR6qIg9zae/wCKjxOI0pZZxN9deNU1duwUdm9v+ibfS86nKZUMnnfEIy9Wn8Dn88boLCOk6VbeFSy/ilv+hK8ZlmM910B2u0ddPbldVKlBZVp1JVp5JV35Z8eGMZLJEvbZ1qenOANVyzLio6j1qKpTHdJa7bZ+Y5fPGhxaOTuLCrS5W3qN9KpU6qTW4cJouvOHLhyA+so9wHjjxI0UaMqktMd2WCpNPbptMiwGzqRFbS3q8SOZ+ZxJSO5o0vDgo+iNvMDiTkBxJ8sem0rnXJonVmbMT7L77jifulRy/LEVnBXE9dSUvVhSok6Js92YUm6IFOjzbnuWRIQzPlth5ESPFOgpbQeGtZ45/wC7HJXFKV/ezoSk40aKWyeNTl6+xti/Dgn3ZuC5VbQLAuSry47dMuy2W2ZCavTgYvWYzq9KmX0tkAkZEj/856fof0C7pU4tzoVm1pl5tLXdZPdeuDf1kRa37qp1L2TXNTW5hj3JV50dCkgL3rsJKc1jeZZAaic8zxxaXVlOpf0p4zRpwfyUvka4zxB+rHro+R6pEqtXrcpK2rPj02UmtvOZiO4ktkIa49lS9XLL/HEL+KZQlCFKO9w5x0eq35+Rna5zn6pCLEoqKjWN66nOLDG9Wk8irPsJPz4/LHb2VHXPfhFB1a68Klhcy2ClJksxo7sl9WhppJW4s9wGLuUsLLORhByaiuWDubtNqZkkwmWm4wPZS4NSiPtHMflipn1GWduDpqXQ6enzNuQ+UTaHS5pDU4dSfPvHi0f3uafn+OJNG/jL4tmV910apDeHmX4krSpKkhSSFJVxSocQfgcTynaNeoU2BUGdzNYS+33auY+6eY+WMJ04yWGbaNedN5i8Mg1b2bPt6nqQvfI59WcIC/3VcjirrdPf1DoLXrae1Tb3IXIjSIzqmX21NOJ9pCxkR8jiulFrZl7CaksrdGLHhkZozbq9WhCl5ZZ6QT/DAGJXtH44AlWyX/pStD/xmB/8yjAHSjACwAsAc2trzQb2qXckcf8AK80/1n1H/HAERwAsAWC6IOzY1u7nrvnNaqZQOzE1clznB2f9Ug6viU4APW0ro27Or23stMb0LW3OPpGCkJCleLzPBDnmeCvPAFVtoOwDabs9dVUNyqfS2TqRWKdqIQPF1A9Y1559nzwMoycXlbMHdYrtVrDrTtRfL7jTYaQo5Dsg593fx549bybK1xOq8yecGhjw0hZsKB1S3GVkZLlKU8r4Hgn8hi+soaafzOO6vV113/t2JFiWVhH7pu6LRW9y3k9UVjsM9yPtL/wHfiJc3Sp7fWLKw6dKu8vaH74BXNnS5slcmU4XXnDmpZ/98sUc5uTy+TrqVKMI6Y7JD1YbO8uiIf5PWv8ABBxJsl/NRB6tLFvL3x+YWxzGL44wGFvW6qu1yVMfH+T231rdP11FWYQP8cUlC38Wbb+HJ1t5e/R6Sivjx93uE1KUpSEpASkDJKRyAHcMXRyZBr/urQF0eEvtn/PXR3D+TH/q/DFZfXP1F9p0HSLDP82X2fr+hDaJSJNXqLcJjgVcVudyEDmo4r6NJzlhF5dXMaMNTC1SLdpFKbCYrCd4PakLAU4fn3fLF9SoRhwcbcXlSq/M/s7DnqOWWfDG4iDTVbXolTSesR0pdPJ9rsL/ABHP540VbaE+UTbe/q0uHt6PghEiJddi1JFTo096OM8m5sclP7jqeXyOYOOf6j0uE46akVOD9f3sdV0/qaq8eWfoPdgbRbTp6F/S2lPTJ7dRTWIdagltE3rCeJbdWrTqbUePPvxzfVOk16n/AK81GOjQ4Szpx6r3LelWS+L1ySxF+U2kUObd0N1lq5L6rOpcdhxKnIVOjvha0Ly4pU4efAZg4qn0ydWrG3km6NtS5a+KbWF9xtVVJau8mS+87blUar1+PRtH0s2kzjCppz/UU1KErlOkjiAo55+WWKjp93GtTpup/Qs4ape8/qo3VKenP90gdfQLY0J5tQXlN9PFzcGduE+izJ9nQfey18NWrLzx0P8AqnUdPj+BHwucZ8+CN4VP4c7/AIDHbtu2Vbt6VCgbSxJYchvNoafiZKZBSvWS6MitTbqMsshnkcTru7ubi2jVstL1J88/Z7pmEIRjLEwlz58SHdl1bVpM6JVYFHZahWmIp1MdZkNZMNjPvYbVmvLvJ8Mc3TpSnQo2CjKEqjcquecJ7v8A/U+PkSW/M5844GPZnLu2l7P63XUvyZtTut9VKtylFRWh+W6SqRL3auwSnjxy5g54m9ZhQqXdOliMYUFrnL0ivhjkwouSg368GiqzbPqez+rVKo0WZZ9ctNlqPJkElbU2SRpQktO6VBxxWWrTyzz443rqFxTu4QhONelXbaXeK+a7Ix8OLi8rS0QOi3xLYcWmqapbLidG87JdQMjllrBSefHMfPF5cdOjJeTyv8DRGr6khpNNoVWkssUdbim3UGPLUpZJbjIyU5k0vUtOsADMHLM4kWNW51uNTjH4ezNtv06ncVIr0lqf2ep7odaqtSvac6pK2KA2043MjOghpEVpBSgKSeAOLBPL9i3t686lxJ8U8brthDjZ1wT7Im0WVVK6kIhPGfSrfmNuSmGS6gthxYChulFCuaeR44x0+pC+g04/1J6W+FjP3hjumv7CtqGUa92/o9ciYm8g1dC+y6wAVAsSANDqQc/Vupz8MYtYIlzbSpSxznhruhusCgW5sM2dy9oddR1m46ynd0GE9pS8GXO0w0QCrStacnHiPZHZ58/CMOEWnXveHRsKGEqnXNflUL0hziEJQuXxWs8d20hmKPgOAwBOtjdk2Ls8mOWdS1+kLt6ombcNSCfZSVANtqP7NKic22+eQ1HxwBUvaTX2762w1iqOuj0X1ooDhVpAgxMmgQftIRmMu840XNRwg2vi7fMyiss0rmsBmOwJ1McUlp2QYjMN7tLU6F6ckLSMvE5K4gDvxA6dfzrTVJrMsZyv3+RlXjGnFy4iiKSqZKpsxLVSjuNJChrTy1Jz46Fcjw78XU6coPDI9vXp1N08oKshy2r5ozNMgTjBcYyUzDVkCClOlIUj30gfVOM9pHXydG8pqEZacdjQ2WR0RTcMdhxD8tlSUNuoz0q06wCM+ORVjymaOjx0+IlvJf8AYLny6XVl7PelR3mrnqz45/PGk5yWc78k32QJkm5HVN57gRlb/wAOJGjP97GylyXHRM+N7YHy3bfpr1y3BXZbaF02M8+20HAC2Vc3lZHhkkfxxlFb5JlrbQdapUl8Kb/7JzYF/SLGp0usWP1edQ3ldYqdFdBGooT2i07+sZcSj3Vak+WPHBPdGi56fSqQ8Wi+O374BfcV+Ju/avJvCfRV1WDIfSr0KVK4x0I3bbRW2DySkHgOJxAvYuVJqM/Dk+JehSQ59QtWpatYVGcquy6ZUqAT2pNp3Aw6YTmfMNuLBQoHx5+YxwF7fU86L6MKvpUptal81yWEKb5hlezIBMpNIvXaWLbqtMj2bWdy9FeED1zD1UGZbKkp1JQg9+n8cX8K9SzsvGhJ3FPKfm2ah3+b+ZGcVOeHs/8AIObltqsW1WZNGq7BjzoqtK0+6oe6tB95KhxBx0NneU7imqlN5i/395HnBxeGe6hddcqFAptAkvg0ukl1UKOlCUZKeOayopA1HzPHGNKypwqyqpeeeMv5Hrm2sdkNIJHEcxyOJZgSaiX9WIGlqSeuxh7rh7YH2V8/xxNo30487oqrrpFKpvHyy/fYntGuqi1YBMd7RIP/AFZ3sr+Xcr5YtKVzCfHJztz0+rR5W3qh4xIIQ0Vi16NVgTJZ0vn/AKy32V/PuPzxHq20J88ky2v6tHh7ej4IHWtn9WganYv6bGHegesA80f7sVdaxnHjdHRWvV6dTaXll+H3nizLxlW5NKHAXKe8r9Kjd4I4a0Z8lD88RIywdN0+/dB+sGGqnVGDUYiJkF5L8dz2Vp/gR3EeBxJR19KrGpHVF5Rs4Gw+KCVJKVgKSeaTxH4YDBpmiUUq1GnRdXjuW/8AdjzBp+j0/wC1fcjbbQhtGhtKW0fVSAkfgMem1LB6wPTytaEIUtaghCBmtajkAB3k4BsEm0G/hVM6XS1kU5J9e/y3xHcPsD88aJzyct1PqXieSHw/n/0MtiW76br7TTgziR/Xyvup5J/ePDGMFlkTp1r41VLst2HfEk7QWAFgBYA8obbRnoQlGr2tIAz+OWB4kkesD0ie0e5EUmhrjNK/Tp4LTQHNLZ4LX/gMYTlhFZ1W78KnhfFICWI5x4QLN2kUmFbjlp3dR/TttKe6zFShzcyYrx9pTK/A+HDFF1DpE51vpFvPw62MPbKkvdG+nWWNMt0SWnz/AKZQXrA2XUEUenPjrtXlTXt49IDHFCXXMiEo15ADvPhxxW1aX0OSu76p4k15YqKwln0XqbU9a0wWDbrdbpE+U3QdrtqO0itgBqNcVLaDbqgOykqaTmh5I4exn5DGm2tqkI+L0+sqlPlwm8r7+V9uPmeykntUWH6jRtkgt2ZSqRYFPrcyc3HS5MqcdRDcfU+vWz6kdoK08SFKPjlxxL/h+q7yc7uVOMc4jF99lvv/ANGNwtCUEzT2ZsJTRH3vedfIJ8kJGX8Tj6H05eTPucV1yX81L0iZ9ozjybcIb9lbyA793if4gYzv3/L+019FS8f7GCvFGdcLADtRrnq9JV+ivZs+9HX2mz8u75Y30ricOCJc2NOt8S39e5P6JftIqGlqT+hSTw0rPqyfJfd88WtG9hLnZnN3XSKlPePmj+P3Em/x5HE0qiEbTZ8RMePB3aFy1neFwgFaGxyAPPtHFZ1Gaxp7l/0OjLLn9X83/wBG7sX2C3FtImdZJVTrZjr0y6opOZWRzajg+2vxPJPf4GpOlLv2Vs/tOy6Oik29ARFjjIvOZannlgZa3XDxUr+HdwwBzQV7R+OAJHs0/wCka1v/ABaD/wDMIwB0vwAsALAHODbU3u9rd3Jzz/yrKP8AWcJ/xwBC8AZ4EGXPmx4MNpT8uU4lmOyjipbjh0pSPMk4A6QbLLEi2NYtLt1nIvR29c50ftJTnaeX8NRyHkBgCWYARAIyPLAFe+kfsb2UsWfVLwcY9CVWMjNpyAEoRJkOHS224x7B1LPFScjlmeOAKYYAk1Bvuq01KI7wEuGgAJbVwWlI7kq/34mUb2UNuUVV30mnV3XlkP1a2jxuopFJSrrbo7SnU5br+IUr8sSq3UFjyclfbdElr/mfCvTuD111x5xTrqitxZzWtRzJJ7ycVTeTpIxSWFweceHpLtmjWqvOOfycdZ/rEJ/xxP6cvP8AYU3XJfycesgmniCOXni6OUMECDGgxG4kZOhloZAeJ7yfMnGEIKKwjZVqyqS1S5YyXldCaPE3LBzqL49UP5NP1z/hiNd3PhrC+Jk/pth40sv4F+PsCdSlKUVKOajxJPE54ojsUFOwaJ1Ck9adTlKm5LPiGvcHz54vLGjpjnuzker3XiVNK+GP5j/UJ0eBCemSDk0ynUfE+AHmTwxKnNRWWVtGk6klGPLBfMv65HpJcaf6u3n2GUJTkB4HMEnFJK+qN84Otp9IoRWGsv1JLal+KnyEQaklKJDnBl9HBKlfVUO4nuxNtr3U9MuSr6h0nw464cLlEulRmJUZyNITrZeTpWny/wB+J8oprD4KWnUcJKS5QF61THKZVJEJZz3Kskq8Unik/MHHOVqeiTR3VtX8Wmp+pog5Y1m8KFpbYqk5tMotyXY9vo8SOac840jTu2FtqbLgSn3gV6lZc8czfdAgrKdG3WHJ6vm85x/glU7h605Dg1sJDdbTU37lpX0LS51g1kSka1R89WQb57wjh8caH/EuaehUqn0nGNOnv8/Q9+jb5ytJrXPtgrELaPW7kosJlMerIabh+kYusqjMgIbdQleWW80HjjZZ9Apzs6dGpJ5hnOmXd7tfZk8nXettdz7eXom7tmSb7jU9qj1iHUU0+tR4g3cWUpTetD6WuQWNXH54dP8AEtL36K5OpTlDVBveUd91n0FTEoauGadE2g29WVUmm3kJVMptEhdTosqiktqjPlepUtaSVKUtQABy+OWN1x0qtR1zttM51JZkp76l/avY8jVTwpbY9B0237QWKlSaFalMri7ghQWhJn1hXBUl9ee7Ch3bpB5HvPHiMRf4c6U6dSpXnT8KUnhR9F3+9mdzVylFPIybGaRs6qFWk/S6W0mQhIFJp8pS2Ij7x/l5CQdIByGXf+WJn8Q17ynTX0dPH1mt5JeyNdvGDfmJZPoNrXEm4YlHpjVr31ajTkvKlyVPQpbLH60IV3KSPDFdb3tzaulOU3Vt6zS8yxOLfBvXfT5Zx9AfVSs7QpNtxalUd8qgSXiy3K0JS2841xKFrSATy7/8Mdar2EqjpalrSy13wKl9XlHzPy/mb9w23Iuqo+naLKYejS0oL7brqW1x1pSEqSsK7hl3YkuOdyZc2ruZeJTaafvwO7z9NpVOaqbbqZaLeimnwH+aHpz3FRR4paBxl/glOUacda38KOle8n+hHjRZkqjU9d0XEqFEyWukwX95IKEOnNS0tg5NJWRmcsYafUrI2K0qVWahq47sOtS6Q8axtk9Gtq24i1XAiG3Gi1BYSuJoSnJcpsj21FXJBHA88xzxawRrm1lSfqnw13POzWfOs/o73ftFqTy3a/dDjgjy3iVOuFRMZlRJ4kh1bi/hjwjAf2ZQVCNI6nuZFUqCdzu1DUqM0FpBcUgnLjrC0kpyGXPHPdZqbrVlQhv836f4578EqgvvY3VFNsv3NOiLkLpTTJAZLLq3WjKTwW9mttpSMwOIKeefHF30amnTTqS8z4eMbenLK3qU6kf6cVJd0Okhdx06NuqpGRcFHP7ZIzcCfE/7/wA8Xz8SK8y1wOegqFWWabdGp6dv3+8DpZGwerbRoNWrdoOJgwqeptqI3N1J6xIKdbraFjPRuwU8TnxOKyto1eTg6G08VQ/mY1exGDTL22YXIBX6S/D3mbbrTo9W+3nxLTozQrIjMEE4wi8FnZXboT1cruPkuFsyuV01Hr/UJLnafRrSySe/UlYKc/NONnlZczp2dw9WrS/u/M9m4bdokUUOzh1uqTFBtLyc1ALVwC1OHLUR3AcBhlLZGX0mlSXh0N5y/fJJ41Lo7UBFqOeuzi7x9OZBWCvJSyRkc1uEnGeOxYwo01HwOfL+/wASJ1Ot2lbVvzqVQHjJmTSpCk5lZSVDQoqVkB2RwAGMG0lsVdW4oW9KUKTzKROtjlI2yWZS1bm34kinVE9ZVTn32otSWNIGpsk5jhySsfhj5v8AxBX6deT3qSU4baknKH2/qitt1UguNhn2i1vr9On1ClX1V6dUIKsp9o1d11qUlZUE6GS3pSsAnlx4cScTOk22icYVLenOMuKsEmvm88GFWW20mvY2LUp1i7NqlHqV3SatBu+RCcKHn4wfiodkp/Xx1t6y4UBWRzPPPPGq+q3XUYOFuqcrdSXEsSwuzzxk9go03mWdRhvyv7L65s6MaVc7lduakj/Is9cRxiWtClD9HeKuytIzJ1E5j489nTLa+o3mVSVOjP4lqTj816CrKDhzmQGqBSXKrVmIY9lZzeV9VtPFR/DHeUKWuWCnu7hUabl+8hLq9kUKoI7LXVHgMkus8OXLUnkf44uatnCXszlrfqtan31L3IHWrIrVMzcCOtRh+2Z45feTzGKutZzh7o6G26pSq7fDL0ZHwSDmOYxFLEk1Ev6sU/S1IPXYw4aXD2wPsr5/jniZRvZx53RVXXSKVTdeWXt+hPaNddFquSWHt3IP/V3eyv5dyvli1pXUJ8cnO3PT6tHlZXqh5xIIIxXNRaBJgvzKg1oLKCoyW+y5w5D7WZ8cRrijTazIsbG6rRmowfPbsQvZ5CvufWnI1mx3Zs5DKpD8NvJQUy3lqKkqIB5gDv8ADFAng7y3up0nmLJ1T9pcNEhUC4ojtHqLR0PIcQrSFfaSRvEfAjG5VDobfrVOXx+V/gSuHUqdOQFw5TUhJ/k1pV+XPGzJbQrQn8LTNrSrwwNhikSY0ZGuQ8hlA5qcUEj88sDGU1HnYi9Y2m2xABSw6ag+OSGPY+bh4fhnjB1EVtfq9GHHmft+oNLmvmtV47p5Qjws80xGs9P755qPxxplPJz931CpW2e0fQjuMSAG/Zzb3oi30OupymT8nnvEJ/Zp/Dj88SILCOx6VbeFS3+KW/6EqxmWRELqulyNctFosR0oW7IaXNUn6i1aUtn72eZ+WMJS3wVV5eaa0Ka9Vn9CX4zLU+KUhCSpaglI5qJyH4nA8bMS5sJtOpyS0hI5lTiQP44ZMXUiu6+8i9f2l2/TW1JhuCozPdbaPqwftOcvwxg6iK656tSpry+aQIavV51WqDk6cvePufIJHclI7gMaG8nK160qstUuQr2W5Y9As+mwKhR2bquG7Ju6lUoK0SIkdvsNBJy1NuLUvUOWYPPhjkOoq6r3EpQm6FKhHaXaT7/NbY9jfT0xjjGXI9bQtiNAiIrtRtGuNPM29/yzS5aiHIxIzCEP5aHD3Ac8+GeeMelfxHVl4cLim06vwyXD+zsKtst3F8GhRqDtFoWyyoSqLT2J1LuZtpUypwV76XGaaUc2XEI9kK97hwz44kXFzZ176MaknGdFvEZbRk33RjGM4w27hEt++aFVqUqnSt3WbEteipeq82pIWZT9QVxShhSzrQoK7Iy5fhjnbrptWlU1x/l3VariKj8Kh745JMaia9YpFcKxU5NUqcioSVrW7IWVEuLU6oDklJWslStKQBmTj6LQoqlBQXC+z8EVsnl5JvswqCDHl08n1iVB9seKSNKvwyGLvp09nE5nrtHeM/sJnKiR5cdyNJQHGHRktBxYyipLD4KOnUlCWqOzQPa7s4mMlT1KV1lnnuFcHR8O5X8cVNbp7Xw7o6S161GW1TZ+vb/ohzrLrLim3UlDieCkKGRHxBxXtYLxST3XB4x4eizwA9US7qxSSENOb2KOcZ3in93vT8sSaN1OHyIN106lW52l6oIuxzZRVNrl4yKjUdca24jgVUpCOZ+pFZJ94p5n3Rx5kZ6qtRzllki3oKlBQXYvTSaTTKPTY9MpcZEOnxEBqNGaGlCEjuAxrNxt4A5Wq9o/HAD5YJIvq3CDkRVIeR//AJhGAOm2AFgBYA5zbdEFG2C7Qf8A95PK/rHP/HAEFwBYfoe7N/TF0yLynNZwKF6uDqHBc1xPP/RNnP4kYAuZgBYAWAKa9MLaV6YuePZkB3OBQ/W1DSeC5rieA/0LZy+KjgCu2AFgBYAWAFgCdbLWv0ioO/VQ2n8VE/4Ys+mrdnP9el5Yr3YQsWxzY216txqPT1Snu0r2WGu9a+4fDxxpr1lTjkk2lrKtPSvtA7UJ8mfLdlSV63nTmo/4DyGOenNyeWdvSpRpxUY8IcbUopq1YaYUP0dv1kg/YT3fvHhjdbUdc8diN1C58Gk334QYuA4AZDuAx0JxAPdpVb1vN0ho9lnJ2Tl9cjsp+QOfzxU9Qrb6DpeiWuF4j78EGxWF+OdswnZtchsNc96laleCUHUT+Axut4appEW9qqFGTfoGk88dGcKCraItCrlcCeaGmwv45Z/wOKK//qHX9GT8D7WR6JClzHwxFaU88rkhAzOIsYuTwuSyqVIwWZPCJCzs6uVaNRQ02fqrcGf5Z4lqwqFbLrVBer+w0KjaVwU9JcfiKU0ObrfbT89OeXzxqqWtSPKJFHqNGpspbk4gbQ7Hr9u06jbQqbMfk0dvq9NrdNWgSOrj2WXUucFBPcf/AL58lV6Vc0K0qlnKKVR5lCXGfVYLdVYtYn2Gy/NoFGqVEg2palOXSrXp7hkaH1BciTJUMt88RmOA5D/7ZSemdLqU6kq9eWuvJY24ivRGFWqmtMfhN7YtQaaJlTvWush2gWqwZC2nACh+WsaWGcjwOZ4/hjR/EVzPTG2pPFWs8fKPdmVvFfE+EZLIs60r5lSaTLelUO9Jz7sqAhEfOnlhSN4G92nJSABmQrgMsuePOpdQuLJKpFRqW8Uk9/PnjOe57TpxntxI3aLT7Zg2pIty+IvVaTLqDxod7QGg6N/GJZdSeAccZ4cOHf8AMaLirWnXVa1eZxgtdKTxs917JnsUktMuM8jlbrNlUBuVb1kVVy5ryutHopucGFMRocZ8+uV2+JVp4nLll+Me7lc18VrqCo29Dz4zlya4Mo6Y7ReZMlN5wYNy2DMsi1mg41a1Yp1KhODjvXFpU286rL+dWvM/E4q+n1JW92rqu/61Oc37LlL7sG6p5oaI9mQ+7Nm1nOuXG/TXTTqPZsJiA9PQC6ajWORTpUrIZnsq09/HFvY9XuF4SmtVS4k5Y40U/wB+ponSjvjZR/FkaqlFvuiWf1K5bVeTSkAmDNcbU31dxfvqUjh3+9jorbrFrWeiFSMpemTd48lS8OccpcezPFfoU67FQ6xQ1IlNmM0xIjbxCFsLaTkQQojh34sms8Em5t5XOKlPfZLHpgkVDorKE0yHvWpb1vodJXqzZM6TxbZCu/d5Zn5YzS/An29BeWOzdPPy1Pt9hqXvXrjnUOj2lIl/ojbhmVKlRM3o8coOlLiQgKWgZOKJQOGfdniPcTUFnbP+Sr6jTjmOyU/rY4MlRrFUYcjSqa5HdW2yGoEdDSk5peVobDcjVmotnI6B2dIOeXLHNWlkqr8NqWZS337+69/Xn8yFWraI6nwkDysUhdJqLTU15ElxWTkkNHVlmrtJJ8cdZUo+G0mVdvc+PBuKa9M/mTwVJtypKdo08z5tW3UOj0hr3Xl5ITmnuyJ8sWU68Y5kpZytkUNGynU005QxpeZS9S4tDg0DZJspbTOcyhUKJvqjIQM1vSFdp1Sc8s1OuqySCfAYpzqT1b967LdqdFcixH4lajLTnJpUtA3qPvsODUMvrDh4HAAj2j9Daizt7Osab6LknNXoqWVORifBt3tON/PV8sAV9ety7dl9ztu3RQXWinUhpxf6pWfArYeTqbUcvPGUXhkuyuVRqasZHTZ/XV1i+6jOeOgyGdMdoniEJWnSgeOSR3Y2Qlllx0y48W5lJ91sNFhKpCNsFMVWNIp6aqd7vPYB3h3eruy16c8U3XVU+iVfD+PS/wDv8Cmf9Z/8mSba3a9wU+5abLfqEqZf9YkyJHUox17iOHiiJuVI7QJA4DuxTdCvaU6MoqMY2tOKWX3ePNkyrwal/uY5bSqfaVW2w0um3ZUTTyqlRWa/Oj6OFR3R9tRCkpHFGo5YjdHq3FLp0528dX8yTgn/AGZ/+ntVRdRavTcmDjWzy2EO2LelxSKhRdAVEhVeEvNoKHYehTmdWSf/AHwxUJ3dz/5VtSUandwkt/acGbvJHyyexX6+6TbVKuWTDtup+l6QnSpiXll7adRRn72jPLPIY77ptetVoqVaGip3X79SBVik9t0ebTuVqhyXFuRt+l8BK1g5LSBx7PdxxcWtx4b4KvqFk68Uk8Y+4J1Jr1KqqNUJ8LXzUyey4Pin/di5pV4z4ZylxaVKL8y/QcMbiMMNasyi1TNZb6tJP7dnhn95PI4i1bSE/ZlhbdTq0tuY+jIFW7IrVM1OJR1uKP2zIzyH2k8xirrWc4e6OiteqUqu3wy9yPcRiIWRJaLftYp+lp89djD3HT2wPsr5/jiZRvZx53RV3XSaVTdeWXt+huXheUarU9iLBC0IUdcpK+BzT7KeHMd+Nl1dqccI09N6Y6M3KePYtT0SNm/0eshdzTWtNUuPS41qHaRCR+qH+kOa/MacV5dBOvrZdY18RdxcVLbkugaWpqfVyW/uPJ7XyPDywBWDaL0Prro28n2ZK9OQ05q6k5k1NQPsng278tJ8sAAieq4qbLcgz1S4ctk6XYz5cbcSfApVkRhk2eLP1Y3uOuOHU4orV4qOeBg3k84HgsASSwbe9M3A0h1OcON6+V4FKTwT+8eGMoLLJ/TbXxav+1bsOuJJ2hrz50eBBfmyDkxHQXF/Adw8zywMKlRQi5PhAMp1UfqV6w6jJPrH5zS1eQ3gyA8gOGIye5xlKs6lwpPvJfmHs88STthivsZ2dVR/Mj8nEnGM+CF1H+hL5ADxGOJFgCU2DYky7Z8lCZbNNptNYMuqVST+qYZByzI7yTyGK3qfU42kFs5zm8RiuWzbSpag8LTU3YUSq1iLHvSmQ9PU70tjJirw9HIraRkVafD8ccKnBSdOm3bzlzSq705fJk73fm91yRePT6VX9/ZNIuFEu1XS9dNxV0MrRP0N82JCFdlTiVZHgB8PGzlVnQxc1KeK6xRhDK0fOPt+8mpLV5U9uWa9rW5EMg1DY1ebrVURxdt+qlLD72nwH6l3PwKfnjZe3csaOpUE4f3w3S/yjyEf/wCW/sNTbXfi36HTrV6kin1hzTPu9tuN1TVO06UoKfeyHa1ZkK4EY2/w70zTVlX1aqfw0vNq8v77dtzy5q7ae/cHUuyquzRmKmlO8C0bx5gDttpPI5d4y4nwx3UrSShqKKHU6cqrp8e/qM9OqEunTG5cVeh5vke4+II7wcaITcXlEytRjUjplwwnUC+aXUwlqQRDmnhoWewo/YV/gcXVC8jPnZnKXnSqlLdeaP75JJiYVY31ag0qrN6ZrAWr3Xh2XB8Ff78aatCM+STb3dSi/K/0IFXNnlSh6nYB66wOOkcHQPu+98sVdawlH4d0dFa9Zpz2n5X+BElIWlRSoaVDgQeBGIBcpj3ZNoVa8Lop9u0pGqZPc0BZ9ltA4rdX9lCQVHAHRmx7Mo1m2xBt6kN6IkNGSnMsluuH9Y6vxUs8T+HLAD9gBYA5Wq9o/HADvZiim8KEpJyUKhFIP+mTgDp3gBYAWAOde31Ck7ZLsCufXlH5FIIwBCKbT5lSqEanwmi/MmOoYjMp5qccVpSkfEnAHSPZnY8OyLJpduRslKiNZynh+1kL7TznzWTl5ZDAEowAsARTajfcKxrHqdxSMi5Hb0QmT+1kudllH9bifLM4A5vVCdLqE6ROmOF6XLcW/IeVzW44rUpR+JOAMGAFgBYAWAFgCRWldYoSnUOMb5iQUlwpOS06c+XcefLEu1ufD+TK3qPT/pGMPDQRYtz0KTBcmtyk7plOp1KuC0jzSeP4Yt43MGs54OZnYVoz0uO7+4Ftx1+RWqgZC+yynsx2fqo/3nvxSXFd1JZOtsrRUIYXPcasaCWFexKJ6Oo6XnE5SpuTi/EI9xP4ccXtlR0Qz3Zx/VrrxKuF8Mf2x5q1SZptOfmu+yynMJ+srklPzOJFWpojkg29B1ZqC7gUlSXpUh2Q8rU66orWrzOOblLLyzvIQUUkuEYhjwyCVs4onV4K6m6nJ6V2WfJoHif3iPyxcdPo4Wr1OX61dap+GuI8/MlsmSzGjOyXjpaZSVrPkMT5SSWSmhBykorlgRqM12fUH5bntvrK8vjyHyxzdSeqWfU7yjSVOCiuEgt2vQWaPTG2wkdadSFSnO8qPHT8E8sX1tQVOPv3ONv7t16mfqrgdXXWWka3VpbR9ZZCR+JxvbSIcYt8bn1pxtxAW0sLQeS0EEfiMExKLXJGLosiJUm1yYKAxUBxyTwQ75Edx88QrmzU91tItrDqkqT0z3h+QL1IU04ULTpWg5KQrxHMEYpGjrU87oMP/C3al22uLVuqB6BDslp9yqUZAQwpSBo3j8YAlWSB3Z8cuWWOQ/0Kva1/HoS8XEWtM+fkpfMmeOpR0y2+RNrguybbezh6YqtU65avP/yRadYgtJRLTGcRk7vSnilSE5AJ8cs8UtrYxuLxR8OdGnHz1IyflyuMfM3Snphym+xu1Ww6DTptkU+51B2m0pmPT6NREZFyfVJSwZLrie5htRGrPn+R00Op1aka86G05tylP+yEV5Uv9z7fvGTpJaVLhfmQuVaLkS6rkvKk1D6MMt1VVJtRMRtP6VLUvcLShs5ANc9RHn4ZYuYX6lQpW1SPjPw9dTL+GOMrL9fQ0un5nLjfCGu075m7JJ16W9PR1ytOZNxZTCtbSZbYWA4rXpUR63PxzGWJV902PVY0K0fLTXKfOl42/Awp1fC1LuZrphyKxZsO0bLfbrEOgQ/T9zzGXAVSJkj2ykHtuboEjLLh38cYWVRUriVxcp05VZeHTTXEV+CyezWY6Y743ZobFb0veZtAp1IdmyavTKqrq1Up8txchlUYpIcUUuFQGhPHP5Y3/wAQ9OtoWkqijGE4bxaWHntx6mNCpLVjkUnZNHepdTqNMefMufXHaTZ9PZ0kSm2nFBxalE+wlI9rPLhx54Q67KM4wnjTGkp1X/blbL5+3ueujzj12MdRoV6bPfQX0hitGgMy1uokwVoeC3ikhSFrSctaOOQOWLfpvW7e7eKbeY74aw8evyJVG4nR0KXwRlnY1rEgMIekyHY76Z1UK/RbmTrfq+0oLbdbHA6hx48AOSgcQer1tT2a0R+Lj8U/37oiw5b9eD5W7gbj3VGEeI4uBTQkzFoyecU8pnQXVrT2dSUZDIHu8cWPQKbp/wA2W+c9uF7fmV3VoqpTdNNJv17mhFqVvN1BLFvQ+vVSWvsypvspKuPDPHQRqU1LFNZk/UpqlGu4ZrS004riI50u/adZu1GDcrdNj1ZdObCZDOe7RvykpU42oZjUkHgSDjRetOe32/Mm9KjJUfNnnbPoTrb5t5b2j2rSqPa8Ga1CWsyaylxo57xvg0zqRqSpIJKz8sRCyADEmT6fMRJhvuxJjCs23mlKbcQod4UnJQOAD1s66YF4UXdQrtYFwU9PAyxk1OSPvew7l9oA/awBZW1touy3ahS3IUGTGqaHU/pVGmoAeA+0w57WX1k5jzwBVjpP2Fs9se5adHtTfRKlLQqVNgJc1MMI1ZNKbzzcSpagrhqyAGATwC64bKvGixY1RrNMkR4s9CX2ZixqQsOjUM1jMBRz5K44hW3UrevJxpzTlF4a7mycJLd9xUm+rvpdabrUOpvelWmDEalOHfLSyUaAgbzVyHLwx5X6Zb1afhyitDeccb89jxVJJ57hzoFmV6l0hMBYod01+qNpq1atispCaiFvpz1MySrMnSOIVyOeOIuuoUqtTV/No0oPRCpD4NvWJPjTaWNm/TuNF63pYMiz37SuW1qnQKvTGlqojLqi9uXvdQ085kvck9xBTly7sS+ndOu43CuKNaFWnN+ftlerS21fiYVKkNOlppgEzx3RAFgD02642sLbUULTxSpJyI+BGCeDxpPZk7s+8K3Lns02QkS0r5vHg4hI4lRI9rLzxaWl3OUtL3Of6l02lCDqLy+3Yn+LU5wWAGKtWbRKrm4tvq8k/t2eBP3k8jiLWtIT9mWFt1KrS2zmPoyA16yatSUrfyEmGnm+33D7SeYxV1rOUN+UdFadUp1tuJeg5bIrAfvu/aZb6QoRFr31SdT7kRri6c+4n2U+ZGIhZHRuLGYixmo0dsNR2EJbZaTwSlCBklI8gBgDLgBYAjF77NbKvaF1W46W1MIGTMrLRIa/o3k5LHwzywBWHaP0OLipgcnWTL9MxBmr0bI0tS0jwQvg27/ZPkcAV7qlJqlKnOQKnEegzWTk7GkIU24n4pUAcAauADjs8t70PQEKdTlMnZPv+IGXq0fIHP4nEiCwjsel2vhUt/ilv+hKMZlkDXa7cOSWaEwrirJ+Zl/5aP8A1fhjVUfY57rdzxTXzf8AggFvECvU4nkJTP8AfGNS5KS2/qx/5IsUeZxKO8GO9gTaNWy/kD+RGMZcEPqH9CfyADiMcQIYALlvx6hsvoon3G1CqFNu1lDE+1i8UzeqKBcbkED2Mu749x5cpdSh1Kppo6ozoPKqY8urhx9yXFeGt+/YydRt6lw5V47LbwXTHYSN9MoFQVupQTn7CeaJAzVkAQfjjHxatSStr6hr1bKcd4//APIwl5oP7B52eUauVSd9LKNWHYm0WUqQ7UKbVIa26fLadVnu0OBOnIpy4fhllniH1a4pU4/R6kE7RYSlCXni13aNlKLfmXxGpfFDshYku3BSZezy8GG1vs9XQXqbMdQCobgo4JUojhpIA88bem3NzsqU43du3jfacV7mNSMe/lYLqQ56buZl6uTVOqeWFPvyFlSnCkZJSVqz55AccdvZUKcWoLEYLsVF/VnGk5R3l+9wv9/hjpjhCGXXYbUvXNpSQ3K5uRhwSvzT4K8uWK65ss7x5L7p/VnDy1Ph9fQHLjbjTim3ElC0HJSFDIgjxGKhrB0yknuh8od6Vml5N6+sxR+wd45fdVzGJNG7nD3RX3XTKVXfiXqgg0S8KNVdKEObiUf+ru8Dn9k8lYtqN3Cfszm7rptWj7x9UPmJJAGO56NQZMF+ZUW9JZQVdZb7LnDkM/ezPccRrmjBrMuxPsLmtGajDu+Owaeh/syRSbaevac1/lCt5tU7VzbhIVxV8XVpz+AHjjnztSxWAFgBYA5Wq9o/HADla6lIuWkqSclJmxyD5h1OAOoGAFgBYA54dIYEbaLrz4fpY/NpGACR0Otmwqlxyr1ntaoVF9RTtQ4KmOJ7Sh/RNn8VDwwBcfACwAsAUw6X+0n01djFoQHdVOoHam6TwXOcHEf6FHZ+JVgCveAFgBYAWAFgBYA9hl4jMIUQe8A4A8YAWAHyz6J6WrLTaxnGZ9bJ+6nu/ePDEm1o65+xA6jdeDSz3eyC/joDigdbSa3vZTdKaPq4/bkebhHAfuj+OKjqFbL0+h03RLXEfEffj5EJxWl8OFBpLlVqjENHALObqvqoHFR/DG2hS1ywRru4VKm5fvIaWmm2mkNNJ0ttgJQkdwHADHRpYOFlJt5fLIVtKre7YapLR7buTsn7g9hPzPHFb1CttoL7olrl+I+2yB8wsIfbWeSVAn5HFUnudHJZQeAtKwFp9lY1J+B4jHUZPnuMbA52n9aFRiFRPVS16tPdrCu18+WKfqWdS9MHT9C06Jf3ZI9QLgm0eah5lRLJPr2PdWnv4ePgcRKFZ03sWd3aRrRw+ezDK04h1pDrZzbcSFIPkoZjHRJ5OGksPHoDPaRTURqw3KbGSZqNSvvp4KPz4YpuoU8Tz6nVdFr6qWl/VZEsQC5M8GdIgzI8yMrTIiuJeZUQFALQdSTpVmDxHfjCpTU4uL4awep4J/bG0p6pbWKRdl7TlKYiu6luIQSloJQrdhDSPZSFkE5fHFFedIVOwnQto7tff65fyN8KuZpyH16913/tqttqKncW/CqLSKTDA0gNpd3i3lJ+u6U6j+GIMem/QOm1XLerKD1P7MY+SNjq66q9Mk/v2qWlSkSLkv8AtyA7X0TnvoxCazRKlx2lqS07OQOzoyyOas/h3YoOl0birijaVZqlpXiN8Rb5UPf5Eiq4reS3zsACnX1X6Xdq7noxbplQccUsMxG0oj6V82tz7Og+H+OO+q9NpVbfwKmZxx3e/wA8+pXqo1LKCbdu0C8rdnt0STSqLadQrjDLlSq9NZ/SUMSfaK9JUptQ46hln4eOOasel21xHxVOrXhTb0xk9sr8yVUqyW2EsjmK1OevalV2z4/X7G2fLj0tCGDrdWiSN2/IS0M1q16j2su7Eb6PFW06Vw9NzdZnvxtulnjb0MtXmzH4YkK2gQ7hpl21rZrTZIcoblR9IsxVlACVONB0Eur4o0tqyPHLFz0qpRqW8L2a/maNOfk8cd9zTVTUnDtk3XpkelUxx9L6oC6UdIpb7XbXu1ENtpcJcCjmoJWtKjw5BOeNKpurPGNWv6yf3vG3zS9fUzzhfIaapUrgpECnyKWjfQXGg/Nk6d5vXnO0tTp58fHHfNyowiqa8mDjqVOlcVJ+M/5mrb5expxPRV4ymoFPpjrV0y1BqE1E9l51XieQHeonkO/GmdWlNZxifsTaNrcUpKKlrp+/Ytfsp6MVkWjBam3DHZr1w5Bbz0hOuKwrmUstK7JA+usZ/DliCW5L5O2fY9R5Hoxy5qbHWz2NyysKQjLuzaBQnL44A912xNlW0ukdYkRINXYeBDVVhqRvkn7EhrtZjwJ+IwBTXbhsNq2zSqNuIdVPtycoiBUCMlJVz3LwHALA4gjgocR3gADONKkxZCJEZ1bEho6mnm1FC0kd6VDIg4Antk0u7tpF9JnTdVfkw0tyqh118t75iOUoSyp4heRWAEjMYqetdQhbUG5S0uXlTSzhvvj2N1Cm5SCejaJdVGq15VC723Y7sgIYt+x5idbL6nFhtBRwKFobQBr3auOZ8sci+k0K1OhC3w0t51lysbv3TfbPBL8aSbcvsRG7/trZ3F2iUilqebs6aIiZVaej6pEWPUHEhbLKGz7ASeKjwGR7sWPS7y8lZznh3EdWIZ2k4d3k11Yw1L6o5eh9pVu1ur3YYovCo1+L1Oj3TTnEuNMOP5NB0tpHZOjIDkB44j/SLK4pQoZ8CFKWqVOS3aW+M/vJlpnF5+JvuRvbtcz59CWSqY5UHLbjhNUmvkqcdnuD1g1Hjk2OA44sf4Zs1/MudKiqz8qXaPb7zVcz4j6Alx1RFFgBYAI2zOlpREkVNQ7bytyyfsJ4q/E/wxb9Op7ORzPXK+ZKn6bjxedaVS6KtTSspMg7pgjmM/aV8hiRd1tEPdkHplt4tXf4VuyIUTaHVIxSzOT15nkFcnh8/e+eK+jfyW0ty7uujU57w8r/AACWk6khRBSSAdJ5jPuOLo5RkH2lVrQ01SWj2l5Oyfu+4n588VnUK31DoOiW2W6j+S/yWT6IezkUKynLqmtaalcRzj6hxRCbPq/9arNfmNOKk6QP2AFgBYAWAFgCOXns7s29IPU7kpbM5IGTTxGl9rPvbdTktPyOWAKybRehzXacXKjYs30pHR2xS5ZS3KTlxybc4NOfPT88AD2LtCr9CnqpF5016PLa4OKU2WX0+a2laQoeYyxtVT1L+1621tU390TJNz0NdIfqzEpD8SOgrd0ntDwSUniCTw4426kXf0ym4OaeUgCVWoyKlUZE+Qc3pCytXlnyA8gOGIzZxNaq6knJ8s9UUgViATyEhr++MEe2/wDUj80WOV7R+OJR34zXkCbTqw/+GX+XHGMuCHff0Z/Ir9iMcOOtrRrfk16HHuGW7Bo7itMuWwnW4gEHIhP3ss/LEa8nVjSbopSqLhPuZQSzvwHS/bqk2yiDXpVpUu4JzrDTFNvYLVIhPttJyaWY/stvZcxq+Byxw/S7JXOqlGtUpRTblS4km+d+6+wnVJ6d8J+5ENs130mqxLb3M6LWbkgpW7U6xDjhljJxQWxH05ZL3YHf/icW/wDD9hUpSq5jKnRl8MW8vbmXtk1XFRPHdnuyOkJd0au53bVJdRoklpxh9trdJW0XBkl5sBKRmjwxj1H+FbeVL/x4RjUTTWc747P5ildPPm4NDadtGpdTtukWfbsudNolNzekT6kf0iQ+rPSOZyQ2FEAf7sSOjdInTrTuKyhGpPZKPCX6sxrVspRXAMc8dIRiaWpfjkXRCqqi5F5NyOa2/JX1k/mMWNte6dpcFH1DpKn5qe0vT1CK24262lxtQW2sZoWk5gg94OLdPJzDTTw+Rjua0YVabLicmJ6R2H+5Xk54/HEW4tVU9mWFj1GVDbmHp+gLKlTZlNlKizGy26nu7iO4g94OKSpTcHhnXUa0akdUd0aoOWMDaSWh33WKdpaePXIo4btw9oD7K+f44mUb2cOd0Vd10mnV3Xll++xJm5R2gXBQLTpO8bFUlNollQ4oGfa+IbRqXjZd3amkomnpvTXRk5T57F/6ZTodMp0WnQmw1DhtIYjtDklttISkfIDFeXRs4AWABvtR282Zs5qMOnVhL8ibMaL+5ihKi22FaUqXmU5ayDl8MAa8Doz7FIbegW4iQe9ch+Q4o/i5lgDaHR42NJcadbtlhp1laXG3G3H0kKQcxyc8RgAjYAWAFgDn/t4pc6q7f6/TIDRemzZ0ePGZHNTjjLSUj8TgC7eziyYNk2ZTLbh5EQmh1h4ftX1dp5w/eWTl5cMASXACwBEdq9+xrFsSp3E6UmQy3u4DKv2kpzsspy7xn2leQOAOcEyZJmy35kpwvSpLinn3lcVLWs6lKPmScAYcALADtbVpXNc88U+36a/UpZ5oYQVBOfetXsoHmogYAPlmdC25ZiW5F21ZqlNniqFEHWX8vBTnBpJ+GrABmtvotbHKKlJdpS6s+Ob1QdU5n/o0btr+zgAgUyyLMpaAmm0KnwwnluIrKPzSkHADqmHESMgw2AO4JGANObbNuTkFE2lQ5SDzS9HacH4KScAQa4ejlscriVb23WYTyuO+gFUVQPklshv8U4AEd1dDOdCcM6xLhUl5GZRDqHYV8BIaGXyLfzxlGTW6MJ04zWJLKBbX5N/WO6qDetDdjv5KEWYAN06oDhk4nNpfnpOfliwp9RaXm3KSv0OLeYPC9P0BTIfdkPrfdVqddUVrV4k8Tiuby8l5CKisLhGPHhkE3Z1ROq01VRdHr5nBvyaB/wDUcXNhRxHV6nK9autc9C4j+ZKZcpmJFdlPnJllJWv4D/fidKSissqKdNzkorlgTqlQeqM9+Y9+seVqy8B3AfAcMc3Um5yyzvKFFU4KK4Rq4wNoWLDrAn0RLKz+kQsmljv0e4fw4fLF7ZVdUMd0cf1a28OrntLf9TZu+i+laM42gZyWPWx/Mjmn94YzuqOuHuaunXXg1U/qvZge78c+dqSiFtCrMOGzEbaYUhhAbSpSVZ5J5Z9rE2F/OKxtsVNXo9KcnLL3NCv3TPriGUym2kbgqKC2CPay55k+GNVe5lU57Em0sIUM6c7jNiOTRYAWAHOlz65btVh1aGVwpzBD8N4p8RzAUCCCDjXdWsasHCosxkjynVWcxfB8uG4qzcVWfqtYkqlz5B7bq+4dyUgcEpHcBjXa2tO3pqnTWmKM5zcnlhM2L7K5E+TCvSp7qRbdN30t6KwrfSVOROLbSmE5q7ahmB3geeOb/iHrapqVtDKrTwsvZYly8+xJt6GfN2HOhVSQYd17Va+236TrTy6NbseUAptLz/YWrSvmmO0MuXcRiNc0Vqo2FLOimtc2vRcfbJ/4M4vmb77I36jQrVsZ+vUy165ULfvGhwESVT5LzaItUSpIWptts8M+12B4+ONFK5r3qpzr04VbepPGEnmn7t/meyhGGUnhr8SDWbHqEpqbdM1xyZVZ75iw1uFC3npChqzSXDnqK9IJGeSdXdnld9QlCLjQjiMIrL9Evs/ecGqkn8Xc81i7HHpUNmPTZj9LiDTUIMtOf6UEltXIZZoSrvA58RnxxZ9Gs3Sk6slGeeGv7WQOoyVSHhqWhiDdSgRzUrWdVIpvEv0l4Els+8Ak9r8Pzx0vmitVLePoc9mFR6LhYn2ku4ceiZb9JrNUq18+jkRJERIp0cDlvnBvJDg5AHQUJHxOK+vVU3lLBd2dvOlHEpavT5DL0uNsFVNaVs/o8lUeBGbQutraVkp511IWlhRHuJQQSO8njyxoJZWPAEs2b7S7msC4GqtRZCg3qHXYCidxJaz4ocTy5clcx3YAvbdFLou1PZO82wN5FrsASqctQGpt4p3jKvJSHMgr5jAHOhSFIWUKGSknIjzGACzs9FuT7Hn2vDucW7cdWWn0g3UGkpjSA0vUw21KT22vtaufhjleq+NTuo15UvFow40vdZ5bj3/e5LpY04zhscJ9zbVbFipo1+0du5baVwY6+OsMke6WJqdRSfDPj8MR6VnY3r8S1m6Nbvp2f2wPXOcNpLKBZOo9zSmXK0/Tphhu+sM1TTymtPd61WeYA4Zk46inXoxfhqUdS7ZWfuIzjLkftlu02dYtYdmpD8qKth1HUEvFtkvKT6txxHFK9J//ADiB1ro8b2np2UsrfG+O6XoZ0azgyHzZkibMemSVl2TJcU684rmpazqUT8ScW1OChFRWySwam8mEAngOeMzwWAFgAvWPp+i8LT4Lz+O8Vi/s/wCkji+q/wDsS/fYa9otFqM9iLIiNqeTH1h1pHFXay7QHfyxov6UpJNb4JfRrmFNyjJ4yNVkWjLXORUKgypqOwdTLbgyK19xyPHIc8aLO1edUuETOqdRioaIPLf5BAmy2IcV2XIOTLKStZ+Hd8Ti2nJRWWc3SpuclFcsgezq0p+0vaXDpatQamPF+ouJ/ZRG+LmR7uz2E+ZGObqT1SyzvKFFU4KK4R0ViRY8SKzEjNhmNHQlphpPBKUIGlKR5ADGBtMuAFgBYAWAFgBYAWAI/eFg2jeNPMC5KYzUGsju1rGTrefe26nJaD8DgCs+0fobVeGl6bYc4z2OaqRMUlt/Lnk292W1/BWn4nAFc63QK3Qqg5TqzBfp85v248hCm1/HJXMeYwBipRAqcMnkH28/64wRso/GvmiyK/bV8cSz6Axnu0Z2tVh/8K6fwTnjyXBEvf6M/wDiyvmIpwxYHZFRrktKCtFxWy3Ltq4ENvorTbDdQ6qso9WX20a1bsau0Mhljguu3FG7l/Jq6a1JtaMuGr1w/X09Swt4uHK2ZnuLahU7DfmWtXrHpTlMnAuDqWtiFLbVydQ2oOo494GRBxhadGhfJV6VxU1x/u3lH2zsxOs4eVxQwbJIFIdsy7Ppo01As2U9HaEgtkPtVBSsmtwrivJpK8znnw8tWJ/XatRXNH6NmVwk9s7OHfPz/fYwoJaXq+EHV+WPVbPraqdNyejuDfU6oNcWZMdXsutqGY+I7jjoemdShd0tcdnxJd4v0ZGq03BjJEptQmBZix3Hw3lvN2kqyz5Z5Ys405S4WSNUrQh8TSyeXYE5n9bHcb+8hQ/jjxwa7HsasXw0YMsYmwkFs3dNoqw2c34Cj22CeXmjwOJVtdOn7orr7p0a6zxP1/UKVOqUKoxUyobgdaV+IPgodxxeU6imso5GtRnTlplszDWaJAq8Xq8xGeX6t0e2g+KT/hjGrRjUWGZ211OjLMf/AKCq4ban0V/Q8NcdZ9TJT7KvLyPliir28qb34Ows72Fdbc90NGNBMLB9DG2Ez7/qNedTmiiw9LJ8HpZ0A/6tLmALoYAWAMUqVHiRnpUhYbjsIU684eSUIGpRPwAwBzb2h3nLvS96vccgnKa8erNq/Zx0dllH7qAM/PAHSnACwAsALACwBUGd/wDrrt/99a//ALeMAW+GAFgBYArl02/+Y1A/8TP/AMuvAFOcALACwBeDogf9Fqv+9uf4YAOeAFgBYAWAFgBYAWABr0if+iKuf0YwBz2OAFgA4Uj/AJJg/wBA1/cGOlpfCvkcDc/1Jf8AJjXfn/NeX8W/74xovf6TJnSf/Yj9v5AjxQnZCwBNdl//ACjM/oB/fxY9O+J/Iouu/wBOPzCOOYxcHLgLqP8AyhK/pV/3jjmJ/Ez6DR+BfJGvjE2CwAsALAH0YAJm0D/m1D/c/ujFzff00ct0f/2JfvuDPvxTHUhp6K3/AD8kf0H+OON/jb/1V8yZY/E/kYtrH/RPZf8A32rf/Mqxs6F/79f/AI0//wDEV/6cftNHpHf876P/AOCQv/Xjb/CP/rz/AP3sv8GN3yvkO+y7/kSL/QSP7ruIvWv6r+a/wbaHBmo/62pf+ISv9pj6N0D/ANOn8jguv/8AtP7DZR+v+YxbFT9UMPRB/wCj+t/+Oyv9kzjmanxP5n0Cj8C+SKy9Ib/pouv/AL2P9kjGBsB3gBYA6G9Hb/oWtX/uq/8AbLwBQGtf8vT/APvTv+0ODBNtvP8Az9d/oGP9mMc//DP/AKq+b/Mk3fxk7rX/AOrjQf8AxSJ/dXijt/8A+MVP/wB3L/Bvl/RXzLGPf831/wDdD/s8fO4/1v8A9X+Sw7HPmZ/nb/8ASK/jj79D4Uc+YcZAIOzz2cWvTznOskCkf5w594/xxVvk6GHBjx4ZBZ2ff812P6R3+9i9sf6Zx3WP/YfyRIxzxMKw+q9o4BcEb2gf813/AOka/vYh339ItOj/APsL5MmfQm/5917/AML/AP8AIbxRHYFx8ALACwAsALACwAsALACwB8wBWvprf83aH/Tr/gMAVJp3/KEb+lR/eGCM6fxL5lk3PbV8TiWfQWNF1f8ANirf90e/uHHkuCLef0Z/8WV7xFOFLJdFX9XJ+KsfOv435RZWXA69Jv8AzC0v/Ez/AATiL/Bvx1v/AN3+psv+3zCHtD/5vOf0w/grHPdK/rfYSqvwgX6Qv/RpY/73+xTjs/4V/wDcuP33IF58ESDbL/8AkyZ/Tp/uY+qdN+FnDde/qR/4/wCSbPewMWcihiQi5/aXisuS/sQfSv8AOFYqpHS0+CabLv10/wC6j+JxY9N5ZQ9e4iEHFsc2MF9f82JXxR/HEW8/pMsek/8AsR+0EXfigOzLZ9B3/ku7v6eF/dewBaDACwBFdqv/AEZXZ/4RN/8Al14A5ts9+AP/2Q=="; + var ImageData = "data:image/jpeg;base64,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"; var img = document.createElement('img'); img.src = ImageData; diff --git a/webgl/webgl.txt b/webgl/webgl.txt index 09a36e4..f9b45ea 100644 --- a/webgl/webgl.txt +++ b/webgl/webgl.txt @@ -14,7 +14,18 @@ = gl.LINEAR = gl.LINEAR_MIPMAP_NEAREST = - = + + = gl1 + = gl2 + + = program1 + = program2 + + = tex1 + = tex2 + + = buffer1 + = buffer2 = 0 = 1 @@ -47,7 +58,6 @@ = true = false - = 536870911 = 536870912 = 1073741823 @@ -143,15 +153,16 @@ = gl.BLEND_SRC_ALPHA = gl.BLEND_SRC_RGB = gl.COLOR_CLEAR_VALUE - = gl.COLOR_CLEAR_VALUE = gl.TEXTURE_2D = gl.TEXTURE_CUBE_MAP = gl.TEXTURE_3D = gl.COLOR_WRITEMASK - = sh1; - = sh2; + = vShader4 + = vShader3 + = fShader3 + = fShader4 = VERTEX_SHADER = FRAGMENT_SHADER @@ -308,9 +319,7 @@ = gl.FLOAT_MAT3x4 = gl.FLOAT_MAT4x2 = gl.FLOAT_MAT4x3 - = gl.SAMPLER_2D = gl.SAMPLER_3D - = gl.SAMPLER_CUBE = gl.SAMPLER_2D_SHADOW = gl.SAMPLER_2D_ARRAY = gl.SAMPLER_2D_ARRAY_SHADOW @@ -355,7 +364,6 @@ = gl.TEXTURE_MIN_FILTER = gl.TEXTURE_WRAP_S = gl.TEXTURE_WRAP_T - = gl.TEXTURE_WRAP_T = gl.TEXTURE_BASE_LEVEL = gl.TEXTURE_COMPARE_FUNC = gl.TEXTURE_COMPARE_MODE @@ -503,7 +511,6 @@ = 'WEBGL_draw_buffers' = 'WEBGL_lose_context' - = this = @@ -515,357 +522,134 @@ !varformat fuzzvar%05d !begin lines -# Image -# = new Image(); -# = new Image(, ); -# .src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///ywAAAAAAQABAAACAUwAOw=="; - -# Uint8ClampedArray -# = new Uint8ClampedArray(); -# = new Uint8ClampedArray([,]); - -# ImageData -# = new ImageData(, , ); - -# ctx.rect(, , , ); - -gl1.activeTexture(gl.TEXTURE); -gl1.attachShader(program1, sh1); -gl1.getParameter(); -gl2.activeTexture(gl.TEXTURE); -gl1.attachShader(program2, sh2); -gl2.getParameter(); -gl1.linkProgram(program1); -gl1.useProgram(program1); -gl2.linkProgram(program2); -gl2.useProgram(program2); -gl1.activeTexture(gl.TEXTURE); -gl1.attachShader(program1, sh1); -gl1.getParameter(); -gl2.activeTexture(gl.TEXTURE); -gl1.attachShader(program2, sh2); -gl2.getParameter(); -gl1.linkProgram(program1); -gl1.useProgram(program1); -gl2.linkProgram(program2); -gl2.useProgram(program2); -gl1.pixelStorei(, ); -gl2.pixelStorei(, ); -gl1.pixelStorei(, ); -gl2.pixelStorei(, ); -gl1.pixelStorei(, ); -gl2.pixelStorei(, ); -gl1.pixelStorei(, ); -gl2.pixelStorei(, ); -gl1.bindTexture(, tex); -gl2.bindTexture(, tex); -gl1.bindTexture(, tex); -gl2.bindTexture(, tex); -gl1.bindAttribLocation(program1, , ); -gl2.bindAttribLocation(program2, , ); -gl1.bindAttribLocation(program2, , ); -gl2.bindAttribLocation(program1, , ); -var buffer1 = gl1.createBuffer(); gl1.bindBuffer(, buffer1); -var buffer2 = gl2.createBuffer(); gl2.bindBuffer(, buffer2); -var buffer2 = gl1.createBuffer(); gl1.bindBuffer(, buffer2); -var buffer1 = gl2.createBuffer(); gl2.bindBuffer(, buffer1); -if (buffer1 != undefined) {gl1.deleteBuffer(buffer1);} -if (buffer2 != undefined) {gl2.deleteBuffer(buffer2);} -if (buffer1 != undefined) {gl2.deleteBuffer(buffer1);} -if (buffer2 != undefined) {gl1.deleteBuffer(buffer2);} -gl1.isBuffer(buffer1); -gl2.isBuffer(buffer2); -gl1.isBuffer(buffer2); -gl2.isBuffer(buffer1); -var fbuffer1 = gl1.createBuffer(); gl1.bindFramebuffer(, fbuffer1); -var fbuffer2 = gl2.createBuffer(); gl2.bindFramebuffer(, fbuffer2); -var fbuffer2 = gl1.createBuffer(); gl1.bindFramebuffer(, fbuffer2); -var fbuffer1 = gl2.createBuffer(); gl2.bindFramebuffer(, fbuffer1); -if (fbuffer1 != undefined) {gl1.deleteFramebuffer(fbuffer1);} -if (fbuffer2 != undefined) {gl2.deleteFramebuffer(fbuffer2);} -if (fbuffer1 != undefined) {gl2.deleteFramebuffer(fbuffer1);} -if (fbuffer2 != undefined) {gl1.deleteFramebuffer(fbuffer2);} -gl1.isFramebuffer(fbuffer1); -gl2.isFramebuffer(fbuffer2); -gl1.isFramebuffer(fbuffer2); -gl2.isFramebuffer(fbuffer1); -var rbuffer1 = gl1.createBuffer(); gl1.bindRenderbuffer(gl.RENDERBUFFER, rbuffer1); -var rbuffer2 = gl2.createBuffer(); gl2.bindRenderbuffer(gl.RENDERBUFFER, rbuffer2); -var rbuffer2 = gl1.createBuffer(); gl1.bindRenderbuffer(gl.RENDERBUFFER, rbuffer2); -var rbuffer1 = gl2.createBuffer(); gl2.bindRenderbuffer(gl.RENDERBUFFER, rbuffer1); -if (rbuffer1 != undefined) {gl1.deleteRenderbuffer(rbuffer1);} -if (rbuffer2 != undefined) {gl2.deleteRenderbuffer(rbuffer2);} -if (rbuffer1 != undefined) {gl2.deleteRenderbuffer(rbuffer1);} -if (rbuffer2 != undefined) {gl1.deleteRenderbuffer(rbuffer2);} -gl1.isRenderbuffer(rbuffer1); -gl2.isRenderbuffer(rbuffer2); -gl1.isRenderbuffer(rbuffer2); -gl2.isRenderbuffer(rbuffer1); -var tex1 = gl.createTexture(); gl1.bindTexture(, tex1); -var tex2 = gl.createTexture(); gl2.bindTexture(, tex2); -var tex2 = gl.createTexture(); gl1.bindTexture(, tex2); -var tex1 = gl.createTexture(); gl2.bindTexture(, tex1); -if (tex1 != undefined) {gl1.deleteTexture(tex1);} -if (tex2 != undefined) {gl2.deleteTexture(tex2);} -if (tex1 != undefined) {gl2.deleteTexture(tex1);} -if (tex2 != undefined) {gl1.deleteTexture(tex2);} -gl1.isTexture(tex1); -gl2.isTexture(tex2); -gl1.isTexture(tex2); -gl2.isTexture(tex1); -gl1.blendColor(, , , ); -gl2.blendColor(, , , ); -gl1.blendColor(, , , ); -gl2.blendColor(, , , ); -gl1.blendEquation(); -gl2.blendEquation(); -gl1.blendEquation(); -gl2.blendEquation(); -gl1.blendEquationSeparate(, ); -gl2.blendEquationSeparate(, ); -gl1.blendEquationSeparate(, ); -gl2.blendEquationSeparate(, ); -gl1.enable(gl1.BLEND); gl1.blendFunc(, ); -gl2.enable(gl2.BLEND); gl2.blendFunc(, ); -gl1.enable(gl1.BLEND); gl1.blendFunc(, ); -gl2.enable(gl2.BLEND); gl2.blendFunc(, ); -gl1.enable(gl1.BLEND); gl1.blendFuncSeparate(, , , ); -gl2.enable(gl2.BLEND); gl2.blendFuncSeparate(, , , ); -gl1.enable(gl1.BLEND); gl1.blendFuncSeparate(, , , ); -gl2.enable(gl2.BLEND); gl2.blendFuncSeparate(, , , ); -var buffer1 = gl1.createBuffer(); gl1.bindBuffer(, buffer1); gl1.bufferData(, , ); -var buffer2 = gl2.createBuffer(); gl2.bindBuffer(, buffer2); gl2.bufferData(, , ); -var buffer1 = gl1.createBuffer(); gl1.bindBuffer(, buffer1); gl1.bufferData(, , ); -var buffer2 = gl2.createBuffer(); gl2.bindBuffer(, buffer2); gl2.bufferData(, , ); -var buffer1 = gl1.createBuffer(); gl1.bindBuffer(, buffer1); gl1.bufferData(, , ); gl1.bufferSubData(, , buffer1, , ); -var buffer2 = gl2.createBuffer(); gl2.bindBuffer(, buffer2); gl2.bufferData(, , ); gl2.bufferSubData(, , buffer2, , ); -gl1.checkFramebufferStatus(gl1.FRAMEBUFFER); -gl2.checkFramebufferStatus(gl2.FRAMEBUFFER); -gl1.clear(); -gl2.clear(); -gl1.clear(); -gl2.clear(); -gl1.clear( | ); -gl2.clear( | ); -gl1.clearColor(, , , ); -gl2.clearColor(, , , ); -gl1.clearColor(, , , ); -gl2.clearColor(, , , ); -gl1.clearDepth(); -gl2.clearDepth(); -gl1.clearDepth(); -gl2.clearDepth(); -gl1.clearStencil(); -gl2.clearStencil(); -gl1.colorMask(, , , ); -gl2.colorMask(, , , ); -gl2.colorMask(, , , ); -gl1.colorMask(, , , ); -gl1.createShader(); -gl2.createShader(); -var tex1 = gl1.createTexture(); -var tex2 = gl1.createTexture(); -var tex1 = gl2.createTexture(); -var tex2 = gl2.createTexture(); -gl1.enable(gl1.CULL_FACE); gl1.cullFace(); -gl2.enable(gl2.CULL_FACE); gl2.cullFace(); -gl1.deleteShader(sh1); -gl2.deleteShader(sh2); -gl1.deleteShader(sh1); -gl2.deleteShader(sh2); -gl1.enable(gl.DEPTH_TEST); gl1.depthFunc(); -gl2.enable(gl.DEPTH_TEST); gl2.depthFunc(); -gl1.depthMask(); -gl2.depthMask(); -gl1.depthRange(, ); -gl2.depthRange(, ); -gl1.detachShader(program1, sh1); -gl2.detachShader(program2, sh2); -gl1.detachShader(program1, sh1); -gl2.detachShader(program2, sh2); -gl1.disable(); -gl2.disable(); -gl1.isEnabled(); -gl2.isEnabled(); -gl1.disableVertexAttribArray(); -gl2.disableVertexAttribArray(); -gl1.drawArrays(, , ); -gl2.drawArrays(, , ); -gl1.drawElements(, , , ); -gl2.drawElements(, , , ); -gl1.finish(); -gl2.finish(); -gl1.flush(); -gl2.flush(); -gl1.frontFace(); -gl2.frontFace(); -gl1.generateMipmap(); -gl2.generateMipmap(); -const info1 = gl1.getActiveAttrib(program1, ); -const info2 = gl2.getActiveAttrib(program2, ); -const ifo1 = gl1.getActiveUniform(program1, ); -const ifo2 = gl2.getActiveUniform(program2, ); -gl1.getAttachedShaders(program1); -gl2.getAttachedShaders(program2); -gl1.getAttribLocation(program1, ); -gl2.getAttribLocation(program2, ); -gl1.getBufferParameter(, ); -gl1.getBufferParameter(, ); -gl1.getContextAttributes(); -gl2.getError(); -gl1.getFramebufferAttachmentParameter(, , ); -gl2.getFramebufferAttachmentParameter(, , ); -gl1.getProgramInfoLog(program1); -gl2.getProgramInfoLog(program2); -gl1.getProgramInfoLog(program2); -gl1.getShaderPrecisionFormat(, ); -var source211 = gl1.getShaderSource(sh1); -var source122 = gl2.getShaderSource(sh2); -gl1.getTexParameter(, ); -gl2.getTexParameter(, ); -var loc = gl1.getUniformLocation(program1, ); gl1.getUniform(program1, loc); -var loc = gl2.getUniformLocation(program2, ); gl2.getUniform(program2, loc); -gl1.getVertexAttrib(, ); -gl2.getVertexAttrib(, ); -gl1.getVertexAttribOffset(, gl.VERTEX_ATTRIB_ARRAY_POINTER); -gl2.getVertexAttribOffset(, gl.VERTEX_ATTRIB_ARRAY_POINTER); -gl1.hint(, ); -gl1.lineWidth(); -gl2.lineWidth(); -var pixels = new Uint8Array(gl1.drawingBufferWidth * gl1.drawingBufferHeight * 4); gl1.readPixels(, , gl1.drawingBufferWidth, gl1.drawingBufferHeight, , , pixels); console.log(pixels); -var pixels = new Uint8Array(gl2.drawingBufferWidth * gl2.drawingBufferHeight * 4); gl2.readPixels(, , gl2.drawingBufferWidth, gl2.drawingBufferHeight, , , pixels); console.log(pixels); -var pixels = new Uint8Array(gl1.drawingBufferWidth * gl1.drawingBufferHeight * 4); gl1.readPixels(, , gl1.drawingBufferWidth, gl1.drawingBufferHeight, , , pixels); console.log(pixels); -var pixels = new Uint8Array(gl2.drawingBufferWidth * gl2.drawingBufferHeight * 4); gl2.readPixels(, , gl2.drawingBufferWidth, gl2.drawingBufferHeight, , , pixels); console.log(pixels); -gl1.renderbufferStorage(gl1.RENDERBUFFER, , , ); -gl2.renderbufferStorage(gl2.RENDERBUFFER, , , ); -gl1.enable(gl.SAMPLE_COVERAGE); gl1.sampleCoverage(, ); -gl2.enable(gl.SAMPLE_COVERAGE); gl2.sampleCoverage(, ); -gl1.scissor(, , , ); -gl2.scissor(, , , ); -gl1.enable(gl.STENCIL_TEST); gl1.stencilFunc(, , ); -gl2.enable(gl.STENCIL_TEST); gl2.stencilFunc(, , ); -gl1.enable(gl.STENCIL_TEST); gl1.stencilFunc(, , ); -gl2.enable(gl.STENCIL_TEST); gl2.stencilFunc(, , ); -gl1.enable(gl.STENCIL_TEST); gl1.stencilFuncSeparate(, , , ); -gl2.enable(gl.STENCIL_TEST); gl2.stencilFuncSeparate(, , , ); -gl1.enable(gl.STENCIL_TEST); gl1.stencilFuncSeparate(, , , ); -gl2.enable(gl.STENCIL_TEST); gl2.stencilFuncSeparate(, , , ); -gl1.stencilMask(); -gl2.stencilMask(); -gl1.stencilMask(, ); -gl2.stencilMask(, ); -gl1.enable(gl1.STENCIL_TEST); gl1.stencilOp(, <_glMgg>, ); -gl2.enable(gl2.STENCIL_TEST); gl2.stencilOp(, <_glMgg>, ); -gl1.enable(gl1.STENCIL_TEST); gl1.stencilOp(, , <_glMgg>, ); -gl2.enable(gl2.STENCIL_TEST); gl2.stencilOp(, , <_glMgg>, ); -gl1.texParameterf(, , ); -gl1.texParameteri(, , ); -gl1.texParameterf(, , ); -gl2.texParameteri(, , ); -gl2.texParameterf(, , ); -gl2.texParameteri(, , ); -gl1.viewport(, , , ); -gl2.viewport(, , , ); -gl1.enableVertexAttribArray(0); -gl2.enableVertexAttribArray(0); -gl1.enableVertexAttribArray(0); gl1.vertexAttribPointer(, , , , , ); -gl2.enableVertexAttribArray(0); gl2.vertexAttribPointer(, , , , , ); -gl1.vertexAttrib1f(, ); -gl1.vertexAttrib2f(, , ); -gl1.vertexAttrib3f(, , , ); -gl1.vertexAttrib4f(, , , , ); -gl1.vertexAttrib1fv(, ); -gl1.vertexAttrib2fv(, ); -gl1.vertexAttrib3fv(, ); -gl1.vertexAttrib4fv(, ); -gl1.vertexAttrib1f(, ); -gl2.vertexAttrib2f(, , ); -gl2.vertexAttrib3f(, , , ); -gl2.vertexAttrib4f(, , , , ); -gl2.vertexAttrib1fv(, ); -gl2.vertexAttrib2fv(, ); -gl2.vertexAttrib3fv(, ); -gl2.vertexAttrib4fv(, ); -gl1.validateProgram(program1); -gl2.validateProgram(program2); -var loc = gl1.getUniformLocation(program1, ); gl1.uniformMatrix2fv(loc, , [,, ,]); -var loc = gl1.getUniformLocation(program1, ); gl1.uniformMatrix2fv(loc, , [,, ,]); -var loc = gl1.getUniformLocation(program1, ); gl1.uniformMatrix3fv(loc, , [,, ,]); -var loc = gl1.getUniformLocation(program1, ); gl1.uniformMatrix4fv(loc, , [,, ,]); -var loc = gl2.getUniformLocation(program2, ); gl2.uniformMatrix2fv(loc, , [,, ,]); -var loc = gl2.getUniformLocation(program2, ); gl2.uniformMatrix2fv(loc, , [,, ,]); -var loc = gl2.getUniformLocation(program2, ); gl2.uniformMatrix3fv(loc, , [,, ,]); -var loc = gl2.getUniformLocation(program2, ); gl2.uniformMatrix4fv(loc, , [,, ,]); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform1f(loc, ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform1fv(loc, ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform1i(loc, ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform1iv(loc, ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform2f(loc, , ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform2fv(loc, ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform2i(loc, , ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform2iv(loc, ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform3f(loc, , , ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform3fv(loc, ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform3i(loc, , , ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform3iv(loc, ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform4f(loc, , , , ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform4fv(loc, ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform4i(loc, , , , ); -var loc = gl1.getUniformLocation(program1, ); gl1.uniform4iv(loc, ); -var loc = gl2.getUniformLocation(program1, ); gl2.uniform1f(loc, ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform1fv(loc, ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform1i(loc, ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform1iv(loc, ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform2f(loc, , ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform2fv(loc, ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform2i(loc, , ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform2iv(loc, ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform3f(loc, , , ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform3fv(loc, ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform3i(loc, , , ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform3iv(loc, ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform4f(loc, , , , ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform4fv(loc, ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform4i(loc, , , , ); -var loc = gl2.getUniformLocation(program2, ); gl2.uniform4iv(loc, ); -gl1.texImage2D(, , , , , 0, , , img); -gl1.texImage2D(, , , , , 0, , , img); -gl1.texImage2D(, , , , , 0, , , img); -gl1.texImage2D(, , , , , 0, , , img); -gl1.texImage2D(, , , , , 0, , , img); -gl1.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -gl1.texImage2D(, , , , , 0, , , img); -gl1.texImage2D(, , , , , 0, , , img); -gl1.texImage2D(, , , , , 0, , , img); -gl1.texImage2D(, , , , , 0, , , img); -gl1.texImage2D(, , , , , 0, , , img); -gl1.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -gl2.texImage2D(, , , , , 0, , , img); -var buffer1 = gl1.createRenderbuffer(); gl1.framebufferRenderbuffer(, , gl.RENDERBUFFER, buffer1); -var buffer2 = gl2.createRenderbuffer(); gl2.framebufferRenderbuffer(, , gl.RENDERBUFFER, buffer2); -var tex1 = gl1.createTexture(); gl1.framebufferTexture2D(, , , tex1, ); -var tex2 = gl2.createTexture(); gl2.framebufferTexture2D(, , , tex2, ); -var ext = gl1.getExtension(); -var ext = gl2.getExtension(); -var ext = gl1.getExtension(); -var ext = gl2.getExtension(); -var ext = gl1.getExtension(); -var ext = gl2.getExtension(); -var vara = gl1.getFramebufferAttachmentParameter(, , ); -var varb = gl2.getFramebufferAttachmentParameter(, , ); -if (!gl1.isContextLost()) {var info = gl1.getProgramInfoLog(program1);} -if (!gl2.isContextLost()) {var info = gl2.getProgramInfoLog(program2);} -if (!gl2.isContextLost()) {var info = gl2.getProgramInfoLog(program1);} +.activeTexture(gl.TEXTURE); +.attachShader(, ); +.getParameter(); +.linkProgram(); +.useProgram(); +.pixelStorei(, ); +.pixelStorei(, ); +.bindTexture(, tex); +.bindAttribLocation(, , ); + +var = .createBuffer(); .bindBuffer(, ); +if ( != undefined) {.deleteBuffer();} +.isBuffer(); +var f = .createBuffer(); .bindFramebuffer(, f); +if (f != undefined) {.deleteFramebuffer(f);} +.isFramebuffer(f); +var r = .createBuffer(); .bindRenderbuffer(gl.RENDERBUFFER, r); +if (r != undefined) {.deleteRenderbuffer(r);} +.isRenderbuffer(r); +var = gl.createTexture(); .bindTexture(, ); +if ( != undefined) {.deleteTexture();} + +.isTexture(); +.blendColor(, , , ); +.blendColor(, , , ); +.blendEquation(); +.blendEquationSeparate(, ); +.enable(.BLEND); .blendFunc(, ); +.enable(.BLEND); .blendFuncSeparate(, , , ); +var = .createBuffer(); .bindBuffer(, ); .bufferData(, , ); +var = .createBuffer(); .bindBuffer(, ); .bufferData(, , ); .bufferSubData(, , , , ); +.checkFramebufferStatus(.FRAMEBUFFER); +.clear(); +.clear( | ); +.clearColor(, , , ); +.clearColor(, , , ); +.clearColor(, , , ); +.clearColor(, , , ); +.clearDepth(); +.clearStencil(); +.colorMask(, , , ); +.colorMask(, , , ); +.createShader(); +var = .createTexture(); +.enable(.CULL_FACE); .cullFace(); +.deleteShader(); +.enable(gl.DEPTH_TEST); .depthFunc(); +.depthMask(); +.depthRange(, ); +.detachShader(, ); +.disable(); +.isEnabled(); +.disableVertexAttribArray(); +.drawArrays(, , ); +.drawElements(, , , ); +.finish(); +.flush(); +.frontFace(); +.generateMipmap(); +const info1 = .getActiveAttrib(, ); +const info2 = .getActiveAttrib(, ); +const ifo1 = .getActiveUniform(, ); +const ifo2 = .getActiveUniform(, ); +.getAttachedShaders(); +.getAttribLocation(, ); +.getBufferParameter(, ); +.getContextAttributes(); +.getError(); +.getFramebufferAttachmentParameter(, , ); +.getProgramInfoLog(); +.getShaderPrecisionFormat(, ); +var source211 = .getShaderSource(); +var source122 = .getShaderSource(); +.getTexParameter(, ); +var loc = .getUniformLocation(, ); .getUniform(, loc); +.getVertexAttrib(, ); +.getVertexAttribOffset(, gl.VERTEX_ATTRIB_ARRAY_POINTER); +.hint(, ); +.lineWidth(); +var pixels = new Uint8Array(.drawingBufferWidth * .drawingBufferHeight * 4); .readPixels(, , .drawingBufferWidth, .drawingBufferHeight, , , pixels); +.renderbufferStorage(.RENDERBUFFER, , , ); +.enable(gl.SAMPLE_COVERAGE); .sampleCoverage(, ); +.scissor(, , , ); +.enable(gl.STENCIL_TEST); .stencilFunc(, , ); +.enable(gl.STENCIL_TEST); .stencilFuncSeparate(, , , ); +.stencilMask(); +.stencilMask(, ); +.enable(.STENCIL_TEST); .stencilOp(, <_glMgg>, ); +.enable(.STENCIL_TEST); .stencilOp(, , <_glMgg>, ); +.texParameterf(, , ); +.texParameteri(, , ); +.viewport(, , , ); +.enableVertexAttribArray(0); +.enableVertexAttribArray(0); .vertexAttribPointer(, , , , , ); +.vertexAttrib1f(, ); +.vertexAttrib2f(, , ); +.vertexAttrib3f(, , , ); +.vertexAttrib4f(, , , , ); +.vertexAttrib1fv(, ); +.vertexAttrib2fv(, ); +.vertexAttrib3fv(, ); +.vertexAttrib4fv(, ); +.validateProgram(); +var loc = .getUniformLocation(, ); .uniformMatrix2fv(loc, , [,, ,]); +var loc = .getUniformLocation(, ); .uniformMatrix3fv(loc, , [,, ,]); +var loc = .getUniformLocation(, ); .uniformMatrix4fv(loc, , [,, ,]); +var loc = .getUniformLocation(, ); .uniform1f(loc, ); +var loc = .getUniformLocation(, ); .uniform1fv(loc, ); +var loc = .getUniformLocation(, ); .uniform1i(loc, ); +var loc = .getUniformLocation(, ); .uniform1iv(loc, ); +var loc = .getUniformLocation(, ); .uniform2f(loc, , ); +var loc = .getUniformLocation(, ); .uniform2fv(loc, ); +var loc = .getUniformLocation(, ); .uniform2i(loc, , ); +var loc = .getUniformLocation(, ); .uniform2iv(loc, ); +var loc = .getUniformLocation(, ); .uniform3f(loc, , , ); +var loc = .getUniformLocation(, ); .uniform3fv(loc, ); +var loc = .getUniformLocation(, ); .uniform3i(loc, , , ); +var loc = .getUniformLocation(, ); .uniform3iv(loc, ); +var loc = .getUniformLocation(, ); .uniform4f(loc, , , , ); +var loc = .getUniformLocation(, ); .uniform4fv(loc, ); +var loc = .getUniformLocation(, ); .uniform4i(loc, , , , ); +var loc = .getUniformLocation(, ); .uniform4iv(loc, ); +.texImage2D(, , , , , 0, , , img); +var = .createRenderbuffer(); .framebufferRenderbuffer(, , gl.RENDERBUFFER, ); +var = .createTexture(); .framebufferTexture2D(, , , , ); +var ext = .getExtension(); +var vara = .getFramebufferAttachmentParameter(, , ); +var varb = .getFramebufferAttachmentParameter(, , ); +if (!.isContextLost()) {var info = .getProgramInfoLog();} !end lines From 0cab3f7dd97a50eb099c17afdd87348f1366eb75 Mon Sep 17 00:00:00 2001 From: Ramon Benitez-Pagan Date: Wed, 18 Sep 2019 17:51:35 -0400 Subject: [PATCH 16/50] Fixed 5 digits long numeric name convention of sample output --- webgl/generator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/webgl/generator.py b/webgl/generator.py index da9db2f..3cb7aa4 100644 --- a/webgl/generator.py +++ b/webgl/generator.py @@ -130,7 +130,7 @@ def main(): outfiles = [] for i in range(nsamples): - outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i) + '.html')) + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(5) + '.html')) generate_samples(fuzzer_dir, outfiles) From 1100e2d9a250134a4b6ad2eaade3503b075cb521 Mon Sep 17 00:00:00 2001 From: Ramon Benitez-Pagan Date: Wed, 18 Sep 2019 18:02:03 -0400 Subject: [PATCH 17/50] Fixed documentation to show correct naming output --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 7bb73f6..0c73119 100644 --- a/README.md +++ b/README.md @@ -27,7 +27,7 @@ To generate multiple samples with a single call run: `python generator.py --output_dir --no_of_files ` -The generated samples will be placed in the specified directory and will be named as fuzz-<number>.html, e.g. fuzz-1.html, fuzz-2.html etc. Generating multiple samples is faster because the input grammar files need to be loaded and parsed only once. +The generated samples will be placed in the specified directory and will be named as fuzz-<number>.html, e.g. fuzz-00001.html, fuzz-00002.html etc. Generating multiple samples is faster because the input grammar files need to be loaded and parsed only once. #### Code organization From 985bcac15d57553386df7090490eb9363a6cdddf Mon Sep 17 00:00:00 2001 From: Tyson Smith Date: Fri, 6 Dec 2019 15:48:41 -0800 Subject: [PATCH 18/50] Use html.escape() by default and fallback to cgi.escape() This fixes support for all Python versions >=2.7. --- grammar.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/grammar.py b/grammar.py index 8ee9f8f..946465a 100755 --- a/grammar.py +++ b/grammar.py @@ -20,7 +20,10 @@ from __future__ import print_function import bisect -import cgi +try: + from html import escape as _escape +except ImportError: + from cgi import escape as _escape import os import random import re @@ -229,7 +232,7 @@ def _generate_string(self, tag): return ''.join(ret_list) def _generate_html_string(self, tag): - return cgi.escape(self._generate_string(tag), quote=True) + return _escape(self._generate_string(tag), quote=True) def _generate_hex(self, tag): """Generates a single hex digit.""" From dab32af8502bece3c9a11b069e1551da86e6fce0 Mon Sep 17 00:00:00 2001 From: Tyson Smith Date: Fri, 6 Dec 2019 16:08:01 -0800 Subject: [PATCH 19/50] Add support for GC and CC on Firefox --- template.html | 2 ++ 1 file changed, 2 insertions(+) diff --git a/template.html b/template.html index f686596..51f06e4 100755 --- a/template.html +++ b/template.html @@ -10,6 +10,8 @@ function freememory() { try { CollectGarbage(); } catch(err) { } + try { FuzzingFunctions.garbageCollect(); } catch(err) { } + try { FuzzingFunctions.cycleCollect(); } catch(err) { } try { window.gc(); } catch(err) { } } From d32a4eb279aeb74ce6bf1cf15787a041e44ebd5a Mon Sep 17 00:00:00 2001 From: jvoisin Date: Mon, 7 Sep 2020 19:00:46 +0200 Subject: [PATCH 20/50] Add support for PHP --- php/README.md | 17 + php/generator.py | 142 +++ php/parse_types.py | 175 +++ php/php.txt | 202 ++++ php/php_generated.txt | 2438 +++++++++++++++++++++++++++++++++++++++++ php/template.php | 173 +++ 6 files changed, 3147 insertions(+) create mode 100644 php/README.md create mode 100755 php/generator.py create mode 100644 php/parse_types.py create mode 100644 php/php.txt create mode 100644 php/php_generated.txt create mode 100644 php/template.php diff --git a/php/README.md b/php/README.md new file mode 100644 index 0000000..8119859 --- /dev/null +++ b/php/README.md @@ -0,0 +1,17 @@ +The `php_generated.txt` file was generated by running `parse_types.py` on the +source code of php. + +Possible improvements: +- Callbacks are currently unused (`` always point to `phpinfo`). + Generating callback code in a similar manner to the main function could + potentially expose additional bugs, especially if callbacks get access to the + same variables / can mess up stuff that the caller didn't expect. +- Currently, the return values from the function / method calls are ignored. + In cases where function / method calls return non-trivial types, it be better + to store these return values in variables and use them as function arguments + in later calls or potentially call methods on these "generated" objects. +- It would be great to be able to infer the expected classes of the objects + parameters taken by functions/methods. +- The `parse_type.py` code is ugly, and should be refactored a bit. +- Randomize the references (`$ref_` in template.php). + diff --git a/php/generator.py b/php/generator.py new file mode 100755 index 0000000..c6b159f --- /dev/null +++ b/php/generator.py @@ -0,0 +1,142 @@ +# Domato - main generator script +# ------------------------------- +# +# Written and maintained by Ivan Fratric +# +# Copyright 2017 Google Inc. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from __future__ import print_function +import os +import re +import random +import sys + +parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)) +sys.path.append(parent_dir) +from grammar import Grammar + +_N_MAIN_LINES = 1000 +_N_EVENTHANDLER_LINES = 500 + + +def generate_new_sample(template, phpgrammar): + """Parses grammar rules from string. + + Args: + template: A template string. + phpgrammar: Grammar for generating PHPcode. + + Returns: + A string containing sample data. + """ + + result = template + handlers = False + while '' in result: + numlines = _N_MAIN_LINES + if handlers: + numlines = _N_EVENTHANDLER_LINES + else: + handlers = True + result = result.replace( + '', + phpgrammar._generate_code(numlines), + 1 + ) + + return result + + +def generate_samples(grammar_dir, outfiles): + """Generates a set of samples and writes them to the output files. + + Args: + grammar_dir: directory to load grammar files from. + outfiles: A list of output filenames. + """ + + f = open(os.path.join(grammar_dir, 'template.php')) + template = f.read() + f.close() + + phpgrammar = Grammar() + err = phpgrammar.parse_from_file(os.path.join(grammar_dir, 'php.txt')) + if err > 0: + print('There were errors parsing grammar') + return + + for outfile in outfiles: + result = generate_new_sample(template, phpgrammar) + + if result is not None: + print('Writing a sample to ' + outfile) + try: + f = open(outfile, 'w') + f.write(result) + f.close() + except IOError: + print('Error writing to output') + + +def get_option(option_name): + for i in range(len(sys.argv)): + if (sys.argv[i] == option_name) and ((i + 1) < len(sys.argv)): + return sys.argv[i + 1] + elif sys.argv[i].startswith(option_name + '='): + return sys.argv[i][len(option_name) + 1:] + return None + + +def main(): + fuzzer_dir = os.path.dirname(__file__) + + multiple_samples = False + + for a in sys.argv: + if a.startswith('--output_dir='): + multiple_samples = True + + if '--output_dir' in sys.argv: + multiple_samples = True + + if multiple_samples: + print('Running on ClusterFuzz') + out_dir = get_option('--output_dir') + nsamples = int(get_option('--no_of_files')) + print('Output directory: ' + out_dir) + print('Number of samples: ' + str(nsamples)) + + if not os.path.exists(out_dir): + os.mkdir(out_dir) + + outfiles = [] + for i in range(nsamples): + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(5) + '.php')) + + generate_samples(fuzzer_dir, outfiles) + + elif len(sys.argv) > 1: + outfile = sys.argv[1] + generate_samples(fuzzer_dir, [outfile]) + + else: + print('Arguments missing') + print("Usage:") + print("\tpython generator.py ") + print("\tpython generator.py --output_dir --no_of_files ") + + +if __name__ == '__main__': + main() diff --git a/php/parse_types.py b/php/parse_types.py new file mode 100644 index 0000000..574b15a --- /dev/null +++ b/php/parse_types.py @@ -0,0 +1,175 @@ +import glob +import re +import sys + +fun = re.compile(r"PHP_FUNCTION\((.+)\)") +met = re.compile(r"PHP_METHOD\(([^,]+), (.+)\)") +ftype = re.compile(r'zend_parse_parameters\([^,]+, "(.+)"') + +in_func = False +in_meth = False +func = meth = obj = None +objs = set() + + +if len(sys.argv) != 2: + print('Usage: %s /path/to/php/source/code' % sys.argv[0]) + sys.exit(1) + +def l2f(fun, params): + in_or = False + p = [] + for param in params: + if param in ['i', 'I']: + p.append('') + if param in ['l', 'L', 'n', 'd']: + p.append('') + elif param in ['z', 'Z']: + p.append('') + elif param in ['s', 'v', 'S']: + p.append('') + elif param in ['|']: + in_or = True + continue + elif param in ['p', 'P']: + p.append('') + elif param in ['!', '/']: + continue + elif param in ['a', 'A', 'h', 'H']: + p.append('') + elif param in ['b']: + p.append('') + elif param in ['C']: + p.append('') + elif param in ['f']: + p.append('') + elif param in ['o', 'O']: + p.append('') + elif param in ['r']: + p.append('') + if in_or is True: + if in_func: + print(" = %s(%s)" % (func, ', '.join(p))) + elif in_meth: + print(" = ->%s(%s)" % (obj, meth, ', '.join(p))) + if in_or is False: + if in_func: + print(" = %s(%s)" % (func, ', '.join(p))) + elif in_meth: + print(" = ->%s(%s)" % (obj, meth, ', '.join(p))) + +for fname in glob.glob(sys.argv[1] + '*/*/*.c'): + with open(fname) as f: + in_params = False + in_or = False + params = [] + + for line in f.readlines(): + if in_func is False and in_meth is False: + func = fun.search(line) + if func: + in_func = True + func = func.group(1) + continue + r = met.search(line) + if r: + in_meth = True + obj = r.group(1) + objs.add(obj) + meth = r.group(2) + continue + + if 'ZEND_PARSE_PARAMETERS_NONE' in line: + print(" = %s()" % (func if func else meth)) + elif 'ZEND_PARSE_PARAMETERS_END' in line: + if in_func: + print(" = %s(%s)" % (func, ', '.join(params))) + params = [] + in_params = False + in_or = False + elif in_meth: + print(" = ->%s(%s)" % (obj, meth, ', '.join(params))) + params = [] + in_params = False + in_or = False + continue + elif 'ZEND_PARSE_PARAMETERS_START' in line: + in_params = True + params = [] + continue + + if in_or is True: + if in_func: + print(" = %s(%s)" % (func, ', '.join(params))) + elif in_meth: + print(" = ->%s(%s)" % (obj, meth, ', '.join(params))) + + if in_params is True: + if 'Z_PARAM_OPTIONAL' in line: + in_or = True + elif 'Z_PARAM_OBJECT_OF_CLASS' in line: + params.append('') + elif 'Z_PARAM_STR_OR_OBJ' in line: + params.append('') + elif 'Z_PARAM_STR_OR_ARRAY' in line: + params.append('') + elif 'Z_PARAM_STR_OR_LONG' in line: + params.append('') + elif 'Z_PARAM_OPTIONAL' in line: + in_or = True + continue + elif 'Z_PARAM_LONG' in line or 'Z_PARAM_LONG_OR_NULL' in line: + params.append("") + elif 'Z_PARAM_ARRAY_OR_OBJECT' in line: + params.append("") + elif 'Z_PARAM_ARRAY' in line: + params.append("") + elif 'Z_PARAM_OBJ' in line: + params.append("") + elif 'Z_PARAM_ZVAL' in line: + params.append('') + elif 'Z_PARAM_BOOL' in line: + params.append('') + elif 'Z_PARAM_CLASS' in line: + params.append('') + elif 'Z_PARAM_CLASS_OR_OBJ' in line: + params.append('') + elif 'Z_PARAM_RESOURCE' in line: + params.append('') + elif 'Z_PARAM_PATH' in line: + params.append('') + elif 'Z_PARAM_NUMBER' in line: + params.append('') + elif 'Z_PARAM_FUNC' in line: + params.append('') + elif 'Z_PARAM_DOUBLE' in line: + params.append('') + elif 'Z_PARAM_PATH' in line: + params.append('') + elif 'Z_PARAM_VARIADIC' in line: + params.append('') + elif 'Z_PARAM_STR' in line: + params.append('') + elif '_OR_' in line: + params.append('') + else: + print('err:' + line) + + + p = ftype.search(line) + if p: + l2f(func, p.group(1)) + in_func = False + in_meth = False + in_params = False + in_or = False + elif line.startswith('}') or "/* }}} */" in line: + in_func = False + in_meth = False + in_params = False + in_or = False + +print("\n") +for obj in objs: + print(' = $vars["%s"]' % (obj, obj)) + diff --git a/php/php.txt b/php/php.txt new file mode 100644 index 0000000..1798363 --- /dev/null +++ b/php/php.txt @@ -0,0 +1,202 @@ + = + +!lineguard try { } catch (Throwable $e) { } + + = + + = true + = false + + = 32768 + = 65535 + = 65536 + = 1073741824 + = 536870912 + = 268435456 + = 4294967295 + = 2147483648 + = 2147483647 + = -2147483648 + = -1073741824 + = -32769 + + = 536870911 + = 536870912 + = 1073741823 + = 1073741824 + = 2147483647 + = 2147483648 + = 4294967295 + = 4294967296 + = 18446744073709551615 + = 18446744073709551616 + + = 0 + = 1 + = -1 + = 2 + = 3 + = 4 + = 5 + = 10 + = 100 + = 1000 + = 1000000 + = + = + = - + = + + = + = + = + + = str_repeat("A", 0x100) + = implode(array_map(function($c) {return "\\x" . str_pad(dechex($c), 2, "0");}, range(0, 255))) + = str_repeat("%s%x%n", 0x100) + = + = . + = . . +# = "" + = str_repeat(chr(), ) + = 17 + = 65 + = 257 + = 1025 + = 4097 + = 65537 + + = + = "/dev/null" + = "/../../../../../../../../../etc/passwd" + + = range(0, 10) + = array("a" => 1, "b" => "2", "c" => 3.0) + + = phpinfo + + = $vars[array_rand($vars)] + + = + = + + = array_rand($vars) + + = + = () + + = + = + + = + = + + = + = + + = + = + = + = + + = + = , + = , , + = , , , + = , , , , + + = $ref_bool + = $ref_int + = $ref_string + = $ref_array + = $ref_object + = $ref_resource + = $ref_path + + = + = + = + = + = + = + = + + = + = + + = + = + + = new ArrayIterator(array(0)) + + = fopen("/dev/null", "r") + = fopen("/etc/passwd", "r") + = fopen("/tmp/doesntexist", "w") + + = new DateTime() + = new DateTimeZone("America/Chicago") + = new DateTimeImmutable() + = new DateInterval("P2Y4DT6H8M") + = new DateTime() + + = new DOMNode() + = new DOMAttr("attr") + = new DOMDocument() + = new DOMDocumentType() + = new DOMElement("root") + = new DOMNodeList() + = new DOMDocumentFragment() + = new DOMText() + = new DOMCDATASection("root value") + = new DOMProcessingInstruction("php", "phpinfo()") + = new DOMEntityReference("nbsp") + = new DOMComment() + + = new RecursiveIterator() + + = new SplObjectStorage() + = new SplFixedArray() + + = new ReflectionClass("ZipArchive") + = new ReflectionClass($vars[array_rand($vars)]) + = new ReflectionClassConstant("ZipArchive", "ZIP_ER_OK") + = new ReflectionType() + = new ReflectionFunctionAbstract() + = new ReflectionExtension("Reflection") + = new ReflectionProperty("ZipArchive", "filename") + = new ReflectionMethod("ZipArchive", "getStatusString") + + = new ArrayIterator(array(0)) + + = new Exception() + + = hash_init("md5") + + = new SimpleXMLElement("aa/a") + = new SimpleXMLIterator("aa/a") + + = new Phar("/tmp/fuzz.phar") + = new PharData("/tmp/fuzz.tar")) + + = new RecursiveFilterIterator(new RecursiveIterator()) + + = dir("/tmp") + + = function () { return 0; } + + = (function () { yield 0; })() + +!include php_generated.txt + +### OTHER + + = ; + = ; + +### LINES + +!begin lines + + + +!end lines diff --git a/php/php_generated.txt b/php/php_generated.txt new file mode 100644 index 0000000..2344ccf --- /dev/null +++ b/php/php_generated.txt @@ -0,0 +1,2438 @@ + = phpdbg_exec() + = phpdbg_break_file(, ) + = phpdbg_break_method(, ) + = phpdbg_break_function() + = phpdbg_color(, ) + = phpdbg_prompt() + = phpdbg_get_executable() + = phpdbg_end_oplog() + = virtual() + = apache_lookup_uri() + = apache_note(, ) + = apache_setenv(, , ) + = apache_getenv(, ) + = cli_set_process_title() + = stream_wrapper_register(, , ) + = stream_wrapper_unregister() + = stream_wrapper_restore() + = curl_share_init() + = curl_share_close() + = curl_share_setopt(, , ) + = curl_share_errno() + = curl_share_strerror() + = curl_multi_init() + = curl_multi_add_handle(, ) + = curl_multi_remove_handle(, ) + = curl_multi_select() + = curl_multi_select(, ) + = curl_multi_exec(, ) + = curl_multi_getcontent() + = curl_multi_info_read() + = curl_multi_info_read(, ) + = curl_multi_close() + = curl_multi_errno() + = curl_multi_strerror() + = curl_multi_setopt(, , ) + = curl_version() + = curl_init() + = curl_init() + = curl_copy_handle() + = curl_setopt(, , ) + = curl_setopt_array(, ) + = curl_exec() + = curl_getinfo() + = curl_getinfo(, ) + = curl_error() + = curl_errno() + = curl_close() + = curl_strerror() + = curl_reset() + = curl_escape(, ) + = curl_unescape(, ) + = curl_pause(, ) + = ->__construct(, ) + = ->__construct(, ) + = ->registerNamespace(, ) + = ->registerPhpFunctions() + = ->registerPhpFunctions() + = dom_import_simplexml() + = ->getNamedItem() + = ->item() + = ->getNamedItemNS(, ) + = ->item() + = ->insertBefore(, ) + = ->replaceChild(, ) + = ->removeChild() + = ->appendChild() + = ->cloneNode() + = ->isSupported(, ) + = ->isSameNode() + = ->lookupPrefix() + = ->isDefaultNamespace() + = ->lookupNamespaceURI() + = ->appendXML() + = ->append() + = ->prepend() + = ->__construct() + = ->splitText() + = ->hasFeature(, ) + = ->createDocumentType(, ) + = ->createDocumentType(, , ) + = ->createDocument() + = ->createDocument(, ) + = ->createDocument(, , ) + = ->getFeature(, ) + = ->__construct(, ) + = ->__construct() + = ->__construct(, ) + = ->__construct(, , ) + = ->getAttribute() + = ->setAttribute(, ) + = ->removeAttribute() + = ->getAttributeNode() + = ->setAttributeNode() + = ->removeAttributeNode() + = ->getElementsByTagName() + = ->getAttributeNS(, ) + = ->setAttributeNS(, , ) + = ->removeAttributeNS(, ) + = ->getAttributeNodeNS(, ) + = ->setAttributeNodeNS() + = ->getElementsByTagNameNS(, ) + = ->hasAttribute() + = ->hasAttributeNS(, ) + = ->setIdAttribute(, ) + = ->setIdAttributeNS(, , ) + = ->setIdAttributeNode(, ) + = ->after() + = ->before() + = ->append() + = ->prepend() + = ->replaceWith() + = ->substringData(, ) + = ->appendData() + = ->insertData(, ) + = ->deleteData(, ) + = ->replaceData(, , ) + = ->after() + = ->before() + = ->replaceWith() + = ->__construct() + = ->__construct() + = ->createElement(, ) + = ->createTextNode() + = ->createComment() + = ->createCDATASection() + = ->createProcessingInstruction(, ) + = ->createAttribute() + = ->createEntityReference() + = ->getElementsByTagName() + = ->importNode(, ) + = ->createElementNS(, , ) + = ->createAttributeNS(, ) + = ->getElementsByTagNameNS(, ) + = ->getElementById() + = ->adoptNode() + = ->__construct() + = ->__construct(, ) + = ->save(, ) + = ->saveXML() + = ->saveXML(, ) + = ->xinclude() + = ->saveHTMLFile() + = ->registerNodeClass(, ) + = ->append() + = ->prepend() + = sem_get(, ) + = sem_get(, , ) + = sem_get(, , , ) + = sem_remove() + = finfo_open() + = finfo_open(, ) + = finfo_close() + = finfo_set_flags() + = hrtime() + = hrtime() + = get_browser() + = get_browser() + = get_browser(, ) + = getrusage() + = getrusage() + = chroot() + = chdir() + = getcwd() + = glob() + = glob(, ) + = scandir() + = scandir(, ) + = scandir(, , ) + = image_type_to_mime_type() + = image_type_to_extension() + = image_type_to_extension(, ) + = soundex() + = bin2hex() + = hex2bin() + = nl_langinfo() + = strcoll(, ) + = wordwrap() + = wordwrap(, ) + = wordwrap(, , ) + = wordwrap(, , , ) + = explode(, ) + = explode(, , ) + = implode() + = implode(, ) + = strtok() + = strtok(, ) + = strtoupper() + = strtolower() + = basename() + = basename(, ) + = dirname() + = dirname(, ) + = pathinfo() + = pathinfo(, ) + = stristr(, ) + = stristr(, , ) + = strstr(, ) + = strstr(, , ) + = str_contains(, ) + = str_starts_with(, ) + = str_ends_with(, ) + = strpos(, ) + = strpos(, , ) + = stripos(, ) + = stripos(, , ) + = strrpos(, ) + = strrpos(, , ) + = strripos(, ) + = strripos(, , ) + = strrchr(, ) + = chunk_split() + = chunk_split(, ) + = chunk_split(, , ) + = substr(, ) + = substr(, , ) + = substr_replace(, , ) + = substr_replace(, , , ) + = quotemeta() + = ord() + = chr() + = ucfirst() + = lcfirst() + = ucwords() + = ucwords(, ) + = strtr(, ) + = strtr(, , ) + = strrev() + = similar_text(, ) + = similar_text(, , ) + = addcslashes(, ) + = addslashes() + = stripcslashes() + = stripslashes() + = hebrev() + = hebrev(, ) + = nl2br() + = nl2br(, ) + = strip_tags() + = strip_tags(, ) + = setlocale(, ) + = parse_str(, ) + = str_getcsv() + = str_getcsv(, ) + = str_getcsv(, , ) + = str_getcsv(, , , ) + = str_repeat(, ) + = count_chars() + = count_chars(, ) + = localeconv() + = substr_count(, ) + = substr_count(, , ) + = substr_count(, , , ) + = str_pad(, ) + = str_pad(, , ) + = str_pad(, , , ) + = sscanf(, , ) + = str_rot13() + = str_shuffle() + = str_word_count() + = str_word_count(, ) + = str_word_count(, , ) + = str_split() + = str_split(, ) + = strpbrk(, ) + = substr_compare(, , ) + = substr_compare(, , , ) + = substr_compare(, , , , ) + = utf8_encode() + = utf8_decode() + = quoted_printable_decode() + = quoted_printable_encode() + = dns_get_mx(, , ) + = dns_check_record(, ) + = dns_get_record(, ) + = dns_get_record(, , ) + = dns_get_record(, , , ) + = dns_get_record(, , , , ) + = disk_total_space() + = disk_free_space() + = chmod(, ) + = touch() + = touch(, ) + = touch(, , ) + = clearstatcache() + = clearstatcache() + = clearstatcache(, ) + = realpath_cache_size() + = realpath_cache_get() + = krsort() + = krsort(, ) + = ksort() + = ksort(, ) + = count() + = count(, ) + = asort() + = asort(, ) + = arsort() + = arsort(, ) + = sort() + = sort(, ) + = rsort() + = rsort(, ) + = end() + = prev() + = next() + = reset() + = current() + = key() + = min() + = max() + = array_walk(, ) + = array_walk(, , ) + = array_walk_recursive(, ) + = array_walk_recursive(, , ) + = extract() + = extract(, ) + = extract(, , ) + = compact() + = array_fill(, , ) + = array_fill_keys(, ) + = range(, ) + = range(, , ) + = shuffle() + = array_push(, ) + = array_pop() + = array_shift() + = array_unshift(, ) + = array_splice(, ) + = array_splice(, , ) + = array_splice(, , , ) + = array_slice(, ) + = array_slice(, , ) + = array_slice(, , , ) + = array_keys() + = array_keys(, ) + = array_keys(, , ) + = array_key_first() + = array_key_last() + = array_values() + = array_count_values() + = array_column(, ) + = array_column(, , ) + = array_reverse() + = array_reverse(, ) + = array_pad(, , ) + = array_flip() + = array_change_key_case() + = array_change_key_case(, ) + = array_unique() + = array_unique(, ) + = array_diff() + = array_multisort() + = array_rand() + = array_rand(, ) + = array_sum() + = array_product() + = array_reduce(, ) + = array_reduce(, , ) + = array_filter() + = array_filter(, ) + = array_filter(, , ) + = array_map(, ) + = array_key_exists(, ) + = array_chunk(, ) + = array_chunk(, , ) + = array_combine(, ) + = proc_terminate() + = proc_terminate(, ) + = proc_close() + = proc_get_status() + = proc_open(, , ) + = proc_open(, , , ) + = proc_open(, , , , ) + = proc_open(, , , , , ) + = uniqid() + = uniqid() + = uniqid(, ) + = strptime(, ) + = stream_socket_pair(, , ) + = stream_socket_client() + = stream_socket_client(, ) + = stream_socket_client(, , ) + = stream_socket_client(, , , ) + = stream_socket_client(, , , , ) + = stream_socket_client(, , , , , ) + = stream_socket_server() + = stream_socket_server(, ) + = stream_socket_server(, , ) + = stream_socket_server(, , , ) + = stream_socket_server(, , , , ) + = stream_socket_accept() + = stream_socket_accept(, ) + = stream_socket_accept(, , ) + = stream_socket_get_name(, ) + = stream_socket_sendto(, ) + = stream_socket_sendto(, , ) + = stream_socket_sendto(, , , ) + = stream_socket_recvfrom(, ) + = stream_socket_recvfrom(, , ) + = stream_socket_recvfrom(, , , ) + = stream_get_contents() + = stream_get_contents(, ) + = stream_get_contents(, , ) + = stream_copy_to_stream(, ) + = stream_copy_to_stream(, , ) + = stream_copy_to_stream(, , , ) + = stream_get_meta_data() + = stream_get_transports() + = stream_get_wrappers() + = stream_select(, , , ) + = stream_select(, , , , ) + = stream_context_get_options() + = stream_context_set_option(, ) + = stream_context_set_option(, , , ) + = stream_context_set_params(, ) + = stream_context_get_params() + = stream_context_get_default() + = stream_context_get_default() + = stream_context_set_default() + = stream_context_create() + = stream_context_create() + = stream_context_create(, ) + = stream_filter_remove() + = stream_get_line(, ) + = stream_get_line(, , ) + = stream_set_blocking(, ) + = stream_set_timeout(, ) + = stream_set_timeout(, , ) + = stream_set_write_buffer(, ) + = stream_set_chunk_size(, ) + = stream_set_read_buffer(, ) + = stream_socket_enable_crypto(, ) + = stream_socket_enable_crypto(, , ) + = stream_socket_enable_crypto(, , , ) + = stream_resolve_include_path() + = stream_is_local() + = stream_supports_lock() + = stream_isatty() + = sapi_windows_vt100_support() + = sapi_windows_vt100_support(, ) + = stream_socket_shutdown(, ) + = sprintf(, ) + = vsprintf(, ) + = printf(, ) + = vprintf(, ) + = fprintf(, , ) + = vfprintf(, , ) + = ->filter(, , , ) + = onCreate() + = onClose() + = stream_bucket_make_writeable() + = stream_bucket_new(, ) + = stream_get_filters() + = stream_filter_register(, ) + = http_build_query() + = http_build_query(, ) + = http_build_query(, , ) + = http_build_query(, , , ) + = escapeshellcmd() + = escapeshellarg() + = shell_exec() + = proc_nice() + = header() + = header(, ) + = header(, , ) + = header_remove() + = header_remove() + = setcookie() + = setcookie(, ) + = setcookie(, , ) + = setcookie(, , , ) + = setcookie(, , , , ) + = setcookie(, , , , , ) + = setcookie(, , , , , , ) + = setrawcookie() + = setrawcookie(, ) + = setrawcookie(, , ) + = setrawcookie(, , , ) + = setrawcookie(, , , , ) + = setrawcookie(, , , , , ) + = setrawcookie(, , , , , , ) + = headers_sent() + = headers_sent() + = headers_sent(, ) + = headers_list() + = http_response_code() + = http_response_code() + = constant() + = inet_ntop() + = inet_pton() + = ip2long() + = long2ip() + = getenv() + = getenv() + = getenv(, ) + = putenv() + = getopt() + = getopt(, ) + = getopt(, , ) + = flush() + = sleep() + = usleep() + = time_nanosleep(, ) + = time_sleep_until() + = get_current_user() + = get_cfg_var() + = error_log() + = error_log(, ) + = error_log(, , ) + = error_log(, , , ) + = error_get_last() + = error_clear_last() + = call_user_func(, ) + = call_user_func_array(, ) + = forward_static_call(, ) + = forward_static_call_array(, ) + = highlight_file() + = highlight_file(, ) + = php_strip_whitespace() + = highlight_string() + = highlight_string(, ) + = ini_get() + = ini_get_all() + = ini_get_all() + = ini_get_all(, ) + = ini_set(, ) + = ini_restore() + = set_include_path() + = get_include_path() + = print_r() + = print_r(, ) + = connection_aborted() + = connection_status() + = ignore_user_abort() + = ignore_user_abort() + = getservbyname(, ) + = getservbyport(, ) + = getprotobyname() + = getprotobynumber() + = unregister_tick_function() + = is_uploaded_file() + = move_uploaded_file(, ) + = parse_ini_file() + = parse_ini_file(, ) + = parse_ini_file(, , ) + = parse_ini_string() + = parse_ini_string(, ) + = parse_ini_string(, , ) + = config_get_hash() + = sys_getloadavg() + = pack(, ) + = unpack(, ) + = unpack(, , ) + = mail(, , ) + = mail(, , , ) + = mail(, , , , ) + = crc32() + = md5() + = md5(, ) + = md5_file() + = md5_file(, ) + = dl() + = htmlspecialchars_decode() + = htmlspecialchars_decode(, ) + = html_entity_decode() + = html_entity_decode(, ) + = html_entity_decode(, , ) + = get_html_translation_table() + = get_html_translation_table() + = get_html_translation_table(, ) + = get_html_translation_table(, , ) + = crypt() + = crypt(, ) + = gettype() + = get_debug_type() + = settype(, ) + = intval() + = intval(, ) + = floatval() + = boolval() + = strval() + = is_bool() + = is_numeric() + = is_scalar() + = is_callable() + = is_callable(, ) + = is_callable(, , ) + = is_iterable() + = is_countable() + = net_get_interfaces() + = net_get_interfaces() + = sha1() + = sha1(, ) + = sha1_file() + = sha1_file(, ) + = levenshtein(, , ) + = levenshtein(, , , ) + = levenshtein(, , , , ) + = abs() + = ceil() + = floor() + = round() + = round(, ) + = round(, , ) + = sin() + = cos() + = tan() + = asin() + = acos() + = atan() + = atan2(, ) + = sinh() + = cosh() + = tanh() + = asinh() + = acosh() + = atanh() + = pi() + = is_finite() + = is_infinite() + = is_nan() + = pow(, ) + = exp() + = expm1() + = log1p() + = log() + = log(, ) + = log10() + = sqrt() + = hypot(, ) + = deg2rad() + = rad2deg() + = bindec() + = hexdec() + = octdec() + = decbin() + = decoct() + = dechex() + = base_convert(, , ) + = number_format() + = number_format(, ) + = number_format(, , ) + = number_format(, , , ) + = fmod(, ) + = fdiv(, ) + = intdiv(, ) + = password_get_info() + = password_needs_rehash(, ) + = password_needs_rehash(, , ) + = password_verify(, ) + = password_hash(, ) + = password_hash(, , ) + = password_algos() + = assert() + = assert(, ) + = assert_options() + = assert_options(, ) + = gethostname() + = gethostbyaddr() + = gethostbyname() + = gethostbynamel() + = dns_check_record() + = dns_check_record(, ) + = dns_get_record() + = dns_get_record(, ) + = dns_get_record(, , ) + = dns_get_record(, , , ) + = dns_get_record(, , , , ) + = dns_get_mx(, ) + = dns_get_mx(, , ) + = mt_srand() + = mt_srand() + = mt_srand(, ) + = mt_rand(, ) + = mt_getrandmax() + = flock(, ) + = flock(, , ) + = get_meta_tags() + = get_meta_tags(, ) + = file_get_contents() + = file_get_contents(, ) + = file_get_contents(, , ) + = file_get_contents(, , , ) + = file_get_contents(, , , , ) + = file_put_contents(, ) + = file_put_contents(, , ) + = file_put_contents(, , , ) + = file() + = file(, ) + = file(, , ) + = tempnam(, ) + = tmpfile() + = fopen(, ) + = fopen(, , ) + = fopen(, , , ) + = fclose() + = popen(, ) + = pclose() + = feof() + = fgets() + = fgets(, ) + = fgetc() + = fscanf(, , ) + = fwrite(, ) + = fwrite(, , ) + = fflush() + = rewind() + = ftell() + = fseek(, ) + = fseek(, , ) + = mkdir() + = mkdir(, ) + = mkdir(, , ) + = mkdir(, , , ) + = rmdir() + = rmdir(, ) + = readfile() + = readfile(, ) + = readfile(, , ) + = umask() + = umask() + = fpassthru() + = rename(, ) + = rename(, , ) + = unlink() + = unlink(, ) + = ftruncate(, ) + = fstat() + = copy(, ) + = copy(, , ) + = fread(, ) + = fputcsv(, ) + = fputcsv(, , ) + = fputcsv(, , , ) + = fputcsv(, , , , ) + = fgetcsv() + = fgetcsv(, ) + = fgetcsv(, , ) + = fgetcsv(, , , ) + = fgetcsv(, , , , ) + = realpath() + = fnmatch(, ) + = fnmatch(, , ) + = sys_get_temp_dir() + = var_dump() + = debug_zval_dump() + = var_export() + = var_export(, ) + = serialize() + = unserialize() + = unserialize(, ) + = memory_get_usage() + = memory_get_usage() + = memory_get_peak_usage() + = memory_get_peak_usage() + = convert_uuencode() + = convert_uudecode() + = openlog(, , ) + = closelog() + = syslog(, ) + = readlink() + = linkinfo() + = symlink(, ) + = link(, ) + = parse_url() + = parse_url(, ) + = urlencode() + = urldecode() + = rawurlencode() + = rawurldecode() + = get_headers() + = get_headers(, ) + = get_headers(, , ) + = ftok(, ) + = iptcembed(, ) + = iptcembed(, , ) + = iptcparse() + = getmyuid() + = getmygid() + = getmypid() + = getmyinode() + = getlastmod() + = rand(, ) + = version_compare(, ) + = version_compare(, , ) + = base64_encode() + = base64_decode() + = base64_decode(, ) + = random_bytes() + = random_int(, ) + = phpinfo() + = phpinfo() + = phpversion() + = phpversion() + = phpcredits() + = phpcredits() + = php_sapi_name() + = php_uname() + = php_uname() + = php_ini_scanned_files() + = php_ini_loaded_file() + = metaphone() + = metaphone(, ) + = lcg_value() + = readline() + = readline_info() + = readline_info(, ) + = readline_add_history() + = readline_read_history() + = readline_write_history() + = readline_completion_function() + = readline_callback_handler_install(, ) + = ->open(, ) + = ->open(, , ) + = ->exec() + = ->enableExtendedResultCodes() + = ->busyTimeout() + = ->loadExtension() + = ->escapeString() + = ->prepare() + = ->query() + = ->querySingle(, ) + = ->createFunction(, , ) + = ->createFunction(, , , ) + = ->createAggregate(, , , ) + = ->createCollation(, ) + = ->openBlob(, , , ) + = ->openBlob(, , , , ) + = ->enableExceptions() + = ->setAuthorizer() + = ->backup(, ) + = ->backup(, , ) + = ->getSQL() + = ->__construct(, ) + = ->columnName() + = ->columnType() + = ->fetchArray() + = odbc_prepare(, ) + = odbc_execute(, ) + = odbc_cursor() + = odbc_data_source(, ) + = odbc_exec(, , ) + = odbc_fetch_into(, , ) + = solid_fetch_prev() + = odbc_fetch_row(, ) + = odbc_result(, ) + = odbc_result_all(, ) + = odbc_free_result() + = odbc_close() + = odbc_num_rows() + = odbc_next_result() + = odbc_num_fields() + = odbc_field_name(, ) + = odbc_field_type(, ) + = odbc_field_num(, ) + = odbc_autocommit(, ) + = odbc_setoption(, , , ) + = odbc_tables(, ) + = odbc_tables(, , ) + = odbc_tables(, , , ) + = odbc_tables(, , , , ) + = odbc_columns(, ) + = odbc_columns(, , ) + = odbc_columns(, , , ) + = odbc_columns(, , , , ) + = odbc_columnprivileges(, , , , ) + = odbc_foreignkeys(, , , , , , ) + = odbc_gettypeinfo(, ) + = odbc_primarykeys(, , , ) + = odbc_procedurecolumns(, ) + = odbc_procedurecolumns(, , ) + = odbc_procedurecolumns(, , , ) + = odbc_procedurecolumns(, , , , ) + = odbc_procedures(, ) + = odbc_procedures(, , ) + = odbc_procedures(, , , ) + = odbc_specialcolumns(, , , , , ) + = odbc_statistics(, , , , , ) + = odbc_tableprivileges(, , , ) + = posix_kill(, ) + = posix_getgroups() + = posix_getlogin() + = posix_setpgid(, ) + = posix_getpgid() + = posix_getsid() + = posix_uname() + = posix_times() + = posix_ctermid() + = posix_ttyname() + = posix_isatty() + = posix_getcwd() + = posix_mkfifo(, ) + = posix_mknod(, ) + = posix_mknod(, , ) + = posix_mknod(, , , ) + = posix_access() + = posix_access(, ) + = posix_getgrnam() + = posix_getgrgid() + = posix_getpwnam() + = posix_getpwuid() + = posix_getrlimit() + = posix_setrlimit(, , ) + = posix_get_last_error() + = posix_strerror() + = posix_initgroups(, ) + = ->running() + = ->mount(, ) + = ->webPhar() + = ->webPhar(, ) + = ->webPhar(, , ) + = ->webPhar(, , , ) + = ->webPhar(, , , , ) + = ->mungServer() + = ->createDefaultStub() + = ->createDefaultStub(, ) + = ->mapPhar() + = ->mapPhar(, ) + = ->loadPhar(, ) + = ->canCompress() + = ->isValidPharFilename(, ) + = ->__construct(, ) + = ->__construct(, , ) + = ->__construct(, , , ) + = ->unlinkArchive() + = ->buildFromDirectory(, ) + = ->buildFromIterator(, ) + = ->count() + = ->isFileFormat() + = ->convertToExecutable() + = ->convertToExecutable(, ) + = ->convertToExecutable(, , ) + = ->convertToData() + = ->convertToData(, ) + = ->convertToData(, , ) + = ->delete() + = ->setAlias() + = ->setStub() + = ->setDefaultStub() + = ->setDefaultStub(, ) + = ->setSignatureAlgorithm(, ) + = ->compress(, ) + = ->decompress() + = ->compressFiles() + = ->copy(, ) + = ->offsetExists() + = ->offsetGet() + = ->offsetSet(, ) + = ->offsetUnset() + = ->addEmptyDir() + = ->addFile(, ) + = ->addFromString(, ) + = ->getMetadata() + = ->getMetadata() + = ->setMetadata() + = ->extractTo() + = ->extractTo(, ) + = ->extractTo(, , ) + = ->__construct() + = ->isCompressed() + = ->chmod() + = ->getMetadata() + = ->getMetadata() + = ->setMetadata() + = ->compress() + = pcntl_alarm() + = pcntl_waitpid(, , ) + = pcntl_waitpid(, , , ) + = pcntl_wait(, ) + = pcntl_wait(, , ) + = pcntl_wifexited() + = pcntl_wifstopped() + = pcntl_wifsignaled() + = pcntl_wifcontinued() + = pcntl_wexitstatus() + = pcntl_wtermsig() + = pcntl_wstopsig() + = pcntl_exec(, ) + = pcntl_exec(, , ) + = pcntl_signal(, , ) + = pcntl_signal_get_handler() + = pcntl_sigprocmask(, , ) + = pcntl_getpriority() + = pcntl_getpriority(, ) + = pcntl_setpriority(, ) + = pcntl_setpriority(, , ) + = pcntl_strerror() + = pcntl_async_signals() + = pcntl_unshare() + = ->insert() + = ->insert(, ) + = ->setExtractFlags() + = ->compare(, ) + = ->compare(, ) + = ->compare(, ) + = ->getSubIterator() + = ->setMaxDepth() + = ->setPrefixPart(, ) + = ->setPostfix() + = ->setMode() + = ->setFlags() + = ->setPregFlags() + = ->seek() + = ->offsetSet(, ) + = ->offsetGet() + = ->offsetUnset() + = ->offsetExists() + = ->setFlags() + = ->append() + = iterator_to_array(, ) + = iterator_count() + = iterator_apply(, , ) + = ->attach(, ) + = ->detach() + = ->getHash() + = ->offsetGet() + = ->addAll() + = ->removeAll() + = ->removeAllExcept() + = ->contains() + = ->count() + = ->setInfo() + = ->unserialize() + = ->__unserialize() + = ->__construct() + = ->setFlags() + = ->attachIterator(, ) + = ->detachIterator() + = ->containsIterator() + = ->__construct() + = ->fromArray(, ) + = ->setSize() + = ->offsetExists() + = ->offsetGet() + = ->offsetSet(, ) + = ->offsetUnset() + = ->seek() + = ->getBasename() + = ->getBasename() + = ->__construct() + = ->setFileClass() + = ->setInfoClass() + = ->getFileInfo() + = ->getPathInfo() + = ->setFlags() + = ->hasChildren() + = ->__construct(, ) + = ->__construct(, , ) + = ->__construct(, , , ) + = ->__construct() + = ->setFlags() + = ->setMaxLineLen() + = ->fgetcsv() + = ->fgetcsv(, ) + = ->fgetcsv(, , ) + = ->fputcsv(, ) + = ->fputcsv(, , ) + = ->fputcsv(, , , ) + = ->setCsvControl() + = ->setCsvControl(, ) + = ->setCsvControl(, , ) + = ->fseek(, ) + = ->fwrite(, ) + = ->fread() + = ->ftruncate() + = ->seek() + = class_parents(, ) + = class_implements(, ) + = class_uses(, ) + = spl_autoload(, ) + = spl_autoload_extensions() + = spl_autoload_call() + = spl_autoload_register() + = spl_autoload_register() + = spl_autoload_register(, ) + = spl_autoload_register(, , ) + = spl_autoload_unregister() + = spl_object_hash() + = spl_object_id() + = ->offsetExists() + = ->offsetGet() + = ->offsetSet(, ) + = ->append() + = ->offsetUnset() + = ->__construct() + = ->__construct(, ) + = ->__construct(, , ) + = ->__construct() + = ->__construct(, ) + = ->setIteratorClass() + = ->setFlags() + = ->exchangeArray() + = ->seek() + = ->unserialize() + = ->__unserialize() + = ->push() + = ->unshift() + = ->setIteratorMode() + = ->offsetExists() + = ->offsetGet() + = ->offsetSet(, ) + = ->offsetUnset() + = ->unserialize() + = ->__unserialize() + = ->add(, ) + = enchant_broker_free() + = enchant_broker_get_error() + = enchant_broker_set_dict_path(, , ) + = enchant_broker_get_dict_path(, ) + = enchant_broker_list_dicts() + = enchant_broker_request_dict(, ) + = enchant_broker_request_pwl_dict(, ) + = enchant_broker_free_dict() + = enchant_broker_dict_exists(, ) + = enchant_broker_set_ordering(, , ) + = enchant_broker_describe() + = enchant_dict_quick_check(, , ) + = enchant_dict_check(, ) + = enchant_dict_suggest(, ) + = enchant_dict_add(, ) + = enchant_dict_add_to_session(, ) + = enchant_dict_is_added(, ) + = enchant_dict_store_replacement(, , ) + = enchant_dict_get_error() + = enchant_dict_describe() + = filter_has_var(, ) + = filter_input(, , ) + = filter_input(, , , ) + = filter_var(, ) + = filter_var(, , ) + = filter_input_array(, ) + = filter_input_array(, , ) + = filter_var_array(, ) + = filter_var_array(, , ) + = filter_id() + = bcadd(, ) + = bcadd(, , ) + = bcsub(, ) + = bcsub(, , ) + = bcmul(, ) + = bcmul(, , ) + = bcdiv(, ) + = bcdiv(, , ) + = bcmod(, ) + = bcmod(, , ) + = bcpowmod(, , ) + = bcpowmod(, , , ) + = bcpow(, ) + = bcpow(, , ) + = bcsqrt() + = bcsqrt(, ) + = bccomp(, ) + = bccomp(, , ) + = bcscale() + = bcscale() + = ->open(, ) + = ->read() + = ->write(, ) + = ->destroy() + = ->gc() + = session_set_cookie_params() + = session_set_cookie_params(, ) + = session_set_cookie_params(, , ) + = session_set_cookie_params(, , , ) + = session_set_cookie_params(, , , , ) + = session_name() + = session_module_name() + = session_set_save_handler(, ) + = session_save_path() + = session_id() + = session_regenerate_id() + = session_create_id() + = session_cache_limiter() + = session_cache_expire() + = session_decode() + = session_start() + = session_register_shutdown() + = imap_reopen(, , ) + = imap_reopen(, , , ) + = imap_append(, , , ) + = imap_append(, , , , ) + = imap_num_msg() + = imap_ping() + = imap_num_recent() + = imap_get_quota(, ) + = imap_get_quotaroot(, ) + = imap_set_quota(, , ) + = imap_setacl(, , , ) + = imap_getacl(, ) + = imap_expunge() + = imap_gc(, ) + = imap_close(, ) + = imap_headers() + = imap_body(, , ) + = imap_mail_copy(, , , ) + = imap_mail_move(, , , ) + = imap_createmailbox(, ) + = imap_renamemailbox(, , ) + = imap_deletemailbox(, ) + = imap_list(, , ) + = imap_getmailboxes(, , ) + = imap_listscan(, , , ) + = imap_check() + = imap_delete(, , ) + = imap_undelete(, , ) + = imap_headerinfo(, , ) + = imap_headerinfo(, , , ) + = imap_headerinfo(, , , , ) + = imap_rfc822_parse_headers(, ) + = imap_lsub(, , ) + = imap_getsubscribed(, , ) + = imap_subscribe(, ) + = imap_unsubscribe(, ) + = imap_fetchstructure(, , ) + = imap_fetchbody(, , , ) + = imap_fetchmime(, , , ) + = imap_savebody(, , , ) + = imap_savebody(, , , , ) + = imap_base64() + = imap_qprint() + = imap_8bit() + = imap_binary() + = imap_mailboxmsginfo() + = imap_rfc822_write_address(, , ) + = imap_rfc822_parse_adrlist(, ) + = imap_utf8() + = imap_utf7_decode() + = imap_utf7_encode() + = imap_setflag_full(, , , ) + = imap_clearflag_full(, , , ) + = imap_sort(, , , ) + = imap_sort(, , , , ) + = imap_sort(, , , , , ) + = imap_fetchheader(, , ) + = imap_uid(, ) + = imap_msgno(, ) + = imap_status(, , ) + = imap_bodystruct(, , ) + = imap_fetch_overview(, , ) + = imap_mail_compose(, ) + = imap_mail(, , , ) + = imap_mail(, , , , ) + = imap_mail(, , , , , ) + = imap_mail(, , , , , , ) + = imap_search(, , ) + = imap_search(, , , ) + = imap_mime_header_decode() + = imap_thread(, ) + = imap_timeout(, ) + = simplexml_load_file(, ) + = simplexml_load_file(, , ) + = simplexml_load_file(, , , ) + = simplexml_load_file(, , , , ) + = simplexml_load_string(, ) + = simplexml_load_string(, , ) + = simplexml_load_string(, , , ) + = simplexml_load_string(, , , , ) + = simplexml_import_dom(, ) + = ftp_connect(, ) + = ftp_connect(, , ) + = ftp_ssl_connect(, ) + = ftp_ssl_connect(, , ) + = ftp_login(, , ) + = ftp_pwd() + = ftp_cdup() + = ftp_chdir(, ) + = ftp_exec(, ) + = ftp_raw(, ) + = ftp_mkdir(, ) + = ftp_rmdir(, ) + = ftp_chmod(, , ) + = ftp_alloc(, , ) + = ftp_nlist(, ) + = ftp_rawlist(, , ) + = ftp_mlsd(, ) + = ftp_systype() + = ftp_fget(, , , ) + = ftp_fget(, , , , ) + = ftp_nb_fget(, , , ) + = ftp_nb_fget(, , , , ) + = ftp_pasv(, ) + = ftp_get(, , , ) + = ftp_get(, , , , ) + = ftp_nb_get(, , , ) + = ftp_nb_get(, , , , ) + = ftp_nb_continue() + = ftp_fput(, , , ) + = ftp_fput(, , , , ) + = ftp_nb_fput(, , , ) + = ftp_nb_fput(, , , , ) + = ftp_put(, , , ) + = ftp_put(, , , , ) + = ftp_append(, , , ) + = ftp_nb_put(, , , ) + = ftp_nb_put(, , , , ) + = ftp_size(, ) + = ftp_mdtm(, ) + = ftp_rename(, , ) + = ftp_delete(, ) + = ftp_site(, ) + = ftp_close() + = ftp_set_option(, , ) + = ftp_get_option(, ) + = zip_open() + = zip_close() + = zip_read() + = zip_entry_open(, , ) + = zip_entry_close() + = zip_entry_read(, ) + = ->open(, ) + = ->setPassword() + = ->addEmptyDir(, ) + = ->addFile(, ) + = ->addFile(, , ) + = ->addFile(, , , ) + = ->addFile(, , , , ) + = ->replaceFile(, , ) + = ->replaceFile(, , , ) + = ->replaceFile(, , , , ) + = ->addFromString(, , ) + = ->statName(, ) + = ->statIndex(, ) + = ->locateName(, ) + = ->getNameIndex(, ) + = ->setArchiveComment() + = ->getArchiveComment() + = ->setCommentName(, ) + = ->setCommentIndex(, ) + = ->setExternalAttributesName(, , , ) + = ->setExternalAttributesIndex(, , , ) + = ->getExternalAttributesName(, , , ) + = ->getExternalAttributesIndex(, , , ) + = ->setEncryptionName(, , ) + = ->setEncryptionIndex(, , ) + = ->getCommentName(, ) + = ->getCommentIndex(, ) + = ->setCompressionName(, , ) + = ->setCompressionIndex(, , ) + = ->setMtimeName(, , ) + = ->setMtimeIndex(, , ) + = ->deleteIndex() + = ->deleteName() + = ->renameIndex(, ) + = ->renameName(, ) + = ->unchangeIndex() + = ->unchangeName() + = ->extractTo(, ) + = ->getStream() + = ->registerProgressCallback(, ) + = ->registerCancelCallback() + = ->isCompressionMethodSupported(, ) + = ->isEncryptionMethodSupported(, ) + = bzread(, ) + = bzopen(, ) + = bzcompress(, ) + = bzcompress(, , ) + = bzdecompress(, ) + = snmp_set_quick_print() + = snmp_set_enum_print() + = snmp_set_oid_output_format() + = snmp_set_valueretrieval() + = snmp_read_mib() + = ->__construct(, , , ) + = ->__construct(, , , , ) + = ->setSecurity(, ) + = ->setSecurity(, , ) + = ->setSecurity(, , , ) + = ->setSecurity(, , , , ) + = ->setSecurity(, , , , , ) + = ->setSecurity(, , , , , , ) + = sodium_memcmp(, ) + = sodium_crypto_shorthash(, ) + = sodium_crypto_secretbox(, , ) + = sodium_crypto_secretbox_open(, , ) + = sodium_crypto_generichash(, ) + = sodium_crypto_generichash(, , ) + = sodium_crypto_generichash_init() + = sodium_crypto_generichash_init(, ) + = sodium_crypto_generichash_update(, ) + = sodium_crypto_generichash_final(, ) + = sodium_crypto_box_seed_keypair() + = sodium_crypto_box_keypair_from_secretkey_and_publickey(, ) + = sodium_crypto_box_secretkey() + = sodium_crypto_box_publickey() + = sodium_crypto_box_publickey_from_secretkey() + = sodium_crypto_box(, , ) + = sodium_crypto_box_open(, , ) + = sodium_crypto_box_seal(, ) + = sodium_crypto_box_seal_open(, ) + = sodium_crypto_sign_seed_keypair() + = sodium_crypto_sign_keypair_from_secretkey_and_publickey(, ) + = sodium_crypto_sign_publickey_from_secretkey() + = sodium_crypto_sign_secretkey() + = sodium_crypto_sign_publickey() + = sodium_crypto_sign(, ) + = sodium_crypto_sign_open(, ) + = sodium_crypto_sign_detached(, ) + = sodium_crypto_sign_verify_detached(, , ) + = sodium_crypto_stream(, , ) + = sodium_crypto_stream_xor(, , ) + = sodium_crypto_pwhash(, , , , , ) + = sodium_crypto_pwhash_str(, , ) + = sodium_crypto_pwhash_str_needs_rehash(, , ) + = sodium_crypto_pwhash_str_verify(, ) + = sodium_crypto_pwhash_scryptsalsa208sha256(, , , , ) + = sodium_crypto_pwhash_scryptsalsa208sha256_str(, , ) + = sodium_crypto_pwhash_scryptsalsa208sha256_str_verify(, ) + = sodium_crypto_aead_aes256gcm_encrypt(, , , ) + = sodium_crypto_aead_aes256gcm_decrypt(, , , ) + = sodium_crypto_aead_chacha20poly1305_encrypt(, , , ) + = sodium_crypto_aead_chacha20poly1305_decrypt(, , , ) + = sodium_crypto_aead_chacha20poly1305_ietf_encrypt(, , , ) + = sodium_crypto_aead_chacha20poly1305_ietf_decrypt(, , , ) + = sodium_crypto_aead_xchacha20poly1305_ietf_encrypt(, , , ) + = sodium_crypto_aead_xchacha20poly1305_ietf_decrypt(, , , ) + = sodium_bin2hex() + = sodium_hex2bin(, ) + = sodium_bin2base64(, ) + = sodium_base642bin(, , ) + = sodium_crypto_scalarmult(, ) + = sodium_crypto_kx_seed_keypair() + = sodium_crypto_kx_secretkey() + = sodium_crypto_kx_publickey() + = sodium_crypto_kx_client_session_keys(, ) + = sodium_crypto_kx_server_session_keys(, ) + = sodium_crypto_auth(, ) + = sodium_crypto_auth_verify(, , ) + = sodium_crypto_sign_ed25519_sk_to_curve25519() + = sodium_crypto_sign_ed25519_pk_to_curve25519() + = sodium_compare(, ) + = sodium_crypto_kdf_derive_from_key(, , , ) + = sodium_pad(, ) + = sodium_unpad(, ) + = sodium_crypto_secretstream_xchacha20poly1305_init_push() + = sodium_crypto_secretstream_xchacha20poly1305_push(, , ) + = sodium_crypto_secretstream_xchacha20poly1305_push(, , , ) + = sodium_crypto_secretstream_xchacha20poly1305_init_pull(, ) + = sodium_crypto_secretstream_xchacha20poly1305_pull(, , ) + = sodium_crypto_secretstream_xchacha20poly1305_rekey() + = exif_tagname() + = exif_read_data() + = exif_read_data(, ) + = exif_read_data(, , ) + = exif_read_data(, , , ) + = exif_thumbnail() + = exif_thumbnail(, ) + = exif_thumbnail(, , ) + = exif_thumbnail(, , , ) + = exif_imagetype() + = pspell_new(, ) + = pspell_new(, , ) + = pspell_new(, , , ) + = pspell_new(, , , , ) + = pspell_new_personal(, , ) + = pspell_new_personal(, , , ) + = pspell_new_personal(, , , , ) + = pspell_new_personal(, , , , , ) + = pspell_new_config() + = pspell_check(, ) + = pspell_suggest(, ) + = pspell_store_replacement(, , ) + = pspell_add_to_personal(, ) + = pspell_add_to_session(, ) + = pspell_clear_session() + = pspell_save_wordlist() + = pspell_config_create(, ) + = pspell_config_create(, , ) + = pspell_config_create(, , , ) + = pspell_config_runtogether(, ) + = pspell_config_mode(, ) + = pspell_config_ignore(, ) + = pspell_config_repl(, ) + = pspell_config_save_repl(, ) + = ->importStylesheet() + = ->transformToDoc(, ) + = ->transformToUri(, ) + = ->transformToXml() + = ->getParameter(, ) + = ->removeParameter(, ) + = ->registerPHPFunctions() + = ->registerPHPFunctions() + = ->setProfiling() + = ->setSecurityPrefs() + = oci_register_taf_callback(, ) + = oci_unregister_taf_callback() + = oci_define_by_name(, , ) + = oci_define_by_name(, , , ) + = oci_bind_by_name(, , ) + = oci_bind_by_name(, , , ) + = oci_bind_by_name(, , , , ) + = oci_bind_array_by_name(, , , ) + = oci_bind_array_by_name(, , , , ) + = oci_bind_array_by_name(, , , , , ) + = oci_lob_copy(, , ) + = oci_lob_is_equal(, ) + = oci_new_descriptor(, ) + = oci_rollback() + = oci_commit() + = oci_execute() + = oci_execute(, ) + = oci_cancel() + = oci_fetch() + = oci_fetch_all(, ) + = oci_fetch_all(, , ) + = oci_fetch_all(, , , ) + = oci_fetch_all(, , , , ) + = oci_free_statement() + = oci_close() + = oci_error() + = oci_error() + = oci_num_fields() + = oci_parse(, ) + = oci_set_prefetch(, ) + = oci_set_client_identifier(, ) + = oci_set_edition() + = oci_set_module_name(, ) + = oci_set_action(, ) + = oci_set_client_info(, ) + = oci_set_db_operation(, ) + = oci_set_call_timeout(, ) + = oci_new_cursor() + = oci_client_version() + = oci_server_version() + = oci_statement_type() + = oci_num_rows() + = oci_new_collection(, , ) + = oci_get_implicit_resultset() + = variant_date_from_timestamp() + = com_get_active_object(, ) + = com_event_sink(, , ) + = com_print_typeinfo(, ) + = com_print_typeinfo(, , ) + = com_message_pump() + = com_load_typelib(, ) + = ->__construct(, , ) + = mb_language() + = mb_internal_encoding() + = mb_http_input() + = mb_http_output() + = mb_detect_order() + = mb_detect_order() + = mb_substitute_character() + = mb_substitute_character() + = mb_preferred_mime_name() + = mb_parse_str(, ) + = mb_output_handler(, ) + = mb_str_split() + = mb_str_split(, ) + = mb_str_split(, , ) + = mb_strlen() + = mb_strlen(, ) + = mb_strpos(, , ) + = mb_strpos(, , , ) + = mb_strrpos(, , ) + = mb_strrpos(, , , ) + = mb_stripos(, , ) + = mb_stripos(, , , ) + = mb_strripos(, , ) + = mb_strripos(, , , ) + = mb_substr_count(, , ) + = mb_substr(, , ) + = mb_substr(, , , ) + = mb_strcut(, , ) + = mb_strcut(, , , ) + = mb_strwidth(, ) + = mb_strimwidth(, , , ) + = mb_strimwidth(, , , , ) + = mb_convert_encoding(, ) + = mb_convert_encoding(, , ) + = mb_convert_case(, , ) + = mb_strtoupper(, ) + = mb_strtolower(, ) + = mb_detect_encoding() + = mb_detect_encoding(, ) + = mb_detect_encoding(, , ) + = mb_encoding_aliases() + = mb_encode_mimeheader(, ) + = mb_encode_mimeheader(, , ) + = mb_encode_mimeheader(, , , ) + = mb_encode_mimeheader(, , , , ) + = mb_decode_mimeheader() + = mb_convert_kana(, ) + = mb_convert_kana(, , ) + = mb_convert_variables(, , ) + = mb_send_mail(, , , ) + = mb_send_mail(, , , , ) + = mb_get_info() + = mb_check_encoding() + = mb_check_encoding() + = mb_check_encoding(, ) + = mb_ord() + = mb_ord(, ) + = mb_chr() + = mb_chr(, ) + = mb_scrub() + = mb_scrub(, ) + = mb_regex_encoding() + = mb_split(, , ) + = mb_ereg_match(, , ) + = mb_ereg_search_init(, ) + = mb_ereg_search_init(, , ) + = mb_ereg_search_setpos() + = mb_regex_set_options() + = tidy_parse_string(, ) + = tidy_parse_string(, , ) + = tidy_parse_file(, ) + = tidy_parse_file(, , ) + = tidy_parse_file(, , , ) + = ->__construct() + = ->__construct(, ) + = ->__construct(, , ) + = ->__construct(, , , ) + = ->parseFile(, ) + = ->parseFile(, , ) + = ->parseFile(, , , ) + = ->parseString(, ) + = ->parseString(, , ) + = ->__construct() + = mysqli_poll(, , , , ) + = mysqli_report() + = ->__construct(, ) + = ->__construct(, ) + = mysqli_debug() + = mysqli_get_client_info() + = ->getAll() + = ->getAll(, ) + = ->__construct(, ) + = ->__construct(, , ) + = ->__construct(, , , ) + = ->is() + = isIgnorable() + = getTokenName() + = __toString() + = token_get_all() + = token_get_all(, ) + = token_name() + = pdo_drivers() + = ->__construct() + = ->__construct(, ) + = ->__construct(, , ) + = ->__construct(, , , ) + = ->prepare() + = ->prepare(, ) + = beginTransaction() + = commit() + = rollBack() + = inTransaction() + = ->setAttribute(, ) + = ->getAttribute() + = ->exec() + = ->lastInsertId() + = ->lastInsertId() + = errorCode() + = errorInfo() + = ->query(, ) + = ->query(, ) + = ->quote() + = ->quote(, ) + = getAvailableDrivers() + = ->execute() + = ->execute() + = ->fetch() + = ->fetch() + = ->fetch(, ) + = ->fetch(, , ) + = ->fetchObject() + = ->fetchObject() + = ->fetchObject(, ) + = ->fetchColumn() + = ->fetchColumn() + = ->fetchAll() + = ->fetchAll() + = ->fetchAll(, ) + = ->fetchAll(, , ) + = ->bindValue(, ) + = ->bindValue(, , ) + = rowCount() + = errorCode() + = errorInfo() + = ->setAttribute(, ) + = ->getAttribute() + = columnCount() + = ->getColumnMeta() + = ->setFetchMode() + = nextRowset() + = closeCursor() + = debugDumpParams() + = debugDumpParams() + = shmop_open(, , , ) + = shmop_read(, , ) + = shmop_close() + = shmop_size() + = shmop_write(, , ) + = shmop_delete() + = hash(, ) + = hash(, , ) + = hash_file(, ) + = hash_file(, , ) + = hash_hmac(, , , ) + = hash_hmac_file(, , , ) + = hash_init(, ) + = hash_init(, , ) + = hash_update(, ) + = hash_update_stream(, , ) + = hash_update_file(, , ) + = hash_final(, ) + = hash_copy() + = hash_hkdf(, , ) + = hash_hkdf(, , , ) + = hash_hkdf(, , , , ) + = hash_pbkdf2(, , , , ) + = hash_pbkdf2(, , , , , ) + = hash_equals(, ) + = mhash(, , ) + = mhash_get_hash_name() + = mhash_get_block_size() + = mhash_keygen_s2k(, , , ) + = ->__unserialize() + = ldap_connect() + = ldap_connect(, ) + = ldap_connect(, , ) + = ldap_connect(, , , ) + = ldap_connect(, , , , ) + = ldap_bind(, ) + = ldap_bind(, , ) + = ldap_bind_ext(, ) + = ldap_bind_ext(, , ) + = ldap_bind_ext(, , , ) + = ldap_sasl_bind(, ) + = ldap_sasl_bind(, , ) + = ldap_sasl_bind(, , , ) + = ldap_sasl_bind(, , , , ) + = ldap_sasl_bind(, , , , , ) + = ldap_sasl_bind(, , , , , , ) + = ldap_sasl_bind(, , , , , , , ) + = ldap_unbind() + = ldap_free_result() + = ldap_count_entries(, ) + = ldap_first_entry(, ) + = ldap_next_entry(, ) + = ldap_get_entries(, ) + = ldap_first_attribute(, , ) + = ldap_next_attribute(, , ) + = ldap_get_attributes(, ) + = ldap_get_values_len(, , ) + = ldap_get_dn(, ) + = ldap_explode_dn(, ) + = ldap_dn2ufn() + = ldap_modify_batch(, , , ) + = ldap_errno() + = ldap_err2str() + = ldap_error() + = ldap_compare(, , , , ) + = ldap_get_option(, , ) + = ldap_set_option(, , ) + = ldap_parse_result(, , , ) + = ldap_parse_result(, , , , ) + = ldap_parse_result(, , , , , ) + = ldap_parse_result(, , , , , , ) + = ldap_parse_exop(, , ) + = ldap_parse_exop(, , , ) + = ldap_count_references(, ) + = ldap_first_reference(, ) + = ldap_next_reference(, ) + = ldap_parse_reference(, , ) + = ldap_start_tls() + = ldap_set_rebind_proc(, ) + = ldap_escape(, ) + = ldap_escape(, , ) + = ldap_control_paged_result(, , ) + = ldap_control_paged_result(, , , ) + = ldap_control_paged_result_response(, , ) + = ldap_control_paged_result_response(, , , ) + = ldap_exop(, , ) + = ldap_exop(, , , ) + = ldap_exop(, , , , ) + = ldap_exop(, , , , , ) + = ldap_exop_passwd(, ) + = ldap_exop_passwd(, , ) + = ldap_exop_passwd(, , , ) + = ldap_exop_passwd(, , , , ) + = ldap_exop_whoami() + = ldap_exop_refresh(, , ) + = preg_replace_callback(, , ) + = preg_replace_callback(, , , ) + = preg_replace_callback(, , , , ) + = preg_replace_callback(, , , , , ) + = preg_replace_callback_array(, ) + = preg_replace_callback_array(, , ) + = preg_replace_callback_array(, , , ) + = preg_replace_callback_array(, , , , ) + = preg_split(, ) + = preg_split(, , ) + = preg_split(, , , ) + = preg_quote() + = preg_quote(, ) + = preg_grep(, ) + = preg_grep(, , ) + = preg_last_error() + = preg_last_error_msg() + = cal_info() + = cal_days_in_month(, , ) + = cal_to_jd(, , , ) + = cal_from_jd(, ) + = jdtogregorian() + = gregoriantojd(, , ) + = jdtojulian() + = juliantojd(, , ) + = jdtojewish(, ) + = jdtojewish(, , ) + = jewishtojd(, , ) + = jdtofrench() + = frenchtojd(, , ) + = jddayofweek(, ) + = jdmonthname(, ) + = unixtojd() + = jdtounix() + = idate() + = idate(, ) + = strtotime() + = strtotime(, ) + = checkdate(, , ) + = time() + = localtime() + = localtime() + = localtime(, ) + = getdate() + = getdate() + = date_create() + = date_create() + = date_create(, ) + = date_create_immutable() + = date_create_immutable() + = date_create_immutable(, ) + = date_create_from_format(, ) + = date_create_from_format(, , ) + = date_create_immutable_from_format(, ) + = date_create_immutable_from_format(, , ) + = ->__construct() + = ->__construct() + = ->__construct(, ) + = ->__construct() + = ->__construct() + = ->__construct(, ) + = ->createFromImmutable() + = ->createFromInterface() + = ->createFromMutable() + = ->createFromInterface() + = ->__set_state() + = ->__set_state() + = __wakeup() + = __wakeup() + = date_get_last_errors() + = date_parse() + = date_parse_from_format(, ) + = ->modify() + = ->add() + = ->sub() + = ->setTimezone() + = ->setTime(, , ) + = ->setTime(, , , ) + = ->setDate(, , ) + = ->setISODate(, , ) + = ->setTimestamp() + = timezone_open() + = ->__construct() + = ->__set_state() + = __wakeup() + = timezone_name_from_abbr() + = timezone_name_from_abbr(, ) + = timezone_name_from_abbr(, , ) + = ->__construct() + = ->__set_state() + = __wakeup() + = date_interval_create_from_date_string() + = getStartDate() + = getEndDate() + = getDateInterval() + = getRecurrences() + = getIterator() + = timezone_identifiers_list() + = timezone_identifiers_list() + = timezone_identifiers_list(, ) + = timezone_version_get() + = timezone_abbreviations_list() + = date_default_timezone_set() + = date_default_timezone_get() + = date_sun_info(, , ) + = ->__set_state() + = __wakeup() + = imageloadfont() + = imagesetstyle(, ) + = imagecreatetruecolor(, ) + = imageistruecolor() + = imagetruecolortopalette(, , ) + = imagepalettetotruecolor() + = imagecolormatch(, ) + = imagesetthickness(, ) + = imagefilledellipse(, , , , , ) + = imagefilledarc(, , , , , , , , ) + = imagealphablending(, ) + = imagesavealpha(, ) + = imagelayereffect(, ) + = imagecolorallocatealpha(, , , , ) + = imagecolorresolvealpha(, , , , ) + = imagecolorclosestalpha(, , , , ) + = imagecolorexactalpha(, , , , ) + = imagecopyresampled(, , , , , , , , , ) + = imagegrabwindow(, ) + = imagerotate(, , , ) + = imagesettile(, ) + = imagesetbrush(, ) + = imagecreate(, ) + = imagecreatefromstring() + = imagexbm(, , ) + = imagewbmp(, ) + = imagewbmp(, , ) + = imagebmp(, ) + = imagebmp(, , ) + = imagedestroy() + = imagecolorallocate(, , , ) + = imagepalettecopy(, ) + = imagecolorat(, , ) + = imagecolorclosest(, , , ) + = imagecolorclosesthwb(, , , ) + = imagecolordeallocate(, ) + = imagecolorresolve(, , , ) + = imagecolorexact(, , , ) + = imagecolorset(, , , , , ) + = imagecolorsforindex(, ) + = imagegammacorrect(, , ) + = imagesetpixel(, , , ) + = imageline(, , , , , ) + = imagedashedline(, , , , , ) + = imagerectangle(, , , , , ) + = imagefilledrectangle(, , , , , ) + = imagearc(, , , , , , , ) + = imageellipse(, , , , , ) + = imagefilltoborder(, , , , ) + = imagefill(, , , ) + = imagecolorstotal() + = imagecolortransparent(, ) + = imageinterlace(, ) + = imagecopy(, , , , , , , ) + = imagecopymerge(, , , , , , , , ) + = imagecopymergegray(, , , , , , , , ) + = imagecopyresized(, , , , , , , , , ) + = imagesx() + = imagesy() + = imagesetclip(, , , , ) + = imagegetclip() + = imagefilter(, ) + = imageconvolution(, , , ) + = imageflip(, ) + = imageantialias(, ) + = imagecrop(, ) + = imagecropauto(, ) + = imagecropauto(, , ) + = imagecropauto(, , , ) + = imagescale(, , ) + = imagescale(, , , ) + = imageaffine(, , ) + = imageaffinematrixget(, ) + = imageaffinematrixconcat(, ) + = imagegetinterpolation() + = imagesetinterpolation(, ) + = imageresolution(, ) + = imageresolution(, , ) + = ->sqliteCreateFunction(, ) + = ->sqliteCreateFunction(, , ) + = ->sqliteCreateFunction(, , , ) + = ->sqliteCreateAggregate(, , ) + = ->sqliteCreateAggregate(, , , ) + = ->sqliteCreateCollation(, ) + = xmlwriter_open_uri() + = pg_connect_poll() + = pg_close() + = pg_parameter_status() + = pg_ping() + = pg_query() + = pg_query_params(, ) + = pg_prepare(, ) + = pg_execute(, ) + = pg_last_notice(, ) + = pg_field_table(, , ) + = pg_field_num(, ) + = pg_fetch_result(, ) + = pg_fetch_all(, ) + = pg_fetch_all_columns(, ) + = pg_result_seek(, ) + = pg_free_result() + = pg_last_oid() + = pg_trace(, ) + = pg_trace(, , ) + = pg_untrace() + = pg_lo_create() + = pg_lo_create(, ) + = pg_lo_close() + = pg_lo_read(, ) + = pg_lo_write(, , ) + = pg_lo_read_all() + = pg_lo_seek(, , ) + = pg_lo_tell() + = pg_lo_truncate(, ) + = pg_set_error_verbosity() + = pg_set_client_encoding() + = pg_client_encoding() + = pg_end_copy() + = pg_put_line() + = pg_copy_to(, , ) + = pg_copy_to(, , , ) + = pg_copy_from(, , , ) + = pg_copy_from(, , , , ) + = pg_escape_string() + = pg_escape_bytea() + = pg_unescape_bytea() + = pg_result_error() + = pg_result_error_field(, ) + = pg_connection_status() + = pg_transaction_status() + = pg_connection_reset() + = pg_send_query(, ) + = pg_send_query_params(, , ) + = pg_send_prepare(, , ) + = pg_send_execute(, , ) + = pg_get_result() + = pg_result_status(, ) + = pg_get_notify(, ) + = pg_get_pid() + = pg_socket() + = pg_consume_input() + = pg_flush() + = pg_meta_data(, , ) + = pg_insert(, , , ) + = pg_update(, , , , ) + = pg_delete(, , , ) + = pg_select(, , , ) + = socket_select(, , , , ) + = socket_create_listen(, ) + = socket_accept() + = socket_set_nonblock() + = socket_set_block() + = socket_listen(, ) + = socket_close() + = socket_write(, , ) + = socket_read(, , ) + = socket_getsockname(, , ) + = socket_getpeername(, , ) + = socket_create(, , ) + = socket_connect(, , ) + = socket_strerror() + = socket_bind(, , ) + = socket_recv(, , , ) + = socket_send(, , , ) + = socket_recvfrom(, , , , , ) + = socket_sendto(, , , , , ) + = socket_get_option(, , ) + = socket_set_option(, , , ) + = socket_create_pair(, , , ) + = socket_shutdown(, ) + = socket_last_error() + = socket_clear_error() + = socket_import_stream() + = socket_export_stream() + = socket_addrinfo_lookup(, ) + = socket_addrinfo_lookup(, , ) + = socket_addrinfo_bind() + = socket_addrinfo_connect() + = socket_addrinfo_explain() + = socket_wsaprotocol_info_export(, ) + = socket_wsaprotocol_info_import() + = socket_wsaprotocol_info_release() + = socket_sendmsg(, , ) + = socket_recvmsg(, , ) + = socket_cmsg_space(, , ) + = json_encode() + = json_encode(, ) + = json_encode(, , ) + = json_decode() + = json_decode(, ) + = json_decode(, , ) + = json_decode(, , , ) + = json_last_error() + = json_last_error_msg() + = ->getAttributeNo() + = ->getAttributeNs(, ) + = ->getParserProperty() + = ->moveToAttribute() + = ->moveToAttributeNo() + = ->moveToAttributeNs(, ) + = ->next() + = ->open(, ) + = ->open(, , ) + = ->setSchema() + = ->setParserProperty(, ) + = ->XML(, ) + = ->XML(, , ) + = ->expand() + = test1() + = test2() + = test2() + = iconv_strlen(, ) + = iconv_substr(, , ) + = iconv_substr(, , , ) + = iconv_strpos(, , ) + = iconv_strpos(, , , ) + = iconv_strrpos(, , ) + = iconv_mime_encode(, , ) + = iconv_mime_decode(, ) + = iconv_mime_decode(, , ) + = iconv_mime_decode_headers(, ) + = iconv_mime_decode_headers(, , ) + = iconv(, , ) + = iconv_set_encoding(, ) + = iconv_get_encoding() + = ->__construct(, ) + = ->__construct(, ) + = ->__construct(, , ) + = ->__construct(, , , ) + = ->__construct(, , , , ) + = ->__construct(, ) + = ->__construct(, , ) + = ->__construct(, , , ) + = ->__construct(, , , , ) + = ->__construct(, , , , , ) + = ->__construct(, , ) + = ->__construct(, , , ) + = ->__construct(, , , , ) + = ->__construct(, , , , , ) + = ->__construct(, ) + = ->setPersistence() + = ->setClass() + = ->setObject() + = ->addFunction() + = ->handle() + = ->fault(, , ) + = ->fault(, , , ) + = ->fault(, , , , ) + = ->addSoapHeader() + = use_soap_error_handler() + = is_soap_fault() + = ->__construct(, ) + = ->__doRequest(, , , , ) + = ->__setCookie(, ) + = ->__setSoapHeaders() + = ->__setLocation() + = ob_gzhandler(, ) + = gzfile(, ) + = gzopen(, , ) + = readgzfile(, ) + = name(, ) + = name(, , ) + = name(, ) + = inflate_init(, ) + = inflate_add(, , ) + = inflate_get_status() + = inflate_get_read_len() + = deflate_init(, ) + = deflate_add(, , ) + = textdomain() + = gettext() + = dgettext(, ) + = dcgettext(, , ) + = bindtextdomain(, ) + = ngettext(, , ) + = dngettext(, , , ) + = dcngettext(, , , , ) + = bind_textdomain_codeset(, ) + = dba_close() + = dba_key_split() + = dba_firstkey() + = dba_nextkey() + = dba_optimize() + = dba_sync() + = dba_handlers() + = shm_attach(, ) + = shm_attach(, , ) + = shm_detach() + = shm_remove() + = shm_put_var(, , ) + = shm_get_var(, ) + = shm_has_var(, ) + = shm_remove_var(, ) + = xml_set_object(, ) + = xml_set_element_handler(, , ) + = xml_set_character_data_handler(, ) + = xml_set_processing_instruction_handler(, ) + = xml_set_default_handler(, ) + = xml_set_unparsed_entity_decl_handler(, ) + = xml_set_notation_decl_handler(, ) + = xml_set_external_entity_ref_handler(, ) + = xml_set_start_namespace_decl_handler(, ) + = xml_set_end_namespace_decl_handler(, ) + = xml_parse(, , ) + = xml_parse_into_struct(, , , ) + = xml_get_error_code() + = xml_error_string() + = xml_get_current_line_number() + = xml_get_current_column_number() + = xml_get_current_byte_index() + = xml_parser_free() + = xml_parser_set_option(, , ) + = xml_parser_get_option(, ) + = ->pgsqlCopyFromArray(, , ) + = ->pgsqlCopyFromArray(, , , ) + = ->pgsqlCopyFromArray(, , , , ) + = ->pgsqlCopyFromFile(, , ) + = ->pgsqlCopyFromFile(, , , ) + = ->pgsqlCopyFromFile(, , , , ) + = ->pgsqlCopyToFile(, , ) + = ->pgsqlCopyToFile(, , , ) + = ->pgsqlCopyToFile(, , , , ) + = ->pgsqlCopyToArray(, ) + = ->pgsqlCopyToArray(, , ) + = ->pgsqlCopyToArray(, , , ) + = pgsqlLOBCreate() + = ->pgsqlLOBOpen(, ) + = ->pgsqlLOBUnlink() + = ->pgsqlGetNotify() + = ->pgsqlGetNotify(, ) + = pgsqlGetPid() + = libxml_set_streams_context() + = libxml_use_internal_errors() + = libxml_use_internal_errors() + = libxml_get_last_error() + = libxml_get_errors() + = libxml_clear_errors() + = libxml_disable_entity_loader() + = libxml_disable_entity_loader() + = libxml_set_external_entity_loader() + = openssl_x509_export_to_file(, ) + = openssl_x509_export_to_file(, , ) + = openssl_spki_new(, , ) + = openssl_spki_verify() + = openssl_spki_export() + = openssl_spki_export_challenge() + = openssl_x509_export(, ) + = openssl_x509_export(, , ) + = openssl_x509_fingerprint() + = openssl_x509_fingerprint(, ) + = openssl_x509_fingerprint(, , ) + = openssl_x509_check_private_key(, ) + = openssl_x509_verify(, ) + = openssl_x509_parse() + = openssl_x509_parse(, ) + = openssl_x509_checkpurpose(, ) + = openssl_x509_checkpurpose(, , ) + = openssl_x509_checkpurpose(, , , ) + = openssl_x509_read() + = openssl_x509_free() + = openssl_pkcs12_export_to_file(, , , ) + = openssl_pkcs12_export_to_file(, , , , ) + = openssl_pkcs12_export(, , , ) + = openssl_pkcs12_export(, , , , ) + = openssl_pkcs12_read(, , ) + = openssl_csr_export_to_file(, ) + = openssl_csr_export_to_file(, , ) + = openssl_csr_export(, ) + = openssl_csr_export(, , ) + = openssl_csr_sign(, , , ) + = openssl_csr_sign(, , , , ) + = openssl_csr_sign(, , , , , ) + = openssl_csr_new(, , ) + = openssl_csr_new(, , , ) + = openssl_csr_get_subject() + = openssl_csr_get_subject(, ) + = openssl_csr_get_public_key() + = openssl_csr_get_public_key(, ) + = openssl_pkey_new() + = openssl_pkey_export_to_file(, , ) + = openssl_pkey_export_to_file(, , , ) + = openssl_pkey_export(, , ) + = openssl_pkey_export(, , , ) + = openssl_pkey_get_public() + = openssl_pkey_free() + = openssl_pkey_get_private(, ) + = openssl_pkey_get_details() + = openssl_dh_compute_key(, ) + = openssl_pkey_derive(, , ) + = openssl_pbkdf2(, , , , ) + = openssl_pkcs7_verify(, , ) + = openssl_pkcs7_verify(, , , ) + = openssl_pkcs7_verify(, , , , ) + = openssl_pkcs7_verify(, , , , , ) + = openssl_pkcs7_verify(, , , , , , ) + = openssl_pkcs7_encrypt(, , , , ) + = openssl_pkcs7_encrypt(, , , , , ) + = openssl_pkcs7_read(, ) + = openssl_pkcs7_sign(, , , , ) + = openssl_pkcs7_sign(, , , , , ) + = openssl_pkcs7_sign(, , , , , , ) + = openssl_pkcs7_decrypt(, , ) + = openssl_pkcs7_decrypt(, , , ) + = openssl_cms_verify(, , ) + = openssl_cms_verify(, , , ) + = openssl_cms_verify(, , , , ) + = openssl_cms_verify(, , , , , ) + = openssl_cms_verify(, , , , , , ) + = openssl_cms_verify(, , , , , , , ) + = openssl_cms_verify(, , , , , , , , ) + = openssl_cms_encrypt(, , , , ) + = openssl_cms_encrypt(, , , , , ) + = openssl_cms_encrypt(, , , , , , ) + = openssl_cms_read(, ) + = openssl_cms_sign(, , , , ) + = openssl_cms_sign(, , , , , ) + = openssl_cms_sign(, , , , , , ) + = openssl_cms_sign(, , , , , , , ) + = openssl_cms_decrypt(, , ) + = openssl_cms_decrypt(, , , ) + = openssl_cms_decrypt(, , , , ) + = openssl_private_encrypt(, , , ) + = openssl_private_decrypt(, , , ) + = openssl_public_encrypt(, , , ) + = openssl_public_decrypt(, , , ) + = openssl_sign(, , , ) + = openssl_verify(, , , ) + = openssl_seal(, , , , ) + = openssl_seal(, , , , , ) + = openssl_open(, , , , ) + = openssl_open(, , , , , ) + = openssl_get_md_methods() + = openssl_get_cipher_methods() + = openssl_digest(, , ) + = openssl_encrypt(, , , ) + = openssl_encrypt(, , , , ) + = openssl_encrypt(, , , , , ) + = openssl_encrypt(, , , , , , ) + = openssl_encrypt(, , , , , , , ) + = openssl_decrypt(, , , ) + = openssl_decrypt(, , , , ) + = openssl_decrypt(, , , , , ) + = openssl_decrypt(, , , , , , ) + = openssl_cipher_iv_length() + = openssl_random_pseudo_bytes(, ) + = msg_set_queue(, ) + = msg_stat_queue() + = msg_queue_exists() + = msg_get_queue(, ) + = msg_remove_queue() + = msg_receive(, , , , , ) + = msg_receive(, , , , , , ) + = msg_receive(, , , , , , , ) + = msg_send(, , , ) + = msg_send(, , , , ) + = msg_send(, , , , , ) + + + = $vars["tidyNode"] + = $vars["com"] + = $vars["SQLite3Result"] + = $vars["InfiniteIterator"] + = $vars["DateTimeZone"] + = $vars["ArrayIterator"] + = $vars["tidy"] + = $vars["PDO"] + = $vars["SoapParam"] + = $vars["DOMElement"] + = $vars["SoapVar"] + = $vars["Phar"] + = $vars["dotnet"] + = $vars["RecursiveRegexIterator"] + = $vars["COMPersistHelper"] + = $vars["DOMAttr"] + = $vars["DOMCdataSection"] + = $vars["RecursiveDirectoryIterator"] + = $vars["PDO_SQLite_Ext"] + = $vars["MultipleIterator"] + = $vars["DOMDocumentFragment"] + = $vars["SplMaxHeap"] + = $vars["RegexIterator"] + = $vars["SplObjectStorage"] + = $vars["DateTimeImmutable"] + = $vars["DOMNamedNodeMap"] + = $vars["ArrayObject"] + = $vars["AppendIterator"] + = $vars["SplHeap"] + = $vars["DOMText"] + = $vars["FilterIterator"] + = $vars["SplFileInfo"] + = $vars["SplDoublyLinkedList"] + = $vars["DateInterval"] + = $vars["XSLTProcessor"] + = $vars["RecursiveCallbackFilterIterator"] + = $vars["SplMinHeap"] + = $vars["cname"] + = $vars["SessionHandler"] + = $vars["SplTempFileObject"] + = $vars["PhpToken"] + = $vars["ZipArchive"] + = $vars["DOMNodeList"] + = $vars["SplPriorityQueue"] + = $vars["RecursiveTreeIterator"] + = $vars["XMLReader"] + = $vars["SoapHeader"] + = $vars["DOMImplementation"] + = $vars["SQLite3"] + = $vars["DOMEntityReference"] + = $vars["SimpleXMLElement"] + = $vars["CallbackFilterIterator"] + = $vars["mysqli"] + = $vars["EmptyIterator"] + = $vars["SplFileObject"] + = $vars["mysqli_warning"] + = $vars["DOMXPath"] + = $vars["PDOStatement"] + = $vars["SoapFault"] + = $vars["SoapClient"] + = $vars["DOMCharacterData"] + = $vars["PharFileInfo"] + = $vars["RecursiveIteratorIterator"] + = $vars["RecursiveFilterIterator"] + = $vars["variant"] + = $vars["mysqli_result"] + = $vars["ParentIterator"] + = $vars["SNMP"] + = $vars["FilesystemIterator"] + = $vars["DOMDocument"] + = $vars["DOMProcessingInstruction"] + = $vars["LimitIterator"] + = $vars["NoRewindIterator"] + = $vars["IteratorIterator"] + = $vars["DOMNode"] + = $vars["DateTime"] + = $vars["SplFixedArray"] + = $vars["SQLite3Stmt"] + = $vars["GlobIterator"] + = $vars["mysqli_stmt"] + = $vars["DOMComment"] + = $vars["DirectoryIterator"] + = $vars["CachingIterator"] + = $vars["RecursiveArrayIterator"] + = $vars["DatePeriod"] + = $vars["PDO_PGSql_Ext"] + = $vars["SoapServer"] + = $vars["RecursiveCachingIterator"] + = $vars["php_user_filter"] + = $vars["HashContext"] diff --git a/php/template.php b/php/template.php new file mode 100644 index 0000000..6b066ff --- /dev/null +++ b/php/template.php @@ -0,0 +1,173 @@ + new stdClass(), + "Exception" => new Exception(), + "ErrorException" => new ErrorException(), + "Error" => new Error(), + "CompileError" => new CompileError(), + "ParseError" => new ParseError(), + "TypeError" => new TypeError(), + "ArgumentCountError" => new ArgumentCountError(), + "ArithmeticError" => new ArithmeticError(), + "DivisionByZeroError" => new DivisionByZeroError(), + "ClosedGeneratorException" => new ClosedGeneratorException(), + "DateTime" => new DateTime(), + "DateTimeImmutable" => new DateTimeImmutable(), + "DateTimeZone" => new DateTimeZone("America/Chicago"), + "DateInterval" => new DateInterval("P2Y4DT6H8M"), + "DatePeriod" => new DatePeriod("R4/2012-07-01T00:00:00Z/P7D"), + "LibXMLError" => new LibXMLError(), + "DOMException" => new DOMException(), + "DOMStringList" => new DOMStringList(), + "DOMNameList" => new DOMNameList(), + "DOMImplementationList" => new DOMImplementationList(), + "DOMImplementationSource" => new DOMImplementationSource(), + "DOMImplementation" => new DOMImplementation(), + "DOMNode" => new DOMNode(), + "DOMNameSpaceNode" => new DOMNameSpaceNode(), + "DOMDocumentFragment" => new DOMDocumentFragment(), + "DOMDocument" => new DOMDocument(), + "DOMNodeList" => new DOMNodeList(), + "DOMNamedNodeMap" => new DOMNamedNodeMap(), + "DOMCharacterData" => new DOMCharacterData(), + "DOMAttr" => new DOMAttr("artr"), + "DOMElement" => new DOMElement("root"), + "DOMText" => new DOMText(), + "DOMComment" => new DOMComment(), + "DOMTypeinfo" => new DOMTypeinfo(), + "DOMUserDataHandler" => new DOMUserDataHandler(), + "DOMDomError" => new DOMDomError(), + "DOMErrorHandler" => new DOMErrorHandler(), + "DOMLocator" => new DOMLocator(), + "DOMConfiguration" => new DOMConfiguration(), + "DOMCdataSection" => new DOMCdataSection("root value"), + "DOMDocumentType" => new DOMDocumentType(), + "DOMNotation" => new DOMNotation(), + "DOMEntity" => new DOMEntity(), + "DOMEntityReference" => new DOMEntityReference("nbsp"), + "DOMProcessingInstruction" => new DOMProcessingInstruction("php"), + "DOMStringExtend" => new DOMStringExtend(), + "DOMXPath" => new DOMXPath(new DOMDocument()), + "finfo" => new finfo(), + "JsonException" => new JsonException(), + "LogicException" => new LogicException(), + "BadFunctionCallException" => new BadFunctionCallException(), + "BadMethodCallException" => new BadMethodCallException(), + "DomainException" => new DomainException(), + "InvalidArgumentException" => new InvalidArgumentException(), + "LengthException" => new LengthException(), + "OutOfRangeException" => new OutOfRangeException(), + "RuntimeException" => new RuntimeException(), + "OutOfBoundsException" => new OutOfBoundsException(), + "OverflowException" => new OverflowException(), + "RangeException" => new RangeException(), + "UnderflowException" => new UnderflowException(), + "UnexpectedValueException" => new UnexpectedValueException(), + "SplFileObject" => new SplFileObject(__FILE__), + "SplTempFileObject" => new SplTempFileObject(), + "SplDoublyLinkedList" => new SplDoublyLinkedList(), + "SplQueue" => new SplQueue(), + "SplStack" => new SplStack(), + "SplMinHeap" => new SplMinHeap(), + "SplMaxHeap" => new SplMaxHeap(), + "SplPriorityQueue" => new SplPriorityQueue(), + "SplFixedArray" => new SplFixedArray(), + "SplObjectStorage" => new SplObjectStorage(), + "MultipleIterator" => new MultipleIterator(), + "SessionHandler" => new SessionHandler(), + "ReflectionException" => new ReflectionException(), + "Reflection" => new Reflection(), + "ReflectionFunction" => new ReflectionFunction("templateFunction"), + "ReflectionGenerator" => new ReflectionGenerator(templateGenerator()), + "ReflectionParameter" => new ReflectionParameter("templateFunction", "templateParameter"), + "ReflectionType" => (new ReflectionClass("ZipArchive"))->getMethod("getCommentName")->getReturnType(), + "ReflectionNamedType" => new ReflectionNamedType(), + "ReflectionMethod" => new ReflectionMethod("TemplateClass", "templateMethod"), + "ReflectionClass" => new ReflectionClass("TemplateClass"), + "ReflectionObject" => new ReflectionObject(new TemplateClass()), + "ReflectionProperty" => new ReflectionProperty("TemplateClass", "templateProperty"), + "ReflectionClassConstant" => new ReflectionClassConstant("TemplateClass", "TEMPLATE_CONSTANT"), + "ReflectionExtension" => new ReflectionExtension("Reflection"), + "__PHP_Incomplete_Class" => new __PHP_Incomplete_Class(), + "php_user_filter" => new php_user_filter(), + "Directory" => new Directory(), + "AssertionError" => new AssertionError(), + "SimpleXMLElement" => new SimpleXMLElement("a"), + "SimpleXMLIterator" => new SimpleXMLIterator("a"), + "PharException" => new PharException(), + "Phar" => new Phar("/tmp/fuzz.phar"), + "PharData" => new PharData("/tmp/fuzz.tar"), + "PharFileInfo" => new PharFileInfo("phar:///tmp/fuzz.phar/fuzz.txt"), + "XMLReader" => new XMLReader(), + "XMLWriter" => new XMLWriter(), + "CURLFile" => new CURLFile("/tmp/fuzz"), + "ZipArchive" => new ZipArchive(), + + /* - Instantiation not allowed - + "ReflectionZendExtension" => new ReflectionZendExtension(), + "ReflectionFunctionAbstract" => new ReflectionFunctionAbstract(), + "PDOException" => new PDOException(), + "PDO" => new PDO(), + "PDOStatement" => new PDOStatement(), + "SplHeap" => new SplHeap(), + "PDORow" => new PDORow(), + "RecursiveIteratorIterator" => new RecursiveIteratorIterator(), + "IteratorIterator" => new IteratorIterator(), + "FilterIterator" => new FilterIterator(), + "RecursiveFilterIterator" => new RecursiveFilterIterator(), + "CallbackFilterIterator" => new CallbackFilterIterator(), + "RecursiveCallbackFilterIterator" => new RecursiveCallbackFilterIterator(), + "ParentIterator" => new ParentIterator(), + "LimitIterator" => new LimitIterator(), + "CachingIterator" => new CachingIterator(), + "RecursiveCachingIterator" => new RecursiveCachingIterator(), + "NoRewindIterator" => new NoRewindIterator(), + "AppendIterator" => new AppendIterator(), + "InfiniteIterator" => new InfiniteIterator(), + "RegexIterator" => new RegexIterator(), + "RecursiveRegexIterator" => new RecursiveRegexIterator(), + "EmptyIterator" => new EmptyIterator(), + "RecursiveTreeIterator" => new RecursiveTreeIterator(), + "ArrayObject" => new ArrayObject(), + "ArrayIterator" => new ArrayIterator(), + "RecursiveArrayIterator" => new RecursiveArrayIterator(), + "SplFileInfo" => new SplFileInfo(), + "DirectoryIterator" => new DirectoryIterator(), + "FilesystemIterator" => new FilesystemIterator(), + "RecursiveDirectoryIterator" => new RecursiveDirectoryIterator(), + "GlobIterator" => new GlobIterator(), + "HashContext" => new HashContext(), + "Closure" => new Closure(), + "Generator" => new Generator(), + */ +); + +// TODO randomize those as well +$ref_bool = true; +$ref_int = 1337; +$ref_string= "bla"; +$ref_array = array(1.0, 2, -3e3); +$ref_object = new StdClass(); +$ref_resource = fopen("/dev/null", "r"); +$ref_path = "/dev/null"; + + + +?> From e449177904b53314dba1d535b700d3444dcbfd0a Mon Sep 17 00:00:00 2001 From: WilliamParks Date: Sat, 3 Oct 2020 12:43:21 -0400 Subject: [PATCH 21/50] Fixes path issues in grammar files --- canvas/canvas.txt | 4 ++-- grammar.py | 4 +--- mathml/mathml.txt | 2 +- php/php.txt | 3 ++- webgl/webgl.txt | 4 ++-- 5 files changed, 8 insertions(+), 9 deletions(-) diff --git a/canvas/canvas.txt b/canvas/canvas.txt index 17db36a..6ed81c2 100644 --- a/canvas/canvas.txt +++ b/canvas/canvas.txt @@ -107,8 +107,8 @@ = -!include common.txt -!include cssproperties.txt +!include ../common.txt +!include ../cssproperties.txt !lineguard try { } catch(e) { console.log(e.message) } !varformat fuzzvar%05d diff --git a/grammar.py b/grammar.py index 946465a..e81e8e6 100755 --- a/grammar.py +++ b/grammar.py @@ -930,8 +930,7 @@ def _include_from_string(self, grammar_str): def _include_from_file(self, filename): try: - f = open(os.path.join( - os.path.dirname(os.path.abspath(__file__)), + f = open(os.path.join(self._definitions_dir, filename )) content = f.read() @@ -939,7 +938,6 @@ def _include_from_file(self, filename): except IOError: print('Error reading ' + filename) return 1 - self._definitions_dir = os.path.dirname(filename) return self.parse_from_string(content) def parse_from_string(self, grammar_str): diff --git a/mathml/mathml.txt b/mathml/mathml.txt index d0edbd3..ddb1a3c 100644 --- a/mathml/mathml.txt +++ b/mathml/mathml.txt @@ -11,7 +11,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -!include common.txt +!include ../common.txt !include mathattrvalues.txt !max_recursion 50 diff --git a/php/php.txt b/php/php.txt index 1798363..c9ee691 100644 --- a/php/php.txt +++ b/php/php.txt @@ -31,6 +31,7 @@ = 18446744073709551615 = 18446744073709551616 + = 0 = 1 = -1 @@ -186,7 +187,7 @@ = (function () { yield 0; })() -!include php_generated.txt +!include ./php_generated.txt ### OTHER diff --git a/webgl/webgl.txt b/webgl/webgl.txt index f9b45ea..77eb0d9 100644 --- a/webgl/webgl.txt +++ b/webgl/webgl.txt @@ -515,8 +515,8 @@ = -!include common.txt -!include cssproperties.txt +!include ../common.txt +!include ../cssproperties.txt !lineguard try { } catch(e) { } !varformat fuzzvar%05d From 8f342eb1fd0e62ef07b66af349300b597b11bb26 Mon Sep 17 00:00:00 2001 From: nonetype-gram Date: Fri, 8 Jan 2021 10:24:00 +0900 Subject: [PATCH 22/50] Fix invisible contents --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 0c73119..9ff4dcb 100644 --- a/README.md +++ b/README.md @@ -200,7 +200,7 @@ Sometimes you might want to call custom Python code in your grammar. For example = ``` -The python functions are defined between ‘!begin function ’ and ‘!end function’ commands. The functions can be called in two ways: using ‘beforeoutput’ attribute and using symbol. +The python functions are defined between ‘!begin function ’ and ‘!end function’ commands. The functions can be called in two ways: using ‘beforeoutput’ attribute and using `` symbol. By specifying the ‘beforeoutput’ attribute in some symbol, the corresponding function will be called when this symbol is expanded, just before the result of the expansion is output to the sample. The expansion result will be passed to the function in the ret_val variable. The function is then free to modify ret_val, store it for later use or perform any other operations. @@ -209,8 +209,8 @@ When using a special `` symbol, the function (specified in a ‘function Your python code has access to the following variables: - `context` - a dictionary that is passed through the whole sample generation. You can use it to store values (such as storing the size in an example above) and retrieve them in the rules that fire subsequently. -- `attributes` - a dictionary corresponding to the symbol currently being processed. You can use it to pass parameters to your functions. For example if you used something like to call your function attributes\[‘foo’\] will be set to ‘bar’. -- `ret_val` - The value that will be output as a result of the function call. It is initialized to an empty value when using symbol to call a function, otherwise it will be initialized to the value generated by the symbol. +- `attributes` - a dictionary corresponding to the symbol currently being processed. You can use it to pass parameters to your functions. For example if you used something like `` to call your function attributes\[‘foo’\] will be set to ‘bar’. +- `ret_val` - The value that will be output as a result of the function call. It is initialized to an empty value when using `` symbol to call a function, otherwise it will be initialized to the value generated by the symbol. ##### Built-in symbols From 04225966c5aa60e418f023b5a2032e1b871bcc4e Mon Sep 17 00:00:00 2001 From: Swapnadeep Som <90515154+GawdOfROFL@users.noreply.github.com> Date: Wed, 29 Sep 2021 14:36:13 +0530 Subject: [PATCH 23/50] Few minor changes to the repo to make it look better (#31) * cleaned the repo * delete pycaches * Add new generation after each iteration * ability to read template and rules if run from outside the domato directory * changes in the code according to the comments * few more changes according to the comments * delete pycaches * readd mistakenly removed info * added info to the new main file as well * rename functions * reduce time complexity * added correct info headers * add result var inside the if statement * commit to make the changes in the follow up inline comments * rename generate_sample to generate_samples * pycaches again * added comments on the svg and html tags file * follow up changes * spaces --- README.md | 6 +- generator.py | 349 +++--------------- html_tags.py | 156 ++++++++ .../attributevalues.txt | 0 common.txt => rules/common.txt | 0 css.txt => rules/css.txt | 0 cssproperties.txt => rules/cssproperties.txt | 0 html.txt => rules/html.txt | 0 js.txt => rules/js.txt | 0 jshelpers.txt => rules/jshelpers.txt | 0 svg.txt => rules/svg.txt | 0 svgattrvalues.txt => rules/svgattrvalues.txt | 0 tagattributes.txt => rules/tagattributes.txt | 0 svg_tags.py | 109 ++++++ 14 files changed, 328 insertions(+), 292 deletions(-) create mode 100644 html_tags.py rename attributevalues.txt => rules/attributevalues.txt (100%) rename common.txt => rules/common.txt (100%) rename css.txt => rules/css.txt (100%) rename cssproperties.txt => rules/cssproperties.txt (100%) rename html.txt => rules/html.txt (100%) rename js.txt => rules/js.txt (100%) rename jshelpers.txt => rules/jshelpers.txt (100%) rename svg.txt => rules/svg.txt (100%) rename svgattrvalues.txt => rules/svgattrvalues.txt (100%) rename tagattributes.txt => rules/tagattributes.txt (100%) create mode 100644 svg_tags.py diff --git a/README.md b/README.md index 9ff4dcb..4105dec 100644 --- a/README.md +++ b/README.md @@ -19,9 +19,13 @@ limitations under the License. #### Usage +To see the usage information run the following command: + +`python3 generator.py --help` + To generate a single .html sample run: -`python generator.py ` +`python generator.py --file ` To generate multiple samples with a single call run: diff --git a/generator.py b/generator.py index 5ca9da9..055e23d 100755 --- a/generator.py +++ b/generator.py @@ -1,5 +1,5 @@ # Domato - main generator script -# ------------------------------- +# -------------------------------------- # # Written and maintained by Ivan Fratric # @@ -21,247 +21,17 @@ import os import re import random -import sys +import argparse from grammar import Grammar +from svg_tags import _SVG_TYPES +from html_tags import _HTML_TYPES _N_MAIN_LINES = 1000 _N_EVENTHANDLER_LINES = 500 _N_ADDITIONAL_HTMLVARS = 5 -# A map from tag name to corresponding type for HTML tags -_HTML_TYPES = { - 'a': 'HTMLAnchorElement', - 'abbr': 'HTMLUnknownElement', - 'acronym': 'HTMLUnknownElement', - 'address': 'HTMLUnknownElement', - 'applet': 'HTMLUnknownElement', - 'area': 'HTMLAreaElement', - 'article': 'HTMLUnknownElement', - 'aside': 'HTMLUnknownElement', - 'audio': 'HTMLAudioElement', - 'b': 'HTMLUnknownElement', - 'base': 'HTMLBaseElement', - 'basefont': 'HTMLUnknownElement', - 'bdi': 'HTMLUnknownElement', - 'bdo': 'HTMLUnknownElement', - 'bgsound': 'HTMLUnknownElement', - 'big': 'HTMLUnknownElement', - 'blockquote': 'HTMLUnknownElement', - 'br': 'HTMLBRElement', - 'button': 'HTMLButtonElement', - 'canvas': 'HTMLCanvasElement', - 'caption': 'HTMLTableCaptionElement', - 'center': 'HTMLUnknownElement', - 'cite': 'HTMLUnknownElement', - 'code': 'HTMLUnknownElement', - 'col': 'HTMLTableColElement', - 'colgroup': 'HTMLUnknownElement', - 'command': 'HTMLUnknownElement', - 'content': 'HTMLContentElement', - 'data': 'HTMLDataElement', - 'datalist': 'HTMLDataListElement', - 'dd': 'HTMLUnknownElement', - 'del': 'HTMLModElement', - 'details': 'HTMLDetailsElement', - 'dfn': 'HTMLUnknownElement', - 'dialog': 'HTMLDialogElement', - 'dir': 'HTMLDirectoryElement', - 'div': 'HTMLDivElement', - 'dl': 'HTMLDListElement', - 'dt': 'HTMLUnknownElement', - 'em': 'HTMLUnknownElement', - 'embed': 'HTMLEmbedElement', - 'fieldset': 'HTMLFieldSetElement', - 'figcaption': 'HTMLUnknownElement', - 'figure': 'HTMLUnknownElement', - 'font': 'HTMLFontElement', - 'footer': 'HTMLUnknownElement', - 'form': 'HTMLFormElement', - 'frame': 'HTMLFrameElement', - 'frameset': 'HTMLFrameSetElement', - 'h1': 'HTMLHeadingElement', - 'h2': 'HTMLHeadingElement', - 'h3': 'HTMLHeadingElement', - 'h4': 'HTMLHeadingElement', - 'h5': 'HTMLHeadingElement', - 'h6': 'HTMLHeadingElement', - 'header': 'HTMLUnknownElement', - 'hgroup': 'HTMLUnknownElement', - 'hr': 'HTMLHRElement', - 'i': 'HTMLUnknownElement', - 'iframe': 'HTMLIFrameElement', - 'image': 'HTMLImageElement', - 'img': 'HTMLImageElement', - 'input': 'HTMLInputElement', - 'ins': 'HTMLModElement', - 'isindex': 'HTMLUnknownElement', - 'kbd': 'HTMLUnknownElement', - 'keygen': 'HTMLKeygenElement', - 'label': 'HTMLLabelElement', - 'layer': 'HTMLUnknownElement', - 'legend': 'HTMLLegendElement', - 'li': 'HTMLLIElement', - 'link': 'HTMLLinkElement', - 'listing': 'HTMLUnknownElement', - 'main': 'HTMLUnknownElement', - 'map': 'HTMLMapElement', - 'mark': 'HTMLUnknownElement', - 'marquee': 'HTMLMarqueeElement', - 'menu': 'HTMLMenuElement', - 'menuitem': 'HTMLMenuItemElement', - 'meta': 'HTMLMetaElement', - 'meter': 'HTMLMeterElement', - 'nav': 'HTMLUnknownElement', - 'nobr': 'HTMLUnknownElement', - 'noembed': 'HTMLUnknownElement', - 'noframes': 'HTMLUnknownElement', - 'nolayer': 'HTMLUnknownElement', - 'noscript': 'HTMLUnknownElement', - 'object': 'HTMLObjectElement', - 'ol': 'HTMLOListElement', - 'optgroup': 'HTMLOptGroupElement', - 'option': 'HTMLOptionElement', - 'output': 'HTMLOutputElement', - 'p': 'HTMLParagraphElement', - 'param': 'HTMLParamElement', - 'picture': 'HTMLPictureElement', - 'plaintext': 'HTMLUnknownElement', - 'pre': 'HTMLPreElement', - 'progress': 'HTMLProgressElement', - 'q': 'HTMLQuoteElement', - 'rp': 'HTMLUnknownElement', - 'rt': 'HTMLUnknownElement', - 'ruby': 'HTMLUnknownElement', - 's': 'HTMLUnknownElement', - 'samp': 'HTMLUnknownElement', - 'section': 'HTMLUnknownElement', - 'select': 'HTMLSelectElement', - 'shadow': 'HTMLShadowElement', - 'small': 'HTMLUnknownElement', - 'source': 'HTMLSourceElement', - 'span': 'HTMLSpanElement', - 'strike': 'HTMLUnknownElement', - 'strong': 'HTMLUnknownElement', - 'style': 'HTMLStyleElement', - 'sub': 'HTMLUnknownElement', - 'summary': 'HTMLUnknownElement', - 'sup': 'HTMLUnknownElement', - 'table': 'HTMLTableElement', - 'tbody': 'HTMLTableSectionElement', - 'td': 'HTMLUnknownElement', - 'template': 'HTMLTemplateElement', - 'textarea': 'HTMLTextAreaElement', - 'tfoot': 'HTMLTableSectionElement', - 'th': 'HTMLTableCellElement', - 'thead': 'HTMLTableSectionElement', - 'time': 'HTMLTimeElement', - 'title': 'HTMLTitleElement', - 'tr': 'HTMLTableRowElement', - 'track': 'HTMLTrackElement', - 'tt': 'HTMLUnknownElement', - 'u': 'HTMLUnknownElement', - 'ul': 'HTMLUListElement', - 'var': 'HTMLUnknownElement', - 'video': 'HTMLVideoElement', - 'wbr': 'HTMLUnknownElement', - 'xmp': 'HTMLUnknownElement' -} - -# A map from tag name to corresponding type for SVG tags -_SVG_TYPES = { - 'a': 'SVGAElement', - 'altGlyph': 'SVGElement', - 'altGlyphDef': 'SVGElement', - 'altGlyphItem': 'SVGElement', - 'animate': 'SVGAnimateElement', - 'animateColor': 'SVGElement', - 'animateMotion': 'SVGAnimateMotionElement', - 'animateTransform': 'SVGAnimateTransformElement', - 'circle': 'SVGCircleElement', - 'clipPath': 'SVGClipPathElement', - 'color-profile': 'SVGElement', - 'cursor': 'SVGCursorElement', - 'defs': 'SVGDefsElement', - 'desc': 'SVGDescElement', - 'discard': 'SVGDiscardElement', - 'ellipse': 'SVGEllipseElement', - 'feBlend': 'SVGFEBlendElement', - 'feColorMatrix': 'SVGFEColorMatrixElement', - 'feComponentTransfer': 'SVGFEComponentTransferElement', - 'feComposite': 'SVGFECompositeElement', - 'feConvolveMatrix': 'SVGFEConvolveMatrixElement', - 'feDiffuseLighting': 'SVGFEDiffuseLightingElement', - 'feDisplacementMap': 'SVGFEDisplacementMapElement', - 'feDistantLight': 'SVGFEDistantLightElement', - 'feDropShadow': 'SVGFEDropShadowElement', - 'feFlood': 'SVGFEFloodElement', - 'feFuncA': 'SVGFEFuncAElement', - 'feFuncB': 'SVGFEFuncBElement', - 'feFuncG': 'SVGFEFuncGElement', - 'feFuncR': 'SVGFEFuncRElement', - 'feGaussianBlur': 'SVGFEGaussianBlurElement', - 'feImage': 'SVGFEImageElement', - 'feMerge': 'SVGFEMergeElement', - 'feMergeNode': 'SVGFEMergeNodeElement', - 'feMorphology': 'SVGFEMorphologyElement', - 'feOffset': 'SVGFEOffsetElement', - 'fePointLight': 'SVGFEPointLightElement', - 'feSpecularLighting': 'SVGFESpecularLightingElement', - 'feSpotLight': 'SVGFESpotLightElement', - 'feTile': 'SVGFETileElement', - 'feTurbulence': 'SVGFETurbulenceElement', - 'filter': 'SVGFilterElement', - 'font': 'SVGElement', - 'font-face': 'SVGElement', - 'font-face-format': 'SVGElement', - 'font-face-name': 'SVGElement', - 'font-face-src': 'SVGElement', - 'font-face-uri': 'SVGElement', - 'foreignObject': 'SVGForeignObjectElement', - 'g': 'SVGGElement', - 'glyph': 'SVGElement', - 'glyphRef': 'SVGElement', - 'hatch': 'SVGElement', - 'hatchpath': 'SVGElement', - 'hkern': 'SVGElement', - 'image': 'SVGImageElement', - 'line': 'SVGLineElement', - 'linearGradient': 'SVGLinearGradientElement', - 'marker': 'SVGMarkerElement', - 'mask': 'SVGMaskElement', - 'mesh': 'SVGElement', - 'meshgradient': 'SVGElement', - 'meshpatch': 'SVGElement', - 'meshrow': 'SVGElement', - 'metadata': 'SVGMetadataElement', - 'missing-glyph': 'SVGElement', - 'mpath': 'SVGMPathElement', - 'path': 'SVGPathElement', - 'pattern': 'SVGPatternElement', - 'polygon': 'SVGPolygonElement', - 'polyline': 'SVGPolylineElement', - 'radialGradient': 'SVGRadialGradientElement', - 'rect': 'SVGRectElement', - 'set': 'SVGSetElement', - 'svg': 'SVGSVGElement', - 'solidcolor': 'SVGElement', - 'stop': 'SVGStopElement', - 'switch': 'SVGSwitchElement', - 'symbol': 'SVGSymbolElement', - 'text': 'SVGTextElement', - 'textPath': 'SVGTextPathElement', - 'title': 'SVGTitleElement', - 'tref': 'SVGElement', - 'tspan': 'SVGTSpanElement', - 'unknown': 'SVGElement', - 'use': 'SVGUseElement', - 'view': 'SVGViewElement', - 'vkern': 'SVGElement' -} - - def generate_html_elements(ctx, n): for i in range(n): tag = random.choice(list(_HTML_TYPES)) @@ -304,7 +74,6 @@ def generate_function_body(jsgrammar, htmlctx, num_lines): def check_grammar(grammar): """Checks if grammar has errors and if so outputs them. - Args: grammar: The grammar to check. """ @@ -321,13 +90,11 @@ def check_grammar(grammar): def generate_new_sample(template, htmlgrammar, cssgrammar, jsgrammar): """Parses grammar rules from string. - Args: template: A template string. htmlgrammar: Grammar for generating HTML code. cssgrammar: Grammar for generating CSS code. jsgrammar: Grammar for generating JS code. - Returns: A string containing sample data. """ @@ -368,38 +135,34 @@ def generate_new_sample(template, htmlgrammar, cssgrammar, jsgrammar): return result - -def generate_samples(grammar_dir, outfiles): +def generate_samples(template, outfiles): """Generates a set of samples and writes them to the output files. - Args: grammar_dir: directory to load grammar files from. outfiles: A list of output filenames. """ - f = open(os.path.join(grammar_dir, 'template.html')) - template = f.read() - f.close() - + grammar_dir = os.path.join(os.path.dirname(__file__), 'rules') htmlgrammar = Grammar() + err = htmlgrammar.parse_from_file(os.path.join(grammar_dir, 'html.txt')) # CheckGrammar(htmlgrammar) if err > 0: - print('There were errors parsing grammar') + print('There were errors parsing html grammar') return cssgrammar = Grammar() - err = cssgrammar.parse_from_file(os.path.join(grammar_dir, 'css.txt')) + err = cssgrammar.parse_from_file(os.path.join(grammar_dir ,'css.txt')) # CheckGrammar(cssgrammar) if err > 0: - print('There were errors parsing grammar') + print('There were errors parsing css grammar') return jsgrammar = Grammar() - err = jsgrammar.parse_from_file(os.path.join(grammar_dir, 'js.txt')) + err = jsgrammar.parse_from_file(os.path.join(grammar_dir,'js.txt')) # CheckGrammar(jsgrammar) if err > 0: - print('There were errors parsing grammar') + print('There were errors parsing js grammar') return # JS and HTML grammar need access to CSS grammar. @@ -408,66 +171,70 @@ def generate_samples(grammar_dir, outfiles): jsgrammar.add_import('cssgrammar', cssgrammar) for outfile in outfiles: - result = generate_new_sample(template, htmlgrammar, cssgrammar, - jsgrammar) - + result = generate_new_sample(template, htmlgrammar, cssgrammar, jsgrammar) if result is not None: print('Writing a sample to ' + outfile) try: - f = open(outfile, 'w') - f.write(result) - f.close() + with open(outfile, 'w') as f: + f.write(result) + f.close() except IOError: print('Error writing to output') +def get_argument_parser(): + + parser = argparse.ArgumentParser(description="DOMATO (A DOM FUZZER)") + + parser.add_argument("-f", "--file", + help="File name which is to be generated in the same directory") -def get_option(option_name): - for i in range(len(sys.argv)): - if (sys.argv[i] == option_name) and ((i + 1) < len(sys.argv)): - return sys.argv[i + 1] - elif sys.argv[i].startswith(option_name + '='): - return sys.argv[i][len(option_name) + 1:] - return None - - -def main(): - fuzzer_dir = os.path.dirname(__file__) + parser.add_argument('-o', '--output_dir', type=str, + help='The output directory to put the generated files in') - multiple_samples = False + parser.add_argument('-n', '--no_of_files', type=int, + help='number of files to be generated') - for a in sys.argv: - if a.startswith('--output_dir='): - multiple_samples = True + return parser - if '--output_dir' in sys.argv: - multiple_samples = True +def main(): - if multiple_samples: - print('Running on ClusterFuzz') - out_dir = get_option('--output_dir') - nsamples = int(get_option('--no_of_files')) - print('Output directory: ' + out_dir) - print('Number of samples: ' + str(nsamples)) + fuzzer_dir = os.path.dirname(__file__) - if not os.path.exists(out_dir): - os.mkdir(out_dir) + with open(os.path.join(fuzzer_dir, "template.html"), "r") as f: + template = f.read() + f.close() - outfiles = [] - for i in range(nsamples): - outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(5) + '.html')) + parser = get_argument_parser() + + args = parser.parse_args() - generate_samples(fuzzer_dir, outfiles) + if args.file: + generate_samples(template, [args.file]) - elif len(sys.argv) > 1: - outfile = sys.argv[1] - generate_samples(fuzzer_dir, [outfile]) + elif args.output_dir: + if not args.no_of_files: + print("Please use switch -n to specify the number of files") + else: + print('Running on ClusterFuzz') + out_dir = args.output_dir + nsamples = args.no_of_files + print('Output directory: ' + out_dir) + print('Number of samples: ' + str(nsamples)) + + if not os.path.exists(out_dir): + os.mkdir(out_dir) + + outfiles = [] + for i in range(nsamples): + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(5) + '.html')) + + generate_samples(template, outfiles) + else: - print('Arguments missing') - print("Usage:") - print("\tpython generator.py ") - print("\tpython generator.py --output_dir --no_of_files ") + parser.print_help() if __name__ == '__main__': + main() diff --git a/html_tags.py b/html_tags.py new file mode 100644 index 0000000..37928ec --- /dev/null +++ b/html_tags.py @@ -0,0 +1,156 @@ +# Domato - HTML types +# -------------------------------------- +# +# Written and maintained by Ivan Fratric +# +# Copyright 2017 Google Inc. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A map from tag name to corresponding type for HTML tags +_HTML_TYPES = { + 'a': 'HTMLAnchorElement', + 'abbr': 'HTMLUnknownElement', + 'acronym': 'HTMLUnknownElement', + 'address': 'HTMLUnknownElement', + 'applet': 'HTMLUnknownElement', + 'area': 'HTMLAreaElement', + 'article': 'HTMLUnknownElement', + 'aside': 'HTMLUnknownElement', + 'audio': 'HTMLAudioElement', + 'b': 'HTMLUnknownElement', + 'base': 'HTMLBaseElement', + 'basefont': 'HTMLUnknownElement', + 'bdi': 'HTMLUnknownElement', + 'bdo': 'HTMLUnknownElement', + 'bgsound': 'HTMLUnknownElement', + 'big': 'HTMLUnknownElement', + 'blockquote': 'HTMLUnknownElement', + 'br': 'HTMLBRElement', + 'button': 'HTMLButtonElement', + 'canvas': 'HTMLCanvasElement', + 'caption': 'HTMLTableCaptionElement', + 'center': 'HTMLUnknownElement', + 'cite': 'HTMLUnknownElement', + 'code': 'HTMLUnknownElement', + 'col': 'HTMLTableColElement', + 'colgroup': 'HTMLUnknownElement', + 'command': 'HTMLUnknownElement', + 'content': 'HTMLContentElement', + 'data': 'HTMLDataElement', + 'datalist': 'HTMLDataListElement', + 'dd': 'HTMLUnknownElement', + 'del': 'HTMLModElement', + 'details': 'HTMLDetailsElement', + 'dfn': 'HTMLUnknownElement', + 'dialog': 'HTMLDialogElement', + 'dir': 'HTMLDirectoryElement', + 'div': 'HTMLDivElement', + 'dl': 'HTMLDListElement', + 'dt': 'HTMLUnknownElement', + 'em': 'HTMLUnknownElement', + 'embed': 'HTMLEmbedElement', + 'fieldset': 'HTMLFieldSetElement', + 'figcaption': 'HTMLUnknownElement', + 'figure': 'HTMLUnknownElement', + 'font': 'HTMLFontElement', + 'footer': 'HTMLUnknownElement', + 'form': 'HTMLFormElement', + 'frame': 'HTMLFrameElement', + 'frameset': 'HTMLFrameSetElement', + 'h1': 'HTMLHeadingElement', + 'h2': 'HTMLHeadingElement', + 'h3': 'HTMLHeadingElement', + 'h4': 'HTMLHeadingElement', + 'h5': 'HTMLHeadingElement', + 'h6': 'HTMLHeadingElement', + 'header': 'HTMLUnknownElement', + 'hgroup': 'HTMLUnknownElement', + 'hr': 'HTMLHRElement', + 'i': 'HTMLUnknownElement', + 'iframe': 'HTMLIFrameElement', + 'image': 'HTMLImageElement', + 'img': 'HTMLImageElement', + 'input': 'HTMLInputElement', + 'ins': 'HTMLModElement', + 'isindex': 'HTMLUnknownElement', + 'kbd': 'HTMLUnknownElement', + 'keygen': 'HTMLKeygenElement', + 'label': 'HTMLLabelElement', + 'layer': 'HTMLUnknownElement', + 'legend': 'HTMLLegendElement', + 'li': 'HTMLLIElement', + 'link': 'HTMLLinkElement', + 'listing': 'HTMLUnknownElement', + 'main': 'HTMLUnknownElement', + 'map': 'HTMLMapElement', + 'mark': 'HTMLUnknownElement', + 'marquee': 'HTMLMarqueeElement', + 'menu': 'HTMLMenuElement', + 'menuitem': 'HTMLMenuItemElement', + 'meta': 'HTMLMetaElement', + 'meter': 'HTMLMeterElement', + 'nav': 'HTMLUnknownElement', + 'nobr': 'HTMLUnknownElement', + 'noembed': 'HTMLUnknownElement', + 'noframes': 'HTMLUnknownElement', + 'nolayer': 'HTMLUnknownElement', + 'noscript': 'HTMLUnknownElement', + 'object': 'HTMLObjectElement', + 'ol': 'HTMLOListElement', + 'optgroup': 'HTMLOptGroupElement', + 'option': 'HTMLOptionElement', + 'output': 'HTMLOutputElement', + 'p': 'HTMLParagraphElement', + 'param': 'HTMLParamElement', + 'picture': 'HTMLPictureElement', + 'plaintext': 'HTMLUnknownElement', + 'pre': 'HTMLPreElement', + 'progress': 'HTMLProgressElement', + 'q': 'HTMLQuoteElement', + 'rp': 'HTMLUnknownElement', + 'rt': 'HTMLUnknownElement', + 'ruby': 'HTMLUnknownElement', + 's': 'HTMLUnknownElement', + 'samp': 'HTMLUnknownElement', + 'section': 'HTMLUnknownElement', + 'select': 'HTMLSelectElement', + 'shadow': 'HTMLShadowElement', + 'small': 'HTMLUnknownElement', + 'source': 'HTMLSourceElement', + 'span': 'HTMLSpanElement', + 'strike': 'HTMLUnknownElement', + 'strong': 'HTMLUnknownElement', + 'style': 'HTMLStyleElement', + 'sub': 'HTMLUnknownElement', + 'summary': 'HTMLUnknownElement', + 'sup': 'HTMLUnknownElement', + 'table': 'HTMLTableElement', + 'tbody': 'HTMLTableSectionElement', + 'td': 'HTMLUnknownElement', + 'template': 'HTMLTemplateElement', + 'textarea': 'HTMLTextAreaElement', + 'tfoot': 'HTMLTableSectionElement', + 'th': 'HTMLTableCellElement', + 'thead': 'HTMLTableSectionElement', + 'time': 'HTMLTimeElement', + 'title': 'HTMLTitleElement', + 'tr': 'HTMLTableRowElement', + 'track': 'HTMLTrackElement', + 'tt': 'HTMLUnknownElement', + 'u': 'HTMLUnknownElement', + 'ul': 'HTMLUListElement', + 'var': 'HTMLUnknownElement', + 'video': 'HTMLVideoElement', + 'wbr': 'HTMLUnknownElement', + 'xmp': 'HTMLUnknownElement' +} diff --git a/attributevalues.txt b/rules/attributevalues.txt similarity index 100% rename from attributevalues.txt rename to rules/attributevalues.txt diff --git a/common.txt b/rules/common.txt similarity index 100% rename from common.txt rename to rules/common.txt diff --git a/css.txt b/rules/css.txt similarity index 100% rename from css.txt rename to rules/css.txt diff --git a/cssproperties.txt b/rules/cssproperties.txt similarity index 100% rename from cssproperties.txt rename to rules/cssproperties.txt diff --git a/html.txt b/rules/html.txt similarity index 100% rename from html.txt rename to rules/html.txt diff --git a/js.txt b/rules/js.txt similarity index 100% rename from js.txt rename to rules/js.txt diff --git a/jshelpers.txt b/rules/jshelpers.txt similarity index 100% rename from jshelpers.txt rename to rules/jshelpers.txt diff --git a/svg.txt b/rules/svg.txt similarity index 100% rename from svg.txt rename to rules/svg.txt diff --git a/svgattrvalues.txt b/rules/svgattrvalues.txt similarity index 100% rename from svgattrvalues.txt rename to rules/svgattrvalues.txt diff --git a/tagattributes.txt b/rules/tagattributes.txt similarity index 100% rename from tagattributes.txt rename to rules/tagattributes.txt diff --git a/svg_tags.py b/svg_tags.py new file mode 100644 index 0000000..b96589f --- /dev/null +++ b/svg_tags.py @@ -0,0 +1,109 @@ +# Domato - SVG types +# -------------------------------------- +# +# Written and maintained by Ivan Fratric +# +# Copyright 2017 Google Inc. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A map from tag name to corresponding type for SVG tags +_SVG_TYPES = { + 'a': 'SVGAElement', + 'altGlyph': 'SVGElement', + 'altGlyphDef': 'SVGElement', + 'altGlyphItem': 'SVGElement', + 'animate': 'SVGAnimateElement', + 'animateColor': 'SVGElement', + 'animateMotion': 'SVGAnimateMotionElement', + 'animateTransform': 'SVGAnimateTransformElement', + 'circle': 'SVGCircleElement', + 'clipPath': 'SVGClipPathElement', + 'color-profile': 'SVGElement', + 'cursor': 'SVGCursorElement', + 'defs': 'SVGDefsElement', + 'desc': 'SVGDescElement', + 'discard': 'SVGDiscardElement', + 'ellipse': 'SVGEllipseElement', + 'feBlend': 'SVGFEBlendElement', + 'feColorMatrix': 'SVGFEColorMatrixElement', + 'feComponentTransfer': 'SVGFEComponentTransferElement', + 'feComposite': 'SVGFECompositeElement', + 'feConvolveMatrix': 'SVGFEConvolveMatrixElement', + 'feDiffuseLighting': 'SVGFEDiffuseLightingElement', + 'feDisplacementMap': 'SVGFEDisplacementMapElement', + 'feDistantLight': 'SVGFEDistantLightElement', + 'feDropShadow': 'SVGFEDropShadowElement', + 'feFlood': 'SVGFEFloodElement', + 'feFuncA': 'SVGFEFuncAElement', + 'feFuncB': 'SVGFEFuncBElement', + 'feFuncG': 'SVGFEFuncGElement', + 'feFuncR': 'SVGFEFuncRElement', + 'feGaussianBlur': 'SVGFEGaussianBlurElement', + 'feImage': 'SVGFEImageElement', + 'feMerge': 'SVGFEMergeElement', + 'feMergeNode': 'SVGFEMergeNodeElement', + 'feMorphology': 'SVGFEMorphologyElement', + 'feOffset': 'SVGFEOffsetElement', + 'fePointLight': 'SVGFEPointLightElement', + 'feSpecularLighting': 'SVGFESpecularLightingElement', + 'feSpotLight': 'SVGFESpotLightElement', + 'feTile': 'SVGFETileElement', + 'feTurbulence': 'SVGFETurbulenceElement', + 'filter': 'SVGFilterElement', + 'font': 'SVGElement', + 'font-face': 'SVGElement', + 'font-face-format': 'SVGElement', + 'font-face-name': 'SVGElement', + 'font-face-src': 'SVGElement', + 'font-face-uri': 'SVGElement', + 'foreignObject': 'SVGForeignObjectElement', + 'g': 'SVGGElement', + 'glyph': 'SVGElement', + 'glyphRef': 'SVGElement', + 'hatch': 'SVGElement', + 'hatchpath': 'SVGElement', + 'hkern': 'SVGElement', + 'image': 'SVGImageElement', + 'line': 'SVGLineElement', + 'linearGradient': 'SVGLinearGradientElement', + 'marker': 'SVGMarkerElement', + 'mask': 'SVGMaskElement', + 'mesh': 'SVGElement', + 'meshgradient': 'SVGElement', + 'meshpatch': 'SVGElement', + 'meshrow': 'SVGElement', + 'metadata': 'SVGMetadataElement', + 'missing-glyph': 'SVGElement', + 'mpath': 'SVGMPathElement', + 'path': 'SVGPathElement', + 'pattern': 'SVGPatternElement', + 'polygon': 'SVGPolygonElement', + 'polyline': 'SVGPolylineElement', + 'radialGradient': 'SVGRadialGradientElement', + 'rect': 'SVGRectElement', + 'set': 'SVGSetElement', + 'svg': 'SVGSVGElement', + 'solidcolor': 'SVGElement', + 'stop': 'SVGStopElement', + 'switch': 'SVGSwitchElement', + 'symbol': 'SVGSymbolElement', + 'text': 'SVGTextElement', + 'textPath': 'SVGTextPathElement', + 'title': 'SVGTitleElement', + 'tref': 'SVGElement', + 'tspan': 'SVGTSpanElement', + 'unknown': 'SVGElement', + 'use': 'SVGUseElement', + 'view': 'SVGViewElement', + 'vkern': 'SVGElement' +} From 52b39b2604b7e44b97c69637c8bbe5ea98422c42 Mon Sep 17 00:00:00 2001 From: Tyson Smith Date: Wed, 29 Sep 2021 16:18:27 -0700 Subject: [PATCH 24/50] Fix grammar paths --- canvas/canvas.txt | 4 ++-- mathml/mathml.txt | 2 +- webgl/webgl.txt | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/canvas/canvas.txt b/canvas/canvas.txt index 6ed81c2..05f77ed 100644 --- a/canvas/canvas.txt +++ b/canvas/canvas.txt @@ -107,8 +107,8 @@ = -!include ../common.txt -!include ../cssproperties.txt +!include ../rules/common.txt +!include ../rules/cssproperties.txt !lineguard try { } catch(e) { console.log(e.message) } !varformat fuzzvar%05d diff --git a/mathml/mathml.txt b/mathml/mathml.txt index ddb1a3c..1aaa32a 100644 --- a/mathml/mathml.txt +++ b/mathml/mathml.txt @@ -11,7 +11,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -!include ../common.txt +!include ../rules/common.txt !include mathattrvalues.txt !max_recursion 50 diff --git a/webgl/webgl.txt b/webgl/webgl.txt index 77eb0d9..bdd9d87 100644 --- a/webgl/webgl.txt +++ b/webgl/webgl.txt @@ -515,8 +515,8 @@ = -!include ../common.txt -!include ../cssproperties.txt +!include ../rules/common.txt +!include ../rules/cssproperties.txt !lineguard try { } catch(e) { } !varformat fuzzvar%05d From 452c99cd12ff9b25bf4a7a457fdbfc051097c4ad Mon Sep 17 00:00:00 2001 From: Tyson Smith Date: Wed, 29 Sep 2021 16:23:25 -0700 Subject: [PATCH 25/50] Remove unnecessary close() calls 'close()' is automatically called by 'with' statement. --- generator.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/generator.py b/generator.py index 055e23d..0e4b29d 100755 --- a/generator.py +++ b/generator.py @@ -177,7 +177,6 @@ def generate_samples(template, outfiles): try: with open(outfile, 'w') as f: f.write(result) - f.close() except IOError: print('Error writing to output') @@ -201,8 +200,7 @@ def main(): fuzzer_dir = os.path.dirname(__file__) with open(os.path.join(fuzzer_dir, "template.html"), "r") as f: - template = f.read() - f.close() + template = f.read() parser = get_argument_parser() From cdb9b97cd2aafd68f0b19cb97069507baf04bad0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Wang?= Date: Fri, 1 Jul 2022 16:11:57 +0200 Subject: [PATCH 26/50] Add support for MathML Core Add support for MathML Core [1] which is the reference spec for browsers and will ship in Chromium soon [2]. Also integrate this into HTML rules so that the main script can generate MathML. [1] https://w3c.github.io/mathml-core/ [2] https://groups.google.com/a/chromium.org/g/blink-dev/c/n4zf_3FWmAA --- rules/html.txt | 3 + rules/mathml.txt | 216 +++++++++++++++++++++++++++++++++++++ rules/mathmlattrvalues.txt | 55 ++++++++++ 3 files changed, 274 insertions(+) create mode 100644 rules/mathml.txt create mode 100644 rules/mathmlattrvalues.txt diff --git a/rules/html.txt b/rules/html.txt index bd5ecf7..e890270 100644 --- a/rules/html.txt +++ b/rules/html.txt @@ -234,6 +234,7 @@ # = = + = = = @@ -1095,4 +1096,6 @@ !include svg.txt !include svgattrvalues.txt +!include mathml.txt +!include mathmlattrvalues.txt diff --git a/rules/mathml.txt b/rules/mathml.txt new file mode 100644 index 0000000..cc9e480 --- /dev/null +++ b/rules/mathml.txt @@ -0,0 +1,216 @@ +# Copyright 2022 Igalia S.L. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# https://w3c.github.io/mathml-core/#the-top-level-math-element + = math /math + = + = display="" + +# A valid MathML child for most MathML elements. + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + +# A valid list of MathML children for most MathML elements. + = + = + +# https://w3c.github.io/mathml-core/#token-elements + = + = + = + = + = + = + +# Interesting content for token elements is generally a single letter or symbol. + = + = + = + = + +# Elements behaving more or less like an . + = + = + = + = + = + +# https://w3c.github.io/mathml-core/#text-mtext + = mtext /mtext + +# https://w3c.github.io/mathml-core/#identifier-mi + = mi /mi + +# https://w3c.github.io/mathml-core/#number-mn + = mn /mn + +# https://w3c.github.io/mathml-core/#operator-fence-separator-or-accent-mo + = mo /mo + = + = form="" + = fence="" + = separator="" + = lspace="" + = rspace="" + = stretchy="" + = symmetric="" + = maxsize="" + = minsize="" + = largeop="" + = movablelimits="" + +# Interesting content for mo are large and stretchy operators. + = + = ∫ + = ∑ + = { + = | + = → + = _ + +# https://w3c.github.io/mathml-core/#space-mspace + = mspace / + = + = width="" + = height="" + = depth="" + +# https://w3c.github.io/mathml-core/#string-literal-ms + = ms /ms + +# https://w3c.github.io/mathml-core/#horizontally-group-sub-expressions-mrow + = mrow /mrow + +# https://w3c.github.io/mathml-core/#fractions-mfrac + = mfrac /mfrac + = +# An interesting value for linethickness is 0px. + = linethickness="" + = linethickness="0px" + +# https://w3c.github.io/mathml-core/#radicals-msqrt-mroot + = msqrt /msqrt + = mroot /mroot + +# https://w3c.github.io/mathml-core/#style-change-mstyle + = mstyle /mstyle + +# https://w3c.github.io/mathml-core/#error-message-merror + = merror /merror + +# https://w3c.github.io/mathml-core/#adjust-space-around-content-mpadded + = mpadded /mpadded + = + = width="" + = height="" + = depth="" + = lspace="" + = voffset="" + +# https://w3c.github.io/mathml-core/#making-sub-expressions-invisible-mphantom + = mphantom /mphantom + +# https://w3c.github.io/mathml-core/#subscripts-and-superscripts-msub-msup-msubsup + = msub /msub + = msup /msup + = msubsup /msubsup + +# https://w3c.github.io/mathml-core/#underscripts-and-overscripts-munder-mover-munderover + = munder /munder + = mover /mover + = munderover /munderover + + = + = + = + + = accent="" + = accentunder="" + +# https://w3c.github.io/mathml-core/#prescripts-and-tensor-indices-mmultiscripts + = mmultiscripts /mmultiscripts + = + = mprescripts / + = none / + + = + = + + = + = + +# https://w3c.github.io/mathml-core/#table-or-matrix-mtable + = mtable /mtable + = + = + +# https://w3c.github.io/mathml-core/#row-in-table-or-matrix-mtr + = mtr /mtr + = + = + +# https://w3c.github.io/mathml-core/#entry-in-table-or-matrix-mtd + = mtd /mtd + = + = columnspan="" + = rowspan="" + +# https://w3c.github.io/mathml-core/#enlivening-expressions + = maction /maction + = + = actiontype="" + = selection="" + +# https://w3c.github.io/mathml-core/#semantics-and-presentation + = semantics /semantics + = + + = + = + + = + = + + = annotation /annotation + = annotation-xml /annotation-xml + + = encoding="" + +# https://w3c.github.io/mathml-core/#global-attributes + = + = class="" + = dir="" + = displaystyle="" +# = id="" + = mathbackground="" + = mathcolor="" + = mathsize="" + = mathvariant="" + = nonce="" + = scriptlevel="" + = style="" + = tabindex="" +# = diff --git a/rules/mathmlattrvalues.txt b/rules/mathmlattrvalues.txt new file mode 100644 index 0000000..a5b9224 --- /dev/null +++ b/rules/mathmlattrvalues.txt @@ -0,0 +1,55 @@ +# Copyright 2022 Igalia S.L. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# https://w3c.github.io/mathml-core/#dfn-length-percentage + = px + = % + +# https://w3c.github.io/mathml-core/#the-top-level-math-element + = inline + = block + +# https://w3c.github.io/mathml-core/#dfn-mathvariant + = normal + = bold + = italic + = bold-italic + = double-struck + = bold-fraktur + = script + = bold-script + = fraktur + = sans-serif + = bold-sans-serif + = sans-serif-italic + = sans-serif-bold-italic + = monospace + = initial + = tailed + = looped + = stretched + +# https://w3c.github.io/mathml-core/#dfn-scriptlevel + = + +# https://w3c.github.io/mathml-core/#dfn-form + = infix + = prefix + = postfix + +# https://www.w3.org/TR/MathML3/chapter3.html#presm.maction + = toggle + = statusline + = tooltip + = input + = From 5441bead9df1fb22d706e6903d7ded498910815f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Wang?= Date: Mon, 4 Jul 2022 11:54:56 +0200 Subject: [PATCH 27/50] Integrate MathML into JS and other places. --- generator.py | 8 ++ mathml_tags.py | 52 +++++++++ rules/common.txt | 33 ++++++ rules/css.txt | 4 +- rules/cssproperties.txt | 1 + rules/js.txt | 220 +++++++++++++++++++++++++++++++++++++ rules/jshelpers.txt | 77 +++++++++++++ rules/mathml.txt | 6 +- rules/mathmlattrvalues.txt | 5 + 9 files changed, 401 insertions(+), 5 deletions(-) create mode 100644 mathml_tags.py diff --git a/generator.py b/generator.py index 0e4b29d..948f472 100755 --- a/generator.py +++ b/generator.py @@ -26,6 +26,7 @@ from grammar import Grammar from svg_tags import _SVG_TYPES from html_tags import _HTML_TYPES +from mathml_tags import _MATHML_TYPES _N_MAIN_LINES = 1000 _N_EVENTHANDLER_LINES = 500 @@ -56,6 +57,12 @@ def add_html_ids(matchobj, ctx): ctx['htmlvars'].append({'name': varname, 'type': _SVG_TYPES[tagname]}) ctx['htmlvargen'] += '/* newvar{' + varname + ':' + _SVG_TYPES[tagname] + '} */ var ' + varname + ' = document.getElementById(\"' + varname + '\"); //' + _SVG_TYPES[tagname] + '\n' return matchobj.group(0) + 'id=\"' + varname + '\" ' + elif tagname in _MATHML_TYPES: + ctx['mathmlvarctr'] += 1 + varname = 'mathmlvar%05d' % ctx['mathmlvarctr'] + ctx['htmlvars'].append({'name': varname, 'type': _MATHML_TYPES[tagname]}) + ctx['htmlvargen'] += '/* newvar{' + varname + ':' + _MATHML_TYPES[tagname] + '} */ var ' + varname + ' = document.getElementById(\"' + varname + '\"); //' + _MATHML_TYPES[tagname] + '\n' + return matchobj.group(0) + 'id=\"' + varname + '\" ' else: return matchobj.group(0) @@ -108,6 +115,7 @@ def generate_new_sample(template, htmlgrammar, cssgrammar, jsgrammar): 'htmlvars': [], 'htmlvarctr': 0, 'svgvarctr': 0, + 'mathmlvarctr': 0, 'htmlvargen': '' } html = re.sub( diff --git a/mathml_tags.py b/mathml_tags.py new file mode 100644 index 0000000..be1910a --- /dev/null +++ b/mathml_tags.py @@ -0,0 +1,52 @@ +# Domato - MathML types +# -------------------------------------- +# +# Written and maintained by Ivan Fratric +# +# Copyright 2017 Google Inc. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# A map from tag name to corresponding type for MathML tags +_MATHML_TYPES = { + 'annotation': 'MathMLElement', + 'annotation-xml': 'MathMLElement', + 'maction': 'MathMLElement', + 'math': 'MathMLElement', + 'merror': 'MathMLElement', + 'mfrac': 'MathMLElement', + 'mi': 'MathMLElement', + 'mmultiscripts': 'MathMLElement', + 'mn': 'MathMLElement', + 'mo': 'MathMLElement', + 'mover': 'MathMLElement', + 'mpadded': 'MathMLElement', + 'mphantom': 'MathMLElement', + 'mprescripts': 'MathMLElement', + 'mroot': 'MathMLElement', + 'mrow': 'MathMLElement', + 'ms': 'MathMLElement', + 'mspace': 'MathMLElement', + 'msqrt': 'MathMLElement', + 'mstyle': 'MathMLElement', + 'msub': 'MathMLElement', + 'msubsup': 'MathMLElement', + 'msup': 'MathMLElement', + 'mtable': 'MathMLElement', + 'mtd': 'MathMLElement', + 'mtext': 'MathMLElement', + 'mtr': 'MathMLElement', + 'munder': 'MathMLElement', + 'munderover': 'MathMLElement', + 'none': 'MathMLElement', + 'semantics': 'MathMLelement' +} diff --git a/rules/common.txt b/rules/common.txt index 327324b..97718b4 100644 --- a/rules/common.txt +++ b/rules/common.txt @@ -44,6 +44,7 @@ = htmlvar0000 = svgvar0000 + = mathmlvar0000 = class = red @@ -279,6 +280,38 @@ = view = vkern + = annotation + = annotation-xml + = maction + = math + = merror + = mfrac + = mi + = mmultiscripts + = mn + = mo + = mover + = mpadded + = mphantom + = mprescripts + = mroot + = mrow + = ms + = mspace + = msqrt + = mstyle + = msub + = msubsup + = msup + = mtable + = mtd + = mtext + = mtr + = munder + = munderover + = none + = semantics + = x = data:image/gif;base64,R0lGODlhIAAgAPIBAGbMzP///wAAADOZZpn/zAAAAAAAAAAAACH5BAAAAAAALAAAAAAgACAAAAOLGLrc/k7ISau9S5DNu/8fICgaYJ5oqqbDGJRrLAMtScw468J5Xr+3nm8XFM5+PGMMWYwxcMyZ40iULQaDhSzqDGBNisGyuhUDrmNb72pWcaXhtpsM/27pVi8UX96rcQpDf3V+QD12d4NKK2+Lc4qOKI2RJ5OUNHyXSDRYnZ6foKAuLxelphMQqaoPCQA7 diff --git a/rules/css.txt b/rules/css.txt index 46d5301..28d34d5 100644 --- a/rules/css.txt +++ b/rules/css.txt @@ -16,10 +16,12 @@ = = + = = data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7 = - = + = + = = :first-child = ::first-letter diff --git a/rules/cssproperties.txt b/rules/cssproperties.txt index 77fc12a..f5ba556 100644 --- a/rules/cssproperties.txt +++ b/rules/cssproperties.txt @@ -339,6 +339,7 @@ = flow1 = = + = = 'dlig' = 'dlig' 0 diff --git a/rules/js.txt b/rules/js.txt index 4d3b265..562d7dc 100644 --- a/rules/js.txt +++ b/rules/js.txt @@ -5831,6 +5831,226 @@ document.all[%document.all.length].appendChild(); = .style; = .style; +################################################ +#MathML +################################################ + +!extends MathMLElement GlobalEventHandlers + = ; + +!extends MathMLElement EventTarget +#NodeList + = .item(%.length); + = .length; + +#Node + = .nodeType; + = .nodeName; + = .baseURI; + = .isConnected; + = .ownerDocument; + = .parentNode; + = .parentElement; + = .hasChildNodes(); + = .childNodes; + = .firstChild; + = .lastChild; + = .previousSibling; + = .nextSibling; + = .getRootNode(); + = .getRootNode(); + = .nodeValue; +.nodeValue = ; + = .textContent; +.textContent = ; +.normalize(); + = .cloneNode(); + = .cloneNode(); + = .isEqualNode(); + = .isSameNode(); + = .compareDocumentPosition(); + = .contains(); + = .lookupPrefix(); + = .lookupNamespaceURI(); + = .isDefaultNamespace(); + = .insertBefore(,.childNodes[%.childNodes.length]); + = .appendChild(); + = .replaceChild(,.childNodes[%.childNodes.length]); + = .removeChild(.childNodes[%.childNodes.length]); + +#ChildNode +.before(); +.before(); +.after(); +.after(); +.replaceWith(); +.replaceWith(); +.remove(); + +#ParentNode + = .children; + = .firstElementChild; + = .lastElementChild; + = .childElementCount; +.prepend(); +.prepend(); +.append(); +.append(); + = .querySelector(""); + = .querySelectorAll(""); + +#NonDocumentTypeChildNode + = .previousElementSibling; + = .nextElementSibling; + +#Element + = .namespaceURI; + = .prefix; + = .localName; + = .tagName; + = .id; +.id = ; + = .className; +.className = ; + = .classList; +.setPointerCapture(); +.releasePointerCapture(); + = .ongotpointercapture; +.ongotpointercapture = ; + = .onlostpointercapture; +.onlostpointercapture = ; + = .hasPointerCapture(); + = .hasAttributes(); + = .attributes; + = .getAttribute(); + = .getAttributeNS("http://www.w3.org/2000/svg",); +#.setAttribute(,); +#.setAttributeNS(,,); +.removeAttribute(.attributes[%.attributes.length].name); +.removeAttributeNS("http://www.w3.org/2000/svg",.attributes[%.attributes.length].name); + = .hasAttribute(); + = .hasAttributeNS("http://www.w3.org/2000/svg",); + = .getAttributeNode(); + = .getAttributeNodeNS("http://www.w3.org/2000/svg",); + = .setAttributeNode(); + = .setAttributeNodeNS(); + = .removeAttributeNode(.attributes[%.attributes.length].name); + = .closest(); + = .matches(); + = .webkitMatchesSelector(); + = .getElementsByTagName(); + = .getElementsByTagNameNS("http://www.w3.org/2000/svg",); + = .getElementsByClassName(""); + = .insertAdjacentElement(,); +.insertAdjacentText(,); + = .innerHTML; +.innerHTML = ; + = .outerHTML; +.outerHTML = ; +.insertAdjacentHTML(,); + = .createShadowRoot(); + = .attachShadow(); + = .getDestinationInsertionPoints(); + = .shadowRoot; + = .slot; +.slot = ; + = .assignedSlot; +.requestPointerLock(); + = .getClientRects(); + = .getBoundingClientRect(); +.scrollIntoView(); +.scrollIntoView(); +.scroll(); +.scroll(); +.scroll(,); +.scrollTo(); +.scrollTo(); +.scrollTo(,); +.scrollBy(); +.scrollBy(); +.scrollBy(,); + = .scrollTop; +.scrollTop = ; + = .scrollLeft; +.scrollLeft = ; + = .scrollWidth; + = .scrollHeight; + = .clientTop; + = .clientLeft; + = .clientWidth; + = .clientHeight; +.setApplyScroll(,); +.setDistributeScroll(,); +.scrollIntoViewIfNeeded(); +.scrollIntoViewIfNeeded(); + = .computedRole; + = .computedName; + = .onbeforecopy; +.onbeforecopy = ; + = .onbeforecut; +.onbeforecut = ; + = .onbeforepaste; +.onbeforepaste = ; + = .oncopy; +.oncopy = ; + = .oncut; +.oncut = ; + = .onpaste; +.onpaste = ; + = .onsearch; +.onsearch = ; + = .onselectstart; +.onselectstart = ; + = .onwheel; +.onwheel = ; + +.setAttribute("display", ""); +.setAttribute("form", ""); +.setAttribute("fence", ""); +.setAttribute("separator", ""); +.setAttribute("lspace", ""); +.setAttribute("rspace", ""); +.setAttribute("stretchy", ""); +.setAttribute("symmetric", ""); +.setAttribute("maxsize", ""); +.setAttribute("minsize", ""); +.setAttribute("largeop", ""); +.setAttribute("movablelimits", ""); +.setAttribute("mfrac_linethickness", ""); +.setAttribute("width", ""); +.setAttribute("height", ""); +.setAttribute("depth", ""); +.setAttribute("lspace", ""); +.setAttribute("voffset", ""); +.setAttribute("accent", ""); +.setAttribute("accentunder", ""); +.setAttribute("columnspan", ""); +.setAttribute("rowspan", ""); +.setAttribute("actiontype", ""); +.setAttribute("selection", ""); +.setAttribute("encoding", ""); +.setAttribute("class", ""); +.setAttribute("dir", ""); +.setAttribute("displaystyle", ""); +.setAttribute("mathbackground", ""); +.setAttribute("mathcolor", ""); +.setAttribute("mathsize", ""); +.setAttribute("mathvariant", ""); +.setAttribute("nonce", ""); +.setAttribute("scriptlevel", ""); +.setAttribute("style", ""); +.setAttribute("tabindex", ""); + + = .style; + = .style; + = .style; + = .style; + = .style; + = .style; + = .style; + = .style; + = .style; + freememory(); freememory(); freememory(); diff --git a/rules/jshelpers.txt b/rules/jshelpers.txt index e5738ab..9a270e6 100644 --- a/rules/jshelpers.txt +++ b/rules/jshelpers.txt @@ -23,6 +23,7 @@ = "" = "" + = "" = "abbr" = "accept" @@ -909,6 +910,43 @@ = "z" = "zoomAndPan" + = "class" + = "dir" + = "displaystyle" + = "mathbackground" + = "mathcolor" + = "mathsize" + = "mathvariant" + = "nonce" + = "scriptlevel" + = "style" + = "tabindex" + = "display" + = "form" + = "fence" + = "separator" + = "lspace" + = "rspace" + = "stretchy" + = "symmetric" + = "maxsize" + = "minsize" + = "largeop" + = "movablelimits" + = "linethickness" + = "width" + = "height" + = "depth" + = "lspace" + = "voffset" + = "accent" + = "accentunder" + = "columnspan" + = "rowspan" + = "actiontype" + = "selection" + = "encoding" + = "-ms-flex-align" = "-ms-font-feature-settings" = "-ms-text-combine-horizontal" @@ -2182,9 +2220,11 @@ !include attributevalues.txt !include svgattrvalues.txt +!include mathmlattrvalues.txt = = + = = data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7 !include cssproperties.txt @@ -2209,9 +2249,11 @@ = { : [, ] }; = { : [, ] }; = { : [, ] }; + = { : [, ] }; = { : [, ] }; = { : [, ] }; = { : [, ] }; + = { : [, ] }; = sequence_StaticRange[0]; = new Array(); = sequence_FontFace_[0]; @@ -2322,8 +2364,10 @@ = {prototype: .prototype}; = {prototype: .prototype, extends: }; = {prototype: .prototype, extends: }; + = {prototype: .prototype, extends: }; = {extends: }; = {extends: }; + = {extends: }; = new Int8Array(); = new Int16Array(); @@ -2606,6 +2650,39 @@ = document.createElementNS("http://www.w3.org/2000/svg", "switch"); = document.createElementNS("http://www.w3.org/2000/svg", "clipPath"); +#MathMLElement constructors + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "annotation"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "annotation-xml"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "maction"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "math"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "merror"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mfrac"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mi"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mmultiscripts"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mn"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mo"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mover"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mpadded"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mphantom"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mprescripts"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mroot"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mrow"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "ms"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mspace"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "msqrt"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mstyle"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "msub"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "msubsup"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "msup"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mtable"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mtd"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mtext"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "mtr"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "munder"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "munderover"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "none"); + = document.createElementNS("http://www.w3.org/1998/Math/MathML", "semantics"); + #events = document.createEvent("InputEvent"); = document.createEvent("PointerEvent"); diff --git a/rules/mathml.txt b/rules/mathml.txt index cc9e480..79a96bc 100644 --- a/rules/mathml.txt +++ b/rules/mathml.txt @@ -107,9 +107,7 @@ # https://w3c.github.io/mathml-core/#fractions-mfrac = mfrac /mfrac = -# An interesting value for linethickness is 0px. - = linethickness="" - = linethickness="0px" + = linethickness="" # https://w3c.github.io/mathml-core/#radicals-msqrt-mroot = msqrt /msqrt @@ -200,7 +198,7 @@ = encoding="" # https://w3c.github.io/mathml-core/#global-attributes - = + = = class="" = dir="" = displaystyle="" diff --git a/rules/mathmlattrvalues.txt b/rules/mathmlattrvalues.txt index a5b9224..de8d891 100644 --- a/rules/mathmlattrvalues.txt +++ b/rules/mathmlattrvalues.txt @@ -47,6 +47,11 @@ = prefix = postfix +# https://w3c.github.io/mathml-core/#fractions-mfrac +# An interesting value for linethickness is 0px. + = + = 0px + # https://www.w3.org/TR/MathML3/chapter3.html#presm.maction = toggle = statusline From 4fc5e520d7b542ffdb0def0a5c91ec22d68ce467 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Wang?= Date: Wed, 6 Jul 2022 12:22:51 +0200 Subject: [PATCH 28/50] Use some HTML definitions from mathml.txt This commit uses the following: - for columnspan attribute. - for rowspan attribute. - for on* attributes. Additionally, allow random HTML on a MathML element, even if not necessarily defined by MathML Core. --- rules/mathml.txt | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/rules/mathml.txt b/rules/mathml.txt index 79a96bc..40be60c 100644 --- a/rules/mathml.txt +++ b/rules/mathml.txt @@ -173,8 +173,8 @@ # https://w3c.github.io/mathml-core/#entry-in-table-or-matrix-mtd = mtd /mtd = - = columnspan="" - = rowspan="" + = columnspan="" + = rowspan="" # https://w3c.github.io/mathml-core/#enlivening-expressions = maction /maction @@ -211,4 +211,5 @@ = scriptlevel="" = style="" = tabindex="" -# = + = + = From dbaafbe0e891ca6e38df58bf195091a5d78c9f4e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Fr=C3=A9d=C3=A9ric=20Wang?= Date: Wed, 6 Jul 2022 12:44:29 +0200 Subject: [PATCH 29/50] Try to improve generation of MathML trees. --- rules/mathml.txt | 38 +++++++++++++++++++++----------------- 1 file changed, 21 insertions(+), 17 deletions(-) diff --git a/rules/mathml.txt b/rules/mathml.txt index 40be60c..c6c991c 100644 --- a/rules/mathml.txt +++ b/rules/mathml.txt @@ -12,29 +12,33 @@ # limitations under the License. # https://w3c.github.io/mathml-core/#the-top-level-math-element - = math /math + = math /math = = display="" + = + = + # A valid MathML child for most MathML elements. - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = # A valid list of MathML children for most MathML elements. - = + = = # https://w3c.github.io/mathml-core/#token-elements From 26d6ae9d50a5c938ca32aa8df72f6ac885fcb321 Mon Sep 17 00:00:00 2001 From: Ivan Fratric Date: Wed, 6 Jul 2022 18:07:48 +0200 Subject: [PATCH 30/50] Remove old MathML3 grammar, replaced with MathML Core --- mathml/mathattrvalues.txt | 251 -------------- mathml/mathml.txt | 713 -------------------------------------- mathml/test.py | 33 -- 3 files changed, 997 deletions(-) delete mode 100644 mathml/mathattrvalues.txt delete mode 100644 mathml/mathml.txt delete mode 100644 mathml/test.py diff --git a/mathml/mathattrvalues.txt b/mathml/mathattrvalues.txt deleted file mode 100644 index 66ecfe6..0000000 --- a/mathml/mathattrvalues.txt +++ /dev/null @@ -1,251 +0,0 @@ -# Copyright 2017 Google Inc. All Rights Reserved. -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - - = - = - - - = - = x - = - = - = - = ltr - = rtl - = toggle - = statusline - = tooltip - = input - = none - = block - = inline - = inherit - - = linebreak - = scroll - = elide - = truncate - = scale - - = x - = true - = false - = before - = after - = duplicate - = - = - = 15 - = +15 - = -5 - = -1 - = - = - = % - = - = - = % - = longdiv - = actuarial - = radical - = box - = roundedbox - = circle - = left - = right - = top - = bottom - = updiagonalstrike - = downdiagonalstrike - = verticalstrike - = horizontalstrike - = madruwb - = updiagonalnarrow - = phasorangle - - = > - = ) - = ] - = } - = < - = ( - = [ - = { - = , - = . - = ; - = ;;, - = : - = ||||, - - - = true - = false - - = left - = right - = center - - - = - = - = thin - = medium - = thick - = left - = right - = center - = http://localhost/image.png - = middle - = bottom - = baseline - = - = - = % - = px - = inherit - = - = - = % - = px - = small - = normal - = big - = normal - = bold - = italic - = bold-italic - = double-struck - = bold-fraktur - = sans-serif - = axis - = baseline - = bottom - = center - = top - = - = - = % - = px - = infinity - = - = - = true - = false - = - = - = % - = px - = true - = false - = true - = false - = true - = false - = left - = center - = right - = - = - = % - = px - = - = - = px - = % - = - = % - = px - = - = - = px - = % - = - = " - = " - = ' - = " - = " - = ' - = auto - = newline - = nobreak - = goodbreak - = badbreak - = - = px - = % - = - = - = - = - = % - = px - = - = - = px - = % - = - = true - = false - = true - = false - = none - = solid - = dashed - = - = % - = px - = - = - = px - = % - = - = none - = solid - = dashed - = - = % - = px - = - = left - = leftoverlap - = right - = rightoverlap - = - = px - = % - = - = left - = center - = right - = left - = center - = right - = true - = false - = none - = MathML-Presentation - = Mathematica - = Maple - = TeX - = ASCII - = MathMLType - = OpenMath - = content-MathML - = x - = - = % - = px - = infinity - = altvalue diff --git a/mathml/mathml.txt b/mathml/mathml.txt deleted file mode 100644 index 1aaa32a..0000000 --- a/mathml/mathml.txt +++ /dev/null @@ -1,713 +0,0 @@ -# Copyright 2017 Google Inc. All Rights Reserved. -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -!include ../rules/common.txt -!include mathattrvalues.txt - -!max_recursion 50 - = math /math - -# = - = - -# testing -# = math /math - - - = -# = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - - - = - = - = - = - = - = - = - = - = - = -# = -# = -# = -# = -# = -# = - - - - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - - -# maction - = maction /maction - = maction /maction - = - = - = - = - = - = - = - = - = - = - = - = - - -# menclose - = menclose /menclose - = menclose /menclose - = - = - = - = - = - = - = - = - = - = - - - -# merror - = merror /merror - = merror /merror - = - = - = - = - = - = - = - = - = - - -# mfenced - = mfenced /mfenced - = mfenced /mfenced - = - = - = - = - = - = - = - = - = - = - = - = - - -# mfrac - = mfrac mfrac /mfrac/mfrac/mfrac - = mfrac mfrac /mfrac mfrac /mfrac /mfrac - = - = - = - = - = - = - = - = - = - = - = - = - - - -# mglyph -# = mglyph /mglyph - = mimglyph //mi - = mglyph / - = - = - = - = - = - = - = - = - = - = - = - - - -# mi - = mi π/mi - = mi /mi - = mi /mi - = - = - = - = - = - = - = - = - = - = - - - -# mlabeledtr - = mlabeledtr /mlabeledtr - = - = - = - = - = - = - = - = - = - = - = - = - = - - - -# multiscripts - = mmultiscripts /mmultiscripts - = - = - = mprescripts / - = none / mprescripts / none / - = - = - = - = - = - = - = - = - = - - - -# mn - = mn /mn - = mn /mn - = mn /mn - = mn /mn - = - = - = - = - = - = - = - = - = - = - = - - -# mo - = mo /mo - = mo +/mo - = mo (/mo - = mo [/mo - = mo )/mo - = mo ]/mo - = mo ;/mo - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - - -# mover - = mover /mover - = - = - = - = - = - = - = - = - = - = - = - = - = - - -# mpadded - = mpadded /mpadded - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - - - -# mphantom - = mphantom /mphantom - = - = - = - = - = - = - = - = - - -# mroot - = mroot /mroot - = - = - = - = - = - = - = - = - = - = - = - - -# mrow - = mrow /mrow - = - = - = - = - = - = - = - = - = - = - = - = - - - -# ms - = ms /ms - = ms /ms - = ms /ms - = ms /ms - = - = - = - = - = - = - = - = - = - = - = - = - - - - -# mspace - = mspace / - = - = - = - = - = - = - = - = - = - - -# msqrt - = msqrt /msqrt - = - = - = - = - = - = - = - = - = - = - = - = - - -# mstyle - = mstyle /mstyle - = - = - = - = - = - = - = - = - = - = - = - = - = - = - - - -# msub - = msub /msub - = - = - = - = - = - = - = - = - = - = - = - = - = - - -# msubsup - = msubsup /msubsup - = - = - = - = - = - = - = - = - = - = - = - = - = - - -# msup - = msup /msup - = - = - = - = - = - = - = - = - = - = - = - = - - - -# mtable - = mtable /mtd - = mtable /mtd - = - = - = - = - = - = - = - = - = - = - = - = - = - = -# = - = - = - = - = - = - = - = - = - = - - - -# mtd - = mtd /mtd - = mtd /mtd - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = - - -# mtext - = mtext /mtext - = mtext /mtext - = - = - = - = - = - = - = - = - = - = - - - -# mtr - = mtr /mtr - = - = - = - = - = - = - = - = - = - = - = - = - = - - -# munder - = munder /munder - = - = - = - = - = - = - = - = - = - = - = - = - = - - -# munderover - = munderover /munderover - = - = - = - = - = - = - = - = - = - = - = - = - - -# semantics - = semantics /semantics - = - = - = - = - = - = - = - = - - -# simple - = - - - = id="" - = class="" - = style="" - = href="" - = mathbackground="" - = mathcolor="" - = selection="" - = dir="" - = actiontype="" - = display="" - = overflow="" - = decimalpoint="" - = displaystyle="" - = infixlinebreakstyle="" - = scriptlevel="" - = scriptminsize="" - = scriptsizemultiplier="" - = notation="" - = close="" - = open="" - = bevelled="" - = denomalign="" - = linethickness="" - = numalign="" - = src="" - = valign="" - = width="" - = mathsize="" - = mathvariant="" - = rowalign="" - = subscriptshift="" - = superscriptshift="" - = maxsize="" - = minsize="" - = movablelimits="" - = rspace="" - = separators="" - = stretchy="" - = symmetric="" - = accent="" - = align="" - = depth="" - = height="" - = lspace="" - = voffset="" - = lquote="" - = rquote="" - = linebreak="" - = alignmentscope="" - = columnlines="" - = columnspacing="" - = columnwidth="" - = equalrows="" - = qeualcolumns="" - = frame="" - = framespacing="" - = minlabelspacing="" - = rowlines="" - = rowspacing="" - = side="" - = rowspan="" - = columnalign="" - = groupalign="" - = accentunder="" - = definitionURL="" - = encoding="" - = name="" - = alt="" - = columnspan="" diff --git a/mathml/test.py b/mathml/test.py deleted file mode 100644 index a2f5e9a..0000000 --- a/mathml/test.py +++ /dev/null @@ -1,33 +0,0 @@ -# Copyright 2017 Google Inc. All Rights Reserved. -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -from __future__ import print_function -import os -import re -import random -import sys - -from grammar import Grammar - -cssgrammar = Grammar() -err = cssgrammar.parse_from_file('css.txt') - -htmlgrammar = Grammar() -htmlgrammar.add_import('cssgrammar', cssgrammar) -htmlgrammar.parse_from_file('mathml.txt') - -# result_string = htmlgrammar .generate_symbol('svgelement_svg') -# just math, without svg - -result_string = htmlgrammar .generate_symbol('mathelement_math') -print('\n' + result_string) From bc64a748b6b5e1e3b8406391b1af681f4cf6d1f0 Mon Sep 17 00:00:00 2001 From: Ivan Fratric Date: Thu, 7 Jul 2022 11:12:38 +0200 Subject: [PATCH 31/50] Restore old mathml grammar as mathml3_legacy as there might be users --- mathml3_legacy/mathattrvalues.txt | 251 +++++++++++ mathml3_legacy/mathml.txt | 713 ++++++++++++++++++++++++++++++ mathml3_legacy/test.py | 33 ++ 3 files changed, 997 insertions(+) create mode 100644 mathml3_legacy/mathattrvalues.txt create mode 100644 mathml3_legacy/mathml.txt create mode 100644 mathml3_legacy/test.py diff --git a/mathml3_legacy/mathattrvalues.txt b/mathml3_legacy/mathattrvalues.txt new file mode 100644 index 0000000..66ecfe6 --- /dev/null +++ b/mathml3_legacy/mathattrvalues.txt @@ -0,0 +1,251 @@ +# Copyright 2017 Google Inc. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + = + = + + + = + = x + = + = + = + = ltr + = rtl + = toggle + = statusline + = tooltip + = input + = none + = block + = inline + = inherit + + = linebreak + = scroll + = elide + = truncate + = scale + + = x + = true + = false + = before + = after + = duplicate + = + = + = 15 + = +15 + = -5 + = -1 + = + = + = % + = + = + = % + = longdiv + = actuarial + = radical + = box + = roundedbox + = circle + = left + = right + = top + = bottom + = updiagonalstrike + = downdiagonalstrike + = verticalstrike + = horizontalstrike + = madruwb + = updiagonalnarrow + = phasorangle + + = > + = ) + = ] + = } + = < + = ( + = [ + = { + = , + = . + = ; + = ;;, + = : + = ||||, + + + = true + = false + + = left + = right + = center + + + = + = + = thin + = medium + = thick + = left + = right + = center + = http://localhost/image.png + = middle + = bottom + = baseline + = + = + = % + = px + = inherit + = + = + = % + = px + = small + = normal + = big + = normal + = bold + = italic + = bold-italic + = double-struck + = bold-fraktur + = sans-serif + = axis + = baseline + = bottom + = center + = top + = + = + = % + = px + = infinity + = + = + = true + = false + = + = + = % + = px + = true + = false + = true + = false + = true + = false + = left + = center + = right + = + = + = % + = px + = + = + = px + = % + = + = % + = px + = + = + = px + = % + = + = " + = " + = ' + = " + = " + = ' + = auto + = newline + = nobreak + = goodbreak + = badbreak + = + = px + = % + = + = + = + = + = % + = px + = + = + = px + = % + = + = true + = false + = true + = false + = none + = solid + = dashed + = + = % + = px + = + = + = px + = % + = + = none + = solid + = dashed + = + = % + = px + = + = left + = leftoverlap + = right + = rightoverlap + = + = px + = % + = + = left + = center + = right + = left + = center + = right + = true + = false + = none + = MathML-Presentation + = Mathematica + = Maple + = TeX + = ASCII + = MathMLType + = OpenMath + = content-MathML + = x + = + = % + = px + = infinity + = altvalue diff --git a/mathml3_legacy/mathml.txt b/mathml3_legacy/mathml.txt new file mode 100644 index 0000000..1aaa32a --- /dev/null +++ b/mathml3_legacy/mathml.txt @@ -0,0 +1,713 @@ +# Copyright 2017 Google Inc. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +!include ../rules/common.txt +!include mathattrvalues.txt + +!max_recursion 50 + = math /math + +# = + = + +# testing +# = math /math + + + = +# = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + + + = + = + = + = + = + = + = + = + = + = +# = +# = +# = +# = +# = +# = + + + + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + + +# maction + = maction /maction + = maction /maction + = + = + = + = + = + = + = + = + = + = + = + = + + +# menclose + = menclose /menclose + = menclose /menclose + = + = + = + = + = + = + = + = + = + = + + + +# merror + = merror /merror + = merror /merror + = + = + = + = + = + = + = + = + = + + +# mfenced + = mfenced /mfenced + = mfenced /mfenced + = + = + = + = + = + = + = + = + = + = + = + = + + +# mfrac + = mfrac mfrac /mfrac/mfrac/mfrac + = mfrac mfrac /mfrac mfrac /mfrac /mfrac + = + = + = + = + = + = + = + = + = + = + = + = + + + +# mglyph +# = mglyph /mglyph + = mimglyph //mi + = mglyph / + = + = + = + = + = + = + = + = + = + = + = + + + +# mi + = mi π/mi + = mi /mi + = mi /mi + = + = + = + = + = + = + = + = + = + = + + + +# mlabeledtr + = mlabeledtr /mlabeledtr + = + = + = + = + = + = + = + = + = + = + = + = + = + + + +# multiscripts + = mmultiscripts /mmultiscripts + = + = + = mprescripts / + = none / mprescripts / none / + = + = + = + = + = + = + = + = + = + + + +# mn + = mn /mn + = mn /mn + = mn /mn + = mn /mn + = + = + = + = + = + = + = + = + = + = + = + + +# mo + = mo /mo + = mo +/mo + = mo (/mo + = mo [/mo + = mo )/mo + = mo ]/mo + = mo ;/mo + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + + +# mover + = mover /mover + = + = + = + = + = + = + = + = + = + = + = + = + = + + +# mpadded + = mpadded /mpadded + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + + + +# mphantom + = mphantom /mphantom + = + = + = + = + = + = + = + = + + +# mroot + = mroot /mroot + = + = + = + = + = + = + = + = + = + = + = + + +# mrow + = mrow /mrow + = + = + = + = + = + = + = + = + = + = + = + = + + + +# ms + = ms /ms + = ms /ms + = ms /ms + = ms /ms + = + = + = + = + = + = + = + = + = + = + = + = + + + + +# mspace + = mspace / + = + = + = + = + = + = + = + = + = + + +# msqrt + = msqrt /msqrt + = + = + = + = + = + = + = + = + = + = + = + = + + +# mstyle + = mstyle /mstyle + = + = + = + = + = + = + = + = + = + = + = + = + = + = + + + +# msub + = msub /msub + = + = + = + = + = + = + = + = + = + = + = + = + = + + +# msubsup + = msubsup /msubsup + = + = + = + = + = + = + = + = + = + = + = + = + = + + +# msup + = msup /msup + = + = + = + = + = + = + = + = + = + = + = + = + + + +# mtable + = mtable /mtd + = mtable /mtd + = + = + = + = + = + = + = + = + = + = + = + = + = + = +# = + = + = + = + = + = + = + = + = + = + + + +# mtd + = mtd /mtd + = mtd /mtd + = + = + = + = + = + = + = + = + = + = + = + = + = + = + = + + +# mtext + = mtext /mtext + = mtext /mtext + = + = + = + = + = + = + = + = + = + = + + + +# mtr + = mtr /mtr + = + = + = + = + = + = + = + = + = + = + = + = + = + + +# munder + = munder /munder + = + = + = + = + = + = + = + = + = + = + = + = + = + + +# munderover + = munderover /munderover + = + = + = + = + = + = + = + = + = + = + = + = + + +# semantics + = semantics /semantics + = + = + = + = + = + = + = + = + + +# simple + = + + + = id="" + = class="" + = style="" + = href="" + = mathbackground="" + = mathcolor="" + = selection="" + = dir="" + = actiontype="" + = display="" + = overflow="" + = decimalpoint="" + = displaystyle="" + = infixlinebreakstyle="" + = scriptlevel="" + = scriptminsize="" + = scriptsizemultiplier="" + = notation="" + = close="" + = open="" + = bevelled="" + = denomalign="" + = linethickness="" + = numalign="" + = src="" + = valign="" + = width="" + = mathsize="" + = mathvariant="" + = rowalign="" + = subscriptshift="" + = superscriptshift="" + = maxsize="" + = minsize="" + = movablelimits="" + = rspace="" + = separators="" + = stretchy="" + = symmetric="" + = accent="" + = align="" + = depth="" + = height="" + = lspace="" + = voffset="" + = lquote="" + = rquote="" + = linebreak="" + = alignmentscope="" + = columnlines="" + = columnspacing="" + = columnwidth="" + = equalrows="" + = qeualcolumns="" + = frame="" + = framespacing="" + = minlabelspacing="" + = rowlines="" + = rowspacing="" + = side="" + = rowspan="" + = columnalign="" + = groupalign="" + = accentunder="" + = definitionURL="" + = encoding="" + = name="" + = alt="" + = columnspan="" diff --git a/mathml3_legacy/test.py b/mathml3_legacy/test.py new file mode 100644 index 0000000..a2f5e9a --- /dev/null +++ b/mathml3_legacy/test.py @@ -0,0 +1,33 @@ +# Copyright 2017 Google Inc. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import print_function +import os +import re +import random +import sys + +from grammar import Grammar + +cssgrammar = Grammar() +err = cssgrammar.parse_from_file('css.txt') + +htmlgrammar = Grammar() +htmlgrammar.add_import('cssgrammar', cssgrammar) +htmlgrammar.parse_from_file('mathml.txt') + +# result_string = htmlgrammar .generate_symbol('svgelement_svg') +# just math, without svg + +result_string = htmlgrammar .generate_symbol('mathelement_math') +print('\n' + result_string) From 9354b29cb2538a29432af0516689bcd1023a96b9 Mon Sep 17 00:00:00 2001 From: Ivan Fratric Date: Fri, 19 Aug 2022 11:23:43 -0700 Subject: [PATCH 32/50] Add toString callbacks --- grammar.py | 7 +++++++ rules/js.txt | 3 +++ 2 files changed, 10 insertions(+) diff --git a/grammar.py b/grammar.py index e81e8e6..ac89714 100755 --- a/grammar.py +++ b/grammar.py @@ -490,6 +490,8 @@ def _expand_rule(self, symbol, rule, context, context, '' ) + elif (part['tagname'] == 'any') and 'variables' in context: + expanded = self._get_any_var(context); else: try: expanded = self._generate( @@ -1024,3 +1026,8 @@ def _get_variable_setters(self, var_name, var_type): for parent_type in self._inheritance[var_type]: ret += self._get_variable_setters(var_name, parent_type) return ret + + def _get_any_var(self, context): + var_type = random.choice(list(context['variables'].keys())) + return random.choice(context['variables'][var_type]) + diff --git a/rules/js.txt b/rules/js.txt index 562d7dc..7fb2ace 100644 --- a/rules/js.txt +++ b/rules/js.txt @@ -6051,6 +6051,9 @@ document.all[%document.all.length].appendChild(); = .style; = .style; +.prop = { toString: }; +.toString = ; + freememory(); freememory(); freememory(); From bc56bd0e458d5f5e4e99e7fa47b6bf4c7fa00ca0 Mon Sep 17 00:00:00 2001 From: Ivan Fratric Date: Fri, 19 Aug 2022 14:34:47 -0700 Subject: [PATCH 33/50] add setTimeout --- rules/js.txt | 2 ++ rules/jshelpers.txt | 3 +++ 2 files changed, 5 insertions(+) diff --git a/rules/js.txt b/rules/js.txt index 7fb2ace..3be16ed 100644 --- a/rules/js.txt +++ b/rules/js.txt @@ -6054,6 +6054,8 @@ document.all[%document.all.length].appendChild(); .prop = { toString: }; .toString = ; +setTimeout(, ); + freememory(); freememory(); freememory(); diff --git a/rules/jshelpers.txt b/rules/jshelpers.txt index 9a270e6..a0e8cf5 100644 --- a/rules/jshelpers.txt +++ b/rules/jshelpers.txt @@ -12,6 +12,9 @@ # limitations under the License. + = 0 + = 100 + = "x" = "foo" = "data:text/html,foo" From 2c56779d228205a2f634ae8a3af3bcf677f7063a Mon Sep 17 00:00:00 2001 From: Maddie Stone Date: Fri, 15 Jul 2022 16:08:35 -0700 Subject: [PATCH 34/50] Added FontFace to grammar to find CVE-2021-30889 --- rules/js.txt | 65 ++++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 60 insertions(+), 5 deletions(-) diff --git a/rules/js.txt b/rules/js.txt index 3be16ed..f747f25 100644 --- a/rules/js.txt +++ b/rules/js.txt @@ -12,7 +12,7 @@ # limitations under the License. - = + = !lineguard try { } catch(e) { } @@ -1097,6 +1097,8 @@ #HTMLAreaElement !extends HTMLAreaElement Element = ; + = .accessKey; +.accessKey = ""; = .alt; .alt = ""; = .coords; @@ -2222,12 +2224,21 @@ .onloadingdone = ; = .onloadingerror; .onloadingerror = ; - = .load(); - = .load(,); - = .check(); - = .check(,); = .ready; = .status; +.add(); +#TODO: check + = .check(); + = .check(,); +.clear(); +.delete(); +#TODO: entries, forEach, has, keys, load, values + = .load(); + = .load(,); + = new FontFaceSet(); + = new FontFaceSet(); + = new FontFaceSet([, , ]); + = new FontFaceSet(); #CSS .registerProperty(); @@ -2255,12 +2266,16 @@ #FontFace = .family; .family = ; +.family = ""; = .style; .style = ""; +.style = ; = .weight; .weight = ; = .stretch; .stretch = ; + = .display; +.display = ; = .unicodeRange; .unicodeRange = ; = .variant; @@ -2270,6 +2285,45 @@ = .status; = .load(); = .loaded; + = "url('https://fonts.gstatic.com/s/roboto/v29/KFOmCnqEu92Fr1Mu72xKOzY.woff2')format('woff2')"; + = "url('')"; + = "url('')format('')"; + = "local(Arial)"; + = "local('')"; + = ""; + = "url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff')" + + = .src; +.src = ; + = new FontFace(, , {}); + = new FontFace(, , {}); + = new FontFace(, , {, , }); + +#FontFaceDescriptor + = "ascent-override: normal"; + = "ascent-override: %"; + = "descent-override: normal"; + = "descent-override: %"; + = "font-feature-settings: ''"; + = "line-gap-override: normal"; + = "line-gap-override: %"; + = "font-stretch: "; + = "font-stretch: "; + = "font-stretch: "; + = "font-style: normal"; + = "font-style: italic"; + = "font-style: oblique"; + = "font-style: oblique deg"; + = "font-style: oblique deg deg"; + + + = 'ultra-condensed'; + = 'extra-condensed'; + = 'normal'; + = '%'; + = 'semi-expanded'; + = 'ultra-expanded'; + #CSSViewportRule !extends CSSViewportRule CSSRule @@ -2426,6 +2480,7 @@ !extends FontFaceSetLoadEvent Event = ; = .fontfaces; + = new Array(); #Attr From a5938103f787d167dafb707a461173c38f8a89e9 Mon Sep 17 00:00:00 2001 From: Maddie Stone Date: Fri, 15 Jul 2022 16:09:17 -0700 Subject: [PATCH 35/50] Added misc CSS properties --- rules/css.txt | 6 ++- rules/cssproperties.txt | 110 +++++++++++++++++++++++++++++++++++++++- 2 files changed, 114 insertions(+), 2 deletions(-) diff --git a/rules/css.txt b/rules/css.txt index 28d34d5..2511b01 100644 --- a/rules/css.txt +++ b/rules/css.txt @@ -389,6 +389,7 @@ = font-variant-ligatures = font-vendor = font-weight + = gap = grid = grid-area = grid-auto-columns @@ -884,6 +885,7 @@ = = = + = = = = @@ -904,6 +906,7 @@ = = = + = = = = @@ -1379,6 +1382,7 @@ = font-variant-ligatures: = font-vendor: = font-weight: + = gap: = grid: = grid-area: = grid-auto-columns: @@ -1582,5 +1586,5 @@ = z-index: = zoom: -!include cssproperties.txt +!include cssproperties.txt diff --git a/rules/cssproperties.txt b/rules/cssproperties.txt index f5ba556..077f599 100644 --- a/rules/cssproperties.txt +++ b/rules/cssproperties.txt @@ -12,6 +12,69 @@ # limitations under the License. + = + = + = + = + = + + = url() + = linear-gradient() + = linear-gradient(to right top, ) + = radial-gradient() + = radial-gradient(farthest-side at px px, ) + = repeating-linear-gradient() + = repeating-linear-gradient(to bottom, ) + = repeating-linear-gradient(to top right, px) + = repeating-radial-gradient() + = repeating-radial-gradient(circle at center, ) + = repeating-radial-gradient(circle at center, px) + = conic-gradient() + = conic-gradient(from deg, ) + = conic-gradient(from .turn, ) + + = , + = deg, , + = , , , , + = , , , %, + = , , %, %, + = .turn, , %, + = % %, % % + + = image( ) + = image() + = image('') + = image(ltr ) + = image(rtl '' ) + = image() + = image(ltr ) + + = + = xywh=,,, + = xywh=pixel:,,, + = xywh=percent:,,, + + = cross-fade + = -webkit-cross-fade + + = (, ) + = (, , %) + = ( %, ) + = ( %, %) + = ( %, %, %) + + = -webkit-image-set + = image-set + + = () + = ( x type("")) + = ( dpcm) + = ( dpi type("image/jpeg")) + = ( x, x type("")) + = ( x type("image/avif"), dpi type("image/jpeg")) + = ( x type("image/jpeg"), dpcm type(""), dpi) + = ( x, x, x, x) + = center = 'frac' 1, 'dlig' 1 @@ -388,6 +451,7 @@ = normal = after-white-space + = inherit = @@ -451,6 +515,7 @@ = copy = url() + = = none = border-box @@ -515,6 +580,7 @@ = url() = inset(px px px px) + = = @@ -851,6 +917,7 @@ = = url() + = = border-box = content-box @@ -999,9 +1066,19 @@ = url() stretch = url() fill = url() round + = + = + = + = + = + = = = px + = % + = rem + = px + = % % % = inherit = @@ -1016,18 +1093,31 @@ = inherit = repeat repeat = initial + = space + = space round + = repeat space = fill + = + = = % = + = fill + = % % % = fill = url() + = = = px = inherit = + = auto + = % + = rem + = em + = % em em % = px solid = px dashed @@ -1894,6 +1984,16 @@ = unset = px + = px px + = % % + = px + = % + = px px px + = none + = normal + = + + = px/px px = px px/px = px px/px px @@ -2209,6 +2309,7 @@ = none = from-image + = none = pixelated = -webkit-optimize-contrast @@ -2342,6 +2443,11 @@ = before-white-space = after-white-space + = auto + = loose + = normal + = strict + = anywhere = px = @@ -2360,7 +2466,8 @@ = inside = inherit - = url() + = url + = = none = inside @@ -3108,6 +3215,7 @@ = polygon( , px px, px ) = polygon( px, px, px px) content-box = polygon(nonzero, px px) + = = px = px From 64e47e2da21a65d635eeb95b4729fe10b80d1df8 Mon Sep 17 00:00:00 2001 From: Maddie Stone Date: Mon, 22 Aug 2022 09:04:58 -0700 Subject: [PATCH 36/50] Fix escaping of quotes --- rules/cssproperties.txt | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/rules/cssproperties.txt b/rules/cssproperties.txt index 077f599..53427ca 100644 --- a/rules/cssproperties.txt +++ b/rules/cssproperties.txt @@ -67,12 +67,12 @@ = image-set = () - = ( x type("")) + = ( x type(\"\")) = ( dpcm) - = ( dpi type("image/jpeg")) - = ( x, x type("")) - = ( x type("image/avif"), dpi type("image/jpeg")) - = ( x type("image/jpeg"), dpcm type(""), dpi) + = ( dpi type(\"image/jpeg\")) + = ( x, x type(\"\")) + = ( x type(\"image/avif\"), dpi type(\"image/jpeg\")) + = ( x type(\"image/jpeg\"), dpcm type(\"\"), dpi) = ( x, x, x, x) = center From b1100dd2678ff100207c5533668471afc0fb8cdc Mon Sep 17 00:00:00 2001 From: Maddie Stone Date: Thu, 25 Aug 2022 17:11:06 -0700 Subject: [PATCH 37/50] Moved FontFaceDescriptors to CSS properties and added @font-face rule to CSS --- rules/common.txt | 13 +++++- rules/cssproperties.txt | 92 +++++++++++++++++++++++++++++++++-------- rules/js.txt | 42 +++---------------- rules/jshelpers.txt | 14 +++++-- 4 files changed, 102 insertions(+), 59 deletions(-) diff --git a/rules/common.txt b/rules/common.txt index 97718b4..34e78e4 100644 --- a/rules/common.txt +++ b/rules/common.txt @@ -312,6 +312,12 @@ = none = semantics + + = + = + = + = data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7 + = x = data:image/gif;base64,R0lGODlhIAAgAPIBAGbMzP///wAAADOZZpn/zAAAAAAAAAAAACH5BAAAAAAALAAAAAAgACAAAAOLGLrc/k7ISau9S5DNu/8fICgaYJ5oqqbDGJRrLAMtScw468J5Xr+3nm8XFM5+PGMMWYwxcMyZ40iULQaDhSzqDGBNisGyuhUDrmNb72pWcaXhtpsM/27pVi8UX96rcQpDf3V+QD12d4NKK2+Lc4qOKI2RJ5OUNHyXSDRYnZ6foKAuLxelphMQqaoPCQA7 @@ -321,4 +327,9 @@ = x = data:audio/mp3;base64,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 - + = url('https://fonts.gstatic.com/s/roboto/v29/KFOmCnqEu92Fr1Mu72xKOzY.woff2')format('woff2') + = url('') + = local(Arial) + = local('') + = + = url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff') \ No newline at end of file diff --git a/rules/cssproperties.txt b/rules/cssproperties.txt index 53427ca..cf19dfc 100644 --- a/rules/cssproperties.txt +++ b/rules/cssproperties.txt @@ -1893,6 +1893,7 @@ = HiraMinProN-W = 'hiragino mincho pron' = 'times' + = '' = 'smcp' = 'frac' , 'dlig' @@ -1900,6 +1901,7 @@ = 'smcp' = 'liga' = 'liga' + = '' = normal = none @@ -1938,27 +1940,40 @@ = % = none + = ex-height + = cap-height + = ch-width + = ic-width + = ic-height + = - = ultra-condensed - = extra-condensed - = condensed - = semi-condensed - = normal - = semi-expanded - = expanded - = extra-expanded - = ultra-expanded + = ultra-condensed + = extra-condensed + = condensed + = semi-condensed + = normal + = semi-expanded + = expanded + = extra-expanded + = ultra-expanded + = % + = + = = normal = italic = oblique = none = inherit + = oblique deg + = oblique deg deg +#TODO - more font-variant values to add = small-caps = normal = all + = none = small-caps garbage = small-caps auto @@ -1974,15 +1989,18 @@ = any - = bolder - = lighter - = - = bold - = normal - = inherit - = - = unset - = px + = bolder + = lighter + = + = bold + = normal + = inherit + = + = unset + = px + = + = + = px px = % % @@ -3772,3 +3790,41 @@ = auto = reset +# @font-face specific descriptor properties + = normal + = % + + = normal + = % + + = auto + = block + = swap + = fallback + = optional + + = normal + = % + + = % + + = + = , + + = + = + + = format('woff') + = format('woff2') + = format('truetype') + = format('opentype') + = format('') + + = + = + + = U+ + = U+ + = U+?? + = U+00125-001FF + diff --git a/rules/js.txt b/rules/js.txt index f747f25..d2da311 100644 --- a/rules/js.txt +++ b/rules/js.txt @@ -12,7 +12,7 @@ # limitations under the License. - = + = !lineguard try { } catch(e) { } @@ -2285,45 +2285,15 @@ = .status; = .load(); = .loaded; - = "url('https://fonts.gstatic.com/s/roboto/v29/KFOmCnqEu92Fr1Mu72xKOzY.woff2')format('woff2')"; - = "url('')"; - = "url('')format('')"; - = "local(Arial)"; - = "local('')"; - = ""; - = "url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff')" + + = "" + = "", = .src; .src = ; = new FontFace(, , {}); - = new FontFace(, , {}); - = new FontFace(, , {, , }); - -#FontFaceDescriptor - = "ascent-override: normal"; - = "ascent-override: %"; - = "descent-override: normal"; - = "descent-override: %"; - = "font-feature-settings: ''"; - = "line-gap-override: normal"; - = "line-gap-override: %"; - = "font-stretch: "; - = "font-stretch: "; - = "font-stretch: "; - = "font-style: normal"; - = "font-style: italic"; - = "font-style: oblique"; - = "font-style: oblique deg"; - = "font-style: oblique deg deg"; - - - = 'ultra-condensed'; - = 'extra-condensed'; - = 'normal'; - = '%'; - = 'semi-expanded'; - = 'ultra-expanded'; - + = new FontFace(, , {}); + = new FontFace(, , {, , }); #CSSViewportRule !extends CSSViewportRule CSSRule diff --git a/rules/jshelpers.txt b/rules/jshelpers.txt index a0e8cf5..af4413e 100644 --- a/rules/jshelpers.txt +++ b/rules/jshelpers.txt @@ -2225,10 +2225,16 @@ !include svgattrvalues.txt !include mathmlattrvalues.txt - = - = - = - = data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7 + = "ascent-override": "" + = "descent-override": "" + = "font-display": "" + = "font-family": "" + = "font-stretch": "" + = "font-style": "" + = "font-weight": "" + = "line-gap-override": "" + = "size-adjust": "" + = "unicode-range": "" !include cssproperties.txt From a0c928f49f1055af66fe64db908057162a5ba95e Mon Sep 17 00:00:00 2001 From: Maddie Stone Date: Thu, 25 Aug 2022 17:11:06 -0700 Subject: [PATCH 38/50] Moved FontFaceDescriptors to CSS properties and added @font-face rule to CSS --- rules/css.txt | 28 ++++++++++++++++++++++------ rules/js.txt | 3 +-- 2 files changed, 23 insertions(+), 8 deletions(-) diff --git a/rules/css.txt b/rules/css.txt index 2511b01..f444b6c 100644 --- a/rules/css.txt +++ b/rules/css.txt @@ -14,11 +14,6 @@ !include common.txt - = - = - = - = data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7 - = = = @@ -76,8 +71,29 @@ = :root = :empty +#at rules + = @font-face + #todo all rules - = { } + = { } + = { } + + = ; + = ; ; ; + = ; ; ; ; ; ; + + = ascent-override: + = descent-override: + = font-display: + = font-family: + = font-stretch: + = font-style: + = font-weight: + = line-gap-override: + = size-adjust: + = src: + = unicode-range: + = font-variant: = = diff --git a/rules/js.txt b/rules/js.txt index d2da311..852c7b8 100644 --- a/rules/js.txt +++ b/rules/js.txt @@ -2285,6 +2285,7 @@ = .status; = .load(); = .loaded; + = new Array(); = "" = "", @@ -2450,8 +2451,6 @@ !extends FontFaceSetLoadEvent Event = ; = .fontfaces; - = new Array(); - #Attr = .namespaceURI; From 5cfa149b20313161f96aad41ebaf42fe69658273 Mon Sep 17 00:00:00 2001 From: Maddie Stone Date: Fri, 26 Aug 2022 06:59:55 -0700 Subject: [PATCH 39/50] Js now uses font-family and font-src from cssproperties --- rules/js.txt | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/rules/js.txt b/rules/js.txt index 852c7b8..719d410 100644 --- a/rules/js.txt +++ b/rules/js.txt @@ -2265,8 +2265,7 @@ #FontFace = .family; -.family = ; -.family = ""; +.family = ""; = .style; .style = ""; .style = ; @@ -2287,14 +2286,11 @@ = .loaded; = new Array(); - = "" - = "", - = .src; -.src = ; - = new FontFace(, , {}); - = new FontFace(, , {}); - = new FontFace(, , {, , }); +.src = ""; + = new FontFace("", "", {}); + = new FontFace("", "", {}); + = new FontFace("", "", {, , }); #CSSViewportRule !extends CSSViewportRule CSSRule From e2218e1f669991251121c17b9f260d80f9a9c106 Mon Sep 17 00:00:00 2001 From: Maddie Stone Date: Wed, 31 Aug 2022 11:33:55 -0700 Subject: [PATCH 40/50] Two mathml rules were causing errors during string generation due to too large min/max values. Removed those rules --- rules/mathml.txt | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/rules/mathml.txt b/rules/mathml.txt index c6c991c..0840aad 100644 --- a/rules/mathml.txt +++ b/rules/mathml.txt @@ -50,9 +50,7 @@ = # Interesting content for token elements is generally a single letter or symbol. - = - = - = + = = # Elements behaving more or less like an . From 35ab8f65b483ac78d520f645f116a60fb0885408 Mon Sep 17 00:00:00 2001 From: Edward <14011954+0xedward@users.noreply.github.com> Date: Tue, 6 Sep 2022 00:04:18 -0400 Subject: [PATCH 41/50] Add `--template` option to supply custom templates --- README.md | 4 ++++ generator.py | 11 ++++++----- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 4105dec..4a54a84 100644 --- a/README.md +++ b/README.md @@ -27,6 +27,10 @@ To generate a single .html sample run: `python generator.py --file ` +To generate a single .html sample run using a template you wrote: + +`python generator.py --file --template ` + To generate multiple samples with a single call run: `python generator.py --output_dir --no_of_files ` diff --git a/generator.py b/generator.py index 948f472..489721c 100755 --- a/generator.py +++ b/generator.py @@ -22,6 +22,7 @@ import re import random import argparse +from pathlib import Path from grammar import Grammar from svg_tags import _SVG_TYPES @@ -201,19 +202,19 @@ def get_argument_parser(): parser.add_argument('-n', '--no_of_files', type=int, help='number of files to be generated') + parser.add_argument('-t', '--template', type=Path, default=(Path(__file__).parent).joinpath('template.html'), + help='template file you want to use') return parser def main(): - fuzzer_dir = os.path.dirname(__file__) - - with open(os.path.join(fuzzer_dir, "template.html"), "r") as f: - template = f.read() - parser = get_argument_parser() args = parser.parse_args() + with args.template.open("r") as f: + template = f.read() + if args.file: generate_samples(template, [args.file]) From ccfa67040f9016b881309ce555ac49d33a30491d Mon Sep 17 00:00:00 2001 From: Chris Bookholt Date: Fri, 3 Feb 2023 09:43:54 -0800 Subject: [PATCH 42/50] Add a gitignore file --- .gitignore | 138 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 138 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..fba9942 --- /dev/null +++ b/.gitignore @@ -0,0 +1,138 @@ +# VIM +*.swp + +# vscode +.*.code-workspace + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# Zip +*.zip From 8003439928a1e6df1b0309cf6f417cad2eb6ef74 Mon Sep 17 00:00:00 2001 From: Chris Bookholt Date: Fri, 3 Feb 2023 09:51:48 -0800 Subject: [PATCH 43/50] Rudimentary WebGPU support --- webgpu/__init__.py | 0 webgpu/generator.py | 153 +++++++++++++++++++++ webgpu/template.html | 65 +++++++++ webgpu/webgpu.txt | 312 +++++++++++++++++++++++++++++++++++++++++++ webgpu/wgsl.txt | 0 5 files changed, 530 insertions(+) create mode 100644 webgpu/__init__.py create mode 100644 webgpu/generator.py create mode 100644 webgpu/template.html create mode 100644 webgpu/webgpu.txt create mode 100644 webgpu/wgsl.txt diff --git a/webgpu/__init__.py b/webgpu/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/webgpu/generator.py b/webgpu/generator.py new file mode 100644 index 0000000..fd14ab6 --- /dev/null +++ b/webgpu/generator.py @@ -0,0 +1,153 @@ +# Domato - generator script for WebGPU +# ------------------------------- +# +# Written and maintained by Chrome Security Team +# +# Copyright 2022 Google Inc. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from __future__ import print_function +import os +import re +import random +import sys + +parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)) +sys.path.append(parent_dir) +from grammar import Grammar + +_N_MAIN_LINES = 100 +_N_EVENTHANDLER_LINES = 1 + +def generate_lines(grammar, num_lines): + output = '' + output += grammar._generate_code(num_lines) + + return output + +def GenerateNewSample(template, jsgrammar, wgslgrammar): + """Parses grammar rules from string. + + Args: + template: A template string. + jsgrammar: Grammar for generating JS code. + wgslgrammar: Grammar for generating WGSL shader code. + + Returns: + A string containing sample data. + """ + + result = template + handlers = False + + # WebGPU JS + while '' in result: + numlines = _N_MAIN_LINES + if handlers: + numlines = _N_EVENTHANDLER_LINES + else: + handlers = True + result = result.replace( + '', + generate_lines(jsgrammar, numlines), + 1 + ) + + return result + + +def generate_samples(grammar_dir, outfiles): + """Generates a set of samples and writes them to the output files. + + Args: + grammar_dir: directory to load grammar files from. + outfiles: A list of output filenames. + """ + + f = open(os.path.join(grammar_dir, 'template.html')) + template = f.read() + f.close() + + jsgrammar = Grammar() + err = jsgrammar.parse_from_file(os.path.join(grammar_dir, 'webgpu.txt')) + if err > 0: + print('There were errors parsing WebGPU JS grammar') + return + + wgslgrammar = Grammar() + err = jsgrammar.parse_from_file(os.path.join(grammar_dir, 'wgsl.txt')) + if err > 0: + print('There were errors parsing WGSL grammar') + return + + for outfile in outfiles: + result = GenerateNewSample(template, jsgrammar, wgslgrammar) + + if result is not None: + print('Writing a sample to ' + outfile) + try: + f = open(outfile, 'w') + f.write(result) + f.close() + except IOError: + print('Error writing to output') + + +def get_option(option_name): + for i in range(len(sys.argv)): + if (sys.argv[i] == option_name) and ((i + 1) < len(sys.argv)): + return sys.argv[i + 1] + elif sys.argv[i].startswith(option_name + '='): + return sys.argv[i][len(option_name) + 1:] + return None + + +def main(): + fuzzer_dir = os.path.dirname(__file__) + + multiple_samples = False + + for a in sys.argv: + if a.startswith('--output_dir='): + multiple_samples = True + if '--output_dir' in sys.argv: + multiple_samples = True + + if multiple_samples: + out_dir = get_option('--output_dir') + nsamples = int(get_option('--no_of_files')) + print('Output directory: ' + out_dir) + print('Number of samples: ' + str(nsamples)) + + if not os.path.exists(out_dir): + os.mkdir(out_dir) + + outfiles = [] + for i in range(nsamples): + outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(5) + '.html')) + + generate_samples(fuzzer_dir, outfiles) + + elif len(sys.argv) > 1: + outfile = sys.argv[1] + generate_samples(fuzzer_dir, [outfile]) + + else: + print('Arguments missing') + print("Usage:") + print("\tpython generator.py ") + print("\tpython generator.py --output_dir --no_of_files ") + +if __name__ == '__main__': + main() diff --git a/webgpu/template.html b/webgpu/template.html new file mode 100644 index 0000000..ffb0c09 --- /dev/null +++ b/webgpu/template.html @@ -0,0 +1,65 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/webgpu/webgpu.txt b/webgpu/webgpu.txt new file mode 100644 index 0000000..846fbb4 --- /dev/null +++ b/webgpu/webgpu.txt @@ -0,0 +1,312 @@ + + = true + = false + + = 0 + = 1 + = 2 + = 4 + = 8 + = 16 + = 32 + = 64 + = 128 + + = 0 + = 1 + = 2 + = 4 + = 8 + = 16 + = 32 + = 64 + = 128 + + = 0x7fffff00 + = 0x64 + = 0x3e8 + = 0x4141 + = 0xefff + = 0xaa + = 0xaf43 + = -0x5a + = true + = false + + = 536870911 + = 536870912 + = 1073741823 + = 1073741824 + = 2147483647 + = 2147483648 + = 4294967295 + = 4294967296 + + = 100 + = 200 + = 500 + = 1000 + = 10000 + + = + = + + = + + + = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + = 17 + = 65 + = 257 + = 1025 + = 4097 + = 65537 + = String.fromCharCode() + = String.fromCharCode().repeat() + + = + = 256 + = 512 + = 1024 + = 4096 + = 16384 + = 65536 + + = + = + = + = + = + + = GPUBufferUsage.MAP_READ + = GPUBufferUsage.MAP_WRITE + = GPUBufferUsage.COPY_SRC + = GPUBufferUsage.COPY_DST + = GPUBufferUsage.STORAGE + = GPUBufferUsage.INDEX + = GPUBufferUsage.INDIRECT + = GPUBufferUsage.UNIFORM + = GPUBufferUsage.VERTEX + = GPUBufferUsage.QUERY_RESOLVE + = 0xffff + = 0x + = 0x003 + = 0x005 + = 0x006 + = 0x007 + = 0x1 + = 0x2 + = 0x3 + = 0x4 + = 0x5 + = 0x6 + = 0x7 + = 0x9 + = 0x11 + = 0x12 + = 0x081 + + = GPUMapMode.READ + = GPUMapMode.WRITE + + = 0 + = 1 + = 2 + + = GPUShaderStage.COMPUTE + = GPUShaderStage.FRAGMENT + = GPUShaderStage.VERTEX + + = "uniform" + = "storage" + = "read-only-storage" + = "filtering" + = "non-filtering" + = "comparison" + = "float" + = "unfilterable-float" + = "depth" + = "sint" + = "uint" + = "write-only" + + = + = + = + = + + = canvas0 + = canvas1 + = canvas2 + = canvas3 + = canvas4 + + = "2d" + = "webgl" + = "webgl2" + = "bitmaprenderer" + + = matrixA + = matrixB + = matrixC + + = "1d" + = "2d" + = "3d" + + = "r8unorm" + = "r8snorm" + = "r8uint" + = "r8sint" + = "r16uint" + = "r16sint" + = "r16float" + = "rg8unorm" + = "rg8snorm" + = "rg8uint" + = "rg8sint" + = "r32uint" + = "r32sint" + = "r32float" + = "rg16uint" + = "rg16sint" + = "rg16float" + = "rgba8unorm" + = "rgba8unorm-srgb" + = "rgba8snorm" + = "rgba8uint" + = "rgba8sint" + = "bgra8unorm" + = "bgra8unorm-srgb" + = "rgb9e5ufloat" + = "rgb10a2unorm" + = "rg11b10ufloat" + = "rg32uint" + = "rg32sint" + = "rg32float" + = "rgba16uint" + = "rgba16sint" + = "rgba16float" + = "rgba32uint" + = "rgba32sint" + = "rgba32float" + = "stencil8" + = "depth16unorm" + = "depth24plus" + = "depth24plus-stencil8" + = "depth32float" + = "depth32float-stencil8" + = "bc1-rgba-unorm" + = "bc1-rgba-unorm-srgb" + = "bc2-rgba-unorm" + = "bc2-rgba-unorm-srgb" + = "bc3-rgba-unorm" + = "bc3-rgba-unorm-srgb" + = "bc4-r-unorm" + = "bc4-r-snorm" + = "bc5-rg-unorm" + = "bc5-rg-snorm" + = "bc6h-rgb-ufloat" + = "bc6h-rgb-float" + = "bc7-rgba-unorm" + = "bc7-rgba-unorm-srgb" + = "etc2-rgb8unorm" + = "etc2-rgb8unorm-srgb" + = "etc2-rgb8a1unorm" + = "etc2-rgb8a1unorm-srgb" + = "etc2-rgba8unorm" + = "etc2-rgba8unorm-srgb" + = "eac-r11unorm" + = "eac-r11snorm" + = "eac-rg11unorm" + = "eac-rg11snorm" + = "astc-4x4-unorm" + = "astc-4x4-unorm-srgb" + = "astc-5x4-unorm" + = "astc-5x4-unorm-srgb" + = "astc-5x5-unorm" + = "astc-5x5-unorm-srgb" + = "astc-6x5-unorm" + = "astc-6x5-unorm-srgb" + = "astc-6x6-unorm" + = "astc-6x6-unorm-srgb" + = "astc-8x5-unorm" + = "astc-8x5-unorm-srgb" + = "astc-8x6-unorm" + = "astc-8x6-unorm-srgb" + = "astc-8x8-unorm" + = "astc-8x8-unorm-srgb" + = "astc-10x5-unorm" + = "astc-10x5-unorm-srgb" + = "astc-10x6-unorm" + = "astc-10x6-unorm-srgb" + = "astc-10x8-unorm" + = "astc-10x8-unorm-srgb" + = "astc-10x10-unorm" + = "astc-10x10-unorm-srgb", + = "astc-12x10-unorm" + = "astc-12x10-unorm-srgb" + = "astc-12x12-unorm" + = "astc-12x12-unorm-srgb" + + = "out-of-memory" + = "validation" + + = + +!include ../rules/common.txt +#include ../canvas/canvas.txt + +!lineguard try { } catch(e) { } +!varformat fuzzvar%05d +!begin lines +setTimeout(function(){location.reload();},); + = await navigator.gpu.requestAdapter(); + = await .requestDevice(); + = .queue; + = .createShaderModule({code: wgsl_shader_src}); + = .createBuffer({mappedAtCreation: , size: , usage: GPUBufferUsage.STORAGE}); + = .createBuffer({mappedAtCreation: , size: , usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC}); + = .createBuffer({mappedAtCreation: , size: , usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); + = ; + = ; + = ; +# = .createBuffer({mappedAtCreation: , size: , usage: }); + = .getMappedRange().fill(0x41); + = .getMappedRange(); + = new Uint8Array(.getMappedRange()); + = Float32Array(); + = Float32Array().set(); + = Uint8Array(); + = Uint8Array().set(); +for (var i = 0; i ; i++) {console.log([i]);} +for (var i = 0; i ; i++) {console.log([i]);} +.unmap(); +.map(); +.mapAsync(); +# = .createBindGroupLayout({entries: [{binding: 0, visibility: , buffer: {type: }}, {binding: 1, visibility: , buffer: {type: }}, {binding: 2, visibility: , buffer: {type: }}]}); + = .createBindGroupLayout({entries: [{binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: {type: "storage"}}, {binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: {type: "storage"}}, {binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: {type: "storage"}}]}); +# = .createBindGroup({layout: , entries: [{binding: 0, resource: {buffer: }}, {binding: 1, resource: {buffer: }}, {binding: 2, resource: {buffer: }}]}); +activeBuffer = .createBuffer({size: , usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC}); + = .createBindGroup({layout: , entries: [{binding: 0, resource: {buffer: }}, {binding: 1, resource: {buffer: }}, {binding: 2, resource: {buffer: activeBuffer}}]}); + = .createComputePipeline({layout: .createPipelineLayout({bindGroupLayouts: []}), compute: {module: , entryPoint: "main"}}); + = .createCommandEncoder(); + = .beginComputePass(); +.setPipeline(); +.setBindGroup(, ) + = Math.ceil([] / ); +.dispatchWorkgroups(, ); +.end(); +.copyBufferToBuffer(, , , , ); + = .finish(); +.submit([]); + = .getContext(); +.configure({device: , format: , usage: }) +.transferControlToOffscreen(); +.pushErrorScope(); +.popErrorScope(); +.pushErrorScope(); +.popErrorScope().then().catch(e => {}); + = .getCurrentTexture(); + = .createView(); +.copyTextureToBuffer({texture: }, {buffer: , bytesPerRow: .width}, {width: , height: , depthOrArrayLayers: 1}); +for (var i = 0; i ; i++) {console.log([i]);} + = new OffscreenCanvas(original_image.width, original_image.height); +!end lines diff --git a/webgpu/wgsl.txt b/webgpu/wgsl.txt new file mode 100644 index 0000000..e69de29 From 9f6222f95355ee93904915a5619f50dc64756068 Mon Sep 17 00:00:00 2001 From: Chris Bookholt Date: Mon, 6 Feb 2023 13:59:19 -0800 Subject: [PATCH 44/50] Removed somome ignores that seem unlikely to be necessary --- .gitignore | 54 ------------------------------------------------------ 1 file changed, 54 deletions(-) diff --git a/.gitignore b/.gitignore index fba9942..d6f1221 100644 --- a/.gitignore +++ b/.gitignore @@ -9,9 +9,6 @@ __pycache__/ *.py[cod] *$py.class -# C extensions -*.so - # Distribution / packaging .Python build/ @@ -57,32 +54,6 @@ coverage.xml .hypothesis/ .pytest_cache/ -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py -db.sqlite3 -db.sqlite3-journal - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ - -# PyBuilder -target/ - -# Jupyter Notebook -.ipynb_checkpoints - # IPython profile_default/ ipython_config.py @@ -100,13 +71,6 @@ ipython_config.py # PEP 582; used by e.g. github.com/David-OConnor/pyflow __pypackages__/ -# Celery stuff -celerybeat-schedule -celerybeat.pid - -# SageMath parsed files -*.sage.py - # Environments .env .venv @@ -116,23 +80,5 @@ ENV/ env.bak/ venv.bak/ -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ -.dmypy.json -dmypy.json - -# Pyre type checker -.pyre/ - # Zip *.zip From 2e73f9fb719024f17de0146192867b4177b48d70 Mon Sep 17 00:00:00 2001 From: Chris Bookholt Date: Mon, 6 Feb 2023 14:00:05 -0800 Subject: [PATCH 45/50] ignore .DS_Store --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index d6f1221..87ac4a0 100644 --- a/.gitignore +++ b/.gitignore @@ -82,3 +82,6 @@ venv.bak/ # Zip *.zip + +# Mac +.DS_Store \ No newline at end of file From 2db538799e2909b94a7921277179fe09e38dc8bc Mon Sep 17 00:00:00 2001 From: Sam Atkins Date: Sat, 27 Jul 2024 13:50:02 +0100 Subject: [PATCH 46/50] Fix typo in definition of HTMLTimeElement --- rules/html.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rules/html.txt b/rules/html.txt index e890270..ab8ee87 100644 --- a/rules/html.txt +++ b/rules/html.txt @@ -1082,7 +1082,7 @@ = tfoot /tfoot = th /th = thead /thead - = time /tt + = time /time = title /title = tr /tr = track /track From 7664c6f9b81e319ede6d9f998fb35d27091fd4c1 Mon Sep 17 00:00:00 2001 From: Paul Semel Date: Thu, 29 Aug 2024 14:14:12 +0000 Subject: [PATCH 47/50] Handle recursive imports/includes from different directories --- grammar.py | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/grammar.py b/grammar.py index ac89714..c03d74f 100755 --- a/grammar.py +++ b/grammar.py @@ -931,16 +931,23 @@ def _include_from_string(self, grammar_str): return num_errors def _include_from_file(self, filename): + filepath = os.path.join(self._definitions_dir, filename) try: - f = open(os.path.join(self._definitions_dir, - filename - )) + f = open(filepath) content = f.read() f.close() except IOError: print('Error reading ' + filename) return 1 - return self.parse_from_string(content) + + # we temporarily change the definitions dir to make it relative to the + # current file being parsed so that we can safely recursively + # include/import other files from it. + saved_definitions_dir = self._definitions_dir + self._definitions_dir = os.path.dirname(filepath) + errors = self.parse_from_string(content) + self._definitions_dir = saved_definitions_dir + return errors def parse_from_string(self, grammar_str): """Parses grammar rules from string. From 1630782e6ebb833c9aac22df5ff38a487798283c Mon Sep 17 00:00:00 2001 From: Brendon Tiszka Date: Wed, 18 Sep 2024 15:32:41 -0400 Subject: [PATCH 48/50] Add WebGPU Support * Add WebGPU and helper grammar. * Add custom generator that reads entrypoints, binding indexes, etc from the wgsl scripts that are injected into the template and injects them into the webgpu domato grammar. * Modify grammar.py so generators can inject into grammars at runtime. * Include helper script that was used to generate ~80% of the grammar. --- grammar.py | 6 +- webgpu/README.md | 12 + webgpu/__init__.py | 0 webgpu/build_grammar.py | 150 +++++ webgpu/generator.py | 141 +++-- webgpu/template.html | 160 +++-- webgpu/webgpu.txt | 1022 +++++++++++++++++++++---------- webgpu/webgpuhelpers.txt | 136 ++++ webgpu/wgsl.txt | 0 webgpu/wgsl/domato-example.wgsl | 24 + 10 files changed, 1219 insertions(+), 432 deletions(-) create mode 100644 webgpu/README.md delete mode 100644 webgpu/__init__.py create mode 100644 webgpu/build_grammar.py create mode 100644 webgpu/webgpuhelpers.txt delete mode 100644 webgpu/wgsl.txt create mode 100644 webgpu/wgsl/domato-example.wgsl diff --git a/grammar.py b/grammar.py index c03d74f..d0226a6 100755 --- a/grammar.py +++ b/grammar.py @@ -970,7 +970,7 @@ def parse_from_string(self, grammar_str): return 0 - def parse_from_file(self, filename): + def parse_from_file(self, filename, extra=None): """Parses grammar from file. Opens a text file, parses it and loads the grammar rules within. @@ -991,6 +991,10 @@ def parse_from_file(self, filename): print('Error reading ' + filename) return 1 self._definitions_dir = os.path.dirname(filename) + + if extra: + content = extra + content + return self.parse_from_string(content) def _compute_interesting_indices(self): diff --git a/webgpu/README.md b/webgpu/README.md new file mode 100644 index 0000000..532f77d --- /dev/null +++ b/webgpu/README.md @@ -0,0 +1,12 @@ +# Simple WebGPU fuzzer + +## Setup + +1. Populate the `wgsl/` directory with wgsl scripts. I would recomment copying wgsl test files from [tint's tests](https://source.chromium.org/chromium/chromium/src/+/main:third_party/dawn/test/tint/bug/). +2. From here, the usage is the same as [vanilla Domato's](https://github.com/googleprojectzero/domato). + +## Bugs +Chrome: [40063883](https://issues.chromium.org/u/0/issues/40063883), [40063356](https://issues.chromium.org/u/0/issues/40063356) + +## Building Grammars +This repo also contains a helper script that can be used to assist in generating Domato grammars using Chrome's [WebIDL compiler](https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/bindings/scripts/web_idl/README.md;l=1?q=f:md%20web_idl&sq=). It is far from complete but may help others generate grammars faster. diff --git a/webgpu/__init__.py b/webgpu/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/webgpu/build_grammar.py b/webgpu/build_grammar.py new file mode 100644 index 0000000..eacf782 --- /dev/null +++ b/webgpu/build_grammar.py @@ -0,0 +1,150 @@ +# Domato - example generator script +# -------------------------------------- +# +# Written by Brendon Tiszka +# +# Copyright 2017 Google Inc. All Rights Reserved. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import web_idl + +# Path to your chromium build directory +PATH_TO_CHROME_BUILD_DIR = "" +web_idl_database_path = '/gen/third_party/blink/renderer/bindings/web_idl_database.pickle' +web_idl_database = web_idl.Database.read_from_file(PATH_TO_CHROME_BUILD_DIR + web_idl_database_path) + +def is_gpu(ident): + if "GPU" in ident: + return True + return False + +def is_promise(ident): + if "Promise" in ident: + return True + return False + +def remove_promise_info(s): + if "OrNullPromise" in s: + return s[:s.index("OrNullPromise")] + + if "Promise" in s: + return s[:s.index("Promise")] + + return s + +def parse_enums(): + builder = "" + + for enum in web_idl_database.enumerations: + if not is_gpu(enum.identifier): + continue + + for value in enum.values: + builder += "<{}> = \"{}\"\n".format(enum.identifier, value) + + builder += "\n" + + return builder + +def parse_namespaces(): + builder = "" + + for ns in web_idl_database.namespaces: + if not is_gpu(ns.identifier): + continue + + for const in ns.constants: + builder += "<{}> = {}.{}\n".format(ns.identifier, ns.identifier, const.identifier) + + builder += "\n" + + return builder + +def parse_dictionaries(): + builder = "" + + for dictionary in web_idl_database.dictionaries: + if not is_gpu(dictionary.identifier): + continue + + print(dictionary.identifier) + +def parse_interfaces(): + builder = "" + + for interface in web_idl_database.interfaces: + if not is_gpu(interface.identifier): + continue + + + builder += "#" + ("~"*16) + interface.identifier + ("~"*16) + "#\n" + for attribute in interface.attributes: + if attribute.is_readonly: + continue + + builder += "<{}>.{} = <{}>".format(interface.identifier, attribute.identifier, attribute.idl_type.type_name) + builder += "\n" + + for operation in interface.operations: + required_args = operation.num_of_required_arguments + num_args = len(operation.arguments) + + lifted_args = [] + for argument in operation.arguments: + lifted_args.append("<{}>".format(argument.idl_type.type_name)) + + for i in range(required_args, num_args + 1): + if operation.return_type.type_name != "Void": + return_type = remove_promise_info(operation.return_type.type_name) + builder += " = ".format(return_type) + + if is_promise(operation.return_type.type_name): + builder += "await " + + builder += "<{}>.{}(".format(interface.identifier, operation.identifier) + builder += "{}".format(",".join(lifted_args[:i])) + builder += ");\n" + + builder += "\n" + return builder + + +def parse_dictionaries(): + builder = "" + + for dictionary in web_idl_database.dictionaries: + if not is_gpu(dictionary.identifier): + continue + + + lifted_members = [] + for member in dictionary.members: + lifted_members.append("{}: <{}>".format(member.identifier, member.idl_type.type_name)) + + builder += "<{}> = ".format(dictionary.identifier) + builder += "{ " + builder += ", ".join(lifted_members) + builder += " };" + builder += "\n" + + return builder + +if __name__ == "__main__": + enums = parse_enums() + namespaces = parse_namespaces() + interfaces = parse_interfaces() + dictionaries = parse_dictionaries() + print(enums) + print(namespaces) + print(interfaces) + print(dictionaries) diff --git a/webgpu/generator.py b/webgpu/generator.py index fd14ab6..95657a3 100644 --- a/webgpu/generator.py +++ b/webgpu/generator.py @@ -1,9 +1,10 @@ # Domato - generator script for WebGPU # ------------------------------- # -# Written and maintained by Chrome Security Team +# Written and maintained by Ivan Fratric +# Modified by Brendon Tiszka to target webgpu # -# Copyright 2022 Google Inc. All Rights Reserved. +# Copyright 2017 Google Inc. All Rights Reserved. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -16,90 +17,113 @@ # See the License for the specific language governing permissions and # limitations under the License. - from __future__ import print_function +import glob import os -import re import random +import re import sys parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)) sys.path.append(parent_dir) from grammar import Grammar -_N_MAIN_LINES = 100 -_N_EVENTHANDLER_LINES = 1 +_N_MAIN_LINES = 1000 +_N_SHADERS = 10 + +def extract_shader_stages_and_functions(code): + # Pattern to match both single-line and multiline stage attributes + pattern = r'@(?:compute|vertex|fragment)(?:\s+@[^(\n]+(?:\([^)]*\))?)*\s*(?:\n\s*)?fn\s+(\w+)' + matches = re.finditer(pattern, code) + + # Extract stage-function pairs + result = [] + for match in matches: + # Find the stage attribute within the matched attributes + stage_attr = re.search(r'@(compute|vertex|fragment)', match.group(0)).group(0) + function_name = match.group(1) + result.append((stage_attr, function_name)) + + return result + +def parse_entrypoints(shaders): + entrypoints = [] + for shader in shaders: + attr_fn_pairs = extract_shader_stages_and_functions(shader) + for attr, fn in attr_fn_pairs: + entrypoints.append(fn) -def generate_lines(grammar, num_lines): - output = '' - output += grammar._generate_code(num_lines) + result = "" + for entrypoint in entrypoints: + result += " = \"{}\"\n".format(entrypoint) - return output + return result -def GenerateNewSample(template, jsgrammar, wgslgrammar): - """Parses grammar rules from string. +def parse_bindings(shaders): + binding_pattern = r'@binding\((\d+)\)' + + binding_numbers = [] + for shader in shaders: + matches = re.finditer(binding_pattern, shader) + binding_numbers.extend(match.group(1) for match in matches) + + return "\n".join(f" = {binding}" for binding in binding_numbers) - Args: - template: A template string. - jsgrammar: Grammar for generating JS code. - wgslgrammar: Grammar for generating WGSL shader code. +def generate_function_body(webgpugrammar, num_lines): + js = '' + js += webgpugrammar._generate_code(num_lines) - Returns: - A string containing sample data. - """ + return js +def generate_new_sample(template, webgpugrammar): result = template - handlers = False - - # WebGPU JS while '' in result: - numlines = _N_MAIN_LINES - if handlers: - numlines = _N_EVENTHANDLER_LINES - else: - handlers = True result = result.replace( '', - generate_lines(jsgrammar, numlines), + generate_function_body(webgpugrammar, _N_MAIN_LINES), 1 ) return result -def generate_samples(grammar_dir, outfiles): - """Generates a set of samples and writes them to the output files. +def generate_samples(template, grammar_dir, outfiles): + extra = "" + shaders_dir = os.path.join(grammar_dir, "wgsl/*.wgsl") + shader_files = glob.glob(shaders_dir) - Args: - grammar_dir: directory to load grammar files from. - outfiles: A list of output filenames. - """ + shaders = [] + for i in range(_N_SHADERS): + shader_path = random.choice(shader_files) + with open(shader_path) as fp: + shader_src = fp.read() + shaders.append(shader_src) + + with open(os.path.join(grammar_dir, template), "r") as fp: + template_contents = fp.read() - f = open(os.path.join(grammar_dir, 'template.html')) - template = f.read() - f.close() + SHADER_CONST = "" + for i, shader in enumerate(shaders): + shader_template = SHADER_CONST % str(i) + template_contents = template_contents.replace(shader_template, shader) - jsgrammar = Grammar() - err = jsgrammar.parse_from_file(os.path.join(grammar_dir, 'webgpu.txt')) - if err > 0: - print('There were errors parsing WebGPU JS grammar') - return + extra += parse_entrypoints(shaders) + "\n" + extra += parse_bindings(shaders) + "\n" - wgslgrammar = Grammar() - err = jsgrammar.parse_from_file(os.path.join(grammar_dir, 'wgsl.txt')) + webgpugrammar = Grammar() + err = webgpugrammar.parse_from_file(os.path.join(grammar_dir, os.path.join(grammar_dir, 'webgpu.txt')), extra) if err > 0: - print('There were errors parsing WGSL grammar') + print('There were errors parsing grammar') return for outfile in outfiles: - result = GenerateNewSample(template, jsgrammar, wgslgrammar) + result = generate_new_sample(template_contents, webgpugrammar) if result is not None: print('Writing a sample to ' + outfile) try: - f = open(outfile, 'w') - f.write(result) - f.close() + with open(outfile, 'w') as f: + f.write(result) except IOError: print('Error writing to output') @@ -112,11 +136,11 @@ def get_option(option_name): return sys.argv[i][len(option_name) + 1:] return None - def main(): fuzzer_dir = os.path.dirname(__file__) multiple_samples = False + template = os.path.join(fuzzer_dir, "template.html") for a in sys.argv: if a.startswith('--output_dir='): @@ -125,29 +149,24 @@ def main(): multiple_samples = True if multiple_samples: + print('Running on ClusterFuzz') out_dir = get_option('--output_dir') nsamples = int(get_option('--no_of_files')) print('Output directory: ' + out_dir) print('Number of samples: ' + str(nsamples)) - if not os.path.exists(out_dir): os.mkdir(out_dir) - outfiles = [] for i in range(nsamples): outfiles.append(os.path.join(out_dir, 'fuzz-' + str(i).zfill(5) + '.html')) - - generate_samples(fuzzer_dir, outfiles) - - elif len(sys.argv) > 1: - outfile = sys.argv[1] - generate_samples(fuzzer_dir, [outfile]) - + generate_samples(template, fuzzer_dir, outfiles) else: print('Arguments missing') print("Usage:") - print("\tpython generator.py ") - print("\tpython generator.py --output_dir --no_of_files ") + print("""--input_dir . ** not used. ** + --output_dir . This is the output directory which the fuzzer should write to. + --no_of_files . This is the number of testcases which the fuzzer should write to the output directory. + """) if __name__ == '__main__': main() diff --git a/webgpu/template.html b/webgpu/template.html index ffb0c09..b34fa7a 100644 --- a/webgpu/template.html +++ b/webgpu/template.html @@ -1,65 +1,103 @@ + + - +setTimeout(function() { cleanup(); }, 12000); +function out_of_scope_gc_flush() { + return new Promise(resolve => setTimeout(() => { + // Let's ensure buffer is garbage collected + try { new ArrayBuffer(0x80000000); } catch(e) {} + + // Flush. + navigator.gpu.requestAdapter().then(adapter => { + adapter.requestDevice().then(device => {}) + }); + + }, 0)); +} + + +function cleanup() { + try { gc(); } catch(e) {} + try { new ArrayBuffer(0x80000000); } catch(e) {} + try { new ArrayBuffer(0x80000000); } catch(e) {} + try { new ArrayBuffer(0x80000000); } catch(e) {} + try { new ArrayBuffer(0x80000000); } catch(e) {} + + navigator.gpu.requestAdapter().then(adapter => { + adapter.requestDevice().then(device => {}) + }); +} + +async function trigger() { + const adapter = await navigator.gpu.requestAdapter(); + const device = await adapter.requestDevice(); + + const Shader0 = device.createShaderModule({ + code: ` + + ` + }); + + const Shader1 = device.createShaderModule({ + code: ` + + ` + }); + + const Shader2 = device.createShaderModule({ + code: ` + + ` + }); + + const Shader3 = device.createShaderModule({ + code: ` + + ` + }); + + const Shader4 = device.createShaderModule({ + code: ` + + ` + }); + + const Shader5 = device.createShaderModule({ + code: ` + + ` + }); + + const Shader6 = device.createShaderModule({ + code: ` + + ` + }); + + const Shader7 = device.createShaderModule({ + code: ` + + ` + }); + + const Shader8 = device.createShaderModule({ + code: ` + + ` + }); + + const Shader9 = device.createShaderModule({ + code: ` + + ` + }); + + + +} + + + \ No newline at end of file diff --git a/webgpu/webgpu.txt b/webgpu/webgpu.txt index 846fbb4..a7f5b5e 100644 --- a/webgpu/webgpu.txt +++ b/webgpu/webgpu.txt @@ -1,312 +1,716 @@ +!include webgpuhelpers.txt - = true - = false - - = 0 - = 1 - = 2 - = 4 - = 8 - = 16 - = 32 - = 64 - = 128 - - = 0 - = 1 - = 2 - = 4 - = 8 - = 16 - = 32 - = 64 - = 128 - - = 0x7fffff00 - = 0x64 - = 0x3e8 - = 0x4141 - = 0xefff - = 0xaa - = 0xaf43 - = -0x5a - = true - = false - - = 536870911 - = 536870912 - = 1073741823 - = 1073741824 - = 2147483647 - = 2147483648 - = 4294967295 - = 4294967296 - - = 100 - = 200 - = 500 - = 1000 - = 10000 - - = - = + - = + + - = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" - = 17 - = 65 - = 257 - = 1025 - = 4097 - = 65537 - = String.fromCharCode() - = String.fromCharCode().repeat() - - = - = 256 - = 512 - = 1024 - = 4096 - = 16384 - = 65536 - - = - = - = - = - = - - = GPUBufferUsage.MAP_READ - = GPUBufferUsage.MAP_WRITE - = GPUBufferUsage.COPY_SRC - = GPUBufferUsage.COPY_DST - = GPUBufferUsage.STORAGE - = GPUBufferUsage.INDEX - = GPUBufferUsage.INDIRECT - = GPUBufferUsage.UNIFORM - = GPUBufferUsage.VERTEX - = GPUBufferUsage.QUERY_RESOLVE - = 0xffff - = 0x - = 0x003 - = 0x005 - = 0x006 - = 0x007 - = 0x1 - = 0x2 - = 0x3 - = 0x4 - = 0x5 - = 0x6 - = 0x7 - = 0x9 - = 0x11 - = 0x12 - = 0x081 - - = GPUMapMode.READ - = GPUMapMode.WRITE - - = 0 - = 1 - = 2 - - = GPUShaderStage.COMPUTE - = GPUShaderStage.FRAGMENT - = GPUShaderStage.VERTEX - - = "uniform" - = "storage" - = "read-only-storage" - = "filtering" - = "non-filtering" - = "comparison" - = "float" - = "unfilterable-float" - = "depth" - = "sint" - = "uint" - = "write-only" - - = - = - = - = - - = canvas0 - = canvas1 - = canvas2 - = canvas3 - = canvas4 - - = "2d" - = "webgl" - = "webgl2" - = "bitmaprenderer" - - = matrixA - = matrixB - = matrixC - - = "1d" - = "2d" - = "3d" - - = "r8unorm" - = "r8snorm" - = "r8uint" - = "r8sint" - = "r16uint" - = "r16sint" - = "r16float" - = "rg8unorm" - = "rg8snorm" - = "rg8uint" - = "rg8sint" - = "r32uint" - = "r32sint" - = "r32float" - = "rg16uint" - = "rg16sint" - = "rg16float" - = "rgba8unorm" - = "rgba8unorm-srgb" - = "rgba8snorm" - = "rgba8uint" - = "rgba8sint" - = "bgra8unorm" - = "bgra8unorm-srgb" - = "rgb9e5ufloat" - = "rgb10a2unorm" - = "rg11b10ufloat" - = "rg32uint" - = "rg32sint" - = "rg32float" - = "rgba16uint" - = "rgba16sint" - = "rgba16float" - = "rgba32uint" - = "rgba32sint" - = "rgba32float" - = "stencil8" - = "depth16unorm" - = "depth24plus" - = "depth24plus-stencil8" - = "depth32float" - = "depth32float-stencil8" - = "bc1-rgba-unorm" - = "bc1-rgba-unorm-srgb" - = "bc2-rgba-unorm" - = "bc2-rgba-unorm-srgb" - = "bc3-rgba-unorm" - = "bc3-rgba-unorm-srgb" - = "bc4-r-unorm" - = "bc4-r-snorm" - = "bc5-rg-unorm" - = "bc5-rg-snorm" - = "bc6h-rgb-ufloat" - = "bc6h-rgb-float" - = "bc7-rgba-unorm" - = "bc7-rgba-unorm-srgb" - = "etc2-rgb8unorm" - = "etc2-rgb8unorm-srgb" - = "etc2-rgb8a1unorm" - = "etc2-rgb8a1unorm-srgb" - = "etc2-rgba8unorm" - = "etc2-rgba8unorm-srgb" - = "eac-r11unorm" - = "eac-r11snorm" - = "eac-rg11unorm" - = "eac-rg11snorm" - = "astc-4x4-unorm" - = "astc-4x4-unorm-srgb" - = "astc-5x4-unorm" - = "astc-5x4-unorm-srgb" - = "astc-5x5-unorm" - = "astc-5x5-unorm-srgb" - = "astc-6x5-unorm" - = "astc-6x5-unorm-srgb" - = "astc-6x6-unorm" - = "astc-6x6-unorm-srgb" - = "astc-8x5-unorm" - = "astc-8x5-unorm-srgb" - = "astc-8x6-unorm" - = "astc-8x6-unorm-srgb" - = "astc-8x8-unorm" - = "astc-8x8-unorm-srgb" - = "astc-10x5-unorm" - = "astc-10x5-unorm-srgb" - = "astc-10x6-unorm" - = "astc-10x6-unorm-srgb" - = "astc-10x8-unorm" - = "astc-10x8-unorm-srgb" - = "astc-10x10-unorm" - = "astc-10x10-unorm-srgb", - = "astc-12x10-unorm" - = "astc-12x10-unorm-srgb" - = "astc-12x12-unorm" - = "astc-12x12-unorm-srgb" - - = "out-of-memory" - = "validation" - - = - -!include ../rules/common.txt -#include ../canvas/canvas.txt - -!lineguard try { } catch(e) { } + = Shader0 + = Shader1 + = Shader2 + = Shader3 + = Shader4 + = Shader5 + = Shader6 + = Shader7 + = Shader8 + = Shader9 + + = 1234 + = o + = wgsize + + = "srgb" + = "display-p3" + + = "uniform-buffer" + = "storage-buffer" + = "readonly-storage-buffer" + = "sampler" + = "comparison-sampler" + = "sampled-texture" + = "multisampled-texture" + = "writeonly-storage-texture" + + = "float" + = "sint" + = "uint" + = "depth-comparison" + + = "zero" + = "one" + = "src" + = "one-minus-src" + = "src-alpha" + = "one-minus-src-alpha" + = "dst" + = "one-minus-dst" + = "dst-alpha" + = "one-minus-dst-alpha" + = "src-alpha-saturated" + = "constant" + = "one-minus-constant" + + = "add" + = "subtract" + = "reverse-subtract" + = "min" + = "max" + + = "unmapped" + = "pending" + = "mapped" + + = "uniform" + = "storage" + = "read-only-storage" + + = "opaque" + = "premultiplied" + + = "error" + = "warning" + = "info" + + = "beginning" + = "end" + + = "out-of-memory" + = "validation" + = "internal" + + = "destroyed" + + = "auto" + + = "uint16" + = "uint32" + + = "occlusion" + = "pipeline-statistics" + = "timestamp" + + = "vertex-shader-invocations" + = "clipper-invocations" + = "clipper-primitives-out" + = "fragment-shader-invocations" + = "compute-shader-invocations" + + = "ccw" + = "cw" + + = "none" + = "front" + = "back" + + = "load" + = "clear" + + = "store" + = "discard" + + = "beginning" + = "end" + + = "point-list" + = "line-list" + = "line-strip" + = "triangle-list" + = "triangle-strip" + + = "low-power" + = "high-performance" + + = "filtering" + = "non-filtering" + = "comparison" + + = "clamp-to-edge" + = "repeat" + = "mirror-repeat" + + = "nearest" + = "linear" + + = "never" + = "less" + = "equal" + = "less-equal" + = "greater" + = "not-equal" + = "greater-equal" + = "always" + + = "keep" + = "zero" + = "replace" + = "invert" + = "increment-clamp" + = "decrement-clamp" + = "increment-wrap" + = "decrement-wrap" + + = "write-only" + + = "pipeline-statistics-query" + = "texture-compression-bc" + = "texture-compression-etc2" + = "texture-compression-astc" + = "timestamp-query" + = "timestamp-query-inside-passes" + = "shader-float16" + = "depth-clip-control" + = "depth32float-stencil8" + = "indirect-first-instance" + = "chromium-experimental-dp4a" + = "rg11b10ufloat-renderable" + + = "float" + = "unfilterable-float" + = "depth" + = "sint" + = "uint" + + = "1d" + = "2d" + = "3d" + + = "r8unorm" + = "r8snorm" + = "r8uint" + = "r8sint" + = "r16uint" + = "r16sint" + = "r16float" + = "rg8unorm" + = "rg8snorm" + = "rg8uint" + = "rg8sint" + = "r32uint" + = "r32sint" + = "r32float" + = "rg16uint" + = "rg16sint" + = "rg16float" + = "rgba8unorm" + = "rgba8unorm-srgb" + = "rgba8snorm" + = "rgba8uint" + = "rgba8sint" + = "bgra8unorm" + = "bgra8unorm-srgb" + = "rgb9e5ufloat" + = "rgb10a2unorm" + = "rg11b10ufloat" + = "rg32uint" + = "rg32sint" + = "rg32float" + = "rgba16uint" + = "rgba16sint" + = "rgba16float" + = "rgba32uint" + = "rgba32sint" + = "rgba32float" + = "depth32float" + = "depth32float-stencil8" + = "depth24plus" + = "depth24plus-stencil8" + = "depth16unorm" + = "stencil8" + = "bc1-rgba-unorm" + = "bc1-rgba-unorm-srgb" + = "bc2-rgba-unorm" + = "bc2-rgba-unorm-srgb" + = "bc3-rgba-unorm" + = "bc3-rgba-unorm-srgb" + = "bc4-r-unorm" + = "bc4-r-snorm" + = "bc5-rg-unorm" + = "bc5-rg-snorm" + = "bc6h-rgb-ufloat" + = "bc6h-rgb-float" + = "bc7-rgba-unorm" + = "bc7-rgba-unorm-srgb" + = "etc2-rgb8unorm" + = "etc2-rgb8unorm-srgb" + = "etc2-rgb8a1unorm" + = "etc2-rgb8a1unorm-srgb" + = "etc2-rgba8unorm" + = "etc2-rgba8unorm-srgb" + = "eac-r11unorm" + = "eac-r11snorm" + = "eac-rg11unorm" + = "eac-rg11snorm" + = "astc-4x4-unorm" + = "astc-4x4-unorm-srgb" + = "astc-5x4-unorm" + = "astc-5x4-unorm-srgb" + = "astc-5x5-unorm" + = "astc-5x5-unorm-srgb" + = "astc-6x5-unorm" + = "astc-6x5-unorm-srgb" + = "astc-6x6-unorm" + = "astc-6x6-unorm-srgb" + = "astc-8x5-unorm" + = "astc-8x5-unorm-srgb" + = "astc-8x6-unorm" + = "astc-8x6-unorm-srgb" + = "astc-8x8-unorm" + = "astc-8x8-unorm-srgb" + = "astc-10x5-unorm" + = "astc-10x5-unorm-srgb" + = "astc-10x6-unorm" + = "astc-10x6-unorm-srgb" + = "astc-10x8-unorm" + = "astc-10x8-unorm-srgb" + = "astc-10x10-unorm" + = "astc-10x10-unorm-srgb" + = "astc-12x10-unorm" + = "astc-12x10-unorm-srgb" + = "astc-12x12-unorm" + = "astc-12x12-unorm-srgb" + + = "1d" + = "2d" + = "2d-array" + = "cube" + = "cube-array" + = "3d" + + = "all" + = "stencil-only" + = "depth-only" + + = "uint8x2" + = "uint8x4" + = "sint8x2" + = "sint8x4" + = "unorm8x2" + = "unorm8x4" + = "snorm8x2" + = "snorm8x4" + = "uint16x2" + = "uint16x4" + = "sint16x2" + = "sint16x4" + = "unorm16x2" + = "unorm16x4" + = "snorm16x2" + = "snorm16x4" + = "float16x2" + = "float16x4" + = "float32" + = "float32x2" + = "float32x3" + = "float32x4" + = "uint32" + = "uint32x2" + = "uint32x3" + = "uint32x4" + = "sint32" + = "sint32x2" + = "sint32x3" + = "sint32x4" + + = "vertex" + = "instance" + +# Namespaces + = GPUBufferUsage.MAP_READ + = GPUBufferUsage.MAP_WRITE + = GPUBufferUsage.COPY_SRC + = GPUBufferUsage.COPY_DST + = GPUBufferUsage.INDEX + = GPUBufferUsage.VERTEX + = GPUBufferUsage.UNIFORM + = GPUBufferUsage.STORAGE + = GPUBufferUsage.INDIRECT + = GPUBufferUsage.QUERY_RESOLVE + + = GPUColorWrite.RED + = GPUColorWrite.GREEN + = GPUColorWrite.BLUE + = GPUColorWrite.ALPHA + = GPUColorWrite.ALL + + = GPUMapMode.READ + = GPUMapMode.WRITE + + = GPUShaderStage.VERTEX + = GPUShaderStage.FRAGMENT + = GPUShaderStage.COMPUTE + + = GPUTextureUsage.COPY_SRC + = GPUTextureUsage.COPY_DST + = GPUTextureUsage.TEXTURE_BINDING + = GPUTextureUsage.STORAGE_BINDING + = GPUTextureUsage.RENDER_ATTACHMENT + +#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~# +#~~~~~~~~~DICTIONARIES~~~~~~~~~~~# +#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~# + = { label: , entries: , layout: } + = { binding: , resource: } + = { binding: , resource: } + = { binding: , resource: } + = { binding: , resource: } + = { label: , entries: } + = { binding: , buffer: , visibility: } + = { binding: , externalTexture: , visibility: } + = { binding: , sampler: , visibility: } + = { binding: , texture: , visibility: } + = { dstFactor: , operation: , srcFactor: } + + = { alpha: , color: } + = { buffer: , offset: , size: } + = { hasDynamicOffset: , minBindingSize: , type: } + = { label: , mappedAtCreation: , size: , usage: } + = { alphaMode: , colorSpace: , device: , format: , usage: , viewFormats: } + = { a: , b: , g: , r: } + = { alphaBlend: , colorBlend: , format: , writeMask: } + = { blend: , format: , writeMask: } + = { label: } + = { label: } + = { label: , timestampWrites: } + = { location: , queryIndex: , querySet: } + = { label: , layout: , compute: } + = { label: , layout: , compute: } + = { depthBias: , depthBiasClamp: , depthBiasSlopeScale: , depthCompare: , depthWriteEnabled: , format: , stencilBack: , stencilFront: , stencilReadMask: , stencilWriteMask: } + = { depthCompare: , depthWriteEnabled: , format: , stencilBack: , stencilFront: , stencilReadMask: , stencilWriteMask: } + = { label: , defaultQueue: , requiredFeatures: , requiredLimits: } + = { depthOrArrayLayers: , height: , width: } + = { } + = { label: , colorSpace: , source: } + = { label: , colorSpace: , source: } + = { constants: , entryPoint: , module: , targets: } + = { constants: , entryPoint: , module: , targets: } + = { bytesPerRow: , offset: , rowsPerImage: , buffer: } + = { flipY: , origin: , source: } + = { flipY: , origin: , source: } + = { flipY: , origin: , source: } + = { flipY: , origin: , source: } + = { imageBitmap: , origin: } + = { aspect: , mipLevel: , origin: , texture: } + = { aspect: , mipLevel: , origin: , texture: , colorSpace: , premultipliedAlpha: } + = { bytesPerRow: , offset: , rowsPerImage: } + = { alphaToCoverageEnabled: , count: , mask: } + = { label: } + = { x: , y: } + = { x: , y: , z: } + = { label: , layout: } + = { label: , layout: } + = { label: , bindGroupLayouts: } + = { cullMode: , frontFace: , stripIndexFormat: , topology: , unclippedDepth: } + = { constants: , entryPoint: , module: } + = { label: , count: , pipelineStatistics: , type: } + = { label: } + = { cullMode: , depthBias: , depthBiasClamp: , depthBiasSlopeScale: , frontFace: } + = { label: } + = { label: , colorFormats: , depthStencilFormat: , sampleCount: , depthReadOnly: , stencilReadOnly: } + = { clearValue: , loadOp: , resolveTarget: , storeOp: , view: } + = { depthClearValue: , depthLoadOp: , depthReadOnly: , depthStoreOp: , stencilClearValue: , stencilLoadOp: , stencilReadOnly: , stencilStoreOp: , view: } + = { label: , colorAttachments: , depthStencilAttachment: , maxDrawCount: , occlusionQuerySet: , timestampWrites: } + = { label: , colorFormats: , depthStencilFormat: , sampleCount: } + = { location: , queryIndex: , querySet: } + = { label: , layout: , depthStencil: , fragment: , multisample: , primitive: , vertex: } + = { label: , layout: , depthStencil: , fragment: , multisample: , primitive: , vertex: } + = { powerPreference: } + = { type: } + = { label: , addressModeU: , addressModeV: , addressModeW: , compare: , lodMaxClamp: , lodMinClamp: , magFilter: , maxAnisotropy: , minFilter: , mipmapFilter: } + = { layout: } + = { layout: } + = { compare: , depthFailOp: , failOp: , passOp: } + = { access: , format: , viewDimension: } + = { multisampled: , sampleType: , viewDimension: } + = { label: , dimension: , format: , mipLevelCount: , sampleCount: , size: , usage: , viewFormats: } + = { label: , arrayLayerCount: , aspect: , baseArrayLayer: , baseMipLevel: , dimension: , format: , mipLevelCount: } + = { bubbles: , cancelable: , composed: , error: } + = { format: , offset: , shaderLocation: } + = { arrayStride: , attributes: , stepMode: } + = { constants: , entryPoint: , module: , buffers: } + + + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [] + = [, ] + = [, , ] + = [, , , ] + = [] + = [, ] + = [, , ] + + = {} + = {} + = {} + = {} + = {} + = {} + = {} + = {} + = {} + = {} + = {} + = {} + = {} + = {} + = {} + = { : } + = { : } + = { : } + + = adapter + = device + +!lineguard try { } catch(e) {} !varformat fuzzvar%05d !begin lines -setTimeout(function(){location.reload();},); - = await navigator.gpu.requestAdapter(); - = await .requestDevice(); - = .queue; - = .createShaderModule({code: wgsl_shader_src}); - = .createBuffer({mappedAtCreation: , size: , usage: GPUBufferUsage.STORAGE}); - = .createBuffer({mappedAtCreation: , size: , usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC}); - = .createBuffer({mappedAtCreation: , size: , usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); - = ; - = ; - = ; -# = .createBuffer({mappedAtCreation: , size: , usage: }); - = .getMappedRange().fill(0x41); - = .getMappedRange(); - = new Uint8Array(.getMappedRange()); - = Float32Array(); - = Float32Array().set(); - = Uint8Array(); - = Uint8Array().set(); -for (var i = 0; i ; i++) {console.log([i]);} -for (var i = 0; i ; i++) {console.log([i]);} -.unmap(); -.map(); -.mapAsync(); -# = .createBindGroupLayout({entries: [{binding: 0, visibility: , buffer: {type: }}, {binding: 1, visibility: , buffer: {type: }}, {binding: 2, visibility: , buffer: {type: }}]}); - = .createBindGroupLayout({entries: [{binding: 0, visibility: GPUShaderStage.COMPUTE, buffer: {type: "storage"}}, {binding: 1, visibility: GPUShaderStage.COMPUTE, buffer: {type: "storage"}}, {binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: {type: "storage"}}]}); -# = .createBindGroup({layout: , entries: [{binding: 0, resource: {buffer: }}, {binding: 1, resource: {buffer: }}, {binding: 2, resource: {buffer: }}]}); -activeBuffer = .createBuffer({size: , usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC}); - = .createBindGroup({layout: , entries: [{binding: 0, resource: {buffer: }}, {binding: 1, resource: {buffer: }}, {binding: 2, resource: {buffer: activeBuffer}}]}); - = .createComputePipeline({layout: .createPipelineLayout({bindGroupLayouts: []}), compute: {module: , entryPoint: "main"}}); - = .createCommandEncoder(); - = .beginComputePass(); -.setPipeline(); -.setBindGroup(, ) - = Math.ceil([] / ); -.dispatchWorkgroups(, ); -.end(); -.copyBufferToBuffer(, , , , ); - = .finish(); -.submit([]); - = .getContext(); -.configure({device: , format: , usage: }) -.transferControlToOffscreen(); -.pushErrorScope(); -.popErrorScope(); -.pushErrorScope(); -.popErrorScope().then().catch(e => {}); - = .getCurrentTexture(); - = .createView(); -.copyTextureToBuffer({texture: }, {buffer: , bytesPerRow: .width}, {width: , height: , depthOrArrayLayers: 1}); -for (var i = 0; i ; i++) {console.log([i]);} - = new OffscreenCanvas(original_image.width, original_image.height); -!end lines + + +#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~# +#~~~~~~~~~~INTERFACES~~~~~~~~~~~~# +#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~# + + +#~~~~~~~~~~~~~~~~GPU~~~~~~~~~~~~~~~~# + = .getPreferredCanvasFormat(); + +#~~~~~~~~~~~~~~~~GPUAdapter~~~~~~~~~~~~~~~~# + + = await .requestAdapterInfo(); + +#~~~~~~~~~~~~~~~~GPUBindGroup~~~~~~~~~~~~~~~~# +.label = + +#~~~~~~~~~~~~~~~~GPUBindGroupLayout~~~~~~~~~~~~~~~~# +.label = + +#~~~~~~~~~~~~~~~~GPUBuffer~~~~~~~~~~~~~~~~# +.label = +await .mapAsync(); +await .mapAsync(,); +await .mapAsync(,,); + = .getMappedRange(); + = .getMappedRange(); + = .getMappedRange(,); +.unmap(); +.destroy(); + +#~~~~~~~~~~~~~~~~GPUCanvasContext~~~~~~~~~~~~~~~~# +.configure(); +.unconfigure(); + = .getCurrentTexture(); + +#~~~~~~~~~~~~~~~~GPUCommandBuffer~~~~~~~~~~~~~~~~# +.label = + +#~~~~~~~~~~~~~~~~GPUCommandEncoder~~~~~~~~~~~~~~~~# +.label = + = .beginRenderPass(); + = .beginComputePass(); + = .beginComputePass(); +.copyBufferToBuffer(,,,,); +.copyBufferToTexture(,,); +.copyTextureToBuffer(,,); +.copyTextureToTexture(,,); +.pushDebugGroup(); +.popDebugGroup(); +.insertDebugMarker(); +.resolveQuerySet(,,,,); +.writeTimestamp(,); +.clearBuffer(); +.clearBuffer(,); +.clearBuffer(,,); + = .finish(); + = .finish(); + +#~~~~~~~~~~~~~~~~GPUComputePassEncoder~~~~~~~~~~~~~~~~# +.label = +.setPipeline(); +.dispatchWorkgroups(); +.dispatchWorkgroups(,); +.dispatchWorkgroups(,,); +.dispatchWorkgroupsIndirect(,); +.writeTimestamp(,); +.end(); +.setBindGroup(,); +.setBindGroup(,,); +.setBindGroup(,,,,); +.pushDebugGroup(); +.popDebugGroup(); +.insertDebugMarker(); + +#~~~~~~~~~~~~~~~~GPUComputePipeline~~~~~~~~~~~~~~~~# +.label = + = .getBindGroupLayout(); + +#~~~~~~~~~~~~~~~~GPUDevice~~~~~~~~~~~~~~~~# + = device.queu; +.onuncapturederror = null +.label = +.destroy(); + = .createBuffer(); + = .createTexture(); + = .experimentalImportTexture(,); + = .createSampler(); + = .createSampler(); + = .importExternalTexture(); + = .createBindGroup(); + = .createBindGroupLayout(); + = .createPipelineLayout(); + = .createRenderPipeline(); + = .createComputePipeline(); + = await .createRenderPipelineAsync(); + = await .createComputePipelineAsync(); + = .createCommandEncoder(); + = .createCommandEncoder(); + = .createRenderBundleEncoder(); + = .createQuerySet(); +.pushErrorScope(); + = await .popErrorScope(); + +#~~~~~~~~~~~~~~~~GPUExternalTexture~~~~~~~~~~~~~~~~# +.label = + +#~~~~~~~~~~~~~~~~GPUInternalError~~~~~~~~~~~~~~~~# + +#~~~~~~~~~~~~~~~~GPUPipelineLayout~~~~~~~~~~~~~~~~# +.label = + +#~~~~~~~~~~~~~~~~GPUQuerySet~~~~~~~~~~~~~~~~# +.label = +.destroy(); + +#~~~~~~~~~~~~~~~~GPUQueue~~~~~~~~~~~~~~~~# +.label = +.submit(); +await .onSubmittedWorkDone(); +.writeBuffer(,,); +.writeBuffer(,,,); +.writeBuffer(,,,,); +.writeBuffer(,,); +.writeBuffer(,,,); +.writeBuffer(,,,,); +.writeTexture(,,,); +.writeTexture(,,,); +.copyExternalImageToTexture(,,); + +#~~~~~~~~~~~~~~~~GPURenderBundle~~~~~~~~~~~~~~~~# +.label = + +#~~~~~~~~~~~~~~~~GPURenderBundleEncoder~~~~~~~~~~~~~~~~# +.label = + = .finish(); + = .finish(); +.setBindGroup(,); +.setBindGroup(,,); +.setBindGroup(,,,,); +.pushDebugGroup(); +.popDebugGroup(); +.insertDebugMarker(); +.setPipeline(); +.setIndexBuffer(,); +.setIndexBuffer(,,); +.setIndexBuffer(,,,); +.setVertexBuffer(,); +.setVertexBuffer(,,); +.setVertexBuffer(,,,); +.draw(); +.draw(,); +.draw(,,); +.draw(,,,); +.drawIndexed(); +.drawIndexed(,); +.drawIndexed(,,); +.drawIndexed(,,,); +.drawIndexed(,,,,); +.drawIndirect(,); +.drawIndexedIndirect(,); + +#~~~~~~~~~~~~~~~~GPURenderPassEncoder~~~~~~~~~~~~~~~~# +.label = +.setViewport(,,,,,); +.setScissorRect(,,,); +.setBlendConstant(); +.setStencilReference(); +.executeBundles(); +.beginOcclusionQuery(); +.endOcclusionQuery(); +.writeTimestamp(,); +.end(); +.setBindGroup(,); +.setBindGroup(,,); +.setBindGroup(,,,,); +.pushDebugGroup(); +.popDebugGroup(); +.insertDebugMarker(); +.setPipeline(); +.setIndexBuffer(,); +.setIndexBuffer(,,); +.setIndexBuffer(,,,); +.setVertexBuffer(,); +.setVertexBuffer(,,); +.setVertexBuffer(,,,); +.draw(); +.draw(,); +.draw(,,); +.draw(,,,); +.drawIndexed(); +.drawIndexed(,); +.drawIndexed(,,); +.drawIndexed(,,,); +.drawIndexed(,,,,); +.drawIndirect(,); +.drawIndexedIndirect(,); + +#~~~~~~~~~~~~~~~~GPURenderPipeline~~~~~~~~~~~~~~~~# +.label = + = .getBindGroupLayout(); + +#~~~~~~~~~~~~~~~~GPUSampler~~~~~~~~~~~~~~~~# +.label = + +#~~~~~~~~~~~~~~~~GPUShaderModule~~~~~~~~~~~~~~~~# +.label = + = await .compilationInfo(); + +#~~~~~~~~~~~~~~~~GPUTexture~~~~~~~~~~~~~~~~# +.label = + = .createView(); + = .createView(); +.destroy(); + +#~~~~~~~~~~~~~~~~GPUTextureView~~~~~~~~~~~~~~~~# +.label = diff --git a/webgpu/webgpuhelpers.txt b/webgpu/webgpuhelpers.txt new file mode 100644 index 0000000..e31b7b2 --- /dev/null +++ b/webgpu/webgpuhelpers.txt @@ -0,0 +1,136 @@ + + + = + = + = + = + = + = + = + = + = {} + + = self +=navigator +=self.navigator + = window + = document + = .contentWindow.document +=self + + = +=.gpu + = "fuzzstr_" + + = .transferControlToOffscreen() += + + = html_tag_to_id("canvas", ) + = + + = + = + = true + = false + + = + = + = . + = . + = + = + = + = + + = 0 + = 1 + = 2 + = 3 + = 4 + = 5 + = 6 + = 7 + = 8 + = 9 + = 10 + = 11 + = 12 + = 13 + = 14 + = 15 + = 16 + = + += + = 0 + = 1 + = 2 + = 4 + = 8 + = 16 + = 32 + = 64 + = 128 + + = 0x64 + = 0x3e8 + = 0x4141 + = 0xefff + = 0xaa + = 0xaf43 + = -0x9c + = true + = false + + = + = + = + = + + = 0x100 + = 65536 + = + = + + = 536870911 + = 536870912 + = 1073741823 + = 1073741824 + = 2147483647 + = 2147483648 + = 4294967295 + = 4294967296 + + +!lineguard try { } catch(e) { } +!varformat fuzzvar%05d +!begin lines + + = html_tag_to_id("iframe", ); + = html_tag_to_id("video", ); + = html_tag_to_id("video", ); + = html_tag_to_id("canvas", ); + + + = await createImageBitmap(,,,,); + = await createImageBitmap(,,,,); + = await createImageBitmap(,,,,); + = new VideoFrame(, { timestamp: }); + = new ImageData(, ); + = self.URL.createObjectURL(new Blob([worker_blob], { type: 'text/javascript' })); +=.getContext('webgpu'); + + + = new Int8Array(); + = new Int16Array(); + = new Int32Array(); + = new Uint8Array(); + = new Uint16Array(); + = new Uint32Array(); + = new Float32Array(); + = new Float64Array(); + = new Uint8ClampedArray(); + +out_of_scope_gc_flush(); +out_of_scope_gc_flush(); +out_of_scope_gc_flush(); diff --git a/webgpu/wgsl.txt b/webgpu/wgsl.txt deleted file mode 100644 index e69de29..0000000 diff --git a/webgpu/wgsl/domato-example.wgsl b/webgpu/wgsl/domato-example.wgsl new file mode 100644 index 0000000..61285b4 --- /dev/null +++ b/webgpu/wgsl/domato-example.wgsl @@ -0,0 +1,24 @@ +alias RTArr = array; + +struct S { + field0 : RTArr, +} + +var x_2 : vec3; + +@group(0) @binding(0) var x_5 : S; + +@group(0) @binding(1) var x_6 : S; + +fn main_1() { + let x_20 : u32 = x_2.x; + let x_22 : u32 = x_5.field0[x_20]; + x_6.field0[x_20] = bitcast(-(bitcast(x_22))); + return; +} + +@compute @workgroup_size(1, 1, 1) +fn main(@builtin(global_invocation_id) x_2_param : vec3) { + x_2 = x_2_param; + main_1(); +} From 82fefd1f028ba63574ac43185355a75dfc1678aa Mon Sep 17 00:00:00 2001 From: Tyson Smith Date: Mon, 25 Nov 2024 10:07:19 -0800 Subject: [PATCH 49/50] Fix typos in tag definitions --- rules/html.txt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/rules/html.txt b/rules/html.txt index ab8ee87..6e49cf1 100644 --- a/rules/html.txt +++ b/rules/html.txt @@ -972,7 +972,7 @@ = bdo /bdo = bgsound /bgsound = big /big - = blink /big + = blink /blink = blockquote /blockquote = br /br = button /button @@ -985,7 +985,7 @@ = colgroup /colgroup = command /command = content /content - = data /command + = data /data = datalist /datalist = dd /dd = del /del @@ -1035,7 +1035,7 @@ = mark /mark = marquee /marquee = menu /menu - = menuitem /menu + = menuitem /menuitem = meta /meta = meter /meter = nav /nav @@ -1066,7 +1066,7 @@ = shadow /shadow = small /small = source /source - = spacer /strike + = spacer /spacer = span /span = strike /strike = strong /strong From 26820b8fe1e7252045515b621c8bfc54ecf6d3db Mon Sep 17 00:00:00 2001 From: Tyson Smith Date: Mon, 25 Nov 2024 10:23:44 -0800 Subject: [PATCH 50/50] Define GetVariable() and SetVariable() in WebGPU template.html --- webgpu/template.html | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/webgpu/template.html b/webgpu/template.html index b34fa7a..8402049 100644 --- a/webgpu/template.html +++ b/webgpu/template.html @@ -1,6 +1,6 @@ -